@aztec/pxe 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/private_kernel/hints/private_kernel_reset_private_inputs_builder.js

@@ -1,17 +1,13 @@
 import { MAX_KEY_VALIDATION_REQUESTS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_PRIVATE_LOGS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { allToCompletion } from '@aztec/foundation/promise';
 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, kernelStateIsForPublic, 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,10 +21,10 @@ 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);
+    const keysHints = await allToCompletion(keyValidationRequests.array.slice(0, numRequestsToProcess).map(async ({ request })=>{
+        const secretKeys = await oracle.getMasterSecretKey(request.request.pkMHash);
         return new KeyValidationHint(secretKeys);
     }));
     return padArrayEnd(keysHints, KeyValidationHint.empty(), MAX_KEY_VALIDATION_REQUESTS_PER_TX);
@@ -51,18 +47,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 +86,24 @@ 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);
+        // Terminal reset picks from the finalTail / finalTailToPublic catalogs; mid-tx resets always
+        // use the inner catalog. The public/private decision must match `kernelStateIsForPublic` - the
+        // same predicate the circuit inputs and the orchestrator use.
+        const mode = isInner ? 'inner' : kernelStateIsForPublic(this.previousKernel) ? 'finalTailToPublic' : 'finalTail';
+        const dimensions = findPrivateKernelResetDimensions(this.requestedDimensions, privateKernelResetDimensionsConfig, mode, allowRemainder);
         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([
+        const [previousVkMembershipWitness, noteHashReadRequestHints, nullifierReadRequestHints, keyValidationHints] = await allToCompletion([
             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),
-            getMasterSecretKeysAndAppKeyGenerators(this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators, dimensions.KEY_VALIDATION, oracle)
+            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);
@@ -130,69 +132,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;
@@ -201,8 +246,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);
@@ -212,27 +255,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;
@@ -243,8 +304,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;
     }
@@ -252,13 +317,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() {
@@ -266,11 +331,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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

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/test_utils.ts"],"names":[],"mappings":"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"}