@aztec/stdlib 0.0.1-commit.b1c78909e → 0.0.1-commit.b2a5d0dd1

package/src/logs/tx_scoped_l2_log.ts

@@ -1,4 +1,5 @@
 import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas as foundationSchemas } from '@aztec/foundation/schemas';
 import {
@@ -83,6 +84,21 @@ export class TxScopedL2Log {
     return new TxScopedL2Log(txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier);
   }
 
+  static getBlockNumberFromBuffer(buffer: Buffer) {
+    return BlockNumber(buffer.readUint32BE(Fr.SIZE_IN_BYTES));
+  }
+
+  static random() {
+    return new TxScopedL2Log(
+      TxHash.fromField(Fr.random()),
+      BlockNumber(Math.floor(Math.random() * 100000) + 1),
+      BigInt(Math.floor(Date.now() / 1000)),
+      times(3, Fr.random),
+      times(3, Fr.random),
+      Fr.random(),
+    );
+  }
+
   equals(other: TxScopedL2Log) {
     return (
       this.txHash.equals(other.txHash) &&

package/src/messaging/l1_to_l2_message.ts

@@ -6,6 +6,7 @@ import { bufferToHex } from '@aztec/foundation/string';
 import { SiblingPath } from '@aztec/foundation/trees';
 
 import type { AztecAddress } from '../aztec-address/index.js';
+import type { BlockParameter } from '../block/block_parameter.js';
 import { computeL1ToL2MessageNullifier } from '../hash/hash.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
@@ -79,20 +80,22 @@ export async function getNonNullifiedL1ToL2MessageWitness(
   contractAddress: AztecAddress,
   messageHash: Fr,
   secret: Fr,
+  referenceBlock: BlockParameter = 'latest',
 ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-  const response = await node.getL1ToL2MessageMembershipWitness('latest', messageHash);
-  if (!response) {
-    throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
-  }
+  const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
 
-  const [messageIndex, siblingPath] = response;
+  const [l1ToL2Response, nullifierResponse] = await Promise.all([
+    node.getL1ToL2MessageMembershipWitness(referenceBlock, messageHash),
+    node.findLeavesIndexes(referenceBlock, MerkleTreeId.NULLIFIER_TREE, [messageNullifier]),
+  ]);
 
-  const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
+  if (!l1ToL2Response) {
+    throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
+  }
 
-  const [nullifierIndex] = await node.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [messageNullifier]);
-  if (nullifierIndex !== undefined) {
+  if (nullifierResponse[0] !== undefined) {
     throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
 
-  return [messageIndex, siblingPath];
+  return l1ToL2Response;
 }

package/src/messaging/l1_to_l2_message_source.ts

@@ -10,7 +10,9 @@ export interface L1ToL2MessageSource {
   /**
    * Gets new L1 to L2 message (to be) included in a given checkpoint.
    * @param checkpointNumber - Checkpoint number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   * @returns The L1 to L2 messages/leaves of the messages subtree.
+   * @throws If the message tree for the given checkpoint has not yet been sealed on L1
+   * (i.e., checkpointNumber >= inbox treeInProgress).
    */
   getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
 

package/src/messaging/l2_to_l1_membership.ts

@@ -3,6 +3,9 @@ import type { EpochNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
 
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { TxHash } from '../tx/tx_hash.js';
+
 /**
  * # L2-to-L1 Message Tree Structure and Leaf IDs
  *
@@ -92,59 +95,94 @@ export function getL2ToL1MessageLeafId(
   return 2n ** BigInt(membershipWitness.siblingPath.pathSize) + membershipWitness.leafIndex;
 }
 
-export interface MessageRetrieval {
-  getL2ToL1Messages(epoch: EpochNumber): Promise<Fr[][][][]>;
-}
-
 export type L2ToL1MembershipWitness = {
   root: Fr;
   leafIndex: bigint;
   siblingPath: SiblingPath<number>;
+  epochNumber: EpochNumber;
 };
 
+/**
+ * Computes the L2 to L1 membership witness for a given message in a transaction.
+ *
+ * @param node - The Aztec node to query for block/tx/epoch data.
+ * @param message - The L2 to L1 message hash to prove membership of.
+ * @param txHash - The hash of the transaction that emitted the message.
+ * @param messageIndexInTx - Optional index of the message within the transaction's L2-to-L1 messages.
+ *   If not provided, the message is found by scanning the tx's messages (throws if duplicates exist).
+ * @returns The membership witness and epoch number, or undefined if the tx is not yet in a block/epoch.
+ */
 export async function computeL2ToL1MembershipWitness(
-  messageRetriever: MessageRetrieval,
-  epoch: EpochNumber,
+  node: Pick<
+    AztecNode,
+    'getL2ToL1Messages' | 'getTxReceipt' | 'getTxEffect' | 'getBlock' | 'getCheckpointsDataForEpoch'
+  >,
   message: Fr,
+  txHash: TxHash,
+  messageIndexInTx?: number,
 ): Promise<L2ToL1MembershipWitness | undefined> {
-  const messagesInEpoch = await messageRetriever.getL2ToL1Messages(epoch);
-  if (messagesInEpoch.length === 0) {
+  const { epochNumber, blockNumber } = await node.getTxReceipt(txHash);
+  if (epochNumber === undefined || blockNumber === undefined) {
+    return undefined;
+  }
+
+  const [messagesInEpoch, block, txEffect, checkpointsData] = await Promise.all([
+    node.getL2ToL1Messages(epochNumber),
+    node.getBlock(blockNumber),
+    node.getTxEffect(txHash),
+    node.getCheckpointsDataForEpoch(epochNumber),
+  ]);
+
+  if (messagesInEpoch.length === 0 || !block || !txEffect) {
+    return undefined;
+  }
+
+  const checkpointIndex = checkpointsData.findIndex(c => c.checkpointNumber === block.checkpointNumber);
+  if (checkpointIndex === -1) {
     return undefined;
   }
 
-  return computeL2ToL1MembershipWitnessFromMessagesInEpoch(messagesInEpoch, message);
+  const blockIndex = block.indexWithinCheckpoint;
+  const txIndex = txEffect.txIndexInBlock;
+
+  const { root, leafIndex, siblingPath } = computeL2ToL1MembershipWitnessFromMessagesInEpoch(
+    messagesInEpoch,
+    message,
+    checkpointIndex,
+    blockIndex,
+    txIndex,
+    messageIndexInTx,
+  );
+  return { epochNumber, root, leafIndex, siblingPath };
 }
 
-// TODO: Allow to specify the message to consume by its index or by an offset, in case there are multiple messages with
-// the same value.
+/**
+ * Computes a membership witness for a message in the epoch's L2-to-L1 message tree, given explicit position indices.
+ *
+ * @param messagesInEpoch - All L2-to-L1 messages in the epoch, organized as checkpoints → blocks → txs → messages.
+ * @param message - The message hash to prove membership of.
+ * @param checkpointIndex - Index of the checkpoint within the epoch's message array.
+ * @param blockIndex - Index of the block within the checkpoint.
+ * @param txIndex - Index of the transaction within the block.
+ * @param messageIndexInTx - Optional index of the message within the transaction's messages.
+ *   If not provided, the message is found by scanning (throws if duplicates exist within the tx).
+ */
+/** @internal Exported for testing only. */
 export function computeL2ToL1MembershipWitnessFromMessagesInEpoch(
   messagesInEpoch: Fr[][][][],
   message: Fr,
-): L2ToL1MembershipWitness {
-  // Find the index of the message in the tx, index of the tx in the block, and index of the block in the epoch.
-  let messageIndexInTx = -1;
-  let txIndex = -1;
-  let blockIndex = -1;
-  const checkpointIndex = messagesInEpoch.findIndex(messagesInCheckpoint => {
-    blockIndex = messagesInCheckpoint.findIndex(messagesInBlock => {
-      txIndex = messagesInBlock.findIndex(messagesInTx => {
-        messageIndexInTx = messagesInTx.findIndex(msg => msg.equals(message));
-        return messageIndexInTx !== -1;
-      });
-      return txIndex !== -1;
-    });
-    return blockIndex !== -1;
-  });
-
-  if (checkpointIndex === -1) {
-    throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
-  }
+  checkpointIndex: number,
+  blockIndex: number,
+  txIndex: number,
+  messageIndexInTx?: number,
+): { root: Fr; leafIndex: bigint; siblingPath: SiblingPath<number> } {
+  const messagesInTx = messagesInEpoch[checkpointIndex][blockIndex][txIndex];
+  const resolvedMessageIndex = resolveMessageIndex(messagesInTx, message, messageIndexInTx);
 
   // Build the tx tree.
-  const messagesInTx = messagesInEpoch[checkpointIndex][blockIndex][txIndex];
   const txTree = UnbalancedMerkleTreeCalculator.create(messagesInTx.map(msg => msg.toBuffer()));
   // Get the sibling path of the target message in the tx tree.
-  const pathToMessageInTxSubtree = txTree.getSiblingPathByLeafIndex(messageIndexInTx);
+  const pathToMessageInTxSubtree = txTree.getSiblingPathByLeafIndex(resolvedMessageIndex);
 
   // Build the tree of the block containing the target message.
   const blockTree = buildBlockTree(messagesInEpoch[checkpointIndex][blockIndex]);
@@ -189,7 +227,7 @@ export function computeL2ToL1MembershipWitnessFromMessagesInEpoch(
   // Compute the combined index.
   // It is the index of the message in the balanced tree (by filling up the wonky tree with empty nodes) at its current
   // height. It's used to validate the membership proof.
-  const messageLeafPosition = txTree.getLeafLocation(messageIndexInTx);
+  const messageLeafPosition = txTree.getLeafLocation(resolvedMessageIndex);
   const txLeafPosition = blockTree.getLeafLocation(txIndex);
   const blockLeafPosition = checkpointTree.getLeafLocation(blockIndex);
   const checkpointLeafPosition = epochTree.getLeafLocation(checkpointIndex);
@@ -207,6 +245,33 @@ export function computeL2ToL1MembershipWitnessFromMessagesInEpoch(
   };
 }
 
+function resolveMessageIndex(messagesInTx: Fr[], message: Fr, messageIndexInTx?: number): number {
+  if (messageIndexInTx !== undefined) {
+    if (!messagesInTx[messageIndexInTx]?.equals(message)) {
+      throw new Error(`Message at index ${messageIndexInTx} in tx does not match the expected message ${message}`);
+    }
+    return messageIndexInTx;
+  }
+
+  const indices = messagesInTx.reduce<number[]>((acc, msg, i) => {
+    if (msg.equals(message)) {
+      acc.push(i);
+    }
+    return acc;
+  }, []);
+
+  if (indices.length === 0) {
+    throw new Error('The L2ToL1Message you are trying to prove inclusion of does not exist');
+  }
+  if (indices.length > 1) {
+    throw new Error(
+      `Multiple messages with the same value ${message} found in tx (indices: ${indices.join(', ')}). ` +
+        `Provide messageIndexInTx to disambiguate.`,
+    );
+  }
+  return indices[0];
+}
+
 function buildCheckpointTree(messagesInCheckpoint: Fr[][][]) {
   const blockOutHashes = messagesInCheckpoint.map(messagesInBlock => buildBlockTree(messagesInBlock).getRoot());
   return buildCompressedTree(blockOutHashes);

package/src/noir/index.ts

@@ -19,7 +19,7 @@ export const AZTEC_VIEW_ATTRIBUTE = 'abi_view';
 export interface NoirFunctionAbi {
   /** The parameters of the function. */
   parameters: ABIParameter[];
-  /** The return type of the function. */
+  /** The return type of the function, or null for void functions. */
   return_type: {
     /**
      * The type of the return value.
@@ -29,7 +29,7 @@ export interface NoirFunctionAbi {
      * The visibility of the return value.
      */
     visibility: ABIParameterVisibility;
-  };
+  } | null;
   /** Mapping of error selector => error type */
   error_types: Partial<Record<string, AbiErrorType>>;
 }

package/src/note/note_dao.ts

@@ -1,6 +1,5 @@
 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';
@@ -148,9 +147,7 @@ export class NoteDao {
    * @returns - Its size in bytes.
    */
   public getSize() {
-    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
-    // 2 numbers for txIndexInBlock and noteIndexInTx (4 bytes each)
-    return noteSize + AztecAddress.SIZE_IN_BYTES * 2 + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + 8;
+    return this.toBuffer().length;
   }
 
   static async random({

package/src/p2p/block_proposal.ts

@@ -1,5 +1,11 @@
-import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import {
+  BlockNumber,
+  BlockProposalHash,
+  type CheckpointNumber,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
+import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -23,11 +29,7 @@ import {
 import { SignedTxs } from './signed_txs.js';
 import { TopicType } from './topic_type.js';
 
-export class BlockProposalHash extends Buffer32 {
-  constructor(hash: Buffer) {
-    super(hash);
-  }
-}
+export type { BlockProposalHash } from '@aztec/foundation/branded-types';
 
 export type BlockProposalOptions = {
   /**
@@ -77,8 +79,8 @@ export class BlockProposal extends Gossipable {
     super();
   }
 
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new BlockProposalHash(keccak256(this.signature.toBuffer())));
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(BlockProposalHash.fromBuffer(keccak256(this.signature.toBuffer())));
   }
 
   get archive(): Fr {
@@ -126,6 +128,7 @@ export class BlockProposal extends Gossipable {
 
   static async createProposalFromSigner(
     blockHeader: BlockHeader,
+    checkpointNumber: CheckpointNumber,
     indexWithinCheckpoint: IndexWithinCheckpoint,
     inHash: Fr,
     archiveRoot: Fr,
@@ -147,6 +150,7 @@ export class BlockProposal extends Gossipable {
     const blockContext: SigningContext = {
       slot: blockHeader.globalVariables.slotNumber,
       blockNumber: blockHeader.globalVariables.blockNumber,
+      checkpointNumber,
       blockIndexWithinCheckpoint: indexWithinCheckpoint,
       dutyType: DutyType.BLOCK_PROPOSAL,
     };

package/src/p2p/checkpoint_attestation.ts

@@ -1,5 +1,5 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { CheckpointAttestationHash, SlotNumber } from '@aztec/foundation/branded-types';
+import type { BaseBuffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { Fr } from '@aztec/foundation/curves/bn254';
@@ -16,11 +16,7 @@ import { Gossipable } from './gossipable.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
 import { TopicType } from './topic_type.js';
 
-export class CheckpointAttestationHash extends Buffer32 {
-  constructor(hash: Buffer) {
-    super(hash);
-  }
-}
+export type { CheckpointAttestationHash } from '@aztec/foundation/branded-types';
 
 /**
  * CheckpointAttestation
@@ -57,8 +53,8 @@ export class CheckpointAttestation extends Gossipable {
       .transform(obj => new CheckpointAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new CheckpointAttestationHash(keccak256(this.signature.toBuffer())));
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(CheckpointAttestationHash.fromBuffer(keccak256(this.signature.toBuffer())));
   }
 
   get archive(): Fr {

package/src/p2p/checkpoint_proposal.ts

@@ -1,5 +1,10 @@
-import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import {
+  type CheckpointNumber,
+  CheckpointProposalHash,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
+import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -24,12 +29,7 @@ import {
 import { SignedTxs } from './signed_txs.js';
 import { TopicType } from './topic_type.js';
 
-// REFACTOR(palla): Use a branded type instead of a subclass of Buffer32
-export class CheckpointProposalHash extends Buffer32 {
-  constructor(hash: Buffer) {
-    super(hash);
-  }
-}
+export type { CheckpointProposalHash } from '@aztec/foundation/branded-types';
 
 export type CheckpointProposalOptions = {
   /**
@@ -93,8 +93,8 @@ export class CheckpointProposal extends Gossipable {
     super();
   }
 
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new CheckpointProposalHash(keccak256(this.signature.toBuffer())));
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(CheckpointProposalHash.fromBuffer(keccak256(this.signature.toBuffer())));
   }
 
   get slotNumber(): SlotNumber {
@@ -160,8 +160,9 @@ export class CheckpointProposal extends Gossipable {
   static async createProposalFromSigner(
     checkpointHeader: CheckpointHeader,
     archiveRoot: Fr,
+    checkpointNumber: CheckpointNumber,
     feeAssetPriceModifier: bigint,
-    lastBlockInfo: CheckpointLastBlockData | undefined,
+    lastBlockProposal: BlockProposal | undefined,
     payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<CheckpointProposal> {
     // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
@@ -175,32 +176,19 @@ export class CheckpointProposal extends Gossipable {
 
     const checkpointContext: SigningContext = {
       slot: checkpointHeader.slotNumber,
-      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      checkpointNumber,
       dutyType: DutyType.CHECKPOINT_PROPOSAL,
     };
-    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
-    if (!lastBlockInfo) {
-      return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature);
-    }
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
-    const lastBlockProposal = await BlockProposal.createProposalFromSigner(
-      lastBlockInfo.blockHeader,
-      lastBlockInfo.indexWithinCheckpoint,
-      checkpointHeader.inHash,
+    return new CheckpointProposal(
+      checkpointHeader,
       archiveRoot,
-      lastBlockInfo.txHashes,
-      lastBlockInfo.txs,
-      payloadSigner,
+      feeAssetPriceModifier,
+      checkpointSignature,
+      lastBlockProposal,
     );
-
-    return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature, {
-      blockHeader: lastBlockInfo.blockHeader,
-      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
-      txHashes: lastBlockInfo.txHashes,
-      signature: lastBlockProposal.signature,
-      signedTxs: lastBlockProposal.signedTxs,
-    });
   }
 
   /**

package/src/p2p/gossipable.ts

@@ -1,4 +1,4 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { BaseBuffer32 } from '@aztec/foundation/buffer';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
@@ -46,7 +46,7 @@ export class P2PMessage {
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
-  private cachedId: Buffer32 | undefined;
+  private cachedId: BaseBuffer32 | undefined;
   /** The p2p topic identifier, this determines how the message is handled */
   static p2pTopic: TopicType;
 
@@ -54,7 +54,7 @@ export abstract class Gossipable {
    * 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 p2pMessageLoggingIdentifier(): Promise<Buffer32> {
+  async p2pMessageLoggingIdentifier(): Promise<BaseBuffer32> {
     if (this.cachedId) {
       return this.cachedId;
     }
@@ -62,7 +62,7 @@ export abstract class Gossipable {
     return this.cachedId;
   }
 
-  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
+  abstract generateP2PMessageIdentifier(): Promise<BaseBuffer32>;
 
   abstract toBuffer(): Buffer;
 

package/src/proofs/chonk_proof.ts

@@ -1,21 +1,41 @@
+import { BarretenbergSync, flattenChonkProofFields } from '@aztec/bb.js';
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
 import { times } from '@aztec/foundation/collection';
 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';
+import { BufferReader, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * Serialization format detection for ChonkProof is size-based:
+ *   - UNCOMPRESSED (legacy): [field_count=1632: uint32] [fields...]  → total ≈ 52KB (>= 40KB)
+ *   - COMPRESSED:            [byte_count: uint32] [compressed_bytes] → total ≈ 35KB (< 40KB)
+ *
+ * Detection: if the first uint32 equals CHONK_PROOF_LENGTH (1632), it's legacy format
+ * (field count). Otherwise, it's compressed format (byte count). The old uncompressed
+ * format is never smaller than 40KB; compressed proofs are always smaller than 40KB.
+ */
 
 // CHONK: "Client Honk" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.
 export class ChonkProof {
+  /**
+   * Optional compressed proof bytes from chonk compression (point compression + u256 encoding).
+   * When set, toBuffer() will serialize in compressed format (~1.7x smaller).
+   * When reading from compressed format, this is populated and fields are decompressed on demand.
+   */
+  public compressedProof?: Buffer;
+
   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[],
+    compressedProof?: Buffer,
   ) {
     if (fields.length !== CHONK_PROOF_LENGTH) {
       throw new Error(`Invalid ChonkProof length: ${fields.length}`);
     }
+    this.compressedProof = compressedProof;
   }
 
   public attachPublicInputs(publicInputs: Fr[]) {
@@ -53,19 +73,84 @@ export class ChonkProof {
     return this.toBuffer();
   }
 
+  /**
+   * Deserialize a ChonkProof from a buffer.
+   * Supports both legacy (field elements) and compressed (chonk compression) formats.
+   *
+   * Size-based format detection:
+   *   - First uint32 == CHONK_PROOF_LENGTH (1632): legacy format, read field elements
+   *     Total proof data ≈ 52KB (always >= 40KB)
+   *   - Otherwise: compressed format, first uint32 is byte count of compressed data
+   *     Total proof data ≈ 35KB (always < 40KB)
+   */
   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);
+    const firstUint32 = reader.readNumber();
+
+    if (firstUint32 === CHONK_PROOF_LENGTH) {
+      // Legacy format: firstUint32 is the field count (1632)
+      // Widen to `number` to prevent TS from narrowing to literal 1632,
+      // which would cause Tuple<Fr, 1632> to exceed the recursion limit.
+      const fieldCount: number = firstUint32;
+      const proof = reader.readArray(fieldCount, Fr);
+      return new ChonkProof(proof);
+    }
+
+    // Compressed format: firstUint32 is the compressed byte count
+    const compressedBytes = reader.readBytes(firstUint32);
+    return ChonkProof.fromCompressedBytes(Buffer.from(compressedBytes));
+  }
+
+  /**
+   * Create a ChonkProof from compressed bytes by decompressing via the BarretenbergSync API.
+   * The compressed format uses point compression and u256 encoding (from PR #20645).
+   *
+   * @param compressed - Compressed proof bytes from chonk compression
+   * @returns ChonkProof with both fields and compressed bytes populated
+   */
+  static fromCompressedBytes(compressed: Buffer): ChonkProof {
+    const api = BarretenbergSync.getSingleton();
+    const result = api.chonkDecompressProof({ compressedProof: new Uint8Array(compressed) });
+
+    // Flatten the structured bb.js ChonkProof into flat Fr[] field elements
+    const flatFields = flattenChonkProofFields(result.proof);
+    const fields = flatFields.map(f => Fr.fromBuffer(Buffer.from(f)));
+
+    // The decompressed proof includes public inputs in hidingOinkProof.
+    // Since ChonkProof stores fields WITHOUT public inputs, strip them.
+    // The number of public inputs = total fields - CHONK_PROOF_LENGTH
+    if (fields.length > CHONK_PROOF_LENGTH) {
+      const numPubInputs = fields.length - CHONK_PROOF_LENGTH;
+      const proofFields = fields.slice(numPubInputs);
+      return new ChonkProof(proofFields, compressed);
+    }
+
+    return new ChonkProof(fields, compressed);
   }
 
+  /**
+   * Serialize the proof to a buffer.
+   * If compressed bytes are available, uses the compressed format (~1.7x smaller).
+   * Otherwise falls back to legacy field element format.
+   */
   public toBuffer() {
+    if (this.compressedProof) {
+      // Compressed format: [compressed_byte_count: uint32] [compressed_bytes]
+      return Buffer.concat([numToUInt32BE(this.compressedProof.length), this.compressedProof]);
+    }
+    // Legacy format: [field_count=1632: uint32] [fields...]
     return serializeToBuffer(this.fields.length, this.fields);
   }
 }
 
 export class ChonkProofWithPublicInputs {
+  /**
+   * Optional compressed proof bytes (covers the full proof WITH public inputs).
+   * Set by the prover when using chonk compression. Flows through to ChonkProof
+   * via removePublicInputs() so the Tx can serialize in compressed format.
+   */
+  public compressedProof?: Buffer;
+
   constructor(
     // The proof fields with public inputs.
     // For recursive verification, use without public inputs via `removePublicInputs()`.
@@ -83,7 +168,8 @@ export class ChonkProofWithPublicInputs {
 
   public removePublicInputs() {
     const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
-    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+    // Flow compressed proof bytes through so the ChonkProof can serialize efficiently
+    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs), this.compressedProof);
   }
 
   public isEmpty() {

package/src/rollup/block_headers_hash.ts

@@ -1,5 +1,7 @@
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { computeUnbalancedPoseidonRoot } from '@aztec/foundation/trees';
+import { computeUnbalancedMerkleTreeRootAsync } from '@aztec/foundation/trees';
 
 import type { BlockHeader } from '../tx/block_header.js';
 
@@ -7,6 +9,13 @@ export async function computeBlockHeadersHash(blockHeaders: BlockHeader[]): Prom
   const blockHeaderHashes = await Promise.all(blockHeaders.map(header => header.hash()));
   // Must match the implementation in merge_block_rollups.nr, with the **unbalanced** rollup structure
   // (see validate_consecutive_block_rollups.nr > assert_rollups_filled_greedily.nr).
-  const blockHeadersHash = await computeUnbalancedPoseidonRoot(blockHeaderHashes.map(hash => hash.toBuffer()));
+  const blockHeadersHasher = async (left: Uint8Array, right: Uint8Array) =>
+    (
+      await poseidon2HashWithSeparator([Buffer.from(left), Buffer.from(right)], DomainSeparator.BLOCK_HEADERS_HASH)
+    ).toBuffer() as Buffer<ArrayBuffer>;
+  const blockHeadersHash = await computeUnbalancedMerkleTreeRootAsync(
+    blockHeaderHashes.map(hash => hash.toBuffer()),
+    blockHeadersHasher,
+  );
   return Fr.fromBuffer(blockHeadersHash);
 }