@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/{kernel_prover → private_kernel}/hints/build_private_kernel_reset_private_inputs.ts

@@ -4,8 +4,8 @@ import {
   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,
-  VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -14,7 +14,9 @@ import { type Tuple, assertLength } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuits-types/client';
 import {
+  ClaimedLengthArray,
   KeyValidationHint,
+  PaddedSideEffects,
   type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
@@ -23,40 +25,38 @@ import {
   PrivateKernelResetHints,
   type PrivateKernelSimulateOutput,
   type ReadRequest,
-  ReadRequestResetStates,
-  ReadRequestState,
+  ReadRequestActionEnum,
+  ReadRequestResetActions,
   type ScopedKeyValidationRequestAndGenerator,
   ScopedNoteHash,
   ScopedNullifier,
   ScopedReadRequest,
-  TransientDataIndexHint,
-  buildNoteHashReadRequestHintsFromResetStates,
-  buildNullifierReadRequestHintsFromResetStates,
+  TransientDataSquashingHint,
+  buildNoteHashReadRequestHintsFromResetActions,
+  buildNullifierReadRequestHintsFromResetActions,
   buildTransientDataHints,
-  countAccumulatedItems,
   findPrivateKernelResetDimensions,
-  getNonEmptyItems,
-  getNoteHashReadRequestResetStates,
-  getNullifierReadRequestResetStates,
+  getNoteHashReadRequestResetActions,
+  getNullifierReadRequestResetActions,
   privateKernelResetDimensionNames,
 } from '@aztec/stdlib/kernel';
 import { type PrivateCallExecutionResult, collectNested } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
 
-import type { ProvingDataOracle } from '../proving_data_oracle.js';
+import type { PrivateKernelOracle } from '../private_kernel_oracle.js';
 
-function collectNestedReadRequests(
+function collectNestedReadRequests<N extends number>(
   executionStack: PrivateCallExecutionResult[],
-  extractReadRequests: (execution: PrivateCallExecutionResult) => ReadRequest[],
+  extractReadRequests: (execution: PrivateCallExecutionResult) => ClaimedLengthArray<ReadRequest, N>,
 ): ScopedReadRequest[] {
   return collectNested(executionStack, executionResult => {
-    const nonEmptyReadRequests = getNonEmptyItems(extractReadRequests(executionResult));
-    return nonEmptyReadRequests.map(
-      readRequest => new ScopedReadRequest(readRequest, executionResult.publicInputs.callContext.contractAddress),
-    );
+    return extractReadRequests(executionResult)
+      .getActiveItems()
+      .map(readRequest => new ScopedReadRequest(readRequest, executionResult.publicInputs.callContext.contractAddress));
   });
 }
 
-function getNullifierMembershipWitnessResolver(oracle: ProvingDataOracle) {
+function getNullifierMembershipWitnessResolver(oracle: PrivateKernelOracle) {
   return async (nullifier: Fr) => {
     const res = await oracle.getNullifierMembershipWitness(nullifier);
     if (!res) {
@@ -72,23 +72,21 @@ function getNullifierMembershipWitnessResolver(oracle: ProvingDataOracle) {
 }
 
 async function getMasterSecretKeysAndAppKeyGenerators(
-  keyValidationRequests: Tuple<ScopedKeyValidationRequestAndGenerator, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
-  oracle: ProvingDataOracle,
+  keyValidationRequests: ClaimedLengthArray<
+    ScopedKeyValidationRequestAndGenerator,
+    typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
+  >,
+  numRequestsToVerify: number,
+  oracle: PrivateKernelOracle,
 ) {
-  const keysHints = [];
-  for (let i = 0; i < keyValidationRequests.length; ++i) {
-    const request = keyValidationRequests[i].request;
-    if (request.isEmpty()) {
-      break;
-    }
-    const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
-    keysHints.push(new KeyValidationHint(secretKeys, i));
-  }
-  return padArrayEnd(
-    keysHints,
-    KeyValidationHint.nada(MAX_KEY_VALIDATION_REQUESTS_PER_TX),
-    MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  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);
+      return new KeyValidationHint(secretKeys);
+    }),
   );
+  return padArrayEnd(keysHints, KeyValidationHint.empty(), MAX_KEY_VALIDATION_REQUESTS_PER_TX);
 }
 
 export class PrivateKernelResetPrivateInputsBuilder {
@@ -96,10 +94,10 @@ export class PrivateKernelResetPrivateInputsBuilder {
   // If there's no next iteration, it's the final reset.
   private nextIteration?: PrivateCircuitPublicInputs;
 
-  private noteHashResetStates: ReadRequestResetStates<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>;
-  private nullifierResetStates: ReadRequestResetStates<typeof 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 transientDataIndexHints: Tuple<TransientDataIndexHint, typeof MAX_NULLIFIERS_PER_TX>;
+  private transientDataSquashingHints: Tuple<TransientDataSquashingHint, typeof MAX_NULLIFIERS_PER_TX>;
   private requestedDimensions: PrivateKernelResetDimensions;
 
   constructor(
@@ -110,11 +108,11 @@ export class PrivateKernelResetPrivateInputsBuilder {
   ) {
     this.previousKernel = previousKernelOutput.publicInputs;
     this.requestedDimensions = PrivateKernelResetDimensions.empty();
-    this.noteHashResetStates = ReadRequestResetStates.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
-    this.nullifierResetStates = ReadRequestResetStates.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
-    this.transientDataIndexHints = makeTuple(
+    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 TransientDataIndexHint(MAX_NULLIFIERS_PER_TX, MAX_NOTE_HASHES_PER_TX),
+      () => new TransientDataSquashingHint(MAX_NULLIFIERS_PER_TX, MAX_NOTE_HASHES_PER_TX),
     );
     this.nextIteration = executionStack[this.executionStack.length - 1]?.publicInputs;
   }
@@ -143,7 +141,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
     }
   }
 
-  async build(oracle: ProvingDataOracle, noteHashLeafIndexMap: Map<bigint, bigint>) {
+  async build(oracle: PrivateKernelOracle, noteHashLeafIndexMap: Map<bigint, bigint>) {
     if (privateKernelResetDimensionNames.every(name => !this.requestedDimensions[name])) {
       throw new Error('Reset is not required.');
     }
@@ -162,122 +160,132 @@ export class PrivateKernelResetPrivateInputsBuilder {
       allowRemainder,
     );
 
-    const previousVkMembershipWitness = await oracle.getVkMembershipWitness(this.previousKernelOutput.verificationKey);
-    const previousKernelData = new PrivateKernelData(
-      this.previousKernelOutput.publicInputs,
+    const previousVkMembershipWitness = await oracle.getVkMembershipWitness(
+      this.previousKernelOutput.verificationKey.keyAsFields,
+    );
+    const vkData = new VkData(
       this.previousKernelOutput.verificationKey,
       Number(previousVkMembershipWitness.leafIndex),
-      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
+      previousVkMembershipWitness.siblingPath,
     );
+    const previousKernelData = new PrivateKernelData(this.previousKernelOutput.publicInputs, vkData);
 
-    this.reduceReadRequestStates(
-      this.noteHashResetStates,
-      dimensions.NOTE_HASH_PENDING_AMOUNT,
-      dimensions.NOTE_HASH_SETTLED_AMOUNT,
+    this.reduceReadRequestActions(
+      this.noteHashResetActions,
+      dimensions.NOTE_HASH_PENDING_READ,
+      dimensions.NOTE_HASH_SETTLED_READ,
     );
-    this.reduceReadRequestStates(
-      this.nullifierResetStates,
-      dimensions.NULLIFIER_PENDING_AMOUNT,
-      dimensions.NULLIFIER_SETTLED_AMOUNT,
+    this.reduceReadRequestActions(
+      this.nullifierResetActions,
+      dimensions.NULLIFIER_PENDING_READ,
+      dimensions.NULLIFIER_SETTLED_READ,
     );
 
+    // 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 buildNoteHashReadRequestHintsFromResetStates(
+        await buildNoteHashReadRequestHintsFromResetActions(
           oracle,
           this.previousKernel.validationRequests.noteHashReadRequests,
           this.previousKernel.end.noteHashes,
-          this.noteHashResetStates,
+          this.noteHashResetActions,
           noteHashLeafIndexMap,
         ),
-        await buildNullifierReadRequestHintsFromResetStates(
+        await buildNullifierReadRequestHintsFromResetActions(
           { getNullifierMembershipWitness: getNullifierMembershipWitnessResolver(oracle) },
           this.previousKernel.validationRequests.nullifierReadRequests,
-          this.nullifierResetStates,
+          this.nullifierResetActions,
         ),
         await getMasterSecretKeysAndAppKeyGenerators(
           this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators,
+          dimensions.KEY_VALIDATION,
           oracle,
         ),
-        this.transientDataIndexHints,
+        this.transientDataSquashingHints,
         this.validationRequestsSplitCounter,
       ),
       dimensions,
     );
   }
 
-  private reduceReadRequestStates<NUM_READS extends number>(
-    resetStates: ReadRequestResetStates<NUM_READS>,
+  private reduceReadRequestActions<NUM_READS extends number>(
+    resetActions: ReadRequestResetActions<NUM_READS>,
     maxPending: number,
     maxSettled: number,
   ) {
     let numPending = 0;
     let numSettled = 0;
-    for (let i = 0; i < resetStates.states.length; i++) {
-      const state = resetStates.states[i];
-      if (state === ReadRequestState.PENDING) {
+    for (let i = 0; i < resetActions.actions.length; i++) {
+      const action = resetActions.actions[i];
+      if (action === ReadRequestActionEnum.READ_AS_PENDING) {
         if (numPending < maxPending) {
           numPending++;
         } else {
-          resetStates.states[i] = ReadRequestState.NADA;
+          resetActions.actions[i] = ReadRequestActionEnum.SKIP;
         }
-      } else if (state === ReadRequestState.SETTLED) {
+      } else if (action === ReadRequestActionEnum.READ_AS_SETTLED) {
         if (numSettled < maxSettled) {
           numSettled++;
         } else {
-          resetStates.states[i] = ReadRequestState.NADA;
+          resetActions.actions[i] = ReadRequestActionEnum.SKIP;
         }
       }
     }
 
-    resetStates.pendingReadHints = resetStates.pendingReadHints.slice(0, maxPending);
+    resetActions.pendingReadHints = resetActions.pendingReadHints.slice(0, maxPending);
   }
 
   private needsResetNoteHashReadRequests(forceResetAll = false) {
-    const numCurr = countAccumulatedItems(this.previousKernel.validationRequests.noteHashReadRequests);
-    const numNext = this.nextIteration ? countAccumulatedItems(this.nextIteration.noteHashReadRequests) : 0;
+    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;
     if (numCurr + numNext <= maxAmountToKeep) {
       return false;
     }
 
     const futureNoteHashes = collectNested(this.executionStack, executionResult => {
-      const nonEmptyNoteHashes = getNonEmptyItems(executionResult.publicInputs.noteHashes);
-      return nonEmptyNoteHashes.map(
-        noteHash => new ScopedNoteHash(noteHash, executionResult.publicInputs.callContext.contractAddress),
-      );
+      return executionResult.publicInputs.noteHashes
+        .getActiveItems()
+        .map(noteHash => new ScopedNoteHash(noteHash, executionResult.publicInputs.callContext.contractAddress));
     });
 
-    const resetStates = getNoteHashReadRequestResetStates(
+    const resetActions = getNoteHashReadRequestResetActions(
       this.previousKernel.validationRequests.noteHashReadRequests,
       this.previousKernel.end.noteHashes,
       futureNoteHashes,
     );
 
-    const numPendingReads = resetStates.pendingReadHints.length;
-    const numSettledReads = resetStates.states.reduce(
-      (accum, state) => accum + (state === ReadRequestState.SETTLED ? 1 : 0),
+    const numPendingReads = resetActions.pendingReadHints.length;
+    const numSettledReads = resetActions.actions.reduce(
+      (accum, action) => accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0),
       0,
     );
 
     if (!this.nextIteration) {
-      this.noteHashResetStates = resetStates;
-      this.requestedDimensions.NOTE_HASH_PENDING_AMOUNT = numPendingReads;
-      this.requestedDimensions.NOTE_HASH_SETTLED_AMOUNT = numSettledReads;
+      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 (numPendingReads > numSettledReads) {
-        this.requestedDimensions.NOTE_HASH_PENDING_AMOUNT = numPendingReads;
-        this.noteHashResetStates.states = assertLength(
-          resetStates.states.map(state => (state === ReadRequestState.PENDING ? state : ReadRequestState.NADA)),
+        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.noteHashResetStates.pendingReadHints = resetStates.pendingReadHints;
+        this.noteHashResetActions.pendingReadHints = resetActions.pendingReadHints;
       } else {
-        this.requestedDimensions.NOTE_HASH_SETTLED_AMOUNT = numSettledReads;
-        this.noteHashResetStates.states = assertLength(
-          resetStates.states.map(state => (state === ReadRequestState.SETTLED ? state : ReadRequestState.NADA)),
+        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,
         );
       }
@@ -287,49 +295,52 @@ export class PrivateKernelResetPrivateInputsBuilder {
   }
 
   private needsResetNullifierReadRequests(forceResetAll = false) {
-    const numCurr = countAccumulatedItems(this.previousKernel.validationRequests.nullifierReadRequests);
-    const numNext = this.nextIteration ? countAccumulatedItems(this.nextIteration.nullifierReadRequests) : 0;
+    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;
     if (numCurr + numNext <= maxAmountToKeep) {
       return false;
     }
 
     const futureNullifiers = collectNested(this.executionStack, executionResult => {
-      const nonEmptyNullifiers = getNonEmptyItems(executionResult.publicInputs.nullifiers);
-      return nonEmptyNullifiers.map(
-        nullifier => new ScopedNullifier(nullifier, executionResult.publicInputs.callContext.contractAddress),
-      );
+      return executionResult.publicInputs.nullifiers
+        .getActiveItems()
+        .map(nullifier => new ScopedNullifier(nullifier, executionResult.publicInputs.callContext.contractAddress));
     });
 
-    const resetStates = getNullifierReadRequestResetStates(
+    const resetActions = getNullifierReadRequestResetActions(
       this.previousKernel.validationRequests.nullifierReadRequests,
       this.previousKernel.end.nullifiers,
       futureNullifiers,
     );
 
-    const numPendingReads = resetStates.pendingReadHints.length;
-    const numSettledReads = resetStates.states.reduce(
-      (accum, state) => accum + (state === ReadRequestState.SETTLED ? 1 : 0),
+    const numPendingReads = resetActions.pendingReadHints.length;
+    const numSettledReads = resetActions.actions.reduce(
+      (accum, action) => accum + (action === ReadRequestActionEnum.READ_AS_SETTLED ? 1 : 0),
       0,
     );
 
     if (!this.nextIteration) {
-      this.nullifierResetStates = resetStates;
-      this.requestedDimensions.NULLIFIER_PENDING_AMOUNT = numPendingReads;
-      this.requestedDimensions.NULLIFIER_SETTLED_AMOUNT = numSettledReads;
+      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 (numPendingReads > numSettledReads) {
-        this.requestedDimensions.NULLIFIER_PENDING_AMOUNT = numPendingReads;
-        this.nullifierResetStates.states = assertLength(
-          resetStates.states.map(state => (state === ReadRequestState.PENDING ? state : ReadRequestState.NADA)),
+        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.nullifierResetStates.pendingReadHints = resetStates.pendingReadHints;
+        this.nullifierResetActions.pendingReadHints = resetActions.pendingReadHints;
       } else {
-        this.requestedDimensions.NULLIFIER_SETTLED_AMOUNT = numSettledReads;
-        this.nullifierResetStates.states = assertLength(
-          resetStates.states.map(state => (state === ReadRequestState.SETTLED ? state : ReadRequestState.NADA)),
+        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,
         );
       }
@@ -339,18 +350,14 @@ export class PrivateKernelResetPrivateInputsBuilder {
   }
 
   private needsResetNullifierKeys() {
-    const numCurr = countAccumulatedItems(
-      this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators,
-    );
-    const numNext = this.nextIteration
-      ? countAccumulatedItems(this.nextIteration.keyValidationRequestsAndGenerators)
-      : 0;
+    const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators.claimedLength;
+    const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndGenerators.claimedLength : 0;
     const maxAmountToKeep = !this.nextIteration ? 0 : MAX_KEY_VALIDATION_REQUESTS_PER_TX;
     if (numCurr + numNext <= maxAmountToKeep) {
       return false;
     }
 
-    this.requestedDimensions.NULLIFIER_KEYS = numCurr;
+    this.requestedDimensions.KEY_VALIDATION = numCurr;
 
     return true;
   }
@@ -360,14 +367,16 @@ export class PrivateKernelResetPrivateInputsBuilder {
     this.numTransientData = 0;
 
     const nextAccumNoteHashes =
-      countAccumulatedItems(this.previousKernel.end.noteHashes) +
-      countAccumulatedItems(this.nextIteration?.noteHashes ?? []);
+      this.previousKernel.end.noteHashes.claimedLength + (this.nextIteration?.noteHashes.claimedLength ?? 0);
     const noteHashWillOverflow = nextAccumNoteHashes > MAX_NOTE_HASHES_PER_TX;
     const nextAccumNullifiers =
-      countAccumulatedItems(this.previousKernel.end.nullifiers) +
-      countAccumulatedItems(this.nextIteration?.nullifiers ?? []);
+      this.previousKernel.end.nullifiers.claimedLength + (this.nextIteration?.nullifiers.claimedLength ?? 0);
     const nullifierWillOverflow = nextAccumNullifiers > MAX_NULLIFIERS_PER_TX;
-    if (this.nextIteration && !noteHashWillOverflow && !nullifierWillOverflow) {
+    const nextAccumLogs =
+      this.previousKernel.end.privateLogs.claimedLength + (this.nextIteration?.privateLogs.claimedLength ?? 0);
+    const logsWillOverflow = nextAccumLogs > MAX_PRIVATE_LOGS_PER_TX;
+
+    if (this.nextIteration && !noteHashWillOverflow && !nullifierWillOverflow && !logsWillOverflow) {
       return false;
     }
 
@@ -379,35 +388,36 @@ export class PrivateKernelResetPrivateInputsBuilder {
       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.
       // The note hashes and nullifiers for the remaining read requests can't be squashed.
-      futureNoteHashReads.push(
-        ...this.previousKernel.validationRequests.noteHashReadRequests.filter(r => !r.isEmpty()),
-      );
-      futureNullifierReads.push(
-        ...this.previousKernel.validationRequests.nullifierReadRequests.filter(r => !r.isEmpty()),
-      );
+      futureNoteHashReads.push(...this.previousKernel.validationRequests.noteHashReadRequests.getActiveItems());
+      futureNullifierReads.push(...this.previousKernel.validationRequests.nullifierReadRequests.getActiveItems());
     }
 
-    const { numTransientData, hints: transientDataIndexHints } = buildTransientDataHints(
+    const { numTransientData, hints: transientDataSquashingHints } = buildTransientDataHints(
       this.previousKernel.end.noteHashes,
       this.previousKernel.end.nullifiers,
       futureNoteHashReads,
       futureNullifierReads,
       this.noteHashNullifierCounterMap,
       this.validationRequestsSplitCounter,
-      MAX_NOTE_HASHES_PER_TX,
-      MAX_NULLIFIERS_PER_TX,
     );
 
     if (this.nextIteration && !numTransientData) {
       const forceResetAll = true;
       const canClearReadRequests =
         (noteHashWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll)) ||
-        (nullifierWillOverflow && this.needsResetNullifierReadRequests(forceResetAll));
+        (nullifierWillOverflow && this.needsResetNullifierReadRequests(forceResetAll)) ||
+        (logsWillOverflow && this.needsResetNoteHashReadRequests(forceResetAll));
       if (!canClearReadRequests) {
-        const overflownData = noteHashWillOverflow ? 'note hashes' : 'nullifiers';
+        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.
@@ -416,8 +426,8 @@ export class PrivateKernelResetPrivateInputsBuilder {
     }
 
     this.numTransientData = numTransientData;
-    this.transientDataIndexHints = transientDataIndexHints;
-    this.requestedDimensions.TRANSIENT_DATA_AMOUNT = numTransientData;
+    this.transientDataSquashingHints = transientDataSquashingHints;
+    this.requestedDimensions.TRANSIENT_DATA_SQUASHING = numTransientData;
 
     return numTransientData > 0;
   }
@@ -427,9 +437,11 @@ export class PrivateKernelResetPrivateInputsBuilder {
       throw new Error('`needsResetTransientData` must be run before `needsSiloNoteHashes`.');
     }
 
-    const numNoteHashes = this.previousKernel.end.noteHashes.filter(n => !n.contractAddress.isZero()).length;
+    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_AMOUNT = numToSilo;
+    this.requestedDimensions.NOTE_HASH_SILOING = numToSilo;
 
     return numToSilo > 0;
   }
@@ -439,13 +451,15 @@ export class PrivateKernelResetPrivateInputsBuilder {
       throw new Error('`needsResetTransientData` must be run before `needsSiloNullifiers`.');
     }
 
-    const numNullifiers = this.previousKernel.end.nullifiers.filter(n => !n.contractAddress.isZero()).length;
+    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_AMOUNT = cappedSize;
+    this.requestedDimensions.NULLIFIER_SILOING = cappedSize;
 
     return numToSilo > 0;
   }
@@ -456,16 +470,18 @@ export class PrivateKernelResetPrivateInputsBuilder {
     }
 
     const privateLogs = this.previousKernel.end.privateLogs;
-    const numLogs = privateLogs.filter(l => !l.contractAddress.isZero()).length;
+    const numLogs = privateLogs.getActiveItems().filter(l => !l.contractAddress.isZero()).length;
 
     const noteHashes = this.previousKernel.end.noteHashes;
-    const squashedNoteHashCounters = this.transientDataIndexHints
-      .filter(h => h.noteHashIndex < noteHashes.length)
-      .map(h => noteHashes[h.noteHashIndex].counter);
-    const numSquashedLogs = privateLogs.filter(l => squashedNoteHashCounters.includes(l.inner.noteHashCounter)).length;
+    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_AMOUNT = numToSilo;
+    this.requestedDimensions.PRIVATE_LOG_SILOING = numToSilo;
 
     return numToSilo > 0;
   }

package/src/private_kernel/hints/compute_tx_include_by_timestamp.ts

@@ -0,0 +1,58 @@
+import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import type { PrivateKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+const ROUNDED_DURATIONS = [
+  3600, // 1 hour
+  1800, // 30 mins
+  1, // 1 second
+];
+
+function roundTimestamp(blockTimestamp: bigint, includeByTimestamp: bigint): UInt64 {
+  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 roundedDuration = totalDuration - (totalDuration % BigInt(duration));
+      return blockTimestamp + roundedDuration;
+    }
+    return timestamp;
+  }, 0n);
+}
+
+export function computeTxIncludeByTimestamp(
+  previousKernel: PrivateKernelCircuitPublicInputs,
+  maxDuration = MAX_INCLUDE_BY_TIMESTAMP_DURATION,
+): UInt64 {
+  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}.`,
+    );
+  }
+
+  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,
+  // 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) {
+    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);
+
+  // 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}.`,
+    );
+  }
+
+  return roundedTimestamp;
+}

package/src/{kernel_prover → private_kernel}/hints/index.ts

@@ -1 +1,2 @@
 export * from './build_private_kernel_reset_private_inputs.js';
+export * from './compute_tx_include_by_timestamp.js';

package/src/private_kernel/index.ts

@@ -0,0 +1,2 @@
+export * from './private_kernel_execution_prover.js';
+export * from './private_kernel_oracle.js';