@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/interfaces/world_state.ts

@@ -1,7 +1,12 @@
+import type { PromiseWithResolvers } from '@aztec/foundation/promise';
+
 import { z } from 'zod';
 
+import type { SnapshotDataKeys } from '../snapshots/types.js';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from './merkle_tree_operations.js';
 
+export type { SnapshotDataKeys };
+
 /**
  * Defines the possible states of the world state synchronizer.
  */
@@ -15,7 +20,7 @@ export enum WorldStateRunningState {
 export interface WorldStateSyncStatus {
   latestBlockNumber: number;
   latestBlockHash: string;
-  finalisedBlockNumber: number;
+  finalizedBlockNumber: number;
   oldestHistoricBlockNumber: number;
   treesAreSynched: boolean;
 }
@@ -41,42 +46,45 @@ export interface ForkMerkleTreeOperations {
 
   /** Gets a handle that allows reading the state as it was at the given block number. */
   getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+
+  /** Backups the db to the target path. */
+  backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
 }
 
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
-  /**
-   * Starts the synchronizer.
-   * @returns A promise that resolves once the initial sync is completed.
-   */
-  start(): void;
+  /** Starts the synchronizer. */
+  start(): Promise<void | PromiseWithResolvers<void>>;
 
-  /**
-   * Returns the current status of the synchronizer.
-   * @returns The current status of the synchronizer.
-   */
+  /** Returns the current status of the synchronizer. */
   status(): Promise<WorldStateSynchronizerStatus>;
 
-  /**
-   * Stops the synchronizer.
-   */
+  /** Stops the synchronizer and its database. */
   stop(): Promise<void>;
 
+  /** Stops the synchronizer from syncing, but keeps the database online. */
+  stopSync(): Promise<void>;
+
+  /** Resumes synching after a stopSync call. */
+  resumeSync(): void;
+
   /**
    * Forces an immediate sync to an optionally provided minimum block number
-   * @param minBlockNumber - The minimum block number that we must sync to
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  syncImmediate(minBlockNumber?: number): Promise<number>;
+  syncImmediate(minBlockNumber?: number, skipThrowIfTargetNotReached?: boolean): Promise<number>;
 
-  /**
-   * Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data.
-   */
+  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
   getCommitted(): MerkleTreeReadOperations;
+
+  /** Deletes the db */
+  clear(): Promise<void>;
 }
 
 export const WorldStateSyncStatusSchema = z.object({
-  finalisedBlockNumber: z.number().int().nonnegative(),
+  finalizedBlockNumber: z.number().int().nonnegative(),
   latestBlockNumber: z.number().int().nonnegative(),
   latestBlockHash: z.string(),
   oldestHistoricBlockNumber: z.number().int().nonnegative(),

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/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,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/find_private_kernel_reset_dimensions.ts

@@ -148,9 +148,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

@@ -5,20 +5,18 @@ 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());
   }
 }