@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/kernel/private_kernel_init_4_circuit_private_inputs.ts

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/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-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/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

@@ -0,0 +1,69 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/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 private kernel circuit - initial call.
+ */
+export class PrivateKernelInitCircuitPrivateInputs {
+  constructor(
+    /**
+     * The transaction request which led to the creation of these inputs.
+     */
+    public txRequest: TxRequest,
+    /**
+     * The root of the vk tree.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * The protocol contracts.
+     */
+    public protocolContracts: ProtocolContracts,
+    /**
+     * Private calldata corresponding to this iteration of the kernel.
+     */
+    public privateCall: PrivateCallData,
+    /**
+     * Wether this tx will make public calls or not.
+     */
+    public isPrivateOnly: boolean,
+    /**
+     * A claim to the final min revertible side effect counter of a tx.
+     */
+    public revertibleCounterHint: number,
+  ) {}
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(
+      this.txRequest,
+      this.vkTreeRoot,
+      this.protocolContracts,
+      this.privateCall,
+      this.revertibleCounterHint,
+    );
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInitCircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInitCircuitPrivateInputs(
+      reader.readObject(TxRequest),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+      reader.readObject(PrivateCallData),
+      reader.readBoolean(),
+      reader.readNumber(),
+    );
+  }
+}

package/src/kernel/private_kernel_inner_2_circuit_private_inputs.ts

@@ -0,0 +1,29 @@
+import { BufferReader, serializeToBuffer } from '@aztec-labs/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-labs/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-labs/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-labs/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_inner_circuit_private_inputs.ts

@@ -0,0 +1,41 @@
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { PrivateCallData } from './private_call_data.js';
+import { PrivateKernelData } from './private_kernel_data.js';
+
+/**
+ * Input to the private kernel circuit - Inner call.
+ */
+export class PrivateKernelInnerCircuitPrivateInputs {
+  constructor(
+    /**
+     * The previous kernel data
+     */
+    public previousKernel: PrivateKernelData,
+    /**
+     * Private calldata corresponding to this iteration of the kernel.
+     */
+    public privateCall: PrivateCallData,
+  ) {}
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.previousKernel, this.privateCall);
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateKernelInnerCircuitPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateKernelInnerCircuitPrivateInputs(
+      reader.readObject(PrivateKernelData),
+      reader.readObject(PrivateCallData),
+    );
+  }
+}

package/src/kernel/private_kernel_prover_output.ts

@@ -0,0 +1,74 @@
+import { CircuitKind } from '@aztec/bb.js';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
+
+import { bufferSchema, mapSchema } from '@aztec-labs/foundation/schemas';
+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,
+  kind: z.nativeEnum(CircuitKind),
+  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;
+  kind: CircuitKind;
+  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,
+      kind: step.kind,
+    };
+  };
+  return new Encoder({ useRecords: false }).pack(steps.map(stepToStruct));
+}

package/src/kernel/private_kernel_reset_circuit_private_inputs.ts

@@ -0,0 +1,80 @@
+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-labs/constants';
+import { serializeToBuffer } from '@aztec-labs/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';
+
+export class PrivateKernelResetCircuitPrivateInputsVariants<
+  NH_RR_PENDING extends number,
+  NH_RR_SETTLED extends number,
+  NLL_RR_PENDING extends number,
+  NLL_RR_SETTLED 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_HINTS_LEN,
+      TRANSIENT_DATA_HINTS_LEN
+    >,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints);
+  }
+}
+
+/**
+ * Input to the private kernel circuit - reset call.
+ */
+export class PrivateKernelResetCircuitPrivateInputs {
+  constructor(
+    /**
+     * 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,
+      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,
+  ) {}
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.previousKernel, this.paddedSideEffects, this.hints, this.dimensions);
+  }
+
+  trimToSizes() {
+    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);
+  }
+}

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -0,0 +1,91 @@
+import { serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+
+export class PrivateKernelResetDimensions {
+  constructor(
+    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_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,
+    );
+  }
+
+  static empty() {
+    return new PrivateKernelResetDimensions(0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+
+  static from(fields: Partial<FieldsOf<PrivateKernelResetDimensions>>) {
+    const dimensions = PrivateKernelResetDimensions.empty();
+    privateKernelResetDimensionNames.forEach(name => (dimensions[name] = fields[name] ?? 0));
+    return dimensions;
+  }
+
+  static fromValues(values: number[]) {
+    if (values.length !== privateKernelResetDimensionNames.length) {
+      throw new Error(
+        `Not enough values for all dimensions. Required ${privateKernelResetDimensionNames.length}. Got ${values.length}.`,
+      );
+    }
+    const dimensions = PrivateKernelResetDimensions.empty();
+    privateKernelResetDimensionNames.forEach((name, i) => (dimensions[name] = values[i]));
+    return dimensions;
+  }
+
+  toValues() {
+    return privateKernelResetDimensionNames.map(name => this[name]);
+  }
+}
+
+export type DimensionName = keyof FieldsOf<PrivateKernelResetDimensions>;
+
+export const privateKernelResetDimensionNames: DimensionName[] = [
+  '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 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 shipped private_kernel_reset_config.json, loaded by @aztec-labs/noir-protocol-circuits-types.
+export interface PrivateKernelResetDimensionsConfig {
+  // 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-labs/constants';
+import { bigintToUInt64BE, serializeToBuffer } from '@aztec-labs/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),
+    );
+  }
+}