@aztec/stdlib 1.2.1 → 2.0.0-nightly.20250813

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(),
     );
   }

package/src/kernel/hints/read_request_hints.ts

@@ -2,37 +2,37 @@ import { makeTuple } from '@aztec/foundation/array';
 import { BufferReader, type Bufferable, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
-export enum ReadRequestState {
-  NADA = 0,
-  PENDING = 1,
-  SETTLED = 2,
+export enum ReadRequestActionEnum {
+  SKIP = 0,
+  READ_AS_PENDING = 1,
+  READ_AS_SETTLED = 2,
 }
 
-export class ReadRequestStatus {
+export class ReadRequestAction {
   constructor(
-    public state: ReadRequestState,
+    public action: ReadRequestActionEnum,
     public hintIndex: number,
   ) {}
 
-  static nada() {
-    return new ReadRequestStatus(ReadRequestState.NADA, 0);
+  static skip() {
+    return new ReadRequestAction(ReadRequestActionEnum.SKIP, 0);
   }
 
-  static pending(hintIndex: number) {
-    return new ReadRequestStatus(ReadRequestState.PENDING, hintIndex);
+  static readAsPending(hintIndex: number) {
+    return new ReadRequestAction(ReadRequestActionEnum.READ_AS_PENDING, hintIndex);
   }
 
-  static settled(hintIndex: number) {
-    return new ReadRequestStatus(ReadRequestState.SETTLED, hintIndex);
+  static readAsSettled(hintIndex: number) {
+    return new ReadRequestAction(ReadRequestActionEnum.READ_AS_SETTLED, hintIndex);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ReadRequestStatus(reader.readNumber(), reader.readNumber());
+    return new ReadRequestAction(reader.readNumber(), reader.readNumber());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.state, this.hintIndex);
+    return serializeToBuffer(this.action, this.hintIndex);
   }
 }
 
@@ -100,7 +100,7 @@ export class ReadRequestResetHints<
   LEAF_PREIMAGE extends Bufferable,
 > {
   constructor(
-    public readRequestStatuses: Tuple<ReadRequestStatus, READ_REQUEST_LEN>,
+    public readRequestActions: Tuple<ReadRequestAction, READ_REQUEST_LEN>,
     /**
      * The hints for read requests reading pending values.
      */
@@ -122,7 +122,7 @@ export class ReadRequestResetHints<
     LEAF_PREIMAGE
   > {
     return new ReadRequestResetHints(
-      this.readRequestStatuses,
+      this.readRequestActions,
       this.pendingReadHints.slice(0, numPendingReads) as Tuple<PendingReadHint, NEW_PENDING_READ_HINTS_LEN>,
       this.settledReadHints.slice(0, numSettledReads) as Tuple<
         SettledReadHint<TREE_HEIGHT, LEAF_PREIMAGE>,
@@ -158,7 +158,7 @@ export class ReadRequestResetHints<
   > {
     const reader = BufferReader.asReader(buffer);
     return new ReadRequestResetHints(
-      reader.readArray(readRequestLen, ReadRequestStatus),
+      reader.readArray(readRequestLen, ReadRequestAction),
       reader.readArray(numPendingReads, PendingReadHint),
       reader.readArray(numSettledReads, {
         fromBuffer: r => SettledReadHint.fromBuffer(r, treeHeight, leafPreimageFromBuffer),
@@ -167,19 +167,19 @@ export class ReadRequestResetHints<
   }
 
   toBuffer() {
-    return serializeToBuffer(this.readRequestStatuses, this.pendingReadHints, this.settledReadHints);
+    return serializeToBuffer(this.readRequestActions, this.pendingReadHints, this.settledReadHints);
   }
 }
 
-export class ReadRequestResetStates<NUM_READS extends number> {
+export class ReadRequestResetActions<NUM_READS extends number> {
   constructor(
-    public states: Tuple<ReadRequestState, NUM_READS>,
+    public actions: Tuple<ReadRequestActionEnum, NUM_READS>,
     public pendingReadHints: PendingReadHint[],
   ) {}
 
   static empty<NUM_READS extends number>(numReads: NUM_READS) {
-    return new ReadRequestResetStates(
-      makeTuple(numReads, () => ReadRequestState.NADA),
+    return new ReadRequestResetActions(
+      makeTuple(numReads, () => ReadRequestActionEnum.SKIP),
       [],
     );
   }

package/src/kernel/hints/{transient_data_index_hint.ts → transient_data_squashing_hint.ts}

@@ -3,7 +3,7 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 
 import { inspect } from 'util';
 
-export class TransientDataIndexHint {
+export class TransientDataSquashingHint {
   constructor(
     public nullifierIndex: number,
     public noteHashIndex: number,
@@ -15,7 +15,7 @@ export class TransientDataIndexHint {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new TransientDataIndexHint(reader.readU32(), reader.readU32());
+    return new TransientDataSquashingHint(reader.readU32(), reader.readU32());
   }
 
   isEmpty() {
@@ -23,7 +23,7 @@ export class TransientDataIndexHint {
   }
 
   static empty() {
-    return new TransientDataIndexHint(0, 0);
+    return new TransientDataSquashingHint(0, 0);
   }
 
   toBuffer(): Buffer {
@@ -32,7 +32,7 @@ export class TransientDataIndexHint {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new TransientDataIndexHint(reader.readNumber(), reader.readNumber());
+    return new TransientDataSquashingHint(reader.readNumber(), reader.readNumber());
   }
 
   toString(): string {
@@ -40,6 +40,6 @@ export class TransientDataIndexHint {
   }
 
   [inspect.custom](): string {
-    return `TransientDataIndexHint { ${this.toString()} }`;
+    return `TransientDataSquashingHint { ${this.toString()} }`;
   }
 }

package/src/kernel/index.ts

@@ -1,3 +1,4 @@
+export * from './claimed_length_array.js';
 export * from './private_to_rollup_accumulated_data.js';
 export * from './private_to_rollup_kernel_circuit_public_inputs.js';
 export * from './private_accumulated_data.js';

package/src/kernel/private_accumulated_data.ts

@@ -7,11 +7,11 @@ import {
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { ScopedCountedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedCountedLogHash } from './log_hash.js';
 import { ScopedNoteHash } from './note_hash.js';
 import { ScopedNullifier } from './nullifier.js';
@@ -28,32 +28,32 @@ export class PrivateAccumulatedData {
     /**
      * The new note hashes made in this transaction.
      */
-    public noteHashes: Tuple<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
+    public noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
     /**
      * The new nullifiers made in this transaction.
      */
-    public nullifiers: Tuple<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
+    public nullifiers: ClaimedLengthArray<ScopedNullifier, typeof MAX_NULLIFIERS_PER_TX>,
     /**
      * All the new L2 to L1 messages created in this transaction.
      */
-    public l2ToL1Msgs: Tuple<ScopedCountedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_TX>,
+    public l2ToL1Msgs: ClaimedLengthArray<ScopedCountedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_TX>,
     /**
      * Accumulated logs from all the previous kernel iterations.
      */
-    public privateLogs: Tuple<ScopedPrivateLogData, typeof MAX_PRIVATE_LOGS_PER_TX>,
+    public privateLogs: ClaimedLengthArray<ScopedPrivateLogData, typeof MAX_PRIVATE_LOGS_PER_TX>,
     /**
      * Accumulated contract class logs from all the previous kernel iterations.
      * Note: Truncated to 31 bytes to fit in Fr.
      */
-    public contractClassLogsHashes: Tuple<ScopedCountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsHashes: ClaimedLengthArray<ScopedCountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Accumulated public call requests from all the previous kernel iterations.
      */
-    public publicCallRequests: Tuple<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
+    public publicCallRequests: ClaimedLengthArray<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     /**
      * Current private call stack.
      */
-    public privateCallStack: Tuple<PrivateCallRequest, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX>,
+    public privateCallStack: ClaimedLengthArray<PrivateCallRequest, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX>,
   ) {}
 
   toBuffer() {
@@ -80,13 +80,13 @@ export class PrivateAccumulatedData {
   static fromBuffer(buffer: Buffer | BufferReader): PrivateAccumulatedData {
     const reader = BufferReader.asReader(buffer);
     return new PrivateAccumulatedData(
-      reader.readArray(MAX_NOTE_HASHES_PER_TX, ScopedNoteHash),
-      reader.readArray(MAX_NULLIFIERS_PER_TX, ScopedNullifier),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedCountedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, ScopedPrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedCountedLogHash),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, CountedPublicCallRequest),
-      reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, PrivateCallRequest),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedNoteHash, MAX_NOTE_HASHES_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedNullifier, MAX_NULLIFIERS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedCountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedPrivateLogData, MAX_PRIVATE_LOGS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedCountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_TX)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX)),
     );
   }
 
@@ -101,13 +101,13 @@ export class PrivateAccumulatedData {
 
   static empty() {
     return new PrivateAccumulatedData(
-      makeTuple(MAX_NOTE_HASHES_PER_TX, ScopedNoteHash.empty),
-      makeTuple(MAX_NULLIFIERS_PER_TX, ScopedNullifier.empty),
-      makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedCountedL2ToL1Message.empty),
-      makeTuple(MAX_PRIVATE_LOGS_PER_TX, ScopedPrivateLogData.empty),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedCountedLogHash.empty),
-      makeTuple(MAX_ENQUEUED_CALLS_PER_TX, CountedPublicCallRequest.empty),
-      makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, PrivateCallRequest.empty),
+      ClaimedLengthArray.empty(ScopedNoteHash, MAX_NOTE_HASHES_PER_TX),
+      ClaimedLengthArray.empty(ScopedNullifier, MAX_NULLIFIERS_PER_TX),
+      ClaimedLengthArray.empty(ScopedCountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_TX),
+      ClaimedLengthArray.empty(ScopedPrivateLogData, MAX_PRIVATE_LOGS_PER_TX),
+      ClaimedLengthArray.empty(ScopedCountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      ClaimedLengthArray.empty(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_TX),
+      ClaimedLengthArray.empty(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX),
     );
   }
 }