@aztec/stdlib 1.2.0 → 2.0.0-nightly.20250813

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

package/src/kernel/private_call_data.ts

@@ -9,8 +9,8 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { DelayedPublicMutableValues } from '../delayed_public_mutable/delayed_public_mutable_values.js';
 import { PublicKeys } from '../keys/public_keys.js';
-import { SharedMutableValues } from '../shared_mutable/shared_mutable_values.js';
 import { ProtocolContractLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
 import { VerificationKeyAsFields } from '../vks/verification_key.js';
 import { PrivateCircuitPublicInputs } from './private_circuit_public_inputs.js';
@@ -162,7 +162,7 @@ export class UpdatedClassIdHints {
   constructor(
     public updatedClassIdWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
     public updatedClassIdLeaf: PublicDataTreeLeafPreimage,
-    public updatedClassIdValues: SharedMutableValues,
+    public updatedClassIdValues: DelayedPublicMutableValues,
   ) {}
 
   static getFields(fields: FieldsOf<UpdatedClassIdHints>) {
@@ -193,7 +193,7 @@ export class UpdatedClassIdHints {
       reader.readObject(PublicDataTreeLeafPreimage),
       reader.readObject({
         fromBuffer(reader) {
-          return SharedMutableValues.fromBuffer(reader, UPDATES_VALUE_SIZE);
+          return DelayedPublicMutableValues.fromBuffer(reader, UPDATES_VALUE_SIZE);
         },
       }),
     );

package/src/kernel/private_circuit_public_inputs.ts

@@ -9,15 +9,13 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
   MAX_PRIVATE_LOGS_PER_CALL,
-  PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import {
   BufferReader,
   FieldReader,
-  type Tuple,
+  bigintToUInt64BE,
   serializeToBuffer,
   serializeToFields,
 } from '@aztec/foundation/serialize';
@@ -30,13 +28,17 @@ import { PrivateLogData } from '../kernel/private_log_data.js';
 import { CountedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
-import { IncludeByTimestamp } from '../tx/include_by_timestamp.js';
 import { TxContext } from '../tx/tx_context.js';
+import type { UInt64 } from '../types/shared.js';
+import {
+  ClaimedLengthArray,
+  ClaimedLengthArrayFromBuffer,
+  ClaimedLengthArrayFromFields,
+} from './claimed_length_array.js';
 import { ReadRequest } from './hints/read_request.js';
 import { NoteHash } from './note_hash.js';
 import { Nullifier } from './nullifier.js';
 import { CountedPublicCallRequest, PublicCallRequest } from './public_call_request.js';
-import { isEmptyArray } from './utils/order_and_comparison.js';
 
 /**
  * Public inputs to a private circuit.
@@ -66,38 +68,38 @@ export class PrivateCircuitPublicInputs {
     /**
      * The highest timestamp of a block in which the transaction can still be included.
      */
-    public includeByTimestamp: IncludeByTimestamp,
+    public includeByTimestamp: UInt64,
     /**
      * Read requests created by the corresponding function call.
      */
-    public noteHashReadRequests: Tuple<ReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,
+    public noteHashReadRequests: ClaimedLengthArray<ReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,
     /**
      * Nullifier read requests created by the corresponding function call.
      */
-    public nullifierReadRequests: Tuple<ReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,
+    public nullifierReadRequests: ClaimedLengthArray<ReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,
     /**
      * Key validation requests and generators created by the corresponding function call.
      */
-    public keyValidationRequestsAndGenerators: Tuple<
+    public keyValidationRequestsAndGenerators: ClaimedLengthArray<
       KeyValidationRequestAndGenerator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_CALL
     >,
     /**
      * New note hashes created by the corresponding function call.
      */
-    public noteHashes: Tuple<NoteHash, typeof MAX_NOTE_HASHES_PER_CALL>,
+    public noteHashes: ClaimedLengthArray<NoteHash, typeof MAX_NOTE_HASHES_PER_CALL>,
     /**
      * New nullifiers created by the corresponding function call.
      */
-    public nullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_CALL>,
+    public nullifiers: ClaimedLengthArray<Nullifier, typeof MAX_NULLIFIERS_PER_CALL>,
     /**
      * Private call requests made within the current kernel iteration.
      */
-    public privateCallRequests: Tuple<PrivateCallRequest, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,
+    public privateCallRequests: ClaimedLengthArray<PrivateCallRequest, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,
     /**
      * Public call stack at the current kernel iteration.
      */
-    public publicCallRequests: Tuple<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_CALL>,
+    public publicCallRequests: ClaimedLengthArray<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_CALL>,
     /**
      * Hash of the public teardown function.
      */
@@ -105,15 +107,15 @@ export class PrivateCircuitPublicInputs {
     /**
      * New L2 to L1 messages created by the corresponding function call.
      */
-    public l2ToL1Msgs: Tuple<CountedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_CALL>,
+    public l2ToL1Msgs: ClaimedLengthArray<CountedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_CALL>,
     /**
      * Logs emitted in this function call.
      */
-    public privateLogs: Tuple<PrivateLogData, typeof MAX_PRIVATE_LOGS_PER_CALL>,
+    public privateLogs: ClaimedLengthArray<PrivateLogData, typeof MAX_PRIVATE_LOGS_PER_CALL>,
     /**
      * Hash of the contract class logs emitted in this function call.
      */
-    public contractClassLogsHashes: Tuple<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
+    public contractClassLogsHashes: ClaimedLengthArray<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
     /**
      * The side effect counter at the start of this call.
      */
@@ -158,18 +160,20 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readBoolean(),
-      reader.readObject(IncludeByTimestamp),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator),
-      reader.readArray(MAX_NOTE_HASHES_PER_CALL, NoteHash),
-      reader.readArray(MAX_NULLIFIERS_PER_CALL, Nullifier),
-      reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PrivateCallRequest),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_CALL, CountedPublicCallRequest),
+      reader.readUInt64(),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
+      reader.readObject(
+        ClaimedLengthArrayFromBuffer(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+      ),
+      reader.readObject(ClaimedLengthArrayFromBuffer(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(Nullifier, MAX_NULLIFIERS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
       reader.readObject(PublicCallRequest),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_CALL, CountedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash),
+      reader.readObject(ClaimedLengthArrayFromBuffer(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(BlockHeader),
@@ -185,18 +189,20 @@ export class PrivateCircuitPublicInputs {
       reader.readField(),
       reader.readField(),
       reader.readBoolean(),
-      reader.readObject(IncludeByTimestamp),
-      reader.readArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest),
-      reader.readArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest),
-      reader.readArray(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator),
-      reader.readArray(MAX_NOTE_HASHES_PER_CALL, NoteHash),
-      reader.readArray(MAX_NULLIFIERS_PER_CALL, Nullifier),
-      reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PrivateCallRequest),
-      reader.readArray(MAX_ENQUEUED_CALLS_PER_CALL, CountedPublicCallRequest),
+      reader.readU64(),
+      reader.readObject(ClaimedLengthArrayFromFields(ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
+      reader.readObject(
+        ClaimedLengthArrayFromFields(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+      ),
+      reader.readObject(ClaimedLengthArrayFromFields(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(Nullifier, MAX_NULLIFIERS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL)),
       reader.readObject(PublicCallRequest),
-      reader.readArray(MAX_L2_TO_L1_MSGS_PER_CALL, CountedL2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash),
+      reader.readObject(ClaimedLengthArrayFromFields(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL)),
       reader.readField(),
       reader.readField(),
       reader.readObject(BlockHeader),
@@ -215,18 +221,18 @@ export class PrivateCircuitPublicInputs {
       Fr.ZERO,
       Fr.ZERO,
       false,
-      IncludeByTimestamp.empty(),
-      makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, ReadRequest.empty),
-      makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, ReadRequest.empty),
-      makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, KeyValidationRequestAndGenerator.empty),
-      makeTuple(MAX_NOTE_HASHES_PER_CALL, NoteHash.empty),
-      makeTuple(MAX_NULLIFIERS_PER_CALL, Nullifier.empty),
-      makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PrivateCallRequest.empty),
-      makeTuple(MAX_ENQUEUED_CALLS_PER_CALL, CountedPublicCallRequest.empty),
+      0n,
+      ClaimedLengthArray.empty(ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(NoteHash, MAX_NOTE_HASHES_PER_CALL),
+      ClaimedLengthArray.empty(Nullifier, MAX_NULLIFIERS_PER_CALL),
+      ClaimedLengthArray.empty(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL),
+      ClaimedLengthArray.empty(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL),
       PublicCallRequest.empty(),
-      makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, CountedL2ToL1Message.empty),
-      makeTuple(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData.empty),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash.empty),
+      ClaimedLengthArray.empty(CountedL2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL),
+      ClaimedLengthArray.empty(PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL),
+      ClaimedLengthArray.empty(CountedLogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL),
       Fr.ZERO,
       Fr.ZERO,
       BlockHeader.empty(),
@@ -241,18 +247,18 @@ export class PrivateCircuitPublicInputs {
       this.returnsHash.isZero() &&
       this.minRevertibleSideEffectCounter.isZero() &&
       !this.isFeePayer &&
-      this.includeByTimestamp.isEmpty() &&
-      isEmptyArray(this.noteHashReadRequests) &&
-      isEmptyArray(this.nullifierReadRequests) &&
-      isEmptyArray(this.keyValidationRequestsAndGenerators) &&
-      isEmptyArray(this.noteHashes) &&
-      isEmptyArray(this.nullifiers) &&
-      isEmptyArray(this.privateCallRequests) &&
-      isEmptyArray(this.publicCallRequests) &&
+      !this.includeByTimestamp &&
+      this.noteHashReadRequests.isEmpty() &&
+      this.nullifierReadRequests.isEmpty() &&
+      this.keyValidationRequestsAndGenerators.isEmpty() &&
+      this.noteHashes.isEmpty() &&
+      this.nullifiers.isEmpty() &&
+      this.privateCallRequests.isEmpty() &&
+      this.publicCallRequests.isEmpty() &&
       this.publicTeardownCallRequest.isEmpty() &&
-      isEmptyArray(this.l2ToL1Msgs) &&
-      isEmptyArray(this.privateLogs) &&
-      isEmptyArray(this.contractClassLogsHashes) &&
+      this.l2ToL1Msgs.isEmpty() &&
+      this.privateLogs.isEmpty() &&
+      this.contractClassLogsHashes.isEmpty() &&
       this.startSideEffectCounter.isZero() &&
       this.endSideEffectCounter.isZero() &&
       this.historicalHeader.isEmpty() &&
@@ -296,20 +302,38 @@ export class PrivateCircuitPublicInputs {
    * @returns The buffer.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(...PrivateCircuitPublicInputs.getFields(this));
+    // TODO(#15525): Use the line below once UInt64 can be serialized correctly.
+    // return serializeToBuffer(...PrivateCircuitPublicInputs.getFields(this));
+    return serializeToBuffer([
+      this.callContext,
+      this.argsHash,
+      this.returnsHash,
+      this.minRevertibleSideEffectCounter,
+      this.isFeePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
+      this.noteHashReadRequests,
+      this.nullifierReadRequests,
+      this.keyValidationRequestsAndGenerators,
+      this.noteHashes,
+      this.nullifiers,
+      this.privateCallRequests,
+      this.publicCallRequests,
+      this.publicTeardownCallRequest,
+      this.l2ToL1Msgs,
+      this.privateLogs,
+      this.contractClassLogsHashes,
+      this.startSideEffectCounter,
+      this.endSideEffectCounter,
+      this.historicalHeader,
+      this.txContext,
+    ]);
   }
 
   /**
    * Serialize this as a field array.
    */
   toFields(): Fr[] {
-    const fields = serializeToFields(...PrivateCircuitPublicInputs.getFields(this));
-    if (fields.length !== PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH) {
-      throw new Error(
-        `Invalid number of fields for PrivateCircuitPublicInputs. Expected ${PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH}, got ${fields.length}`,
-      );
-    }
-    return fields;
+    return serializeToFields(...PrivateCircuitPublicInputs.getFields(this));
   }
 
   public toJSON() {

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -1,9 +1,10 @@
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
+import type { UInt64 } from '../types/shared.js';
 import { PrivateAccumulatedData } from './private_accumulated_data.js';
 import { PrivateValidationRequests } from './private_validation_requests.js';
 import { PublicCallRequest } from './public_call_request.js';
@@ -37,6 +38,10 @@ export class PrivateKernelCircuitPublicInputs {
      * The address of the fee payer for the transaction
      */
     public feePayer: AztecAddress,
+    /**
+     * The timestamp by which the transaction must be included in a block.
+     */
+    public includeByTimestamp: UInt64,
     /**
      * Wether this is a private only tx or not
      */
@@ -63,6 +68,7 @@ export class PrivateKernelCircuitPublicInputs {
       this.end,
       this.publicTeardownCallRequest,
       this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
       this.isPrivateOnly,
       this.claimedFirstNullifier,
     );
@@ -82,6 +88,7 @@ export class PrivateKernelCircuitPublicInputs {
       reader.readObject(PrivateAccumulatedData),
       reader.readObject(PublicCallRequest),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
       reader.readBoolean(),
       reader.readObject(Fr),
     );
@@ -95,6 +102,7 @@ export class PrivateKernelCircuitPublicInputs {
       PrivateAccumulatedData.empty(),
       PublicCallRequest.empty(),
       AztecAddress.ZERO,
+      0n,
       false,
       Fr.zero(),
     );

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

@@ -1,8 +1,8 @@
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { UInt64 } from '../types/shared.js';
 import { PaddedSideEffectAmounts } from './padded_side_effects.js';
 import { PrivateKernelData } from './private_kernel_data.js';
-import { countAccumulatedItems } from './utils/order_and_comparison.js';
 
 /**
  * Input to the private kernel circuit - tail call.
@@ -17,11 +17,15 @@ export class PrivateKernelTailCircuitPrivateInputs {
      * The number of the padded side effects.
      */
     public paddedSideEffectAmounts: PaddedSideEffectAmounts,
+    /**
+     * The timestamp by which the transaction must be included in a block.
+     */
+    public includeByTimestampUpperBound: UInt64,
   ) {}
 
   isForPublic() {
     return (
-      countAccumulatedItems(this.previousKernel.publicInputs.end.publicCallRequests) > 0 ||
+      this.previousKernel.publicInputs.end.publicCallRequests.claimedLength > 0 ||
       !this.previousKernel.publicInputs.publicTeardownCallRequest.isEmpty()
     );
   }
@@ -31,7 +35,11 @@ export class PrivateKernelTailCircuitPrivateInputs {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousKernel, this.paddedSideEffectAmounts);
+    return serializeToBuffer(
+      this.previousKernel,
+      this.paddedSideEffectAmounts,
+      bigintToUInt64BE(this.includeByTimestampUpperBound),
+    );
   }
 
   /**
@@ -44,6 +52,7 @@ export class PrivateKernelTailCircuitPrivateInputs {
     return new PrivateKernelTailCircuitPrivateInputs(
       reader.readObject(PrivateKernelData),
       reader.readObject(PaddedSideEffectAmounts),
+      reader.readUInt64(),
     );
   }
 }