@aztec/stdlib 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/interfaces/validator.ts

@@ -1,4 +1,4 @@
-import type { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { SecretValue } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
@@ -9,7 +9,6 @@ import type {
   BlockProposal,
   BlockProposalOptions,
   CheckpointAttestation,
-  CheckpointLastBlockData,
   CheckpointProposal,
   CheckpointProposalOptions,
 } from '@aztec/stdlib/p2p';
@@ -20,6 +19,7 @@ import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
 import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+import type { ChainConfig } from '../config/chain-config.js';
 import {
   type LocalSignerConfig,
   LocalSignerConfigSchema,
@@ -33,6 +33,9 @@ import { AllowedElementSchema } from './allowed_element.js';
  */
 export type ValidatorClientConfig = ValidatorHASignerConfig &
   LocalSignerConfig & {
+    /** The L1 chain id used for EIP-712 proposal-path signing. */
+    l1ChainId: ChainConfig['l1ChainId'];
+
     /** The private keys of the validators participating in attestation duties */
     validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
 
@@ -48,10 +51,7 @@ export type ValidatorClientConfig = ValidatorHASignerConfig &
     /** Interval between polling for new attestations from peers */
     attestationPollingIntervalMs: number;
 
-    /** Whether to re-execute transactions in a block proposal before attesting */
-    validatorReexecute: boolean;
-
-    /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+    /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the current committee */
     alwaysReexecuteBlockProposals?: boolean;
 
     /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
@@ -66,6 +66,9 @@ export type ValidatorClientConfig = ValidatorHASignerConfig &
     /** Agree to attest to equivocated checkpoint proposals (for testing purposes only) */
     attestToEquivocatedProposals?: boolean;
 
+    /** Accept proposal validation regardless of slot timing (for testing only) */
+    skipProposalSlotValidation?: boolean;
+
     /** Maximum L2 gas per block for validation. Proposals exceeding this limit are rejected. */
     validateMaxL2BlockGas?: number;
 
@@ -80,30 +83,44 @@ export type ValidatorClientConfig = ValidatorHASignerConfig &
   };
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
-  Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal'> &
+  Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal' | 'maxBlocksPerCheckpoint'> &
+  // `blockDurationMs` is optional on the loose `SequencerConfig` but is always populated via the shared
+  // `numberConfigHelper(3000)` mapping, so it is required on the fully-resolved validator config.
+  Required<Pick<SequencerConfig, 'blockDurationMs'>> &
   Pick<
     SlasherConfig,
-    'slashBroadcastedInvalidBlockPenalty' | 'slashDuplicateProposalPenalty' | 'slashDuplicateAttestationPenalty'
+    | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashBroadcastedInvalidCheckpointProposalPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
+    | 'slashAttestInvalidCheckpointProposalPenalty'
   > & {
     /**
      * Whether transactions are disabled for this node
      * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
      */
     disableTransactions?: boolean;
+
+    /**
+     * Maximum clock-disparity tolerance (ms) applied to proposal/attestation receive windows.
+     * @remarks Mirrors the property in P2PConfig. It's not picked from there to avoid circular dependencies.
+     */
+    maxGossipClockDisparityMs?: number;
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
   ValidatorHASignerConfigSchema.merge(LocalSignerConfigSchema).extend({
+    l1ChainId: z.number().int().nonnegative(),
     validatorAddresses: z.array(schemas.EthAddress).optional(),
     disableValidator: z.boolean(),
     disabledValidators: z.array(schemas.EthAddress),
     attestationPollingIntervalMs: z.number().min(0),
-    validatorReexecute: z.boolean(),
     alwaysReexecuteBlockProposals: z.boolean().optional(),
     fishermanMode: z.boolean().optional(),
     skipCheckpointProposalValidation: z.boolean().optional(),
     skipPushProposedBlocksToArchiver: z.boolean().optional(),
     attestToEquivocatedProposals: z.boolean().optional(),
+    skipProposalSlotValidation: z.boolean().optional(),
     validateMaxL2BlockGas: z.number().optional(),
     validateMaxDABlockGas: z.number().optional(),
     validateMaxTxsPerBlock: z.number().optional(),
@@ -115,15 +132,18 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
   ValidatorClientConfigSchema.extend({
     txPublicSetupAllowListExtend: z.array(AllowedElementSchema).optional(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
+    blockDurationMs: z.number().positive(),
+    maxBlocksPerCheckpoint: z.number().positive().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashBroadcastedInvalidCheckpointProposalPenalty: schemas.BigInt,
     slashDuplicateProposalPenalty: schemas.BigInt,
     slashDuplicateAttestationPenalty: schemas.BigInt,
+    slashAttestInvalidCheckpointProposalPenalty: schemas.BigInt,
     disableTransactions: z.boolean().optional(),
+    maxGossipClockDisparityMs: z.number().optional(),
   }),
 );
 
-export type CreateCheckpointProposalLastBlockData = Omit<CheckpointLastBlockData, 'txHashes'> & { txs: Tx[] };
-
 export interface Validator {
   start(): Promise<void>;
   updateConfig(config: Partial<ValidatorClientFullConfig>): void;
@@ -131,6 +151,7 @@ export interface Validator {
   // Block validation responsibilities
   createBlockProposal(
     blockHeader: BlockHeader,
+    checkpointNumber: CheckpointNumber,
     indexWithinCheckpoint: number,
     inHash: Fr,
     archive: Fr,
@@ -143,8 +164,9 @@ export interface Validator {
   createCheckpointProposal(
     checkpointHeader: CheckpointHeader,
     archive: Fr,
+    checkpointNumber: CheckpointNumber,
     feeAssetPriceModifier: bigint,
-    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    lastBlockProposal: BlockProposal | undefined,
     proposerAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,
   ): Promise<CheckpointProposal>;
@@ -168,15 +190,23 @@ export interface Validator {
   broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
 
   /** Collect own attestations for a checkpoint proposal (used when skipping p2p attestation collection) */
-  collectOwnAttestations(proposal: CheckpointProposal): Promise<CheckpointAttestation[]>;
+  collectOwnAttestations(
+    proposal: CheckpointProposal,
+    checkpointNumber: CheckpointNumber,
+  ): Promise<CheckpointAttestation[]>;
 
   /** Collect attestations from the p2p network for a checkpoint proposal */
-  collectAttestations(proposal: CheckpointProposal, required: number, deadline: Date): Promise<CheckpointAttestation[]>;
+  collectAttestations(
+    proposal: CheckpointProposal,
+    required: number,
+    deadline: Date,
+    checkpointNumber: CheckpointNumber,
+  ): Promise<CheckpointAttestation[]>;
 
   signAttestationsAndSigners(
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     proposer: EthAddress,
     slot: SlotNumber,
-    blockNumber: BlockNumber | CheckpointNumber,
+    checkpointNumber: CheckpointNumber,
   ): Promise<Signature>;
 }

package/src/interfaces/world_state.ts

@@ -92,7 +92,7 @@ export interface WorldStateSynchronizer extends ReadonlyWorldStateAccess, ForkMe
   clear(): Promise<void>;
 }
 
-export const WorldStateSyncStatusSchema: z.ZodType<WorldStateSyncStatus, z.ZodTypeDef, any> = z.object({
+export const WorldStateSyncStatusSchema: z.ZodType<WorldStateSyncStatus, any> = z.object({
   finalizedBlockNumber: BlockNumberSchema,
   latestBlockNumber: BlockNumberSchema,
   latestBlockHash: z.string(),

package/src/kernel/hints/key_validation_request.ts

@@ -1,29 +1,31 @@
 import { KEY_VALIDATION_REQUEST_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**
  * Request for validating keys used in the app.
+ *
+ * The master public key is exposed only as `pkMHash` (its `hashPublicKey` digest).
+ * The kernel reset circuit derives the corresponding point from the master secret key hint and
+ * asserts that its hash matches `pkMHash`.
  */
 export class KeyValidationRequest {
-  /** App-siloed secret key corresponding to the same underlying secret as master public key above. */
+  /** App-siloed secret key corresponding to the same underlying secret as `pkMHash`. */
   public readonly skApp: Fr;
 
   constructor(
-    /** Master public key corresponding to the same underlying secret as app secret key below. */
-    public readonly pkM: Point,
+    /** Hash of the master public key corresponding to the same underlying secret as `skApp`. */
+    public readonly pkMHash: Fr,
     skApp: Fr | GrumpkinScalar,
   ) {
-    // I am doing this conversion here because in some places skApp is represented as GrumpkinScalar (Fq).
-    // I can do this conversion even though Fq.MODULUS is larger than Fr.MODULUS because when we pass in
-    // the skApp as GrumpkinScalar it was converted to that form from Fr. So, it is safe to convert it back
-    // to Fr. If this would change in the future the code below will throw an error so it should be easy to debug.
+    // skApp may arrive as a GrumpkinScalar (Fq) in some code paths; safe to truncate to Fr because
+    // the value originally came from an Fr poseidon hash and was widened to GrumpkinScalar.
     this.skApp = skApp instanceof Fr ? skApp : new Fr(skApp.toBigInt());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.pkM, this.skApp);
+    return serializeToBuffer(this.pkMHash, this.skApp);
   }
 
   get skAppAsGrumpkinScalar() {
@@ -32,11 +34,11 @@ export class KeyValidationRequest {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new KeyValidationRequest(Point.fromBuffer(reader), Fr.fromBuffer(reader));
+    return new KeyValidationRequest(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
   }
 
   toFields(): Fr[] {
-    const fields = [this.pkM.toFields(), this.skApp].flat();
+    const fields = [this.pkMHash, this.skApp];
     if (fields.length !== KEY_VALIDATION_REQUEST_LENGTH) {
       throw new Error(
         `Invalid number of fields for KeyValidationRequest. Expected ${KEY_VALIDATION_REQUEST_LENGTH}, got ${fields.length}`,
@@ -47,18 +49,18 @@ export class KeyValidationRequest {
 
   static fromFields(fields: Fr[] | FieldReader): KeyValidationRequest {
     const reader = FieldReader.asReader(fields);
-    return new KeyValidationRequest(Point.fromFields(reader), reader.readField());
+    return new KeyValidationRequest(reader.readField(), reader.readField());
   }
 
   isEmpty() {
-    return this.pkM.isZero() && this.skApp.isZero();
+    return this.pkMHash.isZero() && this.skApp.isZero();
   }
 
   static empty() {
-    return new KeyValidationRequest(Point.ZERO, Fr.ZERO);
+    return new KeyValidationRequest(Fr.ZERO, Fr.ZERO);
   }
 
-  static async random() {
-    return new KeyValidationRequest(await Point.random(), Fr.random());
+  static random() {
+    return new KeyValidationRequest(Fr.random(), Fr.random());
   }
 }

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

@@ -7,7 +7,11 @@ 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_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_reset_circuit_private_inputs.js';
 export * from './private_kernel_reset_dimensions.js';
 export * from './private_kernel_tail_circuit_private_inputs.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/private_kernel_init_2_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 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 firstNullifierHint: Fr,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.firstNullifierHint,
+      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(),
+      Fr.fromBuffer(reader),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_3_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 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 firstNullifierHint: Fr,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.firstNullifierHint,
+      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(),
+      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_tail_circuit_public_inputs.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
-import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, serializeToSink } from '@aztec/foundation/serialize';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import { Gas } from '../gas/gas.js';
@@ -60,8 +60,14 @@ export class PartialPrivateTailPublicInputsForPublic {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(
+      sink,
       this.nonRevertibleAccumulatedData,
       this.revertibleAccumulatedData,
       this.publicTeardownCallRequest,
@@ -89,8 +95,13 @@ export class PartialPrivateTailPublicInputsForRollup {
     return this.end.getSize();
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.end);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.end);
   }
 
   static empty() {
@@ -300,16 +311,20 @@ export class PrivateKernelTailCircuitPublicInputs {
     );
   }
 
-  toBuffer() {
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
     const isForPublic = !!this.forPublic;
-    return serializeToBuffer(
-      isForPublic,
-      this.constants,
-      this.gasUsed,
-      this.feePayer,
-      bigintToUInt64BE(this.expirationTimestamp),
-      isForPublic ? this.forPublic!.toBuffer() : this.forRollup!.toBuffer(),
-    );
+    serializeToSink(sink, isForPublic, this.constants, this.gasUsed, this.feePayer);
+    sink.writeUInt64(this.expirationTimestamp);
+    if (isForPublic) {
+      this.forPublic!.toBuffer(sink);
+    } else {
+      this.forRollup!.toBuffer(sink);
+    }
   }
 
   static empty() {

package/src/kernel/private_log_data.ts

@@ -85,7 +85,10 @@ export class ScopedPrivateLogData {
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new ScopedPrivateLogData(reader.readObject(PrivateLogData), AztecAddress.fromField(reader.readField()));
+    return new ScopedPrivateLogData(
+      reader.readObject(PrivateLogData),
+      AztecAddress.fromFieldUnsafe(reader.readField()),
+    );
   }
 
   isEmpty() {