@aztec/stdlib 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/src/kernel/hints/find_private_kernel_reset_dimensions.ts

@@ -1,8 +1,7 @@
-import { isDefined } from '@aztec/foundation/types';
-
 import {
   PrivateKernelResetDimensions,
   type PrivateKernelResetDimensionsConfig,
+  type ResetCatalogEntry,
   privateKernelResetDimensionNames,
 } from '../private_kernel_reset_dimensions.js';
 
@@ -12,13 +11,6 @@ interface DimensionOption {
   remainder?: PrivateKernelResetDimensions;
 }
 
-function computeCost(dimensions: PrivateKernelResetDimensions, config: PrivateKernelResetDimensionsConfig) {
-  return privateKernelResetDimensionNames.reduce(
-    (accum, name) => accum + dimensions[name] * config.dimensions[name].cost,
-    0,
-  );
-}
-
 function getSize(dimensions: PrivateKernelResetDimensions) {
   return privateKernelResetDimensionNames.reduce((accum, name) => accum + dimensions[name], 0);
 }
@@ -38,124 +30,42 @@ function getRemainder(
   return remainingDimensions ? remainder : undefined;
 }
 
-function pickFromValues(targetValue: number, values: number[]) {
-  // Find the min value in `values` that's greater than or equal to `targetValue`.
-  const minGte = values.reduce(
-    (prev: number | undefined, curr) => (curr >= targetValue && (prev === undefined || curr < prev) ? curr : prev),
-    undefined,
-  );
-
-  // If no such value is found, returns the max value.
-  return minGte ?? Math.max(...values);
-}
-
-function pickCheapest(options: DimensionOption[]) {
-  return options.reduce((prev, curr) => (curr.cost < prev.cost ? curr : prev), options[0]);
-}
-
-function pickSmallestRemainder(options: DimensionOption[]) {
-  const optionsWithSize = options
-    .filter(o => o.remainder)
-    .map(option => ({ option, size: getSize(option.remainder!) }));
-  return optionsWithSize.reduce((prev, curr) => (curr.size < prev.size ? curr : prev), optionsWithSize[0])?.option;
-}
-
-function pickBestOption(options: DimensionOption[]) {
-  const optionsResetAll = options.filter(opt => !opt.remainder);
-  const optionsResetPartial = options.filter(opt => opt.remainder);
-  // The best option is the cheapest one that can reset all dimensions.
-  // If no such option exists, find one that can reset the most data.
-  return pickCheapest(optionsResetAll) || pickSmallestRemainder(optionsResetPartial);
-}
-
-function findVariant(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const variant = PrivateKernelResetDimensions.empty();
-  privateKernelResetDimensionNames.forEach(name => {
-    variant[name] = pickFromValues(requestedDimensions[name], config.dimensions[name].variants);
-  });
-  if (!isQualified(variant)) {
-    return;
+// Returns the cheapest option that fully covers the request, or the option with the smallest
+// remainder if none do. Caller must pass a non-empty list.
+function pickBestOption(options: DimensionOption[]): DimensionOption {
+  const fullCoverage = options.filter(opt => !opt.remainder);
+  if (fullCoverage.length) {
+    return fullCoverage.reduce((prev, curr) => (curr.cost < prev.cost ? curr : prev));
   }
-
-  return {
-    dimensions: variant,
-    cost: computeCost(variant, config),
-    remainder: getRemainder(requestedDimensions, variant),
-  };
+  return options.reduce((prev, curr) => (getSize(curr.remainder!) < getSize(prev.remainder!) ? curr : prev));
 }
 
-function findStandalone(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const needsReset = privateKernelResetDimensionNames.filter(name => requestedDimensions[name] > 0);
-  if (needsReset.length !== 1) {
-    // At the moment, we only use standalone to reset one dimension when it's about to overflow.
-    return;
-  }
-
-  const name = needsReset[0];
-  const value = pickFromValues(requestedDimensions[name], config.dimensions[name].standalone);
-  if (!value) {
-    return;
-  }
-
-  const dimensions = PrivateKernelResetDimensions.from({ [name]: value });
-  if (!isQualified(dimensions)) {
-    return;
-  }
-
+function buildOption(entry: ResetCatalogEntry, requestedDimensions: PrivateKernelResetDimensions): DimensionOption {
+  const dimensions = PrivateKernelResetDimensions.fromValues(entry.dimensions);
   return {
     dimensions,
-    cost: computeCost(dimensions, config),
+    cost: entry.cost,
     remainder: getRemainder(requestedDimensions, dimensions),
   };
 }
 
-function findSpecialCase(
-  requestedDimensions: PrivateKernelResetDimensions,
-  config: PrivateKernelResetDimensionsConfig,
-  isQualified: (dimensions: PrivateKernelResetDimensions) => boolean,
-): DimensionOption | undefined {
-  const specialCases = config.specialCases.map(PrivateKernelResetDimensions.fromValues);
-  const options = specialCases.filter(isQualified).map(dimensions => ({
-    dimensions,
-    cost: computeCost(dimensions, config),
-    remainder: getRemainder(requestedDimensions, dimensions),
-  }));
-  return pickBestOption(options);
-}
+/**
+ * Picks which catalog group the selector should search. Mid-tx resets go to `inner` (no
+ * siloing); terminal kernels go to `finalTail` or `finalTailToPublic`, depending on whether
+ * the tx has public function calls.
+ */
+export type ResetDimensionsMode = 'inner' | 'finalTail' | 'finalTailToPublic';
 
 export function findPrivateKernelResetDimensions(
   requestedDimensions: PrivateKernelResetDimensions,
   config: PrivateKernelResetDimensionsConfig,
-  isInner = false,
+  mode: ResetDimensionsMode,
   allowRemainder = false,
 ) {
-  const requestedValues = requestedDimensions.toValues();
-  const isEnough = allowRemainder
-    ? () => true
-    : (dimensions: PrivateKernelResetDimensions) => dimensions.toValues().every((v, i) => v >= requestedValues[i]);
-
-  const isQualified = !isInner
-    ? isEnough
-    : // If isInner is true, it's a reset to prevent overflow. The following must be zero because siloing can't be done at the moment.
-      (dimensions: PrivateKernelResetDimensions) =>
-        dimensions.NOTE_HASH_SILOING === 0 &&
-        dimensions.NULLIFIER_SILOING === 0 &&
-        dimensions.PRIVATE_LOG_SILOING === 0 &&
-        isEnough(dimensions);
-
-  const options = [
-    findVariant(requestedDimensions, config, isQualified),
-    findStandalone(requestedDimensions, config, isQualified),
-    findSpecialCase(requestedDimensions, config, isQualified),
-  ].filter(isDefined);
+  const catalog = config[mode];
+  const options = catalog
+    .map(entry => buildOption(entry, requestedDimensions))
+    .filter(option => allowRemainder || !option.remainder);
 
   if (!options.length) {
     throw new Error(`Cannot find an option for dimension: ${requestedDimensions.toValues()}`);

package/src/kernel/hints/read_request.ts

@@ -112,7 +112,7 @@ export class ScopedReadRequest {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedReadRequest(reader.readObject(ReadRequest), AztecAddress.fromField(reader.readField()));
+    return new ScopedReadRequest(reader.readObject(ReadRequest), AztecAddress.fromFieldUnsafe(reader.readField()));
   }
 
   /**

package/src/kernel/index.ts

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

@@ -114,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() {
@@ -156,7 +156,10 @@ export class ScopedCountedLogHash {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedCountedLogHash(reader.readObject(CountedLogHash), AztecAddress.fromField(reader.readField()));
+    return new ScopedCountedLogHash(
+      reader.readObject(CountedLogHash),
+      AztecAddress.fromFieldUnsafe(reader.readField()),
+    );
   }
 
   toBuffer(): Buffer;

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/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

@@ -17,7 +17,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
     public privateCall0: PrivateCallData,
     public privateCall1: PrivateCallData,
     public isPrivateOnly: boolean,
-    public firstNullifierHint: Fr,
     public revertibleCounterHint: number,
   ) {}
 
@@ -28,7 +27,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
       this.protocolContracts,
       this.privateCall0,
       this.privateCall1,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -42,7 +40,6 @@ export class PrivateKernelInit2CircuitPrivateInputs {
       reader.readObject(PrivateCallData),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       reader.readNumber(),
     );
   }

package/src/kernel/private_kernel_init_3_circuit_private_inputs.ts

@@ -18,7 +18,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
     public privateCall1: PrivateCallData,
     public privateCall2: PrivateCallData,
     public isPrivateOnly: boolean,
-    public firstNullifierHint: Fr,
     public revertibleCounterHint: number,
   ) {}
 
@@ -30,7 +29,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
       this.privateCall0,
       this.privateCall1,
       this.privateCall2,
-      this.firstNullifierHint,
       this.revertibleCounterHint,
     );
   }
@@ -45,7 +43,6 @@ export class PrivateKernelInit3CircuitPrivateInputs {
       reader.readObject(PrivateCallData),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
-      Fr.fromBuffer(reader),
       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_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),
+    );
+  }
+}

package/src/kernel/private_kernel_prover_output.ts

@@ -1,3 +1,4 @@
+import { CircuitKind } from '@aztec/bb.js';
 import { bufferSchema, mapSchema } from '@aztec/foundation/schemas';
 import type { WitnessMap } from '@aztec/noir-acvm_js';
 import { serializeWitness } from '@aztec/noir-noirc_abi';
@@ -15,6 +16,7 @@ export const PrivateExecutionStepSchema = z.object({
   bytecode: bufferSchema,
   witness: mapSchema(z.number(), z.string()),
   vk: bufferSchema,
+  kind: z.nativeEnum(CircuitKind),
   timings: z.object({
     witgen: z.number(),
     gateCount: z.number().optional(),
@@ -31,6 +33,7 @@ export interface PrivateExecutionStep {
   witness: WitnessMap;
   /* TODO(https://github.com/AztecProtocol/barretenberg/issues/1328) this should get its own proper class. */
   vk: Buffer;
+  kind: CircuitKind;
   timings: {
     witgen: number;
     gateCount?: number;
@@ -64,6 +67,7 @@ export function serializePrivateExecutionSteps(steps: PrivateExecutionStep[]) {
       witness: serializeWitness(step.witness),
       vk: step.vk,
       functionName: step.functionName,
+      kind: step.kind,
     };
   };
   return new Encoder({ useRecords: false }).pack(steps.map(stepToStruct));