@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/kernel/claimed_length_array.ts

@@ -0,0 +1,104 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+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/hiding_kernel_private_inputs.ts

@@ -0,0 +1,37 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { VkData } from '../vks/index.js';
+import { PrivateToPublicKernelCircuitPublicInputs } from './private_to_public_kernel_circuit_public_inputs.js';
+import { PrivateToRollupKernelCircuitPublicInputs } from './private_to_rollup_kernel_circuit_public_inputs.js';
+
+export class HidingKernelToRollupPrivateInputs {
+  constructor(
+    public previousKernelPublicInputs: PrivateToRollupKernelCircuitPublicInputs,
+    public previousKernelVkData: VkData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernelPublicInputs, this.previousKernelVkData);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readObject(PrivateToRollupKernelCircuitPublicInputs), reader.readObject(VkData));
+  }
+}
+
+export class HidingKernelToPublicPrivateInputs {
+  constructor(
+    public previousKernelPublicInputs: PrivateToPublicKernelCircuitPublicInputs,
+    public previousKernelVkData: VkData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernelPublicInputs, this.previousKernelVkData);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readObject(PrivateToPublicKernelCircuitPublicInputs), reader.readObject(VkData));
+  }
+}

package/src/kernel/hints/build_note_hash_read_request_hints.ts

@@ -3,14 +3,14 @@ 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 { Fr } from '@aztec/foundation/curves/bn254';
 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 +21,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,60 +38,68 @@ 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>>;
+    getNoteHashMembershipWitness(noteHash: Fr): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
   },
-  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>,
-  noteHashLeafIndexMap: Map<bigint, bigint>,
+  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>,
   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];
-      const leafIndex = noteHashLeafIndexMap.get(readRequest.value.toBigInt());
-      if (leafIndex === undefined) {
-        throw new Error('Read request is reading an unknown note hash.');
-      }
-      const membershipWitness = await oracle.getNoteHashMembershipWitness(leafIndex);
-      builder.addSettledReadRequest(i, membershipWitness, readRequest.value);
+  // Collect all settled read requests
+  const settledRequests: { index: number; readRequest: ScopedReadRequest }[] = [];
+  for (let i = 0; i < resetActions.actions.length; i++) {
+    if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+      settledRequests.push({ index: i, readRequest: noteHashReadRequests.array[i] });
     }
   }
 
+  // Fetch all membership witnesses in parallel
+  const membershipWitnesses = await Promise.all(
+    settledRequests.map(({ readRequest }) => oracle.getNoteHashMembershipWitness(readRequest.value)),
+  );
+
+  // Add settled read requests to builder
+  for (let i = 0; i < settledRequests.length; i++) {
+    const membershipWitness = membershipWitnesses[i];
+    if (!membershipWitness) {
+      throw new Error('Read request is reading an unknown note hash.');
+    }
+    builder.addSettledReadRequest(settledRequests[i].index, membershipWitness, settledRequests[i].readRequest.value);
+  }
+
   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 });
@@ -103,22 +111,20 @@ export async function buildNoteHashReadRequestHintsFromResetStates<PENDING exten
 
 export async function buildNoteHashReadRequestHints<PENDING extends number, SETTLED extends number>(
   oracle: {
-    getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
+    getNoteHashMembershipWitness(noteHash: Fr): 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>,
-  noteHashLeafIndexMap: Map<bigint, bigint>,
+  noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  noteHashes: ClaimedLengthArray<ScopedNoteHash, typeof MAX_NOTE_HASHES_PER_TX>,
   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,
-    noteHashLeafIndexMap,
+    resetActions,
     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 { Fr } from '@aztec/foundation/curves/bn254';
+import { MembershipWitness } from '@aztec/foundation/trees';
+
+import type { NullifierLeafPreimage } from '../../trees/nullifier_leaf.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) {
@@ -27,18 +24,18 @@ export function isValidNullifierReadRequest(readRequest: ScopedReadRequest, null
 
 interface NullifierMembershipWitnessWithPreimage {
   membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>;
-  leafPreimage: IndexedTreeLeafPreimage;
+  leafPreimage: NullifierLeafPreimage;
 }
 
-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,60 +44,64 @@ 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];
-      const siloedValue = siloed
-        ? readRequest.value
-        : await siloNullifier(readRequest.contractAddress, readRequest.value);
-      const membershipWitnessWithPreimage = await oracle.getNullifierMembershipWitness(siloedValue);
-      builder.addSettledReadRequest(
-        i,
-        membershipWitnessWithPreimage.membershipWitness,
-        membershipWitnessWithPreimage.leafPreimage,
-      );
+  // Collect all settled read requests
+  const settledRequests: { index: number; readRequest: ScopedReadRequest }[] = [];
+  for (let i = 0; i < resetActions.actions.length; i++) {
+    if (resetActions.actions[i] === ReadRequestActionEnum.READ_AS_SETTLED) {
+      settledRequests.push({ index: i, readRequest: nullifierReadRequests.array[i] });
     }
   }
 
+  const siloedValues = settledRequests.map(({ readRequest }) => readRequest.value);
+
+  // Fetch all membership witnesses in parallel
+  const membershipWitnesses = await Promise.all(siloedValues.map(value => oracle.getNullifierMembershipWitness(value)));
+
+  // Add settled read requests to builder
+  for (let i = 0; i < settledRequests.length; i++) {
+    builder.addSettledReadRequest(
+      settledRequests[i].index,
+      membershipWitnesses[i].membershipWitness,
+      membershipWitnesses[i].leafPreimage,
+    );
+  }
+
   return builder.toHints();
 }
 
@@ -108,46 +109,18 @@ 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> } {
+  splitCounter: number,
+): { 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,9 +42,9 @@ 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) {
+    if (noteHash.counter < splitCounter && nullifier.counter >= splitCounter) {
       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/find_private_kernel_reset_dimensions.ts

@@ -1,3 +1,5 @@
+import { isDefined } from '@aztec/foundation/types';
+
 import {
   PrivateKernelResetDimensions,
   type PrivateKernelResetDimensionsConfig,
@@ -10,10 +12,6 @@ interface DimensionOption {
   remainder?: PrivateKernelResetDimensions;
 }
 
-function isDefined<T>(value: T | undefined): value is T {
-  return value !== undefined;
-}
-
 function computeCost(dimensions: PrivateKernelResetDimensions, config: PrivateKernelResetDimensionsConfig) {
   return privateKernelResetDimensionNames.reduce(
     (accum, name) => accum + dimensions[name] * config.dimensions[name].cost,
@@ -148,9 +146,9 @@ export function findPrivateKernelResetDimensions(
     ? isEnough
     : // If isInner is true, it's a reset to prevent overflow. The following must be zero because siloing can't be done at the moment.
       (dimensions: PrivateKernelResetDimensions) =>
-        dimensions.NOTE_HASH_SILOING_AMOUNT === 0 &&
-        dimensions.NULLIFIER_SILOING_AMOUNT === 0 &&
-        dimensions.PRIVATE_LOG_SILOING_AMOUNT === 0 &&
+        dimensions.NOTE_HASH_SILOING === 0 &&
+        dimensions.NULLIFIER_SILOING === 0 &&
+        dimensions.PRIVATE_LOG_SILOING === 0 &&
         isEnough(dimensions);
 
   const options = [

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/key_validation_hint.ts

@@ -1,24 +1,22 @@
-import { GrumpkinScalar } from '@aztec/foundation/fields';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class KeyValidationHint {
   constructor(
     /** Master secret key used to derive sk_app and pk_m. */
     public skM: GrumpkinScalar,
-    /** Index of the request in the array of hints. */
-    public requestIndex: number,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new KeyValidationHint(reader.readObject(GrumpkinScalar), reader.readNumber());
+    return new KeyValidationHint(reader.readObject(GrumpkinScalar));
   }
 
   toBuffer() {
-    return serializeToBuffer(this.skM, this.requestIndex);
+    return serializeToBuffer(this.skM);
   }
 
-  static nada(keyValidationRequestLen: number) {
-    return new KeyValidationHint(GrumpkinScalar.zero(), keyValidationRequestLen);
+  static empty() {
+    return new KeyValidationHint(GrumpkinScalar.zero());
   }
 }

package/src/kernel/hints/key_validation_request.ts

@@ -1,5 +1,6 @@
 import { KEY_VALIDATION_REQUEST_LENGTH } from '@aztec/constants';
-import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**