@aztec/stdlib 0.0.1-commit.993d52e → 0.0.1-commit.9a89641

package/src/kernel/private_context_inputs.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { serializeToFields } from '@aztec/foundation/serialize';
 
 import { BlockHeader } from '../tx/block_header.js';
@@ -11,13 +11,20 @@ export class PrivateContextInputs {
     public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
     public startSideEffectCounter: number,
+    public txRequestSalt: Fr,
   ) {}
 
   public static empty(): PrivateContextInputs {
-    return new PrivateContextInputs(CallContext.empty(), BlockHeader.empty(), TxContext.empty(), 0);
+    return new PrivateContextInputs(CallContext.empty(), BlockHeader.empty(), TxContext.empty(), 0, Fr.ZERO);
   }
 
   public toFields(): Fr[] {
-    return serializeToFields([this.callContext, this.anchorBlockHeader, this.txContext, this.startSideEffectCounter]);
+    return serializeToFields([
+      this.callContext,
+      this.anchorBlockHeader,
+      this.txContext,
+      this.startSideEffectCounter,
+      this.txRequestSalt,
+    ]);
   }
 }

package/src/kernel/private_kernel_circuit_public_inputs.ts

@@ -46,10 +46,6 @@ export class PrivateKernelCircuitPublicInputs {
      * Wether this is a private only tx or not
      */
     public isPrivateOnly: boolean,
-    /**
-     * The nullifier that will be used for nonce generation
-     */
-    public claimedFirstNullifier: Fr,
     /**
      * A claim to the final min revertible side effect counter of a tx.
      */
@@ -74,7 +70,6 @@ export class PrivateKernelCircuitPublicInputs {
       this.feePayer,
       bigintToUInt64BE(this.expirationTimestamp),
       this.isPrivateOnly,
-      this.claimedFirstNullifier,
       this.claimedRevertibleCounter,
     );
   }
@@ -95,7 +90,6 @@ export class PrivateKernelCircuitPublicInputs {
       reader.readObject(AztecAddress),
       reader.readUInt64(),
       reader.readBoolean(),
-      reader.readObject(Fr),
       reader.readNumber(),
     );
   }
@@ -110,8 +104,16 @@ export class PrivateKernelCircuitPublicInputs {
       AztecAddress.ZERO,
       0n,
       false,
-      Fr.zero(),
       0,
     );
   }
 }
+
+/**
+ * Returns true iff the tx requires the public-bound terminal path: it has either un-processed
+ * public-call requests in the side-effect stream or a pending public-teardown call request. Every
+ * site picking between the rollup-bound and public-bound terminal artifact must route through this.
+ */
+export function kernelStateIsForPublic(publicInputs: PrivateKernelCircuitPublicInputs): boolean {
+  return publicInputs.end.publicCallRequests.claimedLength > 0 || !publicInputs.publicTeardownCallRequest.isEmpty();
+}

package/src/kernel/private_kernel_init_2_circuit_private_inputs.ts

@@ -0,0 +1,46 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first two app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit2CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit2CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit2CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_3_circuit_private_inputs.ts

@@ -0,0 +1,49 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first three app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit3CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit3CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit3CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_4_circuit_private_inputs.ts

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first four app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit4CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit4CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit4CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_5_circuit_private_inputs.ts

@@ -0,0 +1,55 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { PrivateCallData } from './private_call_data.js';
+
+/**
+ * Input to the batched private kernel init circuit, which processes the first five app calls of a
+ * transaction in a single iteration.
+ */
+export class PrivateKernelInit5CircuitPrivateInputs {
+  constructor(
+    public txRequest: TxRequest,
+    public vkTreeRoot: Fr,
+    public protocolContracts: ProtocolContracts,
+    public privateCall0: PrivateCallData,
+    public privateCall1: PrivateCallData,
+    public privateCall2: PrivateCallData,
+    public privateCall3: PrivateCallData,
+    public privateCall4: PrivateCallData,
+    public isPrivateOnly: boolean,
+    public revertibleCounterHint: number,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall0,
+      this.privateCall1,
+      this.privateCall2,
+      this.privateCall3,
+      this.privateCall4,
+      this.revertibleCounterHint,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInit5CircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInit5CircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_init_circuit_private_inputs.ts

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

package/src/kernel/private_kernel_inner_2_circuit_private_inputs.ts

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

package/src/kernel/private_kernel_inner_3_circuit_private_inputs.ts

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

package/src/kernel/private_kernel_inner_4_circuit_private_inputs.ts

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

package/src/kernel/private_kernel_inner_5_circuit_private_inputs.ts

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

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

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -68,14 +68,24 @@ export const privateKernelResetDimensionNames: DimensionName[] = [
   'PRIVATE_LOG_SILOING',
 ];
 
-export interface DimensionConfig {
-  variants: number[];
-  standalone: number[];
+export interface ResetCatalogEntry {
+  name: string;
+  dimensions: number[];
+  // Measured gate count (circuit_size) of the compiled variant. Used by the selector to pick the
+  // cheapest variant that covers the requested dimensions, e.g. if the required dimensions are
+  // `6 - 2 - 2` then a variant with capacity `8 - 2 - 2` might be cheaper than one with capacity
+  // `6 - 4 - 4`.
   cost: number;
 }
 
-// Must match the config in noir-projects/noir-protocol-circuits/private_kernel_reset_config.json
+// Must match the shipped private_kernel_reset_config.json, loaded by @aztec/noir-protocol-circuits-types.
 export interface PrivateKernelResetDimensionsConfig {
-  dimensions: { [K in DimensionName]: DimensionConfig };
-  specialCases: number[][];
+  // Variants used for mid-tx resets that prevent overflow. Never the last kernel in the chain.
+  inner: ResetCatalogEntry[];
+  // Variants used as the terminal kernel for the rollup-bound private-only path. Each runs
+  // final-reset siloing and tail finalisation in one proof.
+  finalTail: ResetCatalogEntry[];
+  // Terminal variants for the public-bound path (transactions with public function calls). Runs
+  // final-reset siloing and tail-to-public partitioning by revertibility in one proof.
+  finalTailToPublic: ResetCatalogEntry[];
 }

package/src/kernel/private_kernel_reset_tail_circuit_private_inputs.ts

@@ -0,0 +1,69 @@
+import type {
+  MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+} from '@aztec/constants';
+import { bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import type { UInt64 } from '../types/shared.js';
+import type { PrivateKernelResetHints } from './hints/private_kernel_reset_hints.js';
+import type { PaddedSideEffectAmounts, PaddedSideEffects } from './padded_side_effects.js';
+import { kernelStateIsForPublic } from './private_kernel_circuit_public_inputs.js';
+import type { PrivateKernelData } from './private_kernel_data.js';
+import { PrivateKernelResetCircuitPrivateInputsVariants } from './private_kernel_reset_circuit_private_inputs.js';
+import type { PrivateKernelResetDimensions } from './private_kernel_reset_dimensions.js';
+
+/**
+ * Input to a terminal reset+tail circuit. `isForPublic()` selects the rollup-bound (`reset_tail`)
+ * or public-bound (`reset_tail_to_public`) family.
+ */
+export class PrivateKernelResetTailCircuitPrivateInputs {
+  constructor(
+    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,
+      typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+      typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+      typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+      typeof MAX_NULLIFIERS_PER_TX
+    >,
+    public dimensions: PrivateKernelResetDimensions,
+    public paddedSideEffectAmounts: PaddedSideEffectAmounts,
+    public expirationTimestampUpperBound: UInt64,
+  ) {}
+
+  isForPublic() {
+    return kernelStateIsForPublic(this.previousKernel.publicInputs);
+  }
+
+  /**
+   * Returns a dimension-trimmed view of the reset portion of these inputs (without the tail
+   * fields). The prover uses this to feed witness generation of the variant matching the chosen
+   * dimensions.
+   */
+  trimResetToSizes() {
+    const hints = this.hints.trimToSizes(
+      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, this.paddedSideEffects, hints);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.previousKernel,
+      this.paddedSideEffects,
+      this.hints,
+      this.dimensions,
+      this.paddedSideEffectAmounts,
+      bigintToUInt64BE(this.expirationTimestampUpperBound),
+    );
+  }
+}

package/src/kernel/private_kernel_simulated_output.ts

@@ -17,10 +17,3 @@ export interface PrivateKernelSimulateOutput<
   verificationKey: VerificationKeyData;
   bytecode: Buffer;
 }
-
-/**
- * Represents the output of the circuit simulation process for init and inner private kernel circuit.
- */
-export type AppCircuitSimulateOutput = {
-  verificationKey: VerificationKeyData;
-};

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() {
@@ -234,6 +245,15 @@ export class PrivateKernelTailCircuitPublicInputs {
     return noteHashes.filter(n => !n.isZero());
   }
 
+  getNonEmptyL2ToL1Msgs() {
+    const l2ToL1Msgs = this.forPublic
+      ? this.forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.concat(
+          this.forPublic.revertibleAccumulatedData.l2ToL1Msgs,
+        )
+      : this.forRollup!.end.l2ToL1Msgs;
+    return l2ToL1Msgs.filter(m => !m.isEmpty());
+  }
+
   getNonEmptyNullifiers() {
     const nullifiers = this.forPublic
       ? this.forPublic.nonRevertibleAccumulatedData.nullifiers.concat(
@@ -291,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() {