@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.03f7ef2

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

package/src/kernel/private_kernel_reset_circuit_private_inputs.ts

@@ -7,6 +7,7 @@ import type {
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { PrivateKernelResetHints } from './hints/private_kernel_reset_hints.js';
+import type { PaddedSideEffects } from './padded_side_effects.js';
 import type { PrivateKernelData } from './private_kernel_data.js';
 import type { PrivateKernelResetDimensions } from './private_kernel_reset_dimensions.js';
 
@@ -15,23 +16,24 @@ export class PrivateKernelResetCircuitPrivateInputsVariants<
   NH_RR_SETTLED extends number,
   NLL_RR_PENDING extends number,
   NLL_RR_SETTLED extends number,
-  KEY_VALIDATION_REQUESTS extends number,
-  NUM_TRANSIENT_DATA_INDEX_HINTS extends number,
+  KEY_VALIDATION_HINTS_LEN extends number,
+  TRANSIENT_DATA_HINTS_LEN extends number,
 > {
   constructor(
     public previousKernel: PrivateKernelData,
+    public paddedSideEffects: PaddedSideEffects,
     public hints: PrivateKernelResetHints<
       NH_RR_PENDING,
       NH_RR_SETTLED,
       NLL_RR_PENDING,
       NLL_RR_SETTLED,
-      KEY_VALIDATION_REQUESTS,
-      NUM_TRANSIENT_DATA_INDEX_HINTS
+      KEY_VALIDATION_HINTS_LEN,
+      TRANSIENT_DATA_HINTS_LEN
     >,
   ) {}
 
   toBuffer() {
-    return serializeToBuffer(this.previousKernel, this.hints);
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints);
   }
 }
 
@@ -44,6 +46,7 @@ export class PrivateKernelResetCircuitPrivateInputs {
      * The previous kernel data
      */
     public previousKernel: PrivateKernelData,
+    public paddedSideEffects: PaddedSideEffects,
     public hints: PrivateKernelResetHints<
       typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
       typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
@@ -60,18 +63,18 @@ export class PrivateKernelResetCircuitPrivateInputs {
    * @returns The buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousKernel, this.hints, this.dimensions);
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints, this.dimensions);
   }
 
   trimToSizes() {
     const hints = this.hints.trimToSizes(
-      this.dimensions.NOTE_HASH_PENDING_AMOUNT,
-      this.dimensions.NOTE_HASH_SETTLED_AMOUNT,
-      this.dimensions.NULLIFIER_PENDING_AMOUNT,
-      this.dimensions.NULLIFIER_SETTLED_AMOUNT,
-      this.dimensions.NULLIFIER_KEYS,
-      this.dimensions.TRANSIENT_DATA_AMOUNT,
+      this.dimensions.NOTE_HASH_PENDING_READ,
+      this.dimensions.NOTE_HASH_SETTLED_READ,
+      this.dimensions.NULLIFIER_PENDING_READ,
+      this.dimensions.NULLIFIER_SETTLED_READ,
+      this.dimensions.KEY_VALIDATION,
+      this.dimensions.TRANSIENT_DATA_SQUASHING,
     );
-    return new PrivateKernelResetCircuitPrivateInputsVariants(this.previousKernel, hints);
+    return new PrivateKernelResetCircuitPrivateInputsVariants(this.previousKernel, this.paddedSideEffects, hints);
   }
 }

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -3,28 +3,28 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 export class PrivateKernelResetDimensions {
   constructor(
-    public NOTE_HASH_PENDING_AMOUNT: number,
-    public NOTE_HASH_SETTLED_AMOUNT: number,
-    public NULLIFIER_PENDING_AMOUNT: number,
-    public NULLIFIER_SETTLED_AMOUNT: number,
-    public NULLIFIER_KEYS: number,
-    public TRANSIENT_DATA_AMOUNT: number,
-    public NOTE_HASH_SILOING_AMOUNT: number,
-    public NULLIFIER_SILOING_AMOUNT: number,
-    public PRIVATE_LOG_SILOING_AMOUNT: number,
+    public NOTE_HASH_PENDING_READ: number,
+    public NOTE_HASH_SETTLED_READ: number,
+    public NULLIFIER_PENDING_READ: number,
+    public NULLIFIER_SETTLED_READ: number,
+    public KEY_VALIDATION: number,
+    public TRANSIENT_DATA_SQUASHING: number,
+    public NOTE_HASH_SILOING: number,
+    public NULLIFIER_SILOING: number,
+    public PRIVATE_LOG_SILOING: number,
   ) {}
 
   toBuffer() {
     return serializeToBuffer(
-      this.NOTE_HASH_PENDING_AMOUNT,
-      this.NOTE_HASH_SETTLED_AMOUNT,
-      this.NULLIFIER_PENDING_AMOUNT,
-      this.NULLIFIER_SETTLED_AMOUNT,
-      this.NULLIFIER_KEYS,
-      this.TRANSIENT_DATA_AMOUNT,
-      this.NOTE_HASH_SILOING_AMOUNT,
-      this.NULLIFIER_SILOING_AMOUNT,
-      this.PRIVATE_LOG_SILOING_AMOUNT,
+      this.NOTE_HASH_PENDING_READ,
+      this.NOTE_HASH_SETTLED_READ,
+      this.NULLIFIER_PENDING_READ,
+      this.NULLIFIER_SETTLED_READ,
+      this.KEY_VALIDATION,
+      this.TRANSIENT_DATA_SQUASHING,
+      this.NOTE_HASH_SILOING,
+      this.NULLIFIER_SILOING,
+      this.PRIVATE_LOG_SILOING,
     );
   }
 
@@ -57,15 +57,15 @@ export class PrivateKernelResetDimensions {
 export type DimensionName = keyof FieldsOf<PrivateKernelResetDimensions>;
 
 export const privateKernelResetDimensionNames: DimensionName[] = [
-  'NOTE_HASH_PENDING_AMOUNT',
-  'NOTE_HASH_SETTLED_AMOUNT',
-  'NULLIFIER_PENDING_AMOUNT',
-  'NULLIFIER_SETTLED_AMOUNT',
-  'NULLIFIER_KEYS',
-  'TRANSIENT_DATA_AMOUNT',
-  'NOTE_HASH_SILOING_AMOUNT',
-  'NULLIFIER_SILOING_AMOUNT',
-  'PRIVATE_LOG_SILOING_AMOUNT',
+  'NOTE_HASH_PENDING_READ',
+  'NOTE_HASH_SETTLED_READ',
+  'NULLIFIER_PENDING_READ',
+  'NULLIFIER_SETTLED_READ',
+  'KEY_VALIDATION',
+  'TRANSIENT_DATA_SQUASHING',
+  'NOTE_HASH_SILOING',
+  'NULLIFIER_SILOING',
+  'PRIVATE_LOG_SILOING',
 ];
 
 export interface DimensionConfig {

package/src/kernel/private_kernel_simulated_output.ts

@@ -1,35 +1,26 @@
-import type { WitnessMap } from '@noir-lang/acvm_js';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
 
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import type { VerificationKeyAsFields } from '../vks/verification_key.js';
+import type { VerificationKeyData } from '../vks/verification_key.js';
 import type { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
-import type { PrivateKernelProverProfileResult } from './private_kernel_prover_profile_result.js';
 import type { PrivateKernelTailCircuitPublicInputs } from './private_kernel_tail_circuit_public_inputs.js';
 
 /**
  * Represents the output of the proof creation process for init and inner private kernel circuit.
  * Contains the public inputs required for the init and inner private kernel circuit and the generated proof.
  */
-export type PrivateKernelSimulateOutput<
+export interface PrivateKernelSimulateOutput<
   PublicInputsType extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
-> = {
+> {
   /** The public inputs required for the proof generation process. */
   publicInputs: PublicInputsType;
-
-  clientIvcProof?: ClientIvcProof;
-
-  verificationKey: VerificationKeyAsFields;
-
   outputWitness: WitnessMap;
-
+  verificationKey: VerificationKeyData;
   bytecode: Buffer;
-
-  profileResult?: PrivateKernelProverProfileResult;
-};
+}
 
 /**
  * Represents the output of the circuit simulation process for init and inner private kernel circuit.
  */
 export type AppCircuitSimulateOutput = {
-  verificationKey: VerificationKeyAsFields;
+  verificationKey: VerificationKeyData;
 };

package/src/kernel/private_kernel_tail_circuit_private_inputs.ts

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

package/src/kernel/private_kernel_tail_circuit_public_inputs.ts

@@ -1,17 +1,19 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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 { Gas } from '../gas/gas.js';
+import type { PrivateLog } from '../logs/index.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
-import { RollupValidationRequests } from './hints/rollup_validation_requests.js';
+import type { UInt64 } from '../types/shared.js';
+import type { ScopedLogHash } from './log_hash.js';
 import { PrivateToPublicAccumulatedData } from './private_to_public_accumulated_data.js';
 import { PrivateToPublicKernelCircuitPublicInputs } from './private_to_public_kernel_circuit_public_inputs.js';
 import { PrivateToRollupAccumulatedData } from './private_to_rollup_accumulated_data.js';
 import { PrivateToRollupKernelCircuitPublicInputs } from './private_to_rollup_kernel_circuit_public_inputs.js';
 import { PublicCallRequest } from './public_call_request.js';
-import { countAccumulatedItems, mergeAccumulatedData } from './utils/order_and_comparison.js';
+import { countAccumulatedItems } from './utils/order_and_comparison.js';
 
 export class PartialPrivateTailPublicInputsForPublic {
   constructor(
@@ -102,7 +104,6 @@ export class PrivateKernelTailCircuitPublicInputs {
      * Data which is not modified by the circuits.
      */
     public constants: TxConstantData,
-    public rollupValidationRequests: RollupValidationRequests,
     /**
      * The accumulated gas used after private execution.
      * If the tx has a teardown call request, the teardown gas limits will also be included.
@@ -112,6 +113,10 @@ export class PrivateKernelTailCircuitPublicInputs {
      * 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,
 
     public forPublic?: PartialPrivateTailPublicInputsForPublic,
     public forRollup?: PartialPrivateTailPublicInputsForRollup,
@@ -139,8 +144,9 @@ export class PrivateKernelTailCircuitPublicInputs {
       (this.forPublic?.getSize() ?? 0) +
       (this.forRollup?.getSize() ?? 0) +
       this.constants.getSize() +
-      this.rollupValidationRequests.getSize() +
-      this.feePayer.size
+      this.gasUsed.getSize() +
+      this.feePayer.size +
+      8 // includeByTimestamp
     );
   }
 
@@ -150,12 +156,12 @@ export class PrivateKernelTailCircuitPublicInputs {
     }
     return new PrivateToPublicKernelCircuitPublicInputs(
       this.constants,
-      this.rollupValidationRequests,
       this.forPublic.nonRevertibleAccumulatedData,
       this.forPublic.revertibleAccumulatedData,
       this.forPublic.publicTeardownCallRequest,
       this.gasUsed,
       this.feePayer,
+      this.includeByTimestamp,
     );
   }
 
@@ -164,20 +170,26 @@ export class PrivateKernelTailCircuitPublicInputs {
       throw new Error('Private tail public inputs is not for rollup circuit.');
     }
     const constants = new TxConstantData(
-      this.constants.historicalHeader,
+      this.constants.anchorBlockHeader,
       this.constants.txContext,
       this.constants.vkTreeRoot,
-      this.constants.protocolContractTreeRoot,
+      this.constants.protocolContractsHash,
     );
     return new PrivateToRollupKernelCircuitPublicInputs(
       constants,
-      this.rollupValidationRequests,
       this.forRollup.end,
       this.gasUsed,
       this.feePayer,
+      this.includeByTimestamp,
     );
   }
 
+  publicInputs(): PrivateToPublicKernelCircuitPublicInputs | PrivateToRollupKernelCircuitPublicInputs {
+    return this.forPublic
+      ? this.toPrivateToPublicKernelCircuitPublicInputs()
+      : this.toPrivateToRollupKernelCircuitPublicInputs();
+  }
+
   numberOfPublicCallRequests() {
     return (
       this.numberOfNonRevertiblePublicCallRequests() +
@@ -215,8 +227,7 @@ export class PrivateKernelTailCircuitPublicInputs {
 
   getNonEmptyNoteHashes() {
     const noteHashes = this.forPublic
-      ? mergeAccumulatedData(
-          this.forPublic.nonRevertibleAccumulatedData.noteHashes,
+      ? this.forPublic.nonRevertibleAccumulatedData.noteHashes.concat(
           this.forPublic.revertibleAccumulatedData.noteHashes,
         )
       : this.forRollup!.end.noteHashes;
@@ -225,8 +236,7 @@ export class PrivateKernelTailCircuitPublicInputs {
 
   getNonEmptyNullifiers() {
     const nullifiers = this.forPublic
-      ? mergeAccumulatedData(
-          this.forPublic.nonRevertibleAccumulatedData.nullifiers,
+      ? this.forPublic.nonRevertibleAccumulatedData.nullifiers.concat(
           this.forPublic.revertibleAccumulatedData.nullifiers,
         )
       : this.forRollup!.end.nullifiers;
@@ -235,8 +245,7 @@ export class PrivateKernelTailCircuitPublicInputs {
 
   getNonEmptyPrivateLogs() {
     const privateLogs = this.forPublic
-      ? mergeAccumulatedData(
-          this.forPublic.nonRevertibleAccumulatedData.privateLogs,
+      ? this.forPublic.nonRevertibleAccumulatedData.privateLogs.concat(
           this.forPublic.revertibleAccumulatedData.privateLogs,
         )
       : this.forRollup!.end.privateLogs;
@@ -245,8 +254,7 @@ export class PrivateKernelTailCircuitPublicInputs {
 
   getNonEmptyContractClassLogsHashes() {
     const contractClassLogsHashes = this.forPublic
-      ? mergeAccumulatedData(
-          this.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes,
+      ? this.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.concat(
           this.forPublic.revertibleAccumulatedData.contractClassLogsHashes,
         )
       : this.forRollup!.end.contractClassLogsHashes;
@@ -254,11 +262,20 @@ export class PrivateKernelTailCircuitPublicInputs {
   }
 
   getEmittedContractClassLogsLength() {
-    return this.getNonEmptyContractClassLogsHashes().reduce((total, log) => total + log.logHash.length, 0);
+    const accumulateLengths = (logHashes: ScopedLogHash[]) =>
+      logHashes.reduce((acc, log) => acc + log.logHash.length, 0);
+    return this.forPublic
+      ? accumulateLengths(this.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes) +
+          accumulateLengths(this.forPublic.revertibleAccumulatedData.contractClassLogsHashes)
+      : accumulateLengths(this.forRollup!.end.contractClassLogsHashes);
   }
 
   getEmittedPrivateLogsLength() {
-    return this.getNonEmptyPrivateLogs().reduce((total, log) => total + log.getEmittedLength(), 0);
+    const accumulateLengths = (logs: PrivateLog[]) => logs.reduce((acc, log) => acc + log.emittedLength, 0);
+    return this.forPublic
+      ? accumulateLengths(this.forPublic.nonRevertibleAccumulatedData.privateLogs) +
+          accumulateLengths(this.forPublic.revertibleAccumulatedData.privateLogs)
+      : accumulateLengths(this.forRollup!.end.privateLogs);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelTailCircuitPublicInputs {
@@ -266,9 +283,9 @@ export class PrivateKernelTailCircuitPublicInputs {
     const isForPublic = reader.readBoolean();
     return new PrivateKernelTailCircuitPublicInputs(
       reader.readObject(TxConstantData),
-      reader.readObject(RollupValidationRequests),
       reader.readObject(Gas),
       reader.readObject(AztecAddress),
+      reader.readUInt64(),
       isForPublic ? reader.readObject(PartialPrivateTailPublicInputsForPublic) : undefined,
       !isForPublic ? reader.readObject(PartialPrivateTailPublicInputsForRollup) : undefined,
     );
@@ -279,9 +296,9 @@ export class PrivateKernelTailCircuitPublicInputs {
     return serializeToBuffer(
       isForPublic,
       this.constants,
-      this.rollupValidationRequests,
       this.gasUsed,
       this.feePayer,
+      bigintToUInt64BE(this.includeByTimestamp),
       isForPublic ? this.forPublic!.toBuffer() : this.forRollup!.toBuffer(),
     );
   }
@@ -289,9 +306,9 @@ export class PrivateKernelTailCircuitPublicInputs {
   static empty() {
     return new PrivateKernelTailCircuitPublicInputs(
       TxConstantData.empty(),
-      RollupValidationRequests.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
+      0n,
       undefined,
       PartialPrivateTailPublicInputsForRollup.empty(),
     );
@@ -307,9 +324,9 @@ export class PrivateKernelTailCircuitPublicInputs {
     data.nullifiers[0] = Fr.random();
     return new PrivateKernelTailCircuitPublicInputs(
       TxConstantData.empty(),
-      RollupValidationRequests.empty(),
       Gas.empty(),
       AztecAddress.ZERO,
+      0n,
       undefined,
       new PartialPrivateTailPublicInputsForRollup(data),
     );

package/src/kernel/private_log_data.ts

@@ -1,5 +1,5 @@
 import { PRIVATE_LOG_DATA_LENGTH } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -10,7 +10,11 @@ import { PrivateLog } from '../logs/private_log.js';
 import type { UInt32 } from '../types/shared.js';
 
 export class PrivateLogData {
-  constructor(public log: PrivateLog, public noteHashCounter: UInt32, public counter: UInt32) {}
+  constructor(
+    public log: PrivateLog,
+    public noteHashCounter: UInt32,
+    public counter: UInt32,
+  ) {}
 
   static from(fields: FieldsOf<PrivateLogData>): PrivateLogData {
     return new PrivateLogData(...PrivateLogData.getFields(fields));
@@ -54,7 +58,7 @@ export class PrivateLogData {
 
   [inspect.custom]() {
     return `PrivateLogData {
-      log: ${this.log}
+      log: ${this.log.fields}
       noteHashCounter: ${this.noteHashCounter}
       counter: ${this.counter}
     }`;
@@ -62,7 +66,10 @@ export class PrivateLogData {
 }
 
 export class ScopedPrivateLogData {
-  constructor(public inner: PrivateLogData, public contractAddress: AztecAddress) {}
+  constructor(
+    public inner: PrivateLogData,
+    public contractAddress: AztecAddress,
+  ) {}
 
   static from(fields: FieldsOf<ScopedPrivateLogData>): ScopedPrivateLogData {
     return new ScopedPrivateLogData(...ScopedPrivateLogData.getFields(fields));
@@ -100,7 +107,9 @@ export class ScopedPrivateLogData {
 
   [inspect.custom]() {
     return `ScopedPrivateLogData {
-      inner: ${this.inner}
+      inner.counter: ${this.inner.counter}
+      inner.noteHashCounter: ${this.inner.noteHashCounter}
+      inner.log: ${this.inner.log.fields}
       contractAddress: ${this.contractAddress}
     }`;
   }

package/src/kernel/private_to_avm_accumulated_data.ts

@@ -6,7 +6,7 @@ import {
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
@@ -22,6 +22,7 @@ import { z } from 'zod';
 
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import type { UInt32 } from '../types/shared.js';
+import { countAccumulatedItems } from './utils/index.js';
 
 export class PrivateToAvmAccumulatedData {
   constructor(
@@ -55,6 +56,14 @@ export class PrivateToAvmAccumulatedData {
     );
   }
 
+  getArrayLengths() {
+    return new PrivateToAvmAccumulatedDataArrayLengths(
+      countAccumulatedItems(this.noteHashes),
+      countAccumulatedItems(this.nullifiers),
+      countAccumulatedItems(this.l2ToL1Msgs),
+    );
+  }
+
   static getFields(fields: FieldsOf<PrivateToAvmAccumulatedData>) {
     return [fields.noteHashes, fields.nullifiers, fields.l2ToL1Msgs] as const;
   }
@@ -103,6 +112,30 @@ export class PrivateToAvmAccumulatedData {
     );
   }
 
+  /**
+   * Creates a PrivateToAvmAccumulatedData instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PrivateToAvmAccumulatedData fields
+   * @returns A PrivateToAvmAccumulatedData instance
+   */
+  static fromPlainObject(obj: any): PrivateToAvmAccumulatedData {
+    return new PrivateToAvmAccumulatedData(
+      assertLength(
+        obj.noteHashes.map((h: any) => Fr.fromPlainObject(h)),
+        MAX_NOTE_HASHES_PER_TX,
+      ),
+      assertLength(
+        obj.nullifiers.map((n: any) => Fr.fromPlainObject(n)),
+        MAX_NULLIFIERS_PER_TX,
+      ),
+      assertLength(
+        obj.l2ToL1Msgs.map((m: any) => ScopedL2ToL1Message.fromPlainObject(m)),
+        MAX_L2_TO_L1_MSGS_PER_TX,
+      ),
+    );
+  }
+
   [inspect.custom]() {
     return `PrivateToAvmAccumulatedData {
       noteHashes: [${this.noteHashes
@@ -122,7 +155,11 @@ export class PrivateToAvmAccumulatedData {
 }
 
 export class PrivateToAvmAccumulatedDataArrayLengths {
-  constructor(public noteHashes: UInt32, public nullifiers: UInt32, public l2ToL1Msgs: UInt32) {}
+  constructor(
+    public noteHashes: UInt32,
+    public nullifiers: UInt32,
+    public l2ToL1Msgs: UInt32,
+  ) {}
 
   static get schema() {
     return z
@@ -150,6 +187,10 @@ export class PrivateToAvmAccumulatedDataArrayLengths {
     return new this(reader.readU32(), reader.readU32(), reader.readU32());
   }
 
+  toFields() {
+    return [this.noteHashes, this.nullifiers, this.l2ToL1Msgs];
+  }
+
   static from(fields: FieldsOf<PrivateToAvmAccumulatedDataArrayLengths>) {
     return new PrivateToAvmAccumulatedDataArrayLengths(...PrivateToAvmAccumulatedDataArrayLengths.getFields(fields));
   }
@@ -167,6 +208,17 @@ export class PrivateToAvmAccumulatedDataArrayLengths {
     return new PrivateToAvmAccumulatedDataArrayLengths(0, 0, 0);
   }
 
+  /**
+   * Creates a PrivateToAvmAccumulatedDataArrayLengths instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PrivateToAvmAccumulatedDataArrayLengths fields
+   * @returns A PrivateToAvmAccumulatedDataArrayLengths instance
+   */
+  static fromPlainObject(obj: any): PrivateToAvmAccumulatedDataArrayLengths {
+    return new PrivateToAvmAccumulatedDataArrayLengths(obj.noteHashes, obj.nullifiers, obj.l2ToL1Msgs);
+  }
+
   [inspect.custom]() {
     return `PrivateToAvmAccumulatedDataArrayLengths {
       noteHashes: ${this.noteHashes},