@aztec/stdlib 1.2.1 → 2.0.0-nightly.20250813

package/src/contract/interfaces/protocol_contract_addresses.ts

@@ -3,23 +3,18 @@ import { z } from 'zod';
 import type { AztecAddress } from '../../aztec-address/index.js';
 import { schemas } from '../../schemas/index.js';
 
-export const ProtocolContractsNames = [
-  'classRegisterer',
-  'feeJuice',
-  'instanceDeployer',
-  'multiCallEntrypoint',
-] as const;
+export const ProtocolContractsNames = ['classRegistry', 'feeJuice', 'instanceRegistry', 'multiCallEntrypoint'] as const;
 
 export type ProtocolContractAddresses = {
-  classRegisterer: AztecAddress;
+  classRegistry: AztecAddress;
   feeJuice: AztecAddress;
-  instanceDeployer: AztecAddress;
+  instanceRegistry: AztecAddress;
   multiCallEntrypoint: AztecAddress;
 };
 
 export const ProtocolContractAddressesSchema = z.object({
-  classRegisterer: schemas.AztecAddress,
+  classRegistry: schemas.AztecAddress,
   feeJuice: schemas.AztecAddress,
-  instanceDeployer: schemas.AztecAddress,
+  instanceRegistry: schemas.AztecAddress,
   multiCallEntrypoint: schemas.AztecAddress,
 });

package/src/contract/private_function_membership_proof.ts

@@ -91,7 +91,7 @@ export async function createPrivateFunctionMembershipProof(
 }
 
 /**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * Verifies that a private function with a membership proof as emitted by the ClassRegistry contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```

package/src/contract/utility_function_membership_proof.ts

@@ -66,7 +66,7 @@ export async function createUtilityFunctionMembershipProof(
 }
 
 /**
- * Verifies that a utility  function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```

package/src/{shared_mutable/shared_mutable_values.ts → delayed_public_mutable/delayed_public_mutable_values.ts}

@@ -6,9 +6,9 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 import { ScheduledDelayChange } from './scheduled_delay_change.js';
 import { ScheduledValueChange } from './scheduled_value_change.js';
 
-export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+export const DELAYED_PUBLIC_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
 
-export class SharedMutableValues {
+export class DelayedPublicMutableValues {
   constructor(
     public svc: ScheduledValueChange,
     public sdc: ScheduledDelayChange,
@@ -58,32 +58,32 @@ export class SharedMutableValues {
     return serializeToBuffer(this.toFields());
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): SharedMutableValues {
+  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): DelayedPublicMutableValues {
     const reader = BufferReader.asReader(buffer);
-    return SharedMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+    return DelayedPublicMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
   }
 
   static empty(valueSize: number) {
     return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
   }
 
-  static async readFromTree(sharedMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
+  static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
     const fields = [];
-    for (let i = 0; i < SHARED_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(sharedMutableSlot.add(new Fr(i))));
+    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
+      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
     }
-    return SharedMutableValues.fromFields(fields);
+    return DelayedPublicMutableValues.fromFields(fields);
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
     const fields = this.toFields();
 
     for (let i = 0; i < fields.length; i++) {
-      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
     }
   }
 

package/src/delayed_public_mutable/delayed_public_mutable_values_with_hash.ts

@@ -0,0 +1,38 @@
+import { UPDATED_CLASS_IDS_SLOT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { deriveStorageSlotInMap } from '../hash/map_slot.js';
+import { DELAYED_PUBLIC_MUTABLE_VALUES_LEN, DelayedPublicMutableValues } from './delayed_public_mutable_values.js';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+
+export class DelayedPublicMutableValuesWithHash {
+  private dpmv: DelayedPublicMutableValues;
+
+  constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange) {
+    this.dpmv = new DelayedPublicMutableValues(svc, sdc);
+  }
+
+  async toFields(): Promise<Fr[]> {
+    return [...this.dpmv.toFields(), await this.dpmv.hash()];
+  }
+
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = await this.toFields();
+
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
+    }
+  }
+
+  static async getContractUpdateSlots(contractAddress: AztecAddress) {
+    const delayedPublicMutableSlot = await deriveStorageSlotInMap(new Fr(UPDATED_CLASS_IDS_SLOT), contractAddress);
+    const delayedPublicMutableHashSlot = delayedPublicMutableSlot.add(new Fr(DELAYED_PUBLIC_MUTABLE_VALUES_LEN));
+
+    return {
+      delayedPublicMutableSlot,
+      delayedPublicMutableHashSlot,
+    };
+  }
+}

package/src/delayed_public_mutable/index.ts

@@ -0,0 +1,4 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './delayed_public_mutable_values.js';
+export * from './delayed_public_mutable_values_with_hash.js';

package/src/gas/gas.ts

@@ -28,6 +28,10 @@ export class Gas {
       .transform(Gas.from);
   }
 
+  getSize() {
+    return 4 /* daGas */ + 4 /* l2Gas */;
+  }
+
   clone(): Gas {
     return new Gas(this.daGas, this.l2Gas);
   }

package/src/hash/hash.ts

@@ -1,5 +1,4 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { poseidon2Hash, poseidon2HashWithSeparator, sha256ToField } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -13,9 +12,7 @@ import type { AztecAddress } from '../aztec-address/index.js';
  */
 export async function hashVK(keyAsFields: Fr[]): Promise<Fr> {
   // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
-  const hash = (await poseidon2Hash(keyAsFields)).toBuffer();
-  // Taking the last 16 bytes (128 bits) of the hash.
-  return new Fr(toBigIntBE(hash.subarray(Fr.SIZE_IN_BYTES - 16)));
+  return await poseidon2Hash(keyAsFields);
 }
 
 /**

package/src/interfaces/archiver.ts

@@ -3,7 +3,7 @@ import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import { L2Block } from '../block/l2_block.js';
-import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
+import { type L2BlockSource, L2TipsSchema, ValidateBlockResultSchema } from '../block/l2_block_source.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
 import {
   ContractClassPublicSchema,
@@ -75,4 +75,6 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
   getL1Timestamp: z.function().args().returns(schemas.BigInt),
   syncImmediate: z.function().args().returns(z.void()),
+  isPendingChainInvalid: z.function().args().returns(z.boolean()),
+  getPendingChainValidationStatus: z.function().args().returns(ValidateBlockResultSchema),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -3,6 +3,7 @@ import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rp
 import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/schemas.js';
+import { type MonitoredSlashPayload, MonitoredSlashPayloadSchema } from '../slashing/index.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
 import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
@@ -13,16 +14,15 @@ import { type SlasherConfig, SlasherConfigSchema } from './slasher.js';
  */
 export interface AztecNodeAdmin {
   /**
-   * Updates the configuration of this node.
-   * @param config - Updated configuration to be merged with the current one.
+   * Retrieves the configuration of this node.
    */
-  setConfig(config: Partial<SequencerConfig & ProverConfig & SlasherConfig & { maxTxPoolSize: number }>): Promise<void>;
+  getConfig(): Promise<AztecNodeAdminConfig>;
 
   /**
-   * Forces the next block to be built bypassing all time and pending checks.
-   * Useful for testing.
+   * Updates the configuration of this node.
+   * @param config - Updated configuration to be merged with the current one.
    */
-  flushTxs(): Promise<void>;
+  setConfig(config: Partial<AztecNodeAdminConfig>): Promise<void>;
 
   /**
    * Pauses syncing, creates a backup of archiver and world-state databases, and uploads them. Returns immediately.
@@ -42,18 +42,25 @@ export interface AztecNodeAdmin {
 
   /** Resumes archiver and world state syncing. */
   resumeSync(): Promise<void>;
+
+  /** Returns all monitored payloads by the slasher. */
+  getSlasherMonitoredPayloads(): Promise<MonitoredSlashPayload[]>;
 }
 
+export type AztecNodeAdminConfig = SequencerConfig & ProverConfig & SlasherConfig & { maxTxPoolSize: number };
+
+export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
+  .merge(SlasherConfigSchema)
+  .merge(z.object({ maxTxPoolSize: z.number() }));
+
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
-  setConfig: z
-    .function()
-    .args(SequencerConfigSchema.merge(ProverConfigSchema).merge(SlasherConfigSchema).partial())
-    .returns(z.void()),
-  flushTxs: z.function().returns(z.void()),
+  getConfig: z.function().returns(AztecNodeAdminConfigSchema),
+  setConfig: z.function().args(AztecNodeAdminConfigSchema.partial()).returns(z.void()),
   startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
   rollbackTo: z.function().args(z.number()).returns(z.void()),
   pauseSync: z.function().returns(z.void()),
   resumeSync: z.function().returns(z.void()),
+  getSlasherMonitoredPayloads: z.function().returns(z.array(MonitoredSlashPayloadSchema)),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/configs.ts

@@ -40,6 +40,18 @@ export interface SequencerConfig {
   enforceTimeTable?: boolean;
   /** How many seconds into an L1 slot we can still send a tx and get it mined. */
   maxL1TxInclusionTimeIntoSlot?: number;
+  /** Used for testing to introduce a fake delay after processing each tx */
+  fakeProcessingDelayPerTxMs?: number;
+  /** How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way) */
+  attestationPropagationTime?: number;
+  /** How many seconds before invalidating a block as a committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsCommitteeMember?: number;
+  /** How many seconds before invalidating a block as a non-committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember?: number;
+  /** Skip collecting attestations (for testing only) */
+  skipCollectingAttestations?: boolean;
+  /** Do not invalidate the previous block if invalid when we are the proposer (for testing only) */
+  skipInvalidateBlockAsProposer?: boolean;
 }
 
 export const SequencerConfigSchema = z.object({
@@ -58,4 +70,9 @@ export const SequencerConfigSchema = z.object({
   governanceProposerPayload: schemas.EthAddress.optional(),
   maxL1TxInclusionTimeIntoSlot: z.number().optional(),
   enforceTimeTable: z.boolean().optional(),
+  fakeProcessingDelayPerTxMs: z.number().optional(),
+  attestationPropagationTime: z.number().optional(),
+  skipCollectingAttestations: z.boolean().optional(),
+  secondsBeforeInvalidatingBlockAsCommitteeMember: z.number(),
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.number(),
 }) satisfies ZodFor<SequencerConfig>;

package/src/interfaces/pxe.ts

@@ -125,6 +125,8 @@ export interface PXE {
    * This is called by aztec.js when instantiating a contract in a given address with a mismatching artifact.
    * @param contractAddress - The address of the contract to update.
    * @param artifact - The updated artifact for the contract.
+   * @throws If the artifact's contract class is not found in the PXE or if the contract class is different from
+   * the current one (current one from the point of view of the node to which the PXE is connected).
    */
   updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void>;
 
@@ -417,7 +419,7 @@ export interface PXEInfo {
 export interface ContractMetadata {
   contractInstance?: ContractInstanceWithAddress | undefined;
   isContractInitialized: boolean;
-  isContractPubliclyDeployed: boolean;
+  isContractPublished: boolean;
 }
 
 export interface ContractClassMetadata {
@@ -429,7 +431,7 @@ export interface ContractClassMetadata {
 const ContractMetadataSchema = z.object({
   contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
   isContractInitialized: z.boolean(),
-  isContractPubliclyDeployed: z.boolean(),
+  isContractPublished: z.boolean(),
 }) satisfies ZodFor<ContractMetadata>;
 
 const ContractClassMetadataSchema = z.object({

package/src/interfaces/server.ts

@@ -20,5 +20,5 @@ export * from './proving-job.js';
 export * from './server_circuit_prover.js';
 export * from './service.js';
 export * from './slasher.js';
-export * from './tx-collector.js';
+export * from './tx_provider.js';
 export * from './world_state.js';

package/src/interfaces/slasher.ts

@@ -1,3 +1,4 @@
+import type { SecretValue } from '@aztec/foundation/config';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 
@@ -18,6 +19,11 @@ export interface SlasherConfig {
   slashInactivityCreatePenalty: bigint;
   slashInactivityMaxPenalty: bigint;
   slashProposerRoundPollingIntervalSeconds: number;
+  slashProposeInvalidAttestationsPenalty: bigint;
+  slashProposeInvalidAttestationsMaxPenalty: bigint;
+  slashAttestDescendantOfInvalidPenalty: bigint;
+  slashAttestDescendantOfInvalidMaxPenalty: bigint;
+  slasherPrivateKey: SecretValue<string | undefined>; // Private key of the slasher account used for creating slash payloads
 }
 
 export const SlasherConfigSchema = z.object({
@@ -35,4 +41,9 @@ export const SlasherConfigSchema = z.object({
   slashInactivityCreatePenalty: schemas.BigInt,
   slashInactivityMaxPenalty: schemas.BigInt,
   slashProposerRoundPollingIntervalSeconds: z.number(),
+  slashProposeInvalidAttestationsPenalty: schemas.BigInt,
+  slashProposeInvalidAttestationsMaxPenalty: schemas.BigInt,
+  slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
+  slashAttestDescendantOfInvalidMaxPenalty: schemas.BigInt,
+  slasherPrivateKey: schemas.SecretValue(z.string().optional()),
 }) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/tx_provider.ts

@@ -0,0 +1,16 @@
+import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+export interface ITxProvider {
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+
+  getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+
+  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+}

package/src/kernel/claimed_length_array.ts

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

package/src/kernel/hints/build_note_hash_read_request_hints.ts

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