@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/kernel/private_circuit_public_inputs.ts

@@ -0,0 +1,377 @@
+import {
+  MAX_CONTRACT_CLASS_LOGS_PER_CALL,
+  MAX_ENQUEUED_CALLS_PER_CALL,
+  MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PRIVATE_LOGS_PER_CALL,
+} from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt64BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
+import { CountedLogHash } from '../kernel/log_hash.js';
+import { PrivateCallRequest } from '../kernel/private_call_request.js';
+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 { TxContext } from '../tx/tx_context.js';
+import type { UInt64 } from '../types/shared.js';
+import {
+  ClaimedLengthArray,
+  ClaimedLengthArrayFromBuffer,
+  ClaimedLengthArrayFromFields,
+} from './claimed_length_array.js';
+import { ScopedReadRequest } from './hints/read_request.js';
+import { NoteHash } from './note_hash.js';
+import { Nullifier } from './nullifier.js';
+import { CountedPublicCallRequest, PublicCallRequest } from './public_call_request.js';
+
+/**
+ * Public inputs to a private circuit.
+ */
+export class PrivateCircuitPublicInputs {
+  constructor(
+    /**
+     * Context of the call corresponding to this private circuit execution.
+     */
+    public callContext: CallContext,
+    /**
+     * Pedersen hash of function arguments.
+     */
+    public argsHash: Fr,
+    /**
+     * Pedersen hash of the return values of the corresponding function call.
+     */
+    public returnsHash: Fr,
+    /**
+     * Header of a block whose state is used during private execution (not the block the transaction is included in).
+     */
+    public anchorBlockHeader: BlockHeader,
+    /**
+     * Transaction context.
+     *
+     * Note: The chainId and version in the txContext are not redundant to the values in self.anchor_block_header.global_variables because
+     * they can be different in case of a protocol upgrade. In such a situation we could be using header from a block
+     * before the upgrade took place but be using the updated protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
+    /**
+     * The side-effect counter under which all side effects are non-revertible.
+     */
+    public minRevertibleSideEffectCounter: Fr,
+    /**
+     * Whether the caller of the function is the fee payer.
+     */
+    public isFeePayer: boolean,
+    /**
+     * The highest timestamp of a block in which the transaction can still be included.
+     */
+    public expirationTimestamp: UInt64,
+    /**
+     * The side effect counter at the start of this call.
+     */
+    public startSideEffectCounter: Fr,
+    /**
+     * The end side effect counter for this call.
+     */
+    public endSideEffectCounter: Fr,
+    /**
+     * The expected non revertible side effect counter for this call.
+     */
+    public expectedNonRevertibleSideEffectCounter: Fr,
+    /**
+     * The expected revertible side effect counter for this call.
+     */
+    public expectedRevertibleSideEffectCounter: Fr,
+    /**
+     * Read requests created by the corresponding function call.
+     */
+    public noteHashReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,
+    /**
+     * Nullifier read requests created by the corresponding function call.
+     */
+    public nullifierReadRequests: ClaimedLengthArray<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,
+    /**
+     * Key validation requests and separators created by the corresponding function call.
+     */
+    public keyValidationRequestsAndSeparators: ClaimedLengthArray<
+      KeyValidationRequestAndSeparator,
+      typeof MAX_KEY_VALIDATION_REQUESTS_PER_CALL
+    >,
+    /**
+     * Private call requests made within the current kernel iteration.
+     */
+    public privateCallRequests: ClaimedLengthArray<PrivateCallRequest, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,
+    /**
+     * Public call stack at the current kernel iteration.
+     */
+    public publicCallRequests: ClaimedLengthArray<CountedPublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_CALL>,
+    /**
+     * Hash of the public teardown function.
+     */
+    public publicTeardownCallRequest: PublicCallRequest,
+    /**
+     * New note hashes created by the corresponding function call.
+     */
+    public noteHashes: ClaimedLengthArray<NoteHash, typeof MAX_NOTE_HASHES_PER_CALL>,
+    /**
+     * New nullifiers created by the corresponding function call.
+     */
+    public nullifiers: ClaimedLengthArray<Nullifier, typeof MAX_NULLIFIERS_PER_CALL>,
+    /**
+     * New L2 to L1 messages created by the corresponding function call.
+     */
+    public l2ToL1Msgs: ClaimedLengthArray<CountedL2ToL1Message, typeof MAX_L2_TO_L1_MSGS_PER_CALL>,
+    /**
+     * Logs emitted in this function call.
+     */
+    public privateLogs: ClaimedLengthArray<PrivateLogData, typeof MAX_PRIVATE_LOGS_PER_CALL>,
+    /**
+     * Hash of the contract class logs emitted in this function call.
+     */
+    public contractClassLogsHashes: ClaimedLengthArray<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
+    /**
+     * The tx request's salt. Keeps `tx_request.hash()` (the protocol nullifier) unpredictable, and lets the init
+     * kernel bind this proof to a specific tx request (it asserts this equals `tx_request.salt`).
+     */
+    public txRequestSalt: Fr,
+  ) {}
+
+  /**
+   * Create PrivateCircuitPublicInputs from a fields dictionary.
+   * @param fields - The dictionary.
+   * @returns A PrivateCircuitPublicInputs object.
+   */
+  static from(fields: FieldsOf<PrivateCircuitPublicInputs>): PrivateCircuitPublicInputs {
+    return new PrivateCircuitPublicInputs(...PrivateCircuitPublicInputs.getFields(fields));
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateCircuitPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateCircuitPublicInputs(
+      reader.readObject(CallContext),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readObject(Fr),
+      reader.readBoolean(),
+      reader.readUInt64(),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
+      reader.readObject(
+        ClaimedLengthArrayFromBuffer(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_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.readObject(ClaimedLengthArrayFromBuffer(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(Nullifier, MAX_NULLIFIERS_PER_CALL)),
+      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),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PrivateCircuitPublicInputs {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateCircuitPublicInputs(
+      reader.readObject(CallContext),
+      reader.readField(),
+      reader.readField(),
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readBoolean(),
+      reader.readU64(),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+      reader.readField(),
+      reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL)),
+      reader.readObject(
+        ClaimedLengthArrayFromFields(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_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.readObject(ClaimedLengthArrayFromFields(NoteHash, MAX_NOTE_HASHES_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(Nullifier, MAX_NULLIFIERS_PER_CALL)),
+      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(),
+    );
+  }
+
+  /**
+   * Create an empty PrivateCircuitPublicInputs.
+   * @returns An empty PrivateCircuitPublicInputs object.
+   */
+  public static empty(): PrivateCircuitPublicInputs {
+    return new PrivateCircuitPublicInputs(
+      CallContext.empty(),
+      Fr.ZERO,
+      Fr.ZERO,
+      BlockHeader.empty(),
+      TxContext.empty(),
+      Fr.ZERO,
+      false,
+      0n,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(KeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL),
+      ClaimedLengthArray.empty(CountedPublicCallRequest, MAX_ENQUEUED_CALLS_PER_CALL),
+      PublicCallRequest.empty(),
+      ClaimedLengthArray.empty(NoteHash, MAX_NOTE_HASHES_PER_CALL),
+      ClaimedLengthArray.empty(Nullifier, MAX_NULLIFIERS_PER_CALL),
+      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,
+    );
+  }
+
+  isEmpty() {
+    return (
+      this.callContext.isEmpty() &&
+      this.argsHash.isZero() &&
+      this.returnsHash.isZero() &&
+      this.anchorBlockHeader.isEmpty() &&
+      this.txContext.isEmpty() &&
+      this.minRevertibleSideEffectCounter.isZero() &&
+      !this.isFeePayer &&
+      !this.expirationTimestamp &&
+      this.startSideEffectCounter.isZero() &&
+      this.endSideEffectCounter.isZero() &&
+      this.expectedNonRevertibleSideEffectCounter.isZero() &&
+      this.expectedRevertibleSideEffectCounter.isZero() &&
+      this.noteHashReadRequests.isEmpty() &&
+      this.nullifierReadRequests.isEmpty() &&
+      this.keyValidationRequestsAndSeparators.isEmpty() &&
+      this.privateCallRequests.isEmpty() &&
+      this.publicCallRequests.isEmpty() &&
+      this.publicTeardownCallRequest.isEmpty() &&
+      this.noteHashes.isEmpty() &&
+      this.nullifiers.isEmpty() &&
+      this.l2ToL1Msgs.isEmpty() &&
+      this.privateLogs.isEmpty() &&
+      this.contractClassLogsHashes.isEmpty() &&
+      this.txRequestSalt.isZero()
+    );
+  }
+
+  /**
+   * Serialize into a field array. Low-level utility.
+   * @param fields - Object with fields.
+   * @returns The array.
+   */
+  static getFields(fields: FieldsOf<PrivateCircuitPublicInputs>) {
+    return [
+      fields.callContext,
+      fields.argsHash,
+      fields.returnsHash,
+      fields.anchorBlockHeader,
+      fields.txContext,
+      fields.minRevertibleSideEffectCounter,
+      fields.isFeePayer,
+      fields.expirationTimestamp,
+      fields.startSideEffectCounter,
+      fields.endSideEffectCounter,
+      fields.expectedNonRevertibleSideEffectCounter,
+      fields.expectedRevertibleSideEffectCounter,
+      fields.noteHashReadRequests,
+      fields.nullifierReadRequests,
+      fields.keyValidationRequestsAndSeparators,
+      fields.privateCallRequests,
+      fields.publicCallRequests,
+      fields.publicTeardownCallRequest,
+      fields.noteHashes,
+      fields.nullifiers,
+      fields.l2ToL1Msgs,
+      fields.privateLogs,
+      fields.contractClassLogsHashes,
+      fields.txRequestSalt,
+    ] as const;
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer(): Buffer {
+    // 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.anchorBlockHeader,
+      this.txContext,
+      this.minRevertibleSideEffectCounter,
+      this.isFeePayer,
+      bigintToUInt64BE(this.expirationTimestamp),
+      this.startSideEffectCounter,
+      this.endSideEffectCounter,
+      this.expectedNonRevertibleSideEffectCounter,
+      this.expectedRevertibleSideEffectCounter,
+      this.noteHashReadRequests,
+      this.nullifierReadRequests,
+      this.keyValidationRequestsAndSeparators,
+      this.privateCallRequests,
+      this.publicCallRequests,
+      this.publicTeardownCallRequest,
+      this.noteHashes,
+      this.nullifiers,
+      this.l2ToL1Msgs,
+      this.privateLogs,
+      this.contractClassLogsHashes,
+      this.txRequestSalt,
+    ]);
+  }
+
+  /**
+   * Serialize this as a field array.
+   */
+  toFields(): Fr[] {
+    return serializeToFields(...PrivateCircuitPublicInputs.getFields(this));
+  }
+
+  public toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PrivateCircuitPublicInputs);
+  }
+}

package/src/kernel/private_context_inputs.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { serializeToFields } from '@aztec-labs/foundation/serialize';
+
+import { BlockHeader } from '../tx/block_header.js';
+import { CallContext } from '../tx/call_context.js';
+import { TxContext } from '../tx/tx_context.js';
+
+export class PrivateContextInputs {
+  constructor(
+    public callContext: CallContext,
+    public anchorBlockHeader: BlockHeader,
+    public txContext: TxContext,
+    public startSideEffectCounter: number,
+    public txRequestSalt: Fr,
+  ) {}
+
+  public static empty(): PrivateContextInputs {
+    return new PrivateContextInputs(CallContext.empty(), BlockHeader.empty(), TxContext.empty(), 0, Fr.ZERO);
+  }
+
+  public toFields(): Fr[] {
+    return serializeToFields([
+      this.callContext,
+      this.anchorBlockHeader,
+      this.txContext,
+      this.startSideEffectCounter,
+      this.txRequestSalt,
+    ]);
+  }
+}

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -0,0 +1,119 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { PrivateTxConstantData } from '../tx/private_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';
+
+/**
+ * Public inputs to the inner private kernel circuit
+ */
+export class PrivateKernelCircuitPublicInputs {
+  constructor(
+    /**
+     * Data which is not modified by the circuits.
+     */
+    public constants: PrivateTxConstantData,
+    /**
+     * The side effect counter that non-revertible side effects are all beneath.
+     */
+    public minRevertibleSideEffectCounter: Fr,
+    /**
+     * Validation requests accumulated from public functions.
+     */
+    public validationRequests: PrivateValidationRequests,
+    /**
+     * Data accumulated from both public and private circuits.
+     */
+    public end: PrivateAccumulatedData,
+    /**
+     * The call request for the public teardown function
+     */
+    public publicTeardownCallRequest: PublicCallRequest,
+    /**
+     * 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 expirationTimestamp: UInt64,
+    /**
+     * Wether this is a private only tx or not
+     */
+    public isPrivateOnly: boolean,
+    /**
+     * A claim to the final min revertible side effect counter of a tx.
+     */
+    public claimedRevertibleCounter: number,
+  ) {}
+
+  static get schema() {
+    return bufferSchemaFor(PrivateKernelCircuitPublicInputs);
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.constants,
+      this.minRevertibleSideEffectCounter,
+      this.validationRequests,
+      this.end,
+      this.publicTeardownCallRequest,
+      this.feePayer,
+      bigintToUInt64BE(this.expirationTimestamp),
+      this.isPrivateOnly,
+      this.claimedRevertibleCounter,
+    );
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns A new instance of PrivateKernelInnerCircuitPublicInputs.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelCircuitPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelCircuitPublicInputs(
+      reader.readObject(PrivateTxConstantData),
+      reader.readObject(Fr),
+      reader.readObject(PrivateValidationRequests),
+      reader.readObject(PrivateAccumulatedData),
+      reader.readObject(PublicCallRequest),
+      reader.readObject(AztecAddress),
+      reader.readUInt64(),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+
+  static empty() {
+    return new PrivateKernelCircuitPublicInputs(
+      PrivateTxConstantData.empty(),
+      Fr.zero(),
+      PrivateValidationRequests.empty(),
+      PrivateAccumulatedData.empty(),
+      PublicCallRequest.empty(),
+      AztecAddress.ZERO,
+      0n,
+      false,
+      0,
+    );
+  }
+}
+
+/**
+ * Returns true iff the tx requires the public-bound terminal path: it has either un-processed
+ * public-call requests in the side-effect stream or a pending public-teardown call request. Every
+ * site picking between the rollup-bound and public-bound terminal artifact must route through this.
+ */
+export function kernelStateIsForPublic(publicInputs: PrivateKernelCircuitPublicInputs): boolean {
+  return publicInputs.end.publicCallRequests.claimedLength > 0 || !publicInputs.publicTeardownCallRequest.isEmpty();
+}

package/src/kernel/private_kernel_data.ts

@@ -0,0 +1,37 @@
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { VkData } from '../vks/index.js';
+import { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
+
+/**
+ * Data of the previous kernel iteration in the chain of kernels.
+ */
+export class PrivateKernelData {
+  constructor(
+    /**
+     * Public inputs of the previous kernel.
+     */
+    public publicInputs: PrivateKernelCircuitPublicInputs,
+    /**
+     * The verification key and the witness of the vk in the vk tree.
+     */
+    public vkData: VkData,
+  ) {}
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.publicInputs, this.vkData);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelData {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readObject(PrivateKernelCircuitPublicInputs), reader.readObject(VkData));
+  }
+
+  static empty(): PrivateKernelData {
+    return new PrivateKernelData(PrivateKernelCircuitPublicInputs.empty(), VkData.empty());
+  }
+}

package/src/kernel/private_kernel_init_2_circuit_private_inputs.ts

@@ -0,0 +1,46 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first two app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit2CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit2CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit2CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_3_circuit_private_inputs.ts

@@ -0,0 +1,49 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first three app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit3CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit3CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit3CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}