@aztec/pxe 0.0.1-commit.96dac018d → 0.0.1-commit.993d52e

package/src/private_kernel/hints/private_kernel_reset_private_inputs_builder.ts

@@ -10,7 +10,7 @@ import {
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { assertLength } from '@aztec/foundation/serialize';
+import { type Tuple, assertLength } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuits-types/client';
 import {
@@ -27,11 +27,13 @@ import {
   ReadRequestActionEnum,
   ReadRequestResetActions,
   type ScopedKeyValidationRequestAndSeparator,
+  ScopedNoteHash,
+  ScopedNullifier,
+  ScopedReadRequest,
   TransientDataSquashingHint,
   buildNoteHashReadRequestHintsFromResetActions,
   buildNullifierReadRequestHintsFromResetActions,
   buildTransientDataHints,
-  countSquashedLogs,
   findPrivateKernelResetDimensions,
   getNoteHashReadRequestResetActions,
   getNullifierReadRequestResetActions,
@@ -42,6 +44,15 @@ import { VkData } from '@aztec/stdlib/vks';
 
 import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
 
+function collectNestedReadRequests<N extends number>(
+  executionStack: PrivateCallExecutionResult[],
+  extractReadRequests: (execution: PrivateCallExecutionResult) => ClaimedLengthArray<ScopedReadRequest, N>,
+): ScopedReadRequest[] {
+  return collectNested(executionStack, executionResult => {
+    return extractReadRequests(executionResult).getActiveItems();
+  });
+}
+
 function getNullifierMembershipWitnessResolver(oracle: PrivateKernelOracle) {
   return async (nullifier: Fr) => {
     const res = await oracle.getNullifierMembershipWitness(nullifier);
@@ -80,14 +91,11 @@ export class PrivateKernelResetPrivateInputsBuilder {
   // If there's no next iteration, it's the final reset.
   private nextIteration?: PrivateCircuitPublicInputs;
 
-  private noteHashResetActions = ReadRequestResetActions.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
-  private nullifierResetActions = ReadRequestResetActions.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+  private noteHashResetActions: ReadRequestResetActions<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>;
+  private nullifierResetActions: ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>;
   private numTransientData?: number;
-  private transientDataSquashingHints = makeTuple(
-    MAX_NULLIFIERS_PER_TX,
-    () => new TransientDataSquashingHint(MAX_NULLIFIERS_PER_TX, MAX_NOTE_HASHES_PER_TX),
-  );
-  private requestedDimensions = PrivateKernelResetDimensions.empty();
+  private transientDataSquashingHints: Tuple<TransientDataSquashingHint, typeof MAX_NULLIFIERS_PER_TX>;
+  private requestedDimensions: PrivateKernelResetDimensions;
 
   constructor(
     private previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
@@ -96,18 +104,21 @@ export class PrivateKernelResetPrivateInputsBuilder {
     private splitCounter: number,
   ) {
     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.nextIteration = executionStack[this.executionStack.length - 1]?.publicInputs;
   }
 
-  getRequestedDimensions(): PrivateKernelResetDimensions {
-    return this.requestedDimensions;
-  }
-
   needsReset(): boolean {
     const fns: (() => boolean)[] = [
       () => this.needsResetNoteHashReadRequests(),
       () => this.needsResetNullifierReadRequests(),
-      () => this.needsResetKeyValidationRequests(),
+      () => this.needsResetNullifierKeys(),
       () => this.needsResetTransientData(),
     ];
 
@@ -134,7 +145,8 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
     const isInner = !!this.nextIteration;
 
-    // "final" reset must be done exactly once, because siloing can't be run repeatedly.
+    // "final" reset must be done at most once.
+    // Because the code that silo note hashes can't be run repeatedly.
     // The dimensions found must be big enough to reset all values, i.e. empty remainder.
     const allowRemainder = isInner;
 
@@ -234,17 +246,24 @@ export class PrivateKernelResetPrivateInputsBuilder {
     resetActions.pendingReadHints = resetActions.pendingReadHints.slice(0, maxPending);
   }
 
-  private needsResetNoteHashReadRequests(forceReset = false) {
+  private needsResetNoteHashReadRequests(forceResetAll = false) {
     const numCurr = this.previousKernel.validationRequests.noteHashReadRequests.claimedLength;
     const numNext = this.nextIteration ? this.nextIteration.noteHashReadRequests.claimedLength : 0;
-    const maxAmountToKeep = !this.nextIteration || forceReset ? 0 : MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
+    const maxAmountToKeep = !this.nextIteration || forceResetAll ? 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 numPendingReads = resetActions.pendingReadHints.length;
@@ -253,72 +272,53 @@ export class PrivateKernelResetPrivateInputsBuilder {
       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 {
-      // 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.
+      // Pick only one dimension to reset if next iteration is not empty.
       if (numPendingReads > numSettledReads) {
-        // Reset the pending read requests.
-        const pendingOnlyActions = assertLength(
+        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 = new ReadRequestResetActions(pendingOnlyActions, resetActions.pendingReadHints);
-        this.requestedDimensions.NOTE_HASH_PENDING_READ = numPendingReads;
+        this.noteHashResetActions.pendingReadHints = resetActions.pendingReadHints;
       } else {
-        // Reset the settled read requests.
-        const settledOnlyActions = assertLength(
+        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,
         );
-        this.noteHashResetActions = new ReadRequestResetActions(settledOnlyActions, []);
-        this.requestedDimensions.NOTE_HASH_SETTLED_READ = numSettledReads;
       }
     }
 
     return true;
   }
 
-  private needsResetNullifierReadRequests(forceReset = false) {
+  private needsResetNullifierReadRequests(forceResetAll = false) {
     const numCurr = this.previousKernel.validationRequests.nullifierReadRequests.claimedLength;
     const numNext = this.nextIteration ? this.nextIteration.nullifierReadRequests.claimedLength : 0;
-    const maxAmountToKeep = !this.nextIteration || forceReset ? 0 : MAX_NULLIFIER_READ_REQUESTS_PER_TX;
+    const maxAmountToKeep = !this.nextIteration || forceResetAll ? 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 numPendingReads = resetActions.pendingReadHints.length;
@@ -327,61 +327,36 @@ export class PrivateKernelResetPrivateInputsBuilder {
       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 {
-      // If there's a next iteration, we can only reset one dimension at a time.
+      // Pick only one dimension to reset if next iteration is not empty.
       if (numPendingReads > numSettledReads) {
-        // Reset the pending read requests.
-        const pendingOnlyActions = assertLength(
+        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 = new ReadRequestResetActions(pendingOnlyActions, resetActions.pendingReadHints);
-        this.requestedDimensions.NULLIFIER_PENDING_READ = numPendingReads;
+        this.nullifierResetActions.pendingReadHints = resetActions.pendingReadHints;
       } else {
-        // Reset the settled read requests.
-        const settledOnlyActions = assertLength(
+        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,
         );
-        this.nullifierResetActions = new ReadRequestResetActions(settledOnlyActions, []);
-        this.requestedDimensions.NULLIFIER_SETTLED_READ = numSettledReads;
       }
     }
 
     return true;
   }
 
-  private needsResetKeyValidationRequests() {
+  private needsResetNullifierKeys() {
     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;
@@ -395,6 +370,9 @@ export class PrivateKernelResetPrivateInputsBuilder {
   }
 
   private 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;
@@ -409,19 +387,19 @@ export class PrivateKernelResetPrivateInputsBuilder {
       return false;
     }
 
-    const futureNoteHashReads = collectNested(this.executionStack, executionResult =>
-      executionResult.publicInputs.noteHashReadRequests.getActiveItems(),
-    );
-    const futureNullifierReads = collectNested(this.executionStack, executionResult =>
-      executionResult.publicInputs.nullifierReadRequests.getActiveItems(),
+    const futureNoteHashReads = collectNestedReadRequests(
+      this.executionStack,
+      executionResult => executionResult.publicInputs.noteHashReadRequests,
     );
-    const futureLogs = collectNested(this.executionStack, executionResult =>
-      executionResult.publicInputs.privateLogs.getActiveItems(),
+    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).
     if (this.nextIteration) {
-      // 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.
+      // 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.
       futureNoteHashReads.push(...this.previousKernel.validationRequests.noteHashReadRequests.getActiveItems());
       futureNullifierReads.push(...this.previousKernel.validationRequests.nullifierReadRequests.getActiveItems());
     }
@@ -431,50 +409,27 @@ export class PrivateKernelResetPrivateInputsBuilder {
       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.');
+    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.`);
       }
+      // 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;
@@ -489,13 +444,10 @@ export class PrivateKernelResetPrivateInputsBuilder {
       throw new Error('`needsResetTransientData` must be run before `needsSiloNoteHashes`.');
     }
 
-    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;
+    const numNoteHashes = this.previousKernel.end.noteHashes
+      .getActiveItems()
+      .filter(n => !n.contractAddress.isZero()).length;
+    const numToSilo = Math.max(0, numNoteHashes - this.numTransientData);
     this.requestedDimensions.NOTE_HASH_SILOING = numToSilo;
 
     return numToSilo > 0;
@@ -506,14 +458,15 @@ export class PrivateKernelResetPrivateInputsBuilder {
       throw new Error('`needsResetTransientData` must be run before `needsSiloNullifiers`.');
     }
 
-    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;
+    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;
 
     return numToSilo > 0;
   }
@@ -524,17 +477,17 @@ export class PrivateKernelResetPrivateInputsBuilder {
     }
 
     const privateLogs = this.previousKernel.end.privateLogs;
-    if (privateLogs.claimedLength > 0 && privateLogs.array[0].contractAddress.isZero()) {
-      // Already siloed.
-      return false;
-    }
+    const numLogs = privateLogs.getActiveItems().filter(l => !l.contractAddress.isZero()).length;
 
-    const numSquashedLogs = countSquashedLogs(
-      this.previousKernel.end.noteHashes,
-      privateLogs,
-      this.transientDataSquashingHints.slice(0, this.numTransientData),
-    );
-    const numToSilo = privateLogs.claimedLength - numSquashedLogs;
+    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;
     this.requestedDimensions.PRIVATE_LOG_SILOING = numToSilo;
 
     return numToSilo > 0;

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -116,7 +116,6 @@ export class PrivateKernelExecutionProver {
           splitCounter,
         );
         while (resetBuilder.needsReset()) {
-          // Inner reset: without siloing.
           const witgenTimer = new Timer();
           const privateInputs = await resetBuilder.build(this.oracle);
           output = generateWitnesses
@@ -217,24 +216,16 @@ export class PrivateKernelExecutionProver {
       firstIteration = false;
     }
 
-    // Final reset: include siloing of note hashes, nullifiers and private logs.
-    const finalResetBuilder = new PrivateKernelResetPrivateInputsBuilder(
+    // Reset.
+    let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
       output,
       [],
       noteHashNullifierCounterMap,
       splitCounter,
     );
-    if (!finalResetBuilder.needsReset()) {
-      // The final reset must be performed exactly once, because each tx has at least one nullifier that requires
-      // siloing, and siloing cannot be done multiple times.
-      // While, in theory, it might be possible to silo note hashes first and then run another reset to silo nullifiers
-      // and/or private logs, we currently don't have standalone dimensions for the arrays that require siloing. As a
-      // result, all necessary siloing must be done together in a single reset.
-      // Refer to the possible combinations of dimensions in private_kernel_reset_config.json.
-      throw new Error('Nothing to reset for the final reset.');
-    } else {
+    while (resetBuilder.needsReset()) {
       const witgenTimer = new Timer();
-      const privateInputs = await finalResetBuilder.build(this.oracle);
+      const privateInputs = await resetBuilder.build(this.oracle);
       output = generateWitnesses
         ? await this.proofCreator.generateResetOutput(privateInputs)
         : await this.proofCreator.simulateReset(privateInputs);
@@ -248,6 +239,8 @@ export class PrivateKernelExecutionProver {
           witgen: witgenTimer.ms(),
         },
       });
+
+      resetBuilder = new PrivateKernelResetPrivateInputsBuilder(output, [], noteHashNullifierCounterMap, splitCounter);
     }
 
     if (output.publicInputs.feePayer.isZero() && skipFeeEnforcement) {

package/src/storage/tagging_store/recipient_tagging_store.ts

@@ -1,5 +1,5 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 
@@ -106,11 +106,11 @@ export class RecipientTaggingStore implements StagedStore {
     return Promise.resolve();
   }
 
-  getHighestAgedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getHighestAgedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readHighestAgedIndex(jobId, secret.toString()));
   }
 
-  updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
+  updateHighestAgedIndex(secret: ExtendedDirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
     return this.#store.transactionAsync(async () => {
       const currentIndex = await this.#readHighestAgedIndex(jobId, secret.toString());
       if (currentIndex !== undefined && index <= currentIndex) {
@@ -121,11 +121,15 @@ export class RecipientTaggingStore implements StagedStore {
     });
   }
 
-  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getHighestFinalizedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readHighestFinalizedIndex(jobId, secret.toString()));
   }
 
-  updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
+  updateHighestFinalizedIndex(
+    secret: ExtendedDirectionalAppTaggingSecret,
+    index: number,
+    jobId: string,
+  ): Promise<void> {
     return this.#store.transactionAsync(async () => {
       const currentIndex = await this.#readHighestFinalizedIndex(jobId, secret.toString());
       if (currentIndex !== undefined && index < currentIndex) {

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -1,5 +1,5 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
@@ -154,7 +154,7 @@ export class SenderTaggingStore implements StagedStore {
 
     // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
     // pair. Below we check that this is the case.
-    const secretsSet = new Set(preTags.map(preTag => preTag.secret.toString()));
+    const secretsSet = new Set(preTags.map(preTag => preTag.extendedSecret.toString()));
     if (secretsSet.size !== preTags.length) {
       return Promise.reject(new Error(`Duplicate secrets found when storing pending indexes`));
     }
@@ -163,10 +163,10 @@ export class SenderTaggingStore implements StagedStore {
 
     return this.#store.transactionAsync(async () => {
       // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-      const preTagReadPromises = preTags.map(({ secret, index }) => {
-        const secretStr = secret.toString();
+      const preTagReadPromises = preTags.map(({ extendedSecret, index }) => {
+        const secretStr = extendedSecret.toString();
         return {
-          secret,
+          extendedSecret,
           secretStr,
           index,
           pending: this.#readPendingIndexes(jobId, secretStr),
@@ -233,7 +233,7 @@ export class SenderTaggingStore implements StagedStore {
    * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
    */
   getTxHashesOfPendingIndexes(
-    secret: DirectionalAppTaggingSecret,
+    secret: ExtendedDirectionalAppTaggingSecret,
     startIndex: number,
     endIndex: number,
     jobId: string,
@@ -252,7 +252,7 @@ export class SenderTaggingStore implements StagedStore {
    * @param secret - The secret to get the last finalized index for.
    * @returns The last (highest) finalized index for the given secret.
    */
-  getLastFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getLastFinalizedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readLastFinalizedIndex(jobId, secret.toString()));
   }
 
@@ -262,7 +262,7 @@ export class SenderTaggingStore implements StagedStore {
    * @param secret - The directional app tagging secret to query the last used index for.
    * @returns The last used index.
    */
-  getLastUsedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     const secretStr = secret.toString();
 
     return this.#store.transactionAsync(async () => {

package/src/tagging/index.ts

@@ -15,5 +15,5 @@ export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 
 // Re-export tagging-related types from stdlib
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { ExtendedDirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
 export { type PreTag } from '@aztec/stdlib/logs';

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,8 +1,7 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
 
 import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
 import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
@@ -10,15 +9,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 import { loadLogsForRange } from './utils/load_logs_for_range.js';
 
 /**
- * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
+ * Loads private logs for the app-sender-recipient triplet defined by `secret` and updates the highest aged and
  * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
  *
  * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
  * in the tagging data provider is indexed by the secret and hence completely disjoint.
  */
 export async function loadPrivateLogsForSenderRecipientPair(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
+  secret: ExtendedDirectionalAppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
@@ -96,7 +94,6 @@ export async function loadPrivateLogsForSenderRecipientPair(
     // Get private logs with their block timestamps and corresponding tagging indexes
     const privateLogsWithIndexes = await loadLogsForRange(
       secret,
-      app,
       aztecNode,
       start,
       end,