@aztec/stdlib 3.0.0-devnet.5 → 3.0.0-devnet.6-patch.1

package/src/note/note_dao.ts

@@ -0,0 +1,182 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Note } from '@aztec/stdlib/note';
+import { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
+ * information required to use it during execution and manage its state.
+ */
+export class NoteDao {
+  constructor(
+    // Note information
+
+    /** The packed content of the note, as will be returned in the getNotes oracle. */
+    public note: Note,
+    /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
+    public contractAddress: AztecAddress,
+    /** The owner of the note - generally the account that can spend the note. */
+    public owner: AztecAddress,
+    /**
+     * The storage location of the note. This value is not used for anything in PXE, but we do index by storage slot
+     * since contracts typically make queries based on it.
+     */
+    public storageSlot: Fr,
+    /**
+     * The randomness injected to the note hash preimage.
+     */
+    public randomness: Fr,
+    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
+    public noteNonce: Fr,
+
+    // Computed values
+    /**
+     * The inner hash (non-unique, non-siloed) of the note. Each contract determines how the note is hashed. Can
+     * be used alongside contractAddress and nonce to compute the uniqueNoteHash and the siloedNoteHash.
+     */
+    public noteHash: Fr,
+    /**
+     * The nullifier of the note, siloed by contract address.
+     * Note: Might be set as 0 if the note was added to PXE as nullified.
+     */
+    public siloedNullifier: Fr,
+
+    // Metadata
+    /** The hash of the tx in which this note was created. Knowing the tx hash allows for efficient node queries e.g.
+     *  when searching for txEffects.
+     */
+    public txHash: TxHash,
+    /** The L2 block number in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockNumber: BlockNumber,
+    /** The L2 block hash in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockHash: string,
+    /** The index of the leaf in the global note hash tree the note is stored at */
+    public index: bigint,
+  ) {}
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.note,
+      this.contractAddress,
+      this.owner,
+      this.storageSlot,
+      this.randomness,
+      this.noteNonce,
+      this.noteHash,
+      this.siloedNullifier,
+      this.txHash,
+      this.l2BlockNumber,
+      Fr.fromHexString(this.l2BlockHash),
+      this.index,
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    const note = Note.fromBuffer(reader);
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const owner = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const randomness = Fr.fromBuffer(reader);
+    const noteNonce = Fr.fromBuffer(reader);
+    const noteHash = Fr.fromBuffer(reader);
+    const siloedNullifier = Fr.fromBuffer(reader);
+    const txHash = reader.readObject(TxHash);
+    const l2BlockNumber = BlockNumber(reader.readNumber());
+    const l2BlockHash = Fr.fromBuffer(reader).toString();
+    const index = toBigIntBE(reader.readBytes(32));
+
+    return new NoteDao(
+      note,
+      contractAddress,
+      owner,
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().toString('hex');
+  }
+
+  static fromString(str: string) {
+    const hex = str.replace(/^0x/, '');
+    return NoteDao.fromBuffer(Buffer.from(hex, 'hex'));
+  }
+
+  /**
+   * Returns true if this note is equal to the `other` one.
+   */
+  equals(other: NoteDao): boolean {
+    return (
+      this.note.equals(other.note) &&
+      this.contractAddress.equals(other.contractAddress) &&
+      this.owner.equals(other.owner) &&
+      this.storageSlot.equals(other.storageSlot) &&
+      this.randomness.equals(other.randomness) &&
+      this.noteNonce.equals(other.noteNonce) &&
+      this.noteHash.equals(other.noteHash) &&
+      this.siloedNullifier.equals(other.siloedNullifier) &&
+      this.txHash.equals(other.txHash) &&
+      this.l2BlockNumber === other.l2BlockNumber &&
+      this.l2BlockHash === other.l2BlockHash &&
+      this.index === other.index
+    );
+  }
+
+  /**
+   * Returns the size in bytes of the Note Dao.
+   * @returns - Its size in bytes.
+   */
+  public getSize() {
+    const indexSize = Math.ceil(Math.log2(Number(this.index)));
+    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
+    return (
+      noteSize + AztecAddress.SIZE_IN_BYTES * 2 + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize
+    );
+  }
+
+  static async random({
+    note = Note.random(),
+    contractAddress = undefined,
+    owner = undefined,
+    storageSlot = Fr.random(),
+    randomness = Fr.random(),
+    noteNonce = Fr.random(),
+    noteHash = Fr.random(),
+    siloedNullifier = Fr.random(),
+    txHash = TxHash.random(),
+    l2BlockNumber = BlockNumber(Math.floor(Math.random() * 1000)),
+    l2BlockHash = Fr.random().toString(),
+    index = Fr.random().toBigInt(),
+  }: Partial<NoteDao> = {}) {
+    return new NoteDao(
+      note,
+      contractAddress ?? (await AztecAddress.random()),
+      owner ?? (await AztecAddress.random()),
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+}

package/src/note/notes_filter.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
@@ -16,6 +16,8 @@ export type NotesFilter = {
    * @remarks Providing a contract address is required as we need that information to trigger private state sync.
    */
   contractAddress: AztecAddress;
+  /** The owner of the note. */
+  owner?: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
   /** The status of the note. Defaults to 'ACTIVE'. */
@@ -28,6 +30,7 @@ export type NotesFilter = {
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
   contractAddress: schemas.AztecAddress,
+  owner: schemas.AztecAddress.optional(),
   storageSlot: schemas.Fr.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),

package/src/p2p/block_attestation.ts

@@ -1,8 +1,10 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
@@ -62,7 +64,7 @@ export class BlockAttestation extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 

package/src/p2p/block_proposal.ts

@@ -1,8 +1,10 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { L2BlockInfo } from '../block/l2_block_info.js';
@@ -65,13 +67,13 @@ export class BlockProposal extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 
   toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
-      slotNumber: this.slotNumber.toNumber(),
+      slotNumber: this.slotNumber,
       lastArchive: this.payload.header.lastArchiveRoot,
       timestamp: this.payload.header.timestamp,
       archive: this.archive,

package/src/p2p/consensus_payload.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
@@ -8,8 +8,8 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
-import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -20,8 +20,6 @@ export class ConsensusPayload implements Signable {
     public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The state reference after the block is added */
-    public readonly stateReference: StateReference,
   ) {}
 
   static get schema() {
@@ -29,13 +27,12 @@ export class ConsensusPayload implements Signable {
       .object({
         header: CheckpointHeader.schema,
         archive: schemas.Fr,
-        stateReference: StateReference.schema,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.stateReference] as const;
+    return [fields.header, fields.archive] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -43,59 +40,53 @@ export class ConsensusPayload implements Signable {
       'uint8, ' + //domainSeperator
         '(' +
         'bytes32, ' + // archive
-        '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
         'bytes32' + // headerHash
         ')',
     );
     const archiveRoot = this.archive.toString();
-    const stateReference = this.stateReference.toAbi();
 
     const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
+      [archiveRoot, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.header, this.archive, this.stateReference]);
+    return serializeToBuffer([this.header, this.archive]);
   }
 
   public equals(other: ConsensusPayload): boolean {
-    return (
-      this.header.equals(other.header) &&
-      this.archive.equals(other.archive) &&
-      this.stateReference.equals(other.stateReference)
-    );
+    return this.header.equals(other.header) && this.archive.equals(other.archive);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    const payload = new ConsensusPayload(
-      reader.readObject(CheckpointHeader),
-      reader.readObject(Fr),
-      reader.readObject(StateReference),
-    );
+    const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr));
     return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+    return new ConsensusPayload(fields.header, fields.archive);
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
+    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root);
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO);
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random());
   }
 
   /**
@@ -115,11 +106,10 @@ export class ConsensusPayload implements Signable {
     return {
       header: this.header.toInspect(),
       archive: this.archive.toString(),
-      stateReference: this.stateReference.toInspect(),
     };
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}}`;
   }
 }

package/src/p2p/gossipable.ts

@@ -1,23 +1,32 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
 
 export class P2PMessage {
-  constructor(public readonly payload: Buffer) {}
+  constructor(
+    public readonly payload: Buffer,
+    public readonly timestamp?: Date,
+  ) {}
 
-  static fromGossipable(message: Gossipable): P2PMessage {
-    return new P2PMessage(message.toBuffer());
+  static fromGossipable(message: Gossipable, instrumentMessages = false): P2PMessage {
+    return new P2PMessage(message.toBuffer(), instrumentMessages ? new Date() : undefined);
   }
 
-  static fromMessageData(messageData: Buffer): P2PMessage {
+  static fromMessageData(messageData: Buffer, instrumentMessages = false): P2PMessage {
     const reader = new BufferReader(messageData);
+    const timestamp = instrumentMessages ? new Date(Number(reader.readUInt64())) : undefined;
     const payload = reader.readBuffer();
-    return new P2PMessage(payload);
+    return new P2PMessage(payload, timestamp);
   }
 
   toMessageData(): Buffer {
-    return serializeToBuffer([serializeToBuffer(this.payload.length, this.payload)]);
+    const arr: Buffer[] = [];
+    if (this.timestamp) {
+      arr.push(bigintToUInt64BE(BigInt(this.timestamp.getTime())));
+    }
+    arr.push(serializeToBuffer(this.payload.length, this.payload));
+    return serializeToBuffer(arr);
   }
 }
 
@@ -28,17 +37,14 @@ 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> {
+  async p2pMessageLoggingIdentifier(): Promise<Buffer32> {
     if (this.cachedId) {
       return this.cachedId;
     }
@@ -48,10 +54,6 @@ export abstract class Gossipable {
 
   abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
-  /** To Buffer
-   *
-   * - Serialization method
-   */
   abstract toBuffer(): Buffer;
 
   toMessage(): Buffer {
@@ -60,7 +62,6 @@ export abstract class Gossipable {
 
   /**
    * Get the size of the gossipable object.
-   *
    * This is used for metrics recording.
    */
   abstract getSize(): number;

package/src/p2p/signature_utils.ts

@@ -1,5 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { makeEthSignDigest } from '@aztec/foundation/crypto/secp256k1-signer';
 
 export enum SignatureDomainSeparator {
   blockProposal = 0,

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/parity/parity_base_private_inputs.ts

@@ -1,5 +1,5 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/parity/parity_public_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

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

@@ -1,23 +1,24 @@
-import { CIVC_PROOF_LENGTH } from '@aztec/constants';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { CHONK_PROOF_LENGTH } from '@aztec/constants';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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';