@aztec/stdlib 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/kernel/index.ts

@@ -7,10 +7,18 @@ export * from './private_call_data.js';
 export * from './private_kernel_circuit_public_inputs.js';
 export * from './private_kernel_data.js';
 export * from './private_kernel_init_circuit_private_inputs.js';
+export * from './private_kernel_init_2_circuit_private_inputs.js';
+export * from './private_kernel_init_3_circuit_private_inputs.js';
+export * from './private_kernel_init_4_circuit_private_inputs.js';
+export * from './private_kernel_init_5_circuit_private_inputs.js';
 export * from './private_kernel_inner_circuit_private_inputs.js';
+export * from './private_kernel_inner_2_circuit_private_inputs.js';
+export * from './private_kernel_inner_3_circuit_private_inputs.js';
+export * from './private_kernel_inner_4_circuit_private_inputs.js';
+export * from './private_kernel_inner_5_circuit_private_inputs.js';
 export * from './private_kernel_reset_circuit_private_inputs.js';
 export * from './private_kernel_reset_dimensions.js';
-export * from './private_kernel_tail_circuit_private_inputs.js';
+export * from './private_kernel_reset_tail_circuit_private_inputs.js';
 export * from './private_kernel_tail_circuit_public_inputs.js';
 export * from './private_to_avm_accumulated_data.js';
 export * from './private_to_public_accumulated_data.js';

package/src/kernel/log_hash.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -33,8 +33,13 @@ export class LogHash {
     return new LogHash(Fr.zero(), 0);
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.length);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.value, this.length);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -78,8 +83,13 @@ export class CountedLogHash {
     return new CountedLogHash(LogHash.empty(), 0);
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.logHash, this.counter);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.logHash, this.counter);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -104,7 +114,7 @@ export class ScopedLogHash {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedLogHash(reader.readObject(LogHash), AztecAddress.fromField(reader.readField()));
+    return new ScopedLogHash(reader.readObject(LogHash), AztecAddress.fromFieldUnsafe(reader.readField()));
   }
 
   isEmpty() {
@@ -115,8 +125,13 @@ export class ScopedLogHash {
     return new ScopedLogHash(LogHash.empty(), AztecAddress.ZERO);
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.logHash, this.contractAddress);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.logHash, this.contractAddress);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -141,11 +156,19 @@ export class ScopedCountedLogHash {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedCountedLogHash(reader.readObject(CountedLogHash), AztecAddress.fromField(reader.readField()));
-  }
-
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.inner, this.contractAddress);
+    return new ScopedCountedLogHash(
+      reader.readObject(CountedLogHash),
+      AztecAddress.fromFieldUnsafe(reader.readField()),
+    );
+  }
+
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.inner, this.contractAddress);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {

package/src/kernel/note_hash.ts

@@ -65,7 +65,7 @@ export class ScopedNoteHash implements Ordered {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedNoteHash(reader.readObject(NoteHash), AztecAddress.fromField(reader.readField()));
+    return new ScopedNoteHash(reader.readObject(NoteHash), AztecAddress.fromFieldUnsafe(reader.readField()));
   }
 
   isEmpty() {

package/src/kernel/nullifier.ts

@@ -70,7 +70,7 @@ export class ScopedNullifier implements Ordered {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedNullifier(reader.readObject(Nullifier), AztecAddress.fromField(reader.readField()));
+    return new ScopedNullifier(reader.readObject(Nullifier), AztecAddress.fromFieldUnsafe(reader.readField()));
   }
 
   isEmpty() {

package/src/kernel/padded_side_effects.ts

@@ -19,9 +19,9 @@ export class PaddedSideEffects {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PaddedSideEffects(
-      reader.readTuple(MAX_NOTE_HASHES_PER_TX, Fr),
-      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
-      reader.readTuple(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
+      reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readArray(MAX_PRIVATE_LOGS_PER_TX, PrivateLog),
     );
   }
 

package/src/kernel/private_circuit_public_inputs.ts

@@ -144,6 +144,11 @@ export class PrivateCircuitPublicInputs {
      * 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,
   ) {}
 
   /**
@@ -188,6 +193,7 @@ export class PrivateCircuitPublicInputs {
       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),
     );
   }
 
@@ -219,6 +225,7 @@ export class PrivateCircuitPublicInputs {
       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(),
     );
   }
 
@@ -251,6 +258,7 @@ export class PrivateCircuitPublicInputs {
       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,
     );
   }
 
@@ -278,7 +286,8 @@ export class PrivateCircuitPublicInputs {
       this.nullifiers.isEmpty() &&
       this.l2ToL1Msgs.isEmpty() &&
       this.privateLogs.isEmpty() &&
-      this.contractClassLogsHashes.isEmpty()
+      this.contractClassLogsHashes.isEmpty() &&
+      this.txRequestSalt.isZero()
     );
   }
 
@@ -312,6 +321,7 @@ export class PrivateCircuitPublicInputs {
       fields.l2ToL1Msgs,
       fields.privateLogs,
       fields.contractClassLogsHashes,
+      fields.txRequestSalt,
     ] as const;
   }
 
@@ -346,6 +356,7 @@ export class PrivateCircuitPublicInputs {
       this.l2ToL1Msgs,
       this.privateLogs,
       this.contractClassLogsHashes,
+      this.txRequestSalt,
     ]);
   }
 

package/src/kernel/private_context_inputs.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { serializeToFields } from '@aztec/foundation/serialize';
 
 import { BlockHeader } from '../tx/block_header.js';
@@ -11,13 +11,20 @@ export class PrivateContextInputs {
     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);
+    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]);
+    return serializeToFields([
+      this.callContext,
+      this.anchorBlockHeader,
+      this.txContext,
+      this.startSideEffectCounter,
+      this.txRequestSalt,
+    ]);
   }
 }

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -46,10 +46,6 @@ export class PrivateKernelCircuitPublicInputs {
      * Wether this is a private only tx or not
      */
     public isPrivateOnly: boolean,
-    /**
-     * The nullifier that will be used for nonce generation
-     */
-    public claimedFirstNullifier: Fr,
     /**
      * A claim to the final min revertible side effect counter of a tx.
      */
@@ -74,7 +70,6 @@ export class PrivateKernelCircuitPublicInputs {
       this.feePayer,
       bigintToUInt64BE(this.expirationTimestamp),
       this.isPrivateOnly,
-      this.claimedFirstNullifier,
       this.claimedRevertibleCounter,
     );
   }
@@ -95,7 +90,6 @@ export class PrivateKernelCircuitPublicInputs {
       reader.readObject(AztecAddress),
       reader.readUInt64(),
       reader.readBoolean(),
-      reader.readObject(Fr),
       reader.readNumber(),
     );
   }
@@ -110,8 +104,16 @@ export class PrivateKernelCircuitPublicInputs {
       AztecAddress.ZERO,
       0n,
       false,
-      Fr.zero(),
       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_init_2_circuit_private_inputs.ts

@@ -0,0 +1,46 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/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/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/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(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_4_circuit_private_inputs.ts

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/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 four app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit4CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit4CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit4CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_5_circuit_private_inputs.ts

@@ -0,0 +1,55 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/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 five app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit5CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+    public privateCall4: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+      this.privateCall4,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit5CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit5CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_circuit_private_inputs.ts

@@ -30,10 +30,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
      * Wether this tx will make public calls or not.
      */
     public isPrivateOnly: boolean,
-    /**
-     * A hint to what will be the first nullifier of the transaction, used for nonce generation.
-     */
-    public firstNullifierHint: Fr,
     /**
      * A claim to the final min revertible side effect counter of a tx.
      */
@@ -50,7 +46,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
       this.vkTreeRoot,
       this.protocolContracts,
       this.privateCall,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -68,7 +63,6 @@ export class PrivateKernelInitCircuitPrivateInputs {
       reader.readObject(ProtocolContracts),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       reader.readNumber(),
     );
   }

package/src/kernel/private_kernel_inner_2_circuit_private_inputs.ts

@@ -0,0 +1,29 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateCallData } from './private_call_data.js';
+import { PrivateKernelData } from './private_kernel_data.js';
+
+/**
+ * Input to the batched private kernel inner circuit, which processes two app calls in a single
+ * iteration following a previous kernel.
+ */
+export class PrivateKernelInner2CircuitPrivateInputs {
+  constructor(
+    public previousKernel: PrivateKernelData,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernel, this.privateCall0, this.privateCall1);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInner2CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInner2CircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+    );
+  }
+}

package/src/kernel/private_kernel_inner_3_circuit_private_inputs.ts

@@ -0,0 +1,31 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateCallData } from './private_call_data.js';
+import { PrivateKernelData } from './private_kernel_data.js';
+
+/**
+ * Input to the batched private kernel inner circuit, which processes three app calls in a single
+ * iteration following a previous kernel.
+ */
+export class PrivateKernelInner3CircuitPrivateInputs {
+  constructor(
+    public previousKernel: PrivateKernelData,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernel, this.privateCall0, this.privateCall1, this.privateCall2);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInner3CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInner3CircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+    );
+  }
+}

package/src/kernel/private_kernel_inner_4_circuit_private_inputs.ts

@@ -0,0 +1,39 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateCallData } from './private_call_data.js';
+import { PrivateKernelData } from './private_kernel_data.js';
+
+/**
+ * Input to the batched private kernel inner circuit, which processes four app calls in a single
+ * iteration following a previous kernel.
+ */
+export class PrivateKernelInner4CircuitPrivateInputs {
+  constructor(
+    public previousKernel: PrivateKernelData,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.previousKernel,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInner4CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInner4CircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+    );
+  }
+}

package/src/kernel/private_kernel_inner_5_circuit_private_inputs.ts

@@ -0,0 +1,42 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { PrivateCallData } from './private_call_data.js';
+import { PrivateKernelData } from './private_kernel_data.js';
+
+/**
+ * Input to the batched private kernel inner circuit, which processes five app calls in a single
+ * iteration following a previous kernel.
+ */
+export class PrivateKernelInner5CircuitPrivateInputs {
+  constructor(
+    public previousKernel: PrivateKernelData,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+    public privateCall4: PrivateCallData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.previousKernel,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+      this.privateCall4,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInner5CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInner5CircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+    );
+  }
+}