@aztec/stdlib 3.0.0-devnet.2 → 3.0.0-manual.20251030

package/src/interfaces/epoch-prover.ts

@@ -51,10 +51,10 @@ export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | '
   startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void>;
 
   /**
-   * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
+   * Note that if the chonk verifier circuits are not started this way, they will be started nonetheless after processing.
    */
-  startTubeCircuits(txs: Tx[]): Promise<void>;
+  startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
 
   /** Returns the block. */
   setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;

package/src/interfaces/private_kernel_prover.ts

@@ -10,7 +10,7 @@ import type {
   PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
-import type { ClientIvcProofWithPublicInputs } from '../proofs/client_ivc_proof.js';
+import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
 
 /**
  * PrivateKernelProver provides functionality to simulate and validate circuits, and retrieve
@@ -110,7 +110,7 @@ export interface PrivateKernelProver {
    * @param acirs The program bytecode.
    * @param witnessStack The witnessses for each program bytecode.
    */
-  createClientIvcProof(executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProofWithPublicInputs>;
+  createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
 
   /**
    * Compute the gate count for a given circuit.

package/src/interfaces/proving-job.ts

@@ -32,8 +32,8 @@ import {
   CheckpointRootSingleBlockRollupPrivateInputs,
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
-import { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
-import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
+import { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -91,7 +91,10 @@ export const ProvingJobInputs = z.discriminatedUnion('type', [
   AvmProvingRequestSchema,
   z.object({ type: z.literal(ProvingRequestType.PARITY_BASE), inputs: ParityBasePrivateInputs.schema }),
   z.object({ type: z.literal(ProvingRequestType.PARITY_ROOT), inputs: ParityRootPrivateInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PUBLIC_TUBE), inputs: PublicTubePrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
+    inputs: PublicChonkVerifierPrivateInputs.schema,
+  }),
   z.object({
     type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
     inputs: PrivateTxBaseRollupPrivateInputs.schema,
@@ -142,8 +145,8 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
   switch (type) {
     case ProvingRequestType.PUBLIC_VM:
       return AvmCircuitInputs;
-    case ProvingRequestType.PUBLIC_TUBE:
-      return PublicTubePrivateInputs;
+    case ProvingRequestType.PUBLIC_CHONK_VERIFIER:
+      return PublicChonkVerifierPrivateInputs;
     case ProvingRequestType.PRIVATE_TX_BASE_ROLLUP:
       return PrivateTxBaseRollupPrivateInputs;
     case ProvingRequestType.PUBLIC_TX_BASE_ROLLUP:
@@ -187,7 +190,7 @@ export type ProvingJobInputs = z.infer<typeof ProvingJobInputs>;
 
 export type ProvingJobInputsMap = {
   [ProvingRequestType.PUBLIC_VM]: AvmCircuitInputs;
-  [ProvingRequestType.PUBLIC_TUBE]: PublicTubePrivateInputs;
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicChonkVerifierPrivateInputs;
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PrivateTxBaseRollupPrivateInputs;
   [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicTxBaseRollupPrivateInputs;
   [ProvingRequestType.TX_MERGE_ROLLUP]: TxMergeRollupPrivateInputs;
@@ -212,9 +215,9 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     result: schemaForRecursiveProofAndVerificationKey(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PUBLIC_TUBE),
+    type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
     result: schemaForPublicInputsAndRecursiveProof(
-      PublicTubePublicInputs.schema,
+      PublicChonkVerifierPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
@@ -325,8 +328,8 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
   [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
-  [ProvingRequestType.PUBLIC_TUBE]: PublicInputsAndRecursiveProof<
-    PublicTubePublicInputs,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
+    PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<

package/src/interfaces/server_circuit_prover.ts

@@ -26,8 +26,8 @@ import type {
   CheckpointRootSingleBlockRollupPrivateInputs,
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
 import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
-import type { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
-import type { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
+import type { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import type { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
 import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -60,11 +60,13 @@ export interface ServerCircuitProver {
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
 
-  getPublicTubeProof(
-    inputs: PublicTubePrivateInputs,
+  getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  >;
 
   /**
    * Creates a proof for the given input.

package/src/kernel/private_kernel_data.ts

@@ -7,8 +7,8 @@ import { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_publi
  * Data of the previous kernel iteration in the chain of kernels.
  */
 export class PrivateKernelData {
-  // NOTE: as of move to honk and client IVC, previous private kernels no longer come with their proof
-  // as we do client IVC not recursive verification. We need to ensure the public inputs here is properly constrained, TODO(https://github.com/AztecProtocol/barretenberg/issues/1048)
+  // NOTE: as of move to honk and chonk, previous private kernels no longer come with their proof
+  // as we do chonk not recursive verification. We need to ensure the public inputs here is properly constrained, TODO(https://github.com/AztecProtocol/barretenberg/issues/1048)
   constructor(
     /**
      * Public inputs of the previous kernel.

package/src/kernel/private_kernel_prover_output.ts

@@ -5,7 +5,7 @@ import { serializeWitness } from '@aztec/noir-noirc_abi';
 import { Encoder } from 'msgpackr';
 import { z } from 'zod';
 
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+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';
 
@@ -45,10 +45,10 @@ export interface PrivateKernelExecutionProofOutput<
   /** 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 tube" circuit.*/
-  clientIvcProof: ClientIvcProof;
+   * which recursively verifies it through the "private tx base" or the "public chonk verifier" circuit.*/
+  chonkProof: ChonkProof;
   /**
-   * The trace the clientIvcProof corresponds to.
+   * 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.
    */

package/src/keys/derivation.ts

@@ -50,7 +50,7 @@ export async function computeAddress(publicKeys: PublicKeys, partialAddress: Fr)
   // 2. addressPoint = (preaddress * G) + ivpk_m
   // 3. address = addressPoint.x
   const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
-  const address = await new Grumpkin().add(
+  const address = await Grumpkin.add(
     await derivePublicKeyFromSecretKey(new Fq(preaddress.toBigInt())),
     publicKeys.masterIncomingViewingPublicKey,
   );
@@ -81,8 +81,7 @@ export async function computeAddressSecret(preaddress: Fr, ivsk: Fq) {
 }
 
 export function derivePublicKeyFromSecretKey(secretKey: Fq) {
-  const curve = new Grumpkin();
-  return curve.mul(curve.generator(), secretKey);
+  return Grumpkin.mul(Grumpkin.generator, secretKey);
 }
 
 /**

package/src/logs/directional_app_tagging_secret.ts

@@ -63,14 +63,13 @@ async function computeSharedTaggingSecret(
   const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
   // TODO: #8970 - Computation of address point from x coordinate might fail
   const externalAddressPoint = await externalAddress.toAddressPoint();
-  const curve = new Grumpkin();
   // Given A (local complete address) -> B (external address) and h == preaddress
   // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
 
   // Beware! h_a + local_ivsk_a (also known as the address secret) can lead to an address point with a negative
   // y-coordinate, since there's two possible candidates computeAddressSecret takes care of selecting the one that
   // leads to a positive y-coordinate, which is the only valid address point
-  return curve.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
+  return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
 }
 
 export const DirectionalAppTaggingSecretSchema = z.object({

package/src/logs/shared_secret_derivation.ts

@@ -16,13 +16,11 @@ import type { PublicKey } from '../keys/public_key.js';
  * TODO(#12656): This function is kept around because of the utilityGetSharedSecret oracle. Nuke this once returning
  * the app-siloed secret.
  */
-export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
+export function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
   if (publicKey.isZero()) {
     throw new Error(
       `Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`,
     );
   }
-  const curve = new Grumpkin();
-  const sharedSecret = await curve.mul(publicKey, secretKey);
-  return sharedSecret;
+  return Grumpkin.mul(publicKey, secretKey);
 }

package/src/p2p/gossipable.ts

@@ -28,15 +28,12 @@ export class P2PMessage {
  */
 export abstract class Gossipable {
   private cachedId: Buffer32 | undefined;
-  /** p2p Topic
-   *
-   * - The p2p topic identifier, this determines how the message is handled
-   */
+  /** The p2p topic identifier, this determines how the message is handled */
   static p2pTopic: TopicType;
 
-  /** p2p Message Identifier
-   *
-   *  - A digest of the message information, this key is used for deduplication
+  /**
+   * A digest of the message information **used for logging only**.
+   * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
    */
   async p2pMessageIdentifier(): Promise<Buffer32> {
     if (this.cachedId) {
@@ -48,10 +45,6 @@ export abstract class Gossipable {
 
   abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
-  /** To Buffer
-   *
-   * - Serialization method
-   */
   abstract toBuffer(): Buffer;
 
   toMessage(): Buffer {
@@ -60,7 +53,6 @@ export abstract class Gossipable {
 
   /**
    * Get the size of the gossipable object.
-   *
    * This is used for metrics recording.
    */
   abstract getSize(): number;

package/src/p2p/topic_type.ts

@@ -1,18 +1,25 @@
 import { P2PClientType } from './client_type.js';
 
-/** Create Topic String
- *
- * The topic channel identifier
- * @param topicType
- * @returns
+/**
+ * Creates the topic channel identifier string from a given topic type
  */
 export function createTopicString(topicType: TopicType, protocolVersion: string) {
   return `/aztec/${TopicType[topicType]}/${protocolVersion}`;
 }
 
-/**
- *
- */
+/** Extracts the topic type from a topic string */
+export function getTopicFromString(topicStr: string): TopicType | undefined {
+  const parts = topicStr.split('/');
+  if (parts.length < 4 || parts[1] !== 'aztec') {
+    return undefined;
+  }
+  const topic = parts[2];
+  if (Object.values(TopicType).includes(topic as TopicType)) {
+    return topic as TopicType;
+  }
+  return undefined;
+}
+
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',

package/src/proofs/{client_ivc_proof.ts → chonk_proof.ts}

@@ -1,23 +1,24 @@
-import { CIVC_PROOF_LENGTH } from '@aztec/constants';
+import { CHONK_PROOF_LENGTH } from '@aztec/constants';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-export class ClientIvcProof {
+// CHONK: "Client Honk" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.
+export class ChonkProof {
   constructor(
     // The proof fields.
     // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
     // Not using Tuple here due to the length being too high.
     public fields: Fr[],
   ) {
-    if (fields.length !== CIVC_PROOF_LENGTH) {
-      throw new Error(`Invalid ClientIvcProof length: ${fields.length}`);
+    if (fields.length !== CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProof length: ${fields.length}`);
     }
   }
 
   public attachPublicInputs(publicInputs: Fr[]) {
-    return new ClientIvcProofWithPublicInputs([...publicInputs, ...this.fields]);
+    return new ChonkProofWithPublicInputs([...publicInputs, ...this.fields]);
   }
 
   public isEmpty() {
@@ -25,22 +26,22 @@ export class ClientIvcProof {
   }
 
   static empty() {
-    return new ClientIvcProof(new Array(CIVC_PROOF_LENGTH).fill(Fr.ZERO));
+    return new ChonkProof(new Array(CHONK_PROOF_LENGTH).fill(Fr.ZERO));
   }
 
   static random() {
     // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
     const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
-    const randomFields = randomBytes(CIVC_PROOF_LENGTH * reducedFrSize);
+    const randomFields = randomBytes(CHONK_PROOF_LENGTH * reducedFrSize);
     const proof = Array.from(
-      { length: CIVC_PROOF_LENGTH },
+      { length: CHONK_PROOF_LENGTH },
       (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
     );
-    return new ClientIvcProof(proof);
+    return new ChonkProof(proof);
   }
 
   static get schema() {
-    return bufferSchemaFor(ClientIvcProof);
+    return bufferSchemaFor(ChonkProof);
   }
 
   // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
@@ -48,11 +49,11 @@ export class ClientIvcProof {
     return this.toBuffer();
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProof {
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProof {
     const reader = BufferReader.asReader(buffer);
     const proofLength = reader.readNumber();
     const proof = reader.readArray(proofLength, Fr);
-    return new ClientIvcProof(proof);
+    return new ChonkProof(proof);
   }
 
   public toBuffer() {
@@ -60,25 +61,25 @@ export class ClientIvcProof {
   }
 }
 
-export class ClientIvcProofWithPublicInputs {
+export class ChonkProofWithPublicInputs {
   constructor(
     // The proof fields with public inputs.
     // For recursive verification, use without public inputs via `removePublicInputs()`.
     public fieldsWithPublicInputs: Fr[],
   ) {
-    if (fieldsWithPublicInputs.length < CIVC_PROOF_LENGTH) {
-      throw new Error(`Invalid ClientIvcProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
+    if (fieldsWithPublicInputs.length < CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
     }
   }
 
   public getPublicInputs() {
-    const numPublicInputs = this.fieldsWithPublicInputs.length - CIVC_PROOF_LENGTH;
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
     return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
   }
 
   public removePublicInputs() {
-    const numPublicInputs = this.fieldsWithPublicInputs.length - CIVC_PROOF_LENGTH;
-    return new ClientIvcProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
   }
 
   public isEmpty() {
@@ -86,11 +87,11 @@ export class ClientIvcProofWithPublicInputs {
   }
 
   static empty() {
-    return ClientIvcProof.empty().attachPublicInputs([]);
+    return ChonkProof.empty().attachPublicInputs([]);
   }
 
   static get schema() {
-    return bufferSchemaFor(ClientIvcProofWithPublicInputs);
+    return bufferSchemaFor(ChonkProofWithPublicInputs);
   }
 
   // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
@@ -98,11 +99,11 @@ export class ClientIvcProofWithPublicInputs {
     return this.toBuffer();
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): ClientIvcProofWithPublicInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProofWithPublicInputs {
     const reader = BufferReader.asReader(buffer);
     const proofLength = reader.readNumber();
     const proof = reader.readArray(proofLength, Fr);
-    return new ClientIvcProofWithPublicInputs(proof);
+    return new ChonkProofWithPublicInputs(proof);
   }
 
   public toBuffer() {
@@ -110,8 +111,8 @@ export class ClientIvcProofWithPublicInputs {
   }
 
   // Called when constructing from bb proving results.
-  static fromBufferArray(fields: Uint8Array[]): ClientIvcProofWithPublicInputs {
+  static fromBufferArray(fields: Uint8Array[]): ChonkProofWithPublicInputs {
     const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
-    return new ClientIvcProofWithPublicInputs(proof);
+    return new ChonkProofWithPublicInputs(proof);
   }
 }

package/src/proofs/index.ts

@@ -1,5 +1,5 @@
 export * from './recursive_proof.js';
-export * from './client_ivc_proof.js';
+export * from './chonk_proof.js';
 export * from './proof.js';
 export * from './proof_data.js';
 export * from './proving_request_type.js';

package/src/proofs/proof_data.ts

@@ -1,4 +1,4 @@
-import type { CIVC_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { CHONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
@@ -29,7 +29,7 @@ export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
   }
 }
 
-export type CivcProofData<T extends Bufferable> = ProofData<T, typeof CIVC_PROOF_LENGTH>;
+export type ChonkProofData<T extends Bufferable> = ProofData<T, typeof CHONK_PROOF_LENGTH>;
 
 export type UltraHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_PROOF_LENGTH>;
 

package/src/proofs/proving_request_type.ts

@@ -1,6 +1,6 @@
 export enum ProvingRequestType {
   PUBLIC_VM,
-  PUBLIC_TUBE,
+  PUBLIC_CHONK_VERIFIER,
 
   PRIVATE_TX_BASE_ROLLUP,
   PUBLIC_TX_BASE_ROLLUP,

package/src/rollup/index.ts

@@ -12,8 +12,8 @@ export * from './checkpoint_root_rollup_private_inputs.js';
 export * from './epoch_constant_data.js';
 export * from './private_tx_base_rollup_private_inputs.js';
 export * from './public_tx_base_rollup_private_inputs.js';
-export * from './public_tube_private_inputs.js';
-export * from './public_tube_public_inputs.js';
+export * from './public_chonk_verifier_private_inputs.js';
+export * from './public_chonk_verifier_public_inputs.js';
 export * from './root_rollup_private_inputs.js';
 export * from './root_rollup_public_inputs.js';
 export * from './tree_snapshot_diff_hints.js';

package/src/rollup/private_tx_base_rollup_private_inputs.ts

@@ -4,12 +4,12 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
-import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
+import { type ChonkProofData, ProofData } from '../proofs/proof_data.js';
 import { PrivateBaseRollupHints } from './base_rollup_hints.js';
 
 export class PrivateTxBaseRollupPrivateInputs {
   constructor(
-    public hidingKernelProofData: CivcProofData<PrivateToRollupKernelCircuitPublicInputs>,
+    public hidingKernelProofData: ChonkProofData<PrivateToRollupKernelCircuitPublicInputs>,
     public hints: PrivateBaseRollupHints,
   ) {}
 

package/src/rollup/{public_tube_private_inputs.ts → public_chonk_verifier_private_inputs.ts}

@@ -5,36 +5,37 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
-import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
+import { type ChonkProofData, ProofData } from '../proofs/proof_data.js';
 
-export class PublicTubePrivateInputs {
+// CHONK_VERIFIER: Recursively verifies Chonk (Client Honk) proofs in circuits
+export class PublicChonkVerifierPrivateInputs {
   constructor(
-    public hidingKernelProofData: CivcProofData<PrivateToPublicKernelCircuitPublicInputs>,
+    public hidingKernelProofData: ChonkProofData<PrivateToPublicKernelCircuitPublicInputs>,
     public proverId: Fr,
   ) {}
 
-  static from(fields: FieldsOf<PublicTubePrivateInputs>) {
-    return new PublicTubePrivateInputs(...PublicTubePrivateInputs.getFields(fields));
+  static from(fields: FieldsOf<PublicChonkVerifierPrivateInputs>) {
+    return new PublicChonkVerifierPrivateInputs(...PublicChonkVerifierPrivateInputs.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PublicTubePrivateInputs>) {
+  static getFields(fields: FieldsOf<PublicChonkVerifierPrivateInputs>) {
     return [fields.hidingKernelProofData, fields.proverId] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicTubePrivateInputs(
+    return new PublicChonkVerifierPrivateInputs(
       ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
       Fr.fromBuffer(reader),
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(...PublicTubePrivateInputs.getFields(this));
+    return serializeToBuffer(...PublicChonkVerifierPrivateInputs.getFields(this));
   }
 
   static fromString(str: string) {
-    return PublicTubePrivateInputs.fromBuffer(hexToBuffer(str));
+    return PublicChonkVerifierPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   toString() {
@@ -48,6 +49,6 @@ export class PublicTubePrivateInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(PublicTubePrivateInputs);
+    return bufferSchemaFor(PublicChonkVerifierPrivateInputs);
   }
 }

package/src/rollup/{public_tube_public_inputs.ts → public_chonk_verifier_public_inputs.ts}

@@ -6,34 +6,35 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 
-export class PublicTubePublicInputs {
+// CHONK_VERIFIER: Recursively verifies Chonk (Client Honk) proofs in circuits
+export class PublicChonkVerifierPublicInputs {
   constructor(
     public privateTail: PrivateToPublicKernelCircuitPublicInputs,
     public proverId: Fr,
   ) {}
 
-  static from(fields: FieldsOf<PublicTubePublicInputs>) {
-    return new PublicTubePublicInputs(...PublicTubePublicInputs.getFields(fields));
+  static from(fields: FieldsOf<PublicChonkVerifierPublicInputs>) {
+    return new PublicChonkVerifierPublicInputs(...PublicChonkVerifierPublicInputs.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PublicTubePublicInputs>) {
+  static getFields(fields: FieldsOf<PublicChonkVerifierPublicInputs>) {
     return [fields.privateTail, fields.proverId] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicTubePublicInputs(
+    return new PublicChonkVerifierPublicInputs(
       reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
       reader.readObject(Fr),
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(...PublicTubePublicInputs.getFields(this));
+    return serializeToBuffer(...PublicChonkVerifierPublicInputs.getFields(this));
   }
 
   static fromString(str: string) {
-    return PublicTubePublicInputs.fromBuffer(hexToBuffer(str));
+    return PublicChonkVerifierPublicInputs.fromBuffer(hexToBuffer(str));
   }
 
   toString() {
@@ -47,6 +48,6 @@ export class PublicTubePublicInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(PublicTubePublicInputs);
+    return bufferSchemaFor(PublicChonkVerifierPublicInputs);
   }
 }

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -7,11 +7,11 @@ import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import type { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
-import { PublicTubePublicInputs } from './public_tube_public_inputs.js';
+import { PublicChonkVerifierPublicInputs } from './public_chonk_verifier_public_inputs.js';
 
 export class PublicTxBaseRollupPrivateInputs {
   constructor(
-    public publicTubeProofData: RollupHonkProofData<PublicTubePublicInputs>,
+    public publicChonkVerifierProofData: RollupHonkProofData<PublicChonkVerifierPublicInputs>,
     public avmProofData: AvmProofData,
     public hints: PublicBaseRollupHints,
   ) {}
@@ -21,13 +21,13 @@ export class PublicTxBaseRollupPrivateInputs {
   }
 
   static getFields(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>) {
-    return [fields.publicTubeProofData, fields.avmProofData, fields.hints] as const;
+    return [fields.publicChonkVerifierProofData, fields.avmProofData, fields.hints] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new PublicTxBaseRollupPrivateInputs(
-      ProofData.fromBuffer(reader, PublicTubePublicInputs),
+      ProofData.fromBuffer(reader, PublicChonkVerifierPublicInputs),
       ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
       reader.readObject(PublicBaseRollupHints),
     );