@aztec/stdlib 1.2.0 → 2.0.0-nightly.20250813

package/src/kernel/claimed_length_array.ts

@@ -0,0 +1,104 @@
+import type { Fr } from '@aztec/foundation/fields';
+import {
+  BufferReader,
+  FieldReader,
+  type Serializable,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+
+export class ClaimedLengthArray<T extends Serializable, N extends number> {
+  constructor(
+    public array: Tuple<T, N>,
+    // Named `claimedLength` instead of `length` to avoid being confused with array.length.
+    public claimedLength: number,
+  ) {}
+
+  static fromBuffer<T extends Serializable, N extends number>(
+    buffer: Buffer | BufferReader,
+    deserializer: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+    arrayLength: N,
+  ): ClaimedLengthArray<T, N> {
+    const reader = BufferReader.asReader(buffer);
+    const array = reader.readArray(arrayLength, deserializer);
+    const claimedLength = reader.readNumber();
+    return new ClaimedLengthArray(array, claimedLength);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.array, this.claimedLength);
+  }
+
+  static fromFields<T extends Serializable, N extends number>(
+    fields: Fr[] | FieldReader,
+    deserializer: {
+      fromFields: (reader: FieldReader) => T;
+    },
+    arrayLength: N,
+  ): ClaimedLengthArray<T, N> {
+    const reader = FieldReader.asReader(fields);
+    const array = reader.readArray(arrayLength, deserializer);
+    const claimedLength = reader.readU32();
+    return new ClaimedLengthArray(array, claimedLength);
+  }
+
+  toFields() {
+    return serializeToFields(this.array, this.claimedLength);
+  }
+
+  static empty<T extends Serializable, N extends number>(
+    elem: { empty: () => T },
+    arraySize: number,
+  ): ClaimedLengthArray<T, N> {
+    const array = Array(arraySize).fill(elem.empty()) as Tuple<T, N>;
+    return new ClaimedLengthArray(array, 0);
+  }
+
+  isEmpty() {
+    return this.claimedLength === 0;
+  }
+
+  getActiveItems(): T[] {
+    return this.array.slice(0, this.claimedLength);
+  }
+
+  getSize() {
+    return this.toBuffer().length;
+  }
+
+  [inspect.custom]() {
+    return `ClaimedLengthArray {
+      array: [${this.getActiveItems()
+        .map(x => inspect(x))
+        .join(', ')}],
+      claimedLength: ${this.claimedLength},
+    `;
+  }
+}
+
+export function ClaimedLengthArrayFromBuffer<T extends Serializable, N extends number>(
+  deserializer: {
+    fromBuffer: (reader: BufferReader) => T;
+  },
+  arrayLength: N,
+): {
+  fromBuffer: (reader: BufferReader) => ClaimedLengthArray<T, N>;
+} {
+  return { fromBuffer: (reader: BufferReader) => ClaimedLengthArray.fromBuffer(reader, deserializer, arrayLength) };
+}
+
+export function ClaimedLengthArrayFromFields<T extends Serializable, N extends number>(
+  deserializer: {
+    fromFields: (reader: FieldReader) => T;
+  },
+  arrayLength: N,
+): {
+  fromFields: (reader: FieldReader) => ClaimedLengthArray<T, N>;
+} {
+  return { fromFields: (reader: FieldReader) => ClaimedLengthArray.fromFields(reader, deserializer, arrayLength) };
+}

package/src/kernel/hints/build_note_hash_read_request_hints.ts

@@ -3,14 +3,13 @@ import {
   MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   type NOTE_HASH_TREE_HEIGHT,
 } from '@aztec/constants';
-import type { Tuple } from '@aztec/foundation/serialize';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 
+import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNoteHash } from '../note_hash.js';
-import { countAccumulatedItems, getNonEmptyItems } from '../utils/order_and_comparison.js';
 import { NoteHashReadRequestHintsBuilder } from './note_hash_read_request_hints.js';
 import type { ScopedReadRequest } from './read_request.js';
-import { PendingReadHint, ReadRequestResetStates, ReadRequestState } from './read_request_hints.js';
+import { PendingReadHint, ReadRequestActionEnum, ReadRequestResetActions } from './read_request_hints.js';
 import { ScopedValueCache } from './scoped_value_cache.js';
 
 export function isValidNoteHashReadRequest(readRequest: ScopedReadRequest, noteHash: ScopedNoteHash) {
@@ -21,15 +20,15 @@ export function isValidNoteHashReadRequest(readRequest: ScopedReadRequest, noteH
   );
 }
 
-export function getNoteHashReadRequestResetStates(
-  noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
-  noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
+export function getNoteHashReadRequestResetActions(
+  noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
   futureNoteHashes: ScopedNoteHash[],
-): ReadRequestResetStates<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX> {
-  const resetStates = ReadRequestResetStates.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
+): ReadRequestResetActions<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX> {
+  const resetActions = ReadRequestResetActions.empty(MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
 
   const noteHashMap: Map<bigint, { noteHash: ScopedNoteHash; index: number }[]> = new Map();
-  getNonEmptyItems(noteHashes).forEach((noteHash, index) => {
+  noteHashes.getActiveItems().forEach((noteHash, index) => {
     const value = noteHash.value.toBigInt();
     const arr = noteHashMap.get(value) ?? [];
     arr.push({ noteHash, index });
@@ -38,49 +37,48 @@ export function getNoteHashReadRequestResetStates(
 
   const futureNoteHashMap = new ScopedValueCache(futureNoteHashes);
 
-  const numReadRequests = countAccumulatedItems(noteHashReadRequests);
-  for (let i = 0; i < numReadRequests; ++i) {
-    const readRequest = noteHashReadRequests[i];
+  for (let i = 0; i < noteHashReadRequests.claimedLength; ++i) {
+    const readRequest = noteHashReadRequests.array[i];
 
     const pendingNoteHash = noteHashMap
       .get(readRequest.value.toBigInt())
       ?.find(n => isValidNoteHashReadRequest(readRequest, n.noteHash));
 
     if (pendingNoteHash !== undefined) {
-      resetStates.states[i] = ReadRequestState.PENDING;
-      resetStates.pendingReadHints.push(new PendingReadHint(i, pendingNoteHash.index));
+      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
+      resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNoteHash.index));
     } else if (
       !futureNoteHashMap
         .get(readRequest)
         .find(futureNoteHash => isValidNoteHashReadRequest(readRequest, futureNoteHash))
     ) {
-      resetStates.states[i] = ReadRequestState.SETTLED;
+      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_SETTLED;
     }
   }
 
-  return resetStates;
+  return resetActions;
 }
 
-export async function buildNoteHashReadRequestHintsFromResetStates<PENDING extends number, SETTLED extends number>(
+export async function buildNoteHashReadRequestHintsFromResetActions<PENDING extends number, SETTLED extends number>(
   oracle: {
     getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
   },
-  noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
-  noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
-  resetStates: ReadRequestResetStates<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
+  resetActions: ReadRequestResetActions<typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
   noteHashLeafIndexMap: Map<bigint, bigint>,
   maxPending: PENDING = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as SETTLED,
 ) {
   const builder = new NoteHashReadRequestHintsBuilder(maxPending, maxSettled);
 
-  resetStates.pendingReadHints.forEach(hint => {
+  resetActions.pendingReadHints.forEach(hint => {
     builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
   });
 
-  for (let i = 0; i < resetStates.states.length; i++) {
-    if (resetStates.states[i] === ReadRequestState.SETTLED) {
-      const readRequest = noteHashReadRequests[i];
+  for (let i = 0; i < resetActions.actions.length; i++) {
+    if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+      const readRequest = noteHashReadRequests.array[i];
       const leafIndex = noteHashLeafIndexMap.get(readRequest.value.toBigInt());
       if (leafIndex === undefined) {
         throw new Error('Read request is reading an unknown note hash.');
@@ -91,7 +89,7 @@ export async function buildNoteHashReadRequestHintsFromResetStates<PENDING exten
   }
 
   const noteHashMap: Map<bigint, { noteHash: ScopedNoteHash; index: number }[]> = new Map();
-  getNonEmptyItems(noteHashes).forEach((noteHash, index) => {
+  noteHashes.getActiveItems().forEach((noteHash, index) => {
     const value = noteHash.value.toBigInt();
     const arr = noteHashMap.get(value) ?? [];
     arr.push({ noteHash, index });
@@ -105,19 +103,19 @@ export async function buildNoteHashReadRequestHints<PENDING extends number, SETT
   oracle: {
     getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
   },
-  noteHashReadRequests: Tuple<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
-  noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
+  noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
   noteHashLeafIndexMap: Map<bigint, bigint>,
   futureNoteHashes: ScopedNoteHash[],
   maxPending: PENDING = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NOTE_HASH_READ_REQUESTS_PER_TX as SETTLED,
 ) {
-  const resetStates = getNoteHashReadRequestResetStates(noteHashReadRequests, noteHashes, futureNoteHashes);
-  return await buildNoteHashReadRequestHintsFromResetStates(
+  const resetActions = getNoteHashReadRequestResetActions(noteHashReadRequests, noteHashes, futureNoteHashes);
+  return await buildNoteHashReadRequestHintsFromResetActions(
     oracle,
     noteHashReadRequests,
     noteHashes,
-    resetStates,
+    resetActions,
     noteHashLeafIndexMap,
     maxPending,
     maxSettled,

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -3,18 +3,15 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type NULLIFIER_TREE_HEIGHT,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
 import { type IndexedTreeLeafPreimage, MembershipWitness } from '@aztec/foundation/trees';
 
-import { AztecAddress } from '../../aztec-address/index.js';
 import { siloNullifier } from '../../hash/hash.js';
-import { Nullifier, type ScopedNullifier } from '../nullifier.js';
-import { countAccumulatedItems, getNonEmptyItems } from '../utils/order_and_comparison.js';
+import type { ClaimedLengthArray } from '../claimed_length_array.js';
+import type { ScopedNullifier } from '../nullifier.js';
 import { NullifierReadRequestHintsBuilder } from './nullifier_read_request_hints.js';
-import { ReadRequest, ScopedReadRequest } from './read_request.js';
-import { PendingReadHint, ReadRequestResetStates, ReadRequestState } from './read_request_hints.js';
+import { ScopedReadRequest } from './read_request.js';
+import { PendingReadHint, ReadRequestActionEnum, ReadRequestResetActions } from './read_request_hints.js';
 import { ScopedValueCache } from './scoped_value_cache.js';
 
 export function isValidNullifierReadRequest(readRequest: ScopedReadRequest, nullifier: ScopedNullifier) {
@@ -30,15 +27,15 @@ interface NullifierMembershipWitnessWithPreimage {
   leafPreimage: IndexedTreeLeafPreimage;
 }
 
-export function getNullifierReadRequestResetStates(
-  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-  nullifiers: Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
+export function getNullifierReadRequestResetActions(
+  nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+  nullifiers: ClaimedLengthArray<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
   futureNullifiers: ScopedNullifier[],
-): ReadRequestResetStates<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX> {
-  const resetStates = ReadRequestResetStates.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
+): ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX> {
+  const resetActions = ReadRequestResetActions.empty(MAX_NULLIFIER_READ_REQUESTS_PER_TX);
 
   const nullifierMap: Map<bigint, { nullifier: ScopedNullifier; index: number }[]> = new Map();
-  getNonEmptyItems(nullifiers).forEach((nullifier, index) => {
+  nullifiers.getActiveItems().forEach((nullifier, index) => {
     const value = nullifier.value.toBigInt();
     const arr = nullifierMap.get(value) ?? [];
     arr.push({ nullifier, index });
@@ -47,48 +44,46 @@ export function getNullifierReadRequestResetStates(
 
   const futureNullifiersMap = new ScopedValueCache(futureNullifiers);
 
-  const numReadRequests = countAccumulatedItems(nullifierReadRequests);
-
-  for (let i = 0; i < numReadRequests; ++i) {
-    const readRequest = nullifierReadRequests[i];
+  for (let i = 0; i < nullifierReadRequests.claimedLength; ++i) {
+    const readRequest = nullifierReadRequests.array[i];
     const pendingNullifier = nullifierMap
       .get(readRequest.value.toBigInt())
       ?.find(({ nullifier }) => isValidNullifierReadRequest(readRequest, nullifier));
 
     if (pendingNullifier !== undefined) {
-      resetStates.states[i] = ReadRequestState.PENDING;
-      resetStates.pendingReadHints.push(new PendingReadHint(i, pendingNullifier.index));
+      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_PENDING;
+      resetActions.pendingReadHints.push(new PendingReadHint(i, pendingNullifier.index));
     } else if (
       !futureNullifiersMap
         .get(readRequest)
         .some(futureNullifier => isValidNullifierReadRequest(readRequest, futureNullifier))
     ) {
-      resetStates.states[i] = ReadRequestState.SETTLED;
+      resetActions.actions[i] = ReadRequestActionEnum.READ_AS_SETTLED;
     }
   }
 
-  return resetStates;
+  return resetActions;
 }
 
-export async function buildNullifierReadRequestHintsFromResetStates<PENDING extends number, SETTLED extends number>(
+export async function buildNullifierReadRequestHintsFromResetActions<PENDING extends number, SETTLED extends number>(
   oracle: {
     getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
   },
-  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-  resetStates: ReadRequestResetStates<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+  nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+  resetActions: ReadRequestResetActions<typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
   siloed = false,
 ) {
   const builder = new NullifierReadRequestHintsBuilder(maxPending, maxSettled);
 
-  resetStates.pendingReadHints.forEach(hint => {
+  resetActions.pendingReadHints.forEach(hint => {
     builder.addPendingReadRequest(hint.readRequestIndex, hint.pendingValueIndex);
   });
 
-  for (let i = 0; i < resetStates.states.length; i++) {
-    if (resetStates.states[i] === ReadRequestState.SETTLED) {
-      const readRequest = nullifierReadRequests[i];
+  for (let i = 0; i < resetActions.actions.length; i++) {
+    if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+      const readRequest = nullifierReadRequests.array[i];
       const siloedValue = siloed
         ? readRequest.value
         : await siloNullifier(readRequest.contractAddress, readRequest.value);
@@ -108,46 +103,20 @@ export async function buildNullifierReadRequestHints<PENDING extends number, SET
   oracle: {
     getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
   },
-  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-  nullifiers: Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
+  nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+  nullifiers: ClaimedLengthArray<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
   futureNullifiers: ScopedNullifier[],
   maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
   maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
   siloed = false,
 ) {
-  const resetStates = getNullifierReadRequestResetStates(nullifierReadRequests, nullifiers, futureNullifiers);
-  return await buildNullifierReadRequestHintsFromResetStates(
+  const resetActions = getNullifierReadRequestResetActions(nullifierReadRequests, nullifiers, futureNullifiers);
+  return await buildNullifierReadRequestHintsFromResetActions(
     oracle,
     nullifierReadRequests,
-    resetStates,
+    resetActions,
     maxPending,
     maxSettled,
     siloed,
   );
 }
-
-export async function buildSiloedNullifierReadRequestHints<PENDING extends number, SETTLED extends number>(
-  oracle: {
-    getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitnessWithPreimage>;
-  },
-  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-  nullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
-  maxPending: PENDING = MAX_NULLIFIER_READ_REQUESTS_PER_TX as PENDING,
-  maxSettled: SETTLED = MAX_NULLIFIER_READ_REQUESTS_PER_TX as SETTLED,
-) {
-  // Nullifiers outputted from public kernels are already siloed while read requests are not.
-  // Siloing the read request values and set the contract addresses to zero to find the matching nullifier contexts.
-  const nonEmptyNullifierReadRequests = getNonEmptyItems(nullifierReadRequests);
-  const readRequests = await Promise.all(
-    nonEmptyNullifierReadRequests.map(async r =>
-      new ReadRequest(await siloNullifier(r.contractAddress, r.value), r.counter).scope(AztecAddress.ZERO),
-    ),
-  );
-  const siloedReadRequests = padArrayEnd(readRequests, ScopedReadRequest.empty(), MAX_NULLIFIER_READ_REQUESTS_PER_TX);
-
-  const scopedNullifiers = nullifiers.map(n =>
-    new Nullifier(n.value, n.counter, n.noteHash).scope(AztecAddress.ZERO),
-  ) as Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>;
-
-  return buildNullifierReadRequestHints(oracle, siloedReadRequests, scopedNullifiers, [], maxPending, maxSettled, true);
-}

package/src/kernel/hints/build_transient_data_hints.ts

@@ -1,35 +1,32 @@
 import { padArrayEnd } from '@aztec/foundation/collection';
 import type { Tuple } from '@aztec/foundation/serialize';
 
+import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNoteHash } from '../note_hash.js';
 import type { ScopedNullifier } from '../nullifier.js';
-import { countAccumulatedItems } from '../utils/order_and_comparison.js';
 import { isValidNoteHashReadRequest } from './build_note_hash_read_request_hints.js';
 import { isValidNullifierReadRequest } from './build_nullifier_read_request_hints.js';
 import type { ScopedReadRequest } from './read_request.js';
 import { ScopedValueCache } from './scoped_value_cache.js';
-import { TransientDataIndexHint } from './transient_data_index_hint.js';
+import { TransientDataSquashingHint } from './transient_data_squashing_hint.js';
 
 export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIERS_LEN extends number>(
-  noteHashes: Tuple<ScopedNoteHash, NOTE_HASHES_LEN>,
-  nullifiers: Tuple<ScopedNullifier, NULLIFIERS_LEN>,
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, NOTE_HASHES_LEN>,
+  nullifiers: ClaimedLengthArray<ScopedNullifier, NULLIFIERS_LEN>,
   futureNoteHashReads: ScopedReadRequest[],
   futureNullifierReads: ScopedReadRequest[],
   noteHashNullifierCounterMap: Map<number, number>,
   validationRequestsSplitCounter: number,
-  noteHashesLength: NOTE_HASHES_LEN = noteHashes.length as NOTE_HASHES_LEN,
-  nullifiersLength: NULLIFIERS_LEN = nullifiers.length as NULLIFIERS_LEN,
-): { numTransientData: number; hints: Tuple<TransientDataIndexHint, NULLIFIERS_LEN> } {
+): { numTransientData: number; hints: Tuple<TransientDataSquashingHint, NULLIFIERS_LEN> } {
   const futureNoteHashReadsMap = new ScopedValueCache(futureNoteHashReads);
   const futureNullifierReadsMap = new ScopedValueCache(futureNullifierReads);
 
   const nullifierIndexMap: Map<number, number> = new Map();
-  nullifiers.forEach((n, i) => nullifierIndexMap.set(n.counter, i));
+  nullifiers.getActiveItems().forEach((n, i) => nullifierIndexMap.set(n.counter, i));
 
   const hints = [];
-  const numNoteHashes = countAccumulatedItems(noteHashes);
-  for (let noteHashIndex = 0; noteHashIndex < numNoteHashes; noteHashIndex++) {
-    const noteHash = noteHashes[noteHashIndex];
+  for (let noteHashIndex = 0; noteHashIndex < noteHashes.claimedLength; noteHashIndex++) {
+    const noteHash = noteHashes.array[noteHashIndex];
     const noteHashNullifierCounter = noteHashNullifierCounterMap.get(noteHash.counter);
     // The note hash might not be linked to a nullifier or it might be read in the future
     if (
@@ -45,7 +42,7 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
       continue;
     }
 
-    const nullifier = nullifiers[nullifierIndex];
+    const nullifier = nullifiers.array[nullifierIndex];
     // Cannot nullify a non-revertible note hash with a revertible nullifier.
     if (noteHash.counter < validationRequestsSplitCounter && nullifier.counter >= validationRequestsSplitCounter) {
       continue;
@@ -71,11 +68,12 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
       continue;
     }
 
-    hints.push(new TransientDataIndexHint(nullifierIndex, noteHashIndex));
+    hints.push(new TransientDataSquashingHint(nullifierIndex, noteHashIndex));
   }
 
+  const noActionHint = new TransientDataSquashingHint(nullifiers.array.length, noteHashes.array.length);
   return {
     numTransientData: hints.length,
-    hints: padArrayEnd(hints, new TransientDataIndexHint(nullifiersLength, noteHashesLength), nullifiersLength),
+    hints: padArrayEnd(hints, noActionHint, nullifiers.array.length as NULLIFIERS_LEN),
   };
 }

package/src/kernel/hints/index.ts

@@ -10,7 +10,6 @@ export * from './key_validation_request_and_generator.js';
 export * from './read_request.js';
 export * from './key_validation_request.js';
 export * from './scoped_key_validation_request_and_generator.js';
-export * from './rollup_validation_requests.js';
-export * from './transient_data_index_hint.js';
+export * from './transient_data_squashing_hint.js';
 export * from './private_kernel_reset_hints.js';
 export * from './tree_leaf_read_request.js';

package/src/kernel/hints/note_hash_read_request_hints.ts

@@ -4,13 +4,7 @@ import { Fr } from '@aztec/foundation/fields';
 import type { BufferReader } from '@aztec/foundation/serialize';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 
-import {
-  PendingReadHint,
-  ReadRequestResetHints,
-  ReadRequestState,
-  ReadRequestStatus,
-  SettledReadHint,
-} from './read_request_hints.js';
+import { PendingReadHint, ReadRequestAction, ReadRequestResetHints, SettledReadHint } from './read_request_hints.js';
 
 type NoteHashLeafValue = Fr;
 
@@ -47,7 +41,7 @@ export class NoteHashReadRequestHintsBuilder<PENDING extends number, SETTLED ext
     public readonly maxSettled: SETTLED,
   ) {
     this.hints = new ReadRequestResetHints(
-      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
+      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ReadRequestAction.skip),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),
       makeTuple(maxSettled, () =>
         SettledReadHint.nada(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, NOTE_HASH_TREE_HEIGHT, Fr.zero),
@@ -63,10 +57,7 @@ export class NoteHashReadRequestHintsBuilder<PENDING extends number, SETTLED ext
     if (this.numPendingReadHints === this.maxPending) {
       throw new Error('Cannot add more pending read request.');
     }
-    this.hints.readRequestStatuses[readRequestIndex] = new ReadRequestStatus(
-      ReadRequestState.PENDING,
-      this.numPendingReadHints,
-    );
+    this.hints.readRequestActions[readRequestIndex] = ReadRequestAction.readAsPending(this.numPendingReadHints);
     this.hints.pendingReadHints[this.numPendingReadHints] = new PendingReadHint(readRequestIndex, noteHashIndex);
     this.numPendingReadHints++;
   }
@@ -79,10 +70,7 @@ export class NoteHashReadRequestHintsBuilder<PENDING extends number, SETTLED ext
     if (this.numSettledReadHints === this.maxSettled) {
       throw new Error('Cannot add more settled read request.');
     }
-    this.hints.readRequestStatuses[readRequestIndex] = new ReadRequestStatus(
-      ReadRequestState.SETTLED,
-      this.numSettledReadHints,
-    );
+    this.hints.readRequestActions[readRequestIndex] = ReadRequestAction.readAsSettled(this.numSettledReadHints);
     this.hints.settledReadHints[this.numSettledReadHints] = new SettledReadHint(
       readRequestIndex,
       membershipWitness,

package/src/kernel/hints/nullifier_read_request_hints.ts

@@ -4,13 +4,7 @@ import type { BufferReader } from '@aztec/foundation/serialize';
 import type { MembershipWitness, TreeLeafPreimage } from '@aztec/foundation/trees';
 
 import { NullifierLeafPreimage } from '../../trees/index.js';
-import {
-  PendingReadHint,
-  ReadRequestResetHints,
-  ReadRequestState,
-  ReadRequestStatus,
-  SettledReadHint,
-} from './read_request_hints.js';
+import { PendingReadHint, ReadRequestAction, ReadRequestResetHints, SettledReadHint } from './read_request_hints.js';
 
 export type NullifierReadRequestHints<PENDING extends number, SETTLED extends number> = ReadRequestResetHints<
   typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX,
@@ -45,7 +39,7 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
     public readonly maxSettled: SETTLED,
   ) {
     this.hints = new ReadRequestResetHints(
-      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
+      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ReadRequestAction.skip),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NULLIFIER_READ_REQUESTS_PER_TX)),
       makeTuple(maxSettled, () =>
         SettledReadHint.nada(MAX_NULLIFIER_READ_REQUESTS_PER_TX, NULLIFIER_TREE_HEIGHT, NullifierLeafPreimage.empty),
@@ -62,10 +56,7 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
       throw new Error('Cannot add more pending read request.');
     }
 
-    this.hints.readRequestStatuses[readRequestIndex] = new ReadRequestStatus(
-      ReadRequestState.PENDING,
-      this.numPendingReadHints,
-    );
+    this.hints.readRequestActions[readRequestIndex] = ReadRequestAction.readAsPending(this.numPendingReadHints);
     this.hints.pendingReadHints[this.numPendingReadHints] = new PendingReadHint(readRequestIndex, nullifierIndex);
     this.numPendingReadHints++;
   }
@@ -78,10 +69,7 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
     if (this.numSettledReadHints === this.maxSettled) {
       throw new Error('Cannot add more settled read request.');
     }
-    this.hints.readRequestStatuses[readRequestIndex] = new ReadRequestStatus(
-      ReadRequestState.SETTLED,
-      this.numSettledReadHints,
-    );
+    this.hints.readRequestActions[readRequestIndex] = ReadRequestAction.readAsSettled(this.numSettledReadHints);
     this.hints.settledReadHints[this.numSettledReadHints] = new SettledReadHint(
       readRequestIndex,
       membershipWitness,

package/src/kernel/hints/private_kernel_reset_hints.ts

@@ -3,7 +3,7 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { KeyValidationHint } from './key_validation_hint.js';
 import { type NoteHashReadRequestHints, noteHashReadRequestHintsFromBuffer } from './note_hash_read_request_hints.js';
 import { type NullifierReadRequestHints, nullifierReadRequestHintsFromBuffer } from './nullifier_read_request_hints.js';
-import { TransientDataIndexHint } from './transient_data_index_hint.js';
+import { TransientDataSquashingHint } from './transient_data_squashing_hint.js';
 
 export class PrivateKernelResetHints<
   NH_RR_PENDING extends number,
@@ -29,7 +29,7 @@ export class PrivateKernelResetHints<
     /**
      * Contains hints for the transient note hashes to locate corresponding nullifiers.
      */
-    public transientDataIndexHints: Tuple<TransientDataIndexHint, TRANSIENT_DATA_HINTS_LEN>,
+    public transientDataSquashingHints: Tuple<TransientDataSquashingHint, TRANSIENT_DATA_HINTS_LEN>,
     /**
      * The "final" minRevertibleSideEffectCounter of a tx, to split the data for squashing.
      * Not the minRevertibleSideEffectCounter at the point the reset circuit is run.
@@ -42,7 +42,7 @@ export class PrivateKernelResetHints<
       this.noteHashReadRequestHints,
       this.nullifierReadRequestHints,
       this.keyValidationHints,
-      this.transientDataIndexHints,
+      this.transientDataSquashingHints,
       this.validationRequestsSplitCounter,
     );
   }
@@ -53,7 +53,7 @@ export class PrivateKernelResetHints<
     numNullifierReadRequestPending: number,
     numNullifierReadRequestSettled: number,
     numKeyValidationHints: number,
-    numTransientDataIndexHints: number,
+    numTransientDataSquashingHints: number,
   ) {
     // Noir does not allow empty arrays. So we make the minimum array size 1.
     // There is a constant for each dimension, coded in the circuit that indicates how many hints should be applied.
@@ -70,7 +70,7 @@ export class PrivateKernelResetHints<
         useSize(numNullifierReadRequestSettled),
       ),
       this.keyValidationHints.slice(0, useSize(numKeyValidationHints)),
-      this.transientDataIndexHints.slice(0, useSize(numTransientDataIndexHints)),
+      this.transientDataSquashingHints.slice(0, useSize(numTransientDataSquashingHints)),
       this.validationRequestsSplitCounter,
     );
   }
@@ -93,7 +93,7 @@ export class PrivateKernelResetHints<
     numNullifierReadRequestPending: NLL_RR_PENDING,
     numNullifierReadRequestSettled: NLL_RR_SETTLED,
     numKeyValidationHints: KEY_VALIDATION_HINTS_LEN,
-    numTransientDataIndexHints: TRANSIENT_DATA_HINTS_LEN,
+    numTransientDataSquashingHints: TRANSIENT_DATA_HINTS_LEN,
   ): PrivateKernelResetHints<
     NH_RR_PENDING,
     NH_RR_SETTLED,
@@ -113,7 +113,7 @@ export class PrivateKernelResetHints<
           nullifierReadRequestHintsFromBuffer(buf, numNullifierReadRequestPending, numNullifierReadRequestSettled),
       }),
       reader.readArray(numKeyValidationHints, KeyValidationHint),
-      reader.readArray(numTransientDataIndexHints, TransientDataIndexHint),
+      reader.readArray(numTransientDataSquashingHints, TransientDataSquashingHint),
       reader.readNumber(),
     );
   }