@aztec/stdlib 3.0.0-nightly.20251026 → 3.0.0-nightly.20251030-2

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/chonk_proof.ts

@@ -0,0 +1,118 @@
+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';
+
+// 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 !== CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProof length: ${fields.length}`);
+    }
+  }
+
+  public attachPublicInputs(publicInputs: Fr[]) {
+    return new ChonkProofWithPublicInputs([...publicInputs, ...this.fields]);
+  }
+
+  public isEmpty() {
+    return this.fields.every(field => field.isZero());
+  }
+
+  static empty() {
+    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(CHONK_PROOF_LENGTH * reducedFrSize);
+    const proof = Array.from(
+      { length: CHONK_PROOF_LENGTH },
+      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
+    );
+    return new ChonkProof(proof);
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ChonkProof);
+  }
+
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProof {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ChonkProof(proof);
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.fields.length, this.fields);
+  }
+}
+
+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 < CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
+    }
+  }
+
+  public getPublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
+  }
+
+  public removePublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+  }
+
+  public isEmpty() {
+    return this.fieldsWithPublicInputs.every(field => field.isZero());
+  }
+
+  static empty() {
+    return ChonkProof.empty().attachPublicInputs([]);
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ChonkProofWithPublicInputs);
+  }
+
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProofWithPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ChonkProofWithPublicInputs(proof);
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.fieldsWithPublicInputs.length, this.fieldsWithPublicInputs);
+  }
+
+  // Called when constructing from bb proving results.
+  static fromBufferArray(fields: Uint8Array[]): ChonkProofWithPublicInputs {
+    const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
+    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/checkpoint_rollup_public_inputs.ts

@@ -1,4 +1,4 @@
-import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -1,4 +1,4 @@
-import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
 import { ARCHIVE_HEIGHT, BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
 import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';

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

package/src/rollup/root_rollup_public_inputs.ts

@@ -1,4 +1,4 @@
-import { FinalBlobAccumulator } from '@aztec/blob-lib';
+import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';

package/src/stats/stats.ts

@@ -88,7 +88,7 @@ export type ClientCircuitName =
 export type ServerCircuitName =
   | 'parity-base'
   | 'parity-root'
-  | 'tube-public'
+  | 'chonk-verifier-public'
   | 'rollup-tx-base-private'
   | 'rollup-tx-base-public'
   | 'rollup-tx-merge'
@@ -181,8 +181,8 @@ export type CircuitVerificationStats = {
   eventName: 'circuit-verification';
   /** Name of the circuit. */
   circuitName: CircuitName;
-  /** Type of proof (client-ivc, honk, etc) */
-  proofType: 'client-ivc' | 'ultra-honk';
+  /** Type of proof (chonk, honk, etc) */
+  proofType: 'chonk' | 'ultra-honk';
   /** Duration in ms. */
   duration: number;
 };

package/src/tests/factories.ts

@@ -1,10 +1,9 @@
-import { BlobAccumulator, FinalBlobAccumulator } from '@aztec/blob-lib';
 import { makeBatchedBlobAccumulator, makeSpongeBlob } from '@aztec/blob-lib/testing';
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AZTEC_MAX_EPOCH_DURATION,
-  CIVC_PROOF_LENGTH,
+  CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   FIXED_DA_GAS,
   FIXED_L2_GAS,
@@ -42,9 +41,9 @@ import {
 } from '@aztec/constants';
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
 import { compact, padArrayEnd } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
+import { Grumpkin, SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Fq, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable, Serializable, Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
@@ -143,7 +142,7 @@ import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { CheckpointRollupPublicInputs, FeeRecipient } from '../rollup/checkpoint_rollup_public_inputs.js';
 import { EpochConstantData } from '../rollup/epoch_constant_data.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
-import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
+import { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
 import { TreeSnapshotDiffHints } from '../rollup/tree_snapshot_diff_hints.js';
@@ -417,8 +416,8 @@ export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   );
 }
 
-export function makePublicTubePublicInputs(seed = 1) {
-  return new PublicTubePublicInputs(makePrivateToPublicKernelCircuitPublicInputs(seed), fr(seed + 0x1000));
+export function makePublicChonkVerifierPublicInputs(seed = 1) {
+  return new PublicChonkVerifierPublicInputs(makePrivateToPublicKernelCircuitPublicInputs(seed), fr(seed + 0x1000));
 }
 
 export function makeProtocolContracts(seed = 1) {
@@ -758,8 +757,8 @@ export function makeCheckpointRollupPublicInputs(seed = 0) {
     makeAppendOnlyTreeSnapshot(seed + 0x200),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x700),
-    BlobAccumulator.fromBatchedBlobAccumulator(startBlobAccumulator),
-    BlobAccumulator.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 1)),
+    startBlobAccumulator.toBlobAccumulator(),
+    makeBatchedBlobAccumulator(seed + 1).toBlobAccumulator(),
     startBlobAccumulator.finalBlobChallenges,
   );
 }
@@ -795,7 +794,7 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
     makeEpochConstantData(seed + 0x600),
-    FinalBlobAccumulator.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed)),
+    makeBatchedBlobAccumulator(seed).toFinalBlobAccumulator(),
   );
 }
 
@@ -1084,18 +1083,22 @@ function makePublicBaseRollupHints(seed = 1) {
 
 export function makePrivateTxBaseRollupPrivateInputs(seed = 0) {
   return PrivateTxBaseRollupPrivateInputs.from({
-    hidingKernelProofData: makeProofData(seed, makePrivateToRollupKernelCircuitPublicInputs, CIVC_PROOF_LENGTH),
+    hidingKernelProofData: makeProofData(seed, makePrivateToRollupKernelCircuitPublicInputs, CHONK_PROOF_LENGTH),
     hints: makePrivateBaseRollupHints(seed + 0x100),
   });
 }
 
 export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
-  const publicTubeProofData = makeProofData(seed, makePublicTubePublicInputs, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH);
+  const publicChonkVerifierProofData = makeProofData(
+    seed,
+    makePublicChonkVerifierPublicInputs,
+    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  );
   const avmProofData = makeProofData(seed + 0x100, makeAvmCircuitPublicInputs, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
   const hints = makePublicBaseRollupHints(seed + 0x200);
 
   return PublicTxBaseRollupPrivateInputs.from({
-    publicTubeProofData,
+    publicChonkVerifierProofData,
     avmProofData,
     hints,
   });
@@ -1183,13 +1186,10 @@ export async function makeMapAsync<T>(size: number, fn: (i: number) => Promise<[
   return new Map(await makeArrayAsync(size, i => fn(i + offset)));
 }
 
-export function makePublicKeys(seed = 0): PublicKeys {
-  return new PublicKeys(
-    new Point(new Fr(seed + 0), new Fr(seed + 1), false),
-    new Point(new Fr(seed + 2), new Fr(seed + 3), false),
-    new Point(new Fr(seed + 4), new Fr(seed + 5), false),
-    new Point(new Fr(seed + 6), new Fr(seed + 7), false),
-  );
+export async function makePublicKeys(seed = 0): Promise<PublicKeys> {
+  const f = (offset: number) => Grumpkin.mul(Grumpkin.generator, new Fq(seed + offset));
+
+  return new PublicKeys(await f(0), await f(1), await f(2), await f(3));
 }
 
 export async function makeContractInstanceFromClassId(
@@ -1205,7 +1205,7 @@ export async function makeContractInstanceFromClassId(
   const salt = new Fr(seed);
   const initializationHash = overrides?.initializationHash ?? new Fr(seed + 1);
   const deployer = overrides?.deployer ?? new AztecAddress(new Fr(seed + 2));
-  const publicKeys = overrides?.publicKeys ?? makePublicKeys(seed + 3);
+  const publicKeys = overrides?.publicKeys ?? (await makePublicKeys(seed + 3));
 
   const saltedInitializationHash = await poseidon2HashWithSeparator(
     [salt, initializationHash, deployer],

package/src/tests/mocks.ts

@@ -30,7 +30,7 @@ import { BlockAttestation } from '../p2p/block_attestation.js';
 import { BlockProposal } from '../p2p/block_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import { HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, StateReference, Tx } from '../tx/index.js';
 import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
@@ -67,7 +67,7 @@ export const mockTx = async (
     hasPublicTeardownCallRequest = false,
     publicCalldataSize = 2,
     feePayer,
-    clientIvcProof = ClientIvcProof.random(),
+    chonkProof = ChonkProof.random(),
     maxPriorityFeesPerGas,
     gasUsed = Gas.empty(),
     chainId = Fr.ZERO,
@@ -81,7 +81,7 @@ export const mockTx = async (
     hasPublicTeardownCallRequest?: boolean;
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
-    clientIvcProof?: ClientIvcProof;
+    chonkProof?: ChonkProof;
     maxPriorityFeesPerGas?: GasFees;
     gasUsed?: Gas;
     chainId?: Fr;
@@ -150,7 +150,7 @@ export const mockTx = async (
 
   return await Tx.create({
     data,
-    clientIvcProof,
+    chonkProof,
     contractClassLogFields: [],
     publicFunctionCalldata,
   });

package/src/tx/processed_tx.ts

@@ -8,7 +8,7 @@ import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
 import { computeL2ToL1MessageHash } from '../hash/hash.js';
 import type { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProof } from '../proofs/chonk_proof.js';
 import type { GlobalVariables } from './global_variables.js';
 import type { Tx } from './tx.js';
 import { TxEffect } from './tx_effect.js';
@@ -36,7 +36,7 @@ export type ProcessedTx = {
   /**
    * Proof for the private execution.
    */
-  clientIvcProof: ClientIvcProof;
+  chonkProof: ChonkProof;
   /**
    * The request for AVM proving.
    */
@@ -118,7 +118,7 @@ export function makeProcessedTxFromPrivateOnlyTx(
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest: undefined,
     globalVariables,
     txEffect,
@@ -128,12 +128,6 @@ export function makeProcessedTxFromPrivateOnlyTx(
   };
 }
 
-export function toNumBlobFields(txs: ProcessedTx[]): number {
-  return txs.reduce((acc, tx) => {
-    return acc + tx.txEffect.toBlobFields().length;
-  }, 0);
-}
-
 export function makeProcessedTxFromTxWithPublicCalls(
   tx: Tx,
   avmProvingRequest: AvmProvingRequest,
@@ -182,7 +176,7 @@ export function makeProcessedTxFromTxWithPublicCalls(
   return {
     hash: txEffect.txHash,
     data: tx.data,
-    clientIvcProof: tx.clientIvcProof,
+    chonkProof: tx.chonkProof,
     avmProvingRequest,
     globalVariables,
     txEffect,

package/src/tx/proven_tx.ts

@@ -4,7 +4,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { OffchainEffect } from './offchain_effect.js';
 import {
   PrivateExecutionResult,
@@ -18,7 +18,7 @@ export class TxProvingResult {
   constructor(
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
-    public clientIvcProof: ClientIvcProof,
+    public chonkProof: ChonkProof,
     public stats?: ProvingStats,
   ) {}
 
@@ -27,7 +27,7 @@ export class TxProvingResult {
 
     return await Tx.create({
       data: this.publicInputs,
-      clientIvcProof: this.clientIvcProof,
+      chonkProof: this.chonkProof,
       contractClassLogFields: contractClassLogs,
       publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
     });
@@ -42,21 +42,21 @@ export class TxProvingResult {
       .object({
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
+        chonkProof: ChonkProof.schema,
         timings: optional(ProvingTimingsSchema),
       })
       .transform(TxProvingResult.from);
   }
 
   static from(fields: FieldsOf<TxProvingResult>) {
-    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+    return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.chonkProof);
   }
 
   static async random() {
     return new TxProvingResult(
       await PrivateExecutionResult.random(),
       PrivateKernelTailCircuitPublicInputs.empty(),
-      ClientIvcProof.empty(),
+      ChonkProof.empty(),
     );
   }
 }