@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/kernel/private_circuit_public_inputs.ts

@@ -9,34 +9,36 @@ 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';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
-import { LogHash } from '../kernel/log_hash.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 { L2ToL1Message } from '../messaging/l2_to_l1_message.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 { MaxBlockNumber } from '../tx/max_block_number.js';
 import { TxContext } from '../tx/tx_context.js';
-import { ReadRequest } from './hints/read_request.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';
-import { isEmptyArray } from './utils/order_and_comparison.js';
 
 /**
  * Public inputs to a private circuit.
@@ -64,40 +66,40 @@ export class PrivateCircuitPublicInputs {
      */
     public isFeePayer: boolean,
     /**
-     * The maximum block number in which this transaction can be included and be valid.
+     * The highest timestamp of a block in which the transaction can still be included.
      */
-    public maxBlockNumber: MaxBlockNumber,
+    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<ScopedReadRequest, 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<ScopedReadRequest, 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<L2ToL1Message, 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<LogHash, 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.
      */
@@ -122,14 +124,22 @@ export class PrivateCircuitPublicInputs {
      * 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,
     /**
      * Header of a block whose state is used during private execution (not the block the transaction is included in).
      */
-    public historicalHeader: BlockHeader,
+    public anchorBlockHeader: BlockHeader,
     /**
      * Transaction context.
      *
-     * Note: The chainId and version in the txContext are not redundant to the values in self.historical_header.global_variables because
+     * 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.
      */
@@ -158,18 +168,22 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readBoolean(),
-      reader.readObject(MaxBlockNumber),
-      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(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, 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, L2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash),
+      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(Fr),
       reader.readObject(Fr),
       reader.readObject(BlockHeader),
@@ -185,18 +199,22 @@ export class PrivateCircuitPublicInputs {
       reader.readField(),
       reader.readField(),
       reader.readBoolean(),
-      reader.readObject(MaxBlockNumber),
-      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(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL)),
+      reader.readObject(ClaimedLengthArrayFromFields(ScopedReadRequest, 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, L2ToL1Message),
-      reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash),
+      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.readField(),
       reader.readField(),
       reader.readObject(BlockHeader),
@@ -215,18 +233,20 @@ export class PrivateCircuitPublicInputs {
       Fr.ZERO,
       Fr.ZERO,
       false,
-      MaxBlockNumber.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(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL),
+      ClaimedLengthArray.empty(ScopedReadRequest, 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, L2ToL1Message.empty),
-      makeTuple(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData.empty),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash.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,
       Fr.ZERO,
       Fr.ZERO,
       BlockHeader.empty(),
@@ -241,21 +261,23 @@ export class PrivateCircuitPublicInputs {
       this.returnsHash.isZero() &&
       this.minRevertibleSideEffectCounter.isZero() &&
       !this.isFeePayer &&
-      this.maxBlockNumber.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() &&
+      this.expectedNonRevertibleSideEffectCounter.isZero() &&
+      this.expectedRevertibleSideEffectCounter.isZero() &&
+      this.anchorBlockHeader.isEmpty() &&
       this.txContext.isEmpty()
     );
   }
@@ -272,7 +294,7 @@ export class PrivateCircuitPublicInputs {
       fields.returnsHash,
       fields.minRevertibleSideEffectCounter,
       fields.isFeePayer,
-      fields.maxBlockNumber,
+      fields.includeByTimestamp,
       fields.noteHashReadRequests,
       fields.nullifierReadRequests,
       fields.keyValidationRequestsAndGenerators,
@@ -286,7 +308,9 @@ export class PrivateCircuitPublicInputs {
       fields.contractClassLogsHashes,
       fields.startSideEffectCounter,
       fields.endSideEffectCounter,
-      fields.historicalHeader,
+      fields.expectedNonRevertibleSideEffectCounter,
+      fields.expectedRevertibleSideEffectCounter,
+      fields.anchorBlockHeader,
       fields.txContext,
     ] as const;
   }
@@ -296,20 +320,40 @@ 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.expectedNonRevertibleSideEffectCounter,
+      this.expectedRevertibleSideEffectCounter,
+      this.anchorBlockHeader,
+      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_context_inputs.ts

@@ -8,7 +8,7 @@ import { TxContext } from '../tx/tx_context.js';
 export class PrivateContextInputs {
   constructor(
     public callContext: CallContext,
-    public historicalHeader: BlockHeader,
+    public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
     public startSideEffectCounter: number,
   ) {}
@@ -18,6 +18,6 @@ export class PrivateContextInputs {
   }
 
   public toFields(): Fr[] {
-    return serializeToFields([this.callContext, this.historicalHeader, this.txContext, this.startSideEffectCounter]);
+    return serializeToFields([this.callContext, this.anchorBlockHeader, this.txContext, this.startSideEffectCounter]);
   }
 }

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 { 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';
@@ -16,7 +17,7 @@ export class PrivateKernelCircuitPublicInputs {
     /**
      * Data which is not modified by the circuits.
      */
-    public constants: TxConstantData,
+    public constants: PrivateTxConstantData,
     /**
      * The side effect counter that non-revertible side effects are all beneath.
      */
@@ -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
      */
@@ -45,6 +50,10 @@ export class PrivateKernelCircuitPublicInputs {
      * 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.
+     */
+    public claimedRevertibleCounter: number,
   ) {}
 
   static get schema() {
@@ -63,8 +72,10 @@ export class PrivateKernelCircuitPublicInputs {
       this.end,
       this.publicTeardownCallRequest,
       this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
       this.isPrivateOnly,
       this.claimedFirstNullifier,
+      this.claimedRevertibleCounter,
     );
   }
 
@@ -76,27 +87,31 @@ export class PrivateKernelCircuitPublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelCircuitPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new PrivateKernelCircuitPublicInputs(
-      reader.readObject(TxConstantData),
+      reader.readObject(PrivateTxConstantData),
       reader.readObject(Fr),
       reader.readObject(PrivateValidationRequests),
       reader.readObject(PrivateAccumulatedData),
       reader.readObject(PublicCallRequest),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
       reader.readBoolean(),
       reader.readObject(Fr),
+      reader.readNumber(),
     );
   }
 
   static empty() {
     return new PrivateKernelCircuitPublicInputs(
-      TxConstantData.empty(),
+      PrivateTxConstantData.empty(),
       Fr.zero(),
       PrivateValidationRequests.empty(),
       PrivateAccumulatedData.empty(),
       PublicCallRequest.empty(),
       AztecAddress.ZERO,
+      0n,
       false,
       Fr.zero(),
+      0,
     );
   }
 }

package/src/kernel/private_kernel_data.ts

@@ -1,35 +1,21 @@
-import { CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS, VK_TREE_HEIGHT } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type { UInt32 } from '../types/shared.js';
-import { VerificationKeyAsFields } from '../vks/verification_key.js';
+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 {
-  // NOTE: as of move to honk and client IVC, previous private kernels no longer come with their proof
-  // as we do client IVC not recursive verification. We need to ensure the public inputs here is properly constrained, TODO(https://github.com/AztecProtocol/barretenberg/issues/1048)
   constructor(
     /**
      * Public inputs of the previous kernel.
      */
     public publicInputs: PrivateKernelCircuitPublicInputs,
     /**
-     * Verification key of the previous kernel.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public vk: VerificationKeyAsFields,
-    /**
-     * Index of the previous kernel's vk in a tree of vks.
-     */
-    public vkIndex: UInt32,
-    /**
-     * Sibling path of the previous kernel's vk in a tree of vks.
-     */
-    public vkPath: Tuple<Fr, typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -37,25 +23,15 @@ export class PrivateKernelData {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.publicInputs, this.vk, this.vkIndex, this.vkPath);
+    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(VerificationKeyAsFields),
-      reader.readNumber(),
-      reader.readArray(VK_TREE_HEIGHT, Fr),
-    );
+    return new this(reader.readObject(PrivateKernelCircuitPublicInputs), reader.readObject(VkData));
   }
 
   static empty(): PrivateKernelData {
-    return new PrivateKernelData(
-      PrivateKernelCircuitPublicInputs.empty(),
-      VerificationKeyAsFields.makeFake(CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS),
-      0,
-      makeTuple(VK_TREE_HEIGHT, Fr.zero),
-    );
+    return new PrivateKernelData(PrivateKernelCircuitPublicInputs.empty(), VkData.empty());
   }
 }

package/src/kernel/private_kernel_init_circuit_private_inputs.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 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';
 
@@ -18,9 +19,9 @@ export class PrivateKernelInitCircuitPrivateInputs {
      */
     public vkTreeRoot: Fr,
     /**
-     * The root of the protocol contract tree.
+     * The protocol contracts.
      */
-    public protocolContractTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
     /**
      * Private calldata corresponding to this iteration of the kernel.
      */
@@ -33,6 +34,10 @@ export class PrivateKernelInitCircuitPrivateInputs {
      * 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.
+     */
+    public revertibleCounterHint: number,
   ) {}
 
   /**
@@ -43,9 +48,10 @@ export class PrivateKernelInitCircuitPrivateInputs {
     return serializeToBuffer(
       this.txRequest,
       this.vkTreeRoot,
-      this.protocolContractTreeRoot,
+      this.protocolContracts,
       this.privateCall,
       this.firstNullifierHint,
+      this.revertibleCounterHint,
     );
   }
 
@@ -59,10 +65,11 @@ export class PrivateKernelInitCircuitPrivateInputs {
     return new PrivateKernelInitCircuitPrivateInputs(
       reader.readObject(TxRequest),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
       reader.readObject(PrivateCallData),
       reader.readBoolean(),
       Fr.fromBuffer(reader),
+      reader.readNumber(),
     );
   }
 }

package/src/kernel/private_kernel_prover_output.ts

@@ -0,0 +1,70 @@
+import { bufferSchema, mapSchema } from '@aztec/foundation/schemas';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
+
+import { Encoder } from 'msgpackr';
+import { z } from 'zod';
+
+import type { ChonkProof } from '../proofs/chonk_proof.js';
+import type { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
+import type { PrivateKernelTailCircuitPublicInputs } from './private_kernel_tail_circuit_public_inputs.js';
+
+export const PrivateExecutionStepSchema = z.object({
+  functionName: z.string(),
+  gateCount: z.number().optional(),
+  bytecode: bufferSchema,
+  witness: mapSchema(z.number(), z.string()),
+  vk: bufferSchema,
+  timings: z.object({
+    witgen: z.number(),
+    gateCount: z.number().optional(),
+  }),
+});
+
+/**
+ *  Represents either a simulated private kernel circuit or one of our application function circuits.
+ */
+export interface PrivateExecutionStep {
+  functionName: string;
+  gateCount?: number;
+  bytecode: Buffer;
+  witness: WitnessMap;
+  /* TODO(https://github.com/AztecProtocol/barretenberg/issues/1328) this should get its own proper class. */
+  vk: Buffer;
+  timings: {
+    witgen: number;
+    gateCount?: number;
+    oracles?: Record<string, { times: number[] }>;
+  };
+}
+
+/** Represents the output of proven PrivateKernelSimulateOutput.*/
+export interface PrivateKernelExecutionProofOutput<
+  PublicInputsType extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+> {
+  /** The public inputs used by the proof generation process. */
+  publicInputs: PublicInputsType;
+  /** The private IVC proof optimized for user devices. It will be consumed by an Aztec prover,
+   * which recursively verifies it through the "private tx base" or the "public chonk verifier" circuit.*/
+  chonkProof: ChonkProof;
+  /**
+   * The trace the chonkProof corresponds to.
+   * A trace of app circuits interleaved with private kernel circuits.
+   * If simulate is ran with profiling mode, also includes gate counts.
+   */
+  executionSteps: PrivateExecutionStep[];
+  /** Performance metrics */
+  timings?: { proving: number };
+}
+
+export function serializePrivateExecutionSteps(steps: PrivateExecutionStep[]) {
+  const stepToStruct = (step: PrivateExecutionStep) => {
+    return {
+      bytecode: step.bytecode,
+      witness: serializeWitness(step.witness),
+      vk: step.vk,
+      functionName: step.functionName,
+    };
+  };
+  return new Encoder({ useRecords: false }).pack(steps.map(stepToStruct));
+}