@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/p2p/index.ts

@@ -1,11 +1,12 @@
 export * from './attestation_utils.js';
-export * from './block_attestation.js';
 export * from './block_proposal.js';
+export * from './checkpoint_attestation.js';
+export * from './checkpoint_proposal.js';
 export * from './consensus_payload.js';
 export * from './gossipable.js';
-export * from './interface.js';
 export * from './signature_utils.js';
+export * from './signed_txs.js';
 export * from './topic_type.js';
-export * from './client_type.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
+export * from './constants.js';

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult =
+  | { result: 'accept' }
+  | { result: 'ignore' }
+  | { result: 'reject'; severity: PeerErrorSeverity };
+
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }

package/src/p2p/peer_error.ts

@@ -15,3 +15,10 @@ export enum PeerErrorSeverity {
    */
   HighToleranceError = 'HighToleranceError',
 }
+
+/** Severities ordered from mildest to harshest. */
+export const PeerErrorSeverityByHarshness = [
+  PeerErrorSeverity.HighToleranceError,
+  PeerErrorSeverity.MidToleranceError,
+  PeerErrorSeverity.LowToleranceError,
+] as const;

package/src/p2p/signature_utils.ts

@@ -1,34 +1,131 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { type BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-export enum SignatureDomainSeparator {
-  blockProposal = 0,
-  blockAttestation = 1,
-  attestationsAndSigners = 2,
-}
+import { type TypedDataDefinition, hashTypedData } from 'viem';
+import { z } from 'zod';
+
+import type { ZodFor } from '../schemas/index.js';
+
+export type CoordinationSignatureType =
+  | 'BlockProposal'
+  | 'CheckpointProposal'
+  | 'CheckpointAttestation'
+  | 'AttestationsAndSigners'
+  | 'SignedTxs';
+
+export type CoordinationSignatureContext = {
+  chainId: number;
+  rollupAddress: EthAddress;
+};
+
+export const EMPTY_COORDINATION_SIGNATURE_CONTEXT: CoordinationSignatureContext = {
+  chainId: 0,
+  rollupAddress: EthAddress.ZERO,
+};
+
+export const coordinationSignatureContextSchema: ZodFor<CoordinationSignatureContext> = z.object({
+  chainId: z.number(),
+  rollupAddress: EthAddress.schema,
+});
 
 export interface Signable {
-  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer;
+  readonly primaryType: CoordinationSignatureType;
+  readonly signatureContext: CoordinationSignatureContext;
+  getPayloadToSign(): Buffer;
+}
+
+export function coordinationSignatureContextEquals(
+  a: CoordinationSignatureContext,
+  b: CoordinationSignatureContext,
+): boolean {
+  return a.chainId === b.chainId && a.rollupAddress.equals(b.rollupAddress);
+}
+
+export function serializeCoordinationSignatureContext(ctx: CoordinationSignatureContext): Buffer {
+  return serializeToBuffer([ctx.chainId, ctx.rollupAddress]);
+}
+
+export function readCoordinationSignatureContext(reader: BufferReader): CoordinationSignatureContext {
+  const chainId = reader.readNumber();
+  const rollupAddress = reader.readObject(EthAddress);
+  return { chainId, rollupAddress };
 }
 
 /**
- * Get the hashed payload for the signature of the `Signable`
- * @param s - The `Signable` to sign
- * @returns The hashed payload for the signature of the `Signable`
+ * Returns true if the signable carries a context matching the node's expected context.
+ * Use this at the P2P ingress boundary to reject foreign-chain messages cheaply before
+ * performing any signature recovery.
  */
-export function getHashedSignaturePayload(s: Signable, domainSeparator: SignatureDomainSeparator): Buffer32 {
-  return Buffer32.fromBuffer(keccak256(s.getPayloadToSign(domainSeparator)));
+export function hasValidSignatureContext(signable: Signable, expected: CoordinationSignatureContext): boolean {
+  return coordinationSignatureContextEquals(signable.signatureContext, expected);
+}
+
+const COORDINATION_SIGNATURE_NAME = 'Aztec Rollup';
+const COORDINATION_SIGNATURE_VERSION = '1';
+
+const EIP712_DOMAIN_FIELDS = [
+  { name: 'name', type: 'string' },
+  { name: 'version', type: 'string' },
+  { name: 'chainId', type: 'uint256' },
+  { name: 'verifyingContract', type: 'address' },
+] as const;
+
+const COORDINATION_SIGNATURE_TYPES = {
+  EIP712Domain: EIP712_DOMAIN_FIELDS,
+  BlockProposal: [{ name: 'payloadHash', type: 'bytes32' }],
+  CheckpointProposal: [{ name: 'payloadHash', type: 'bytes32' }],
+  CheckpointAttestation: [{ name: 'payloadHash', type: 'bytes32' }],
+  AttestationsAndSigners: [{ name: 'payloadHash', type: 'bytes32' }],
+  SignedTxs: [{ name: 'payloadHash', type: 'bytes32' }],
+} as const;
+
+export function getCoordinationSignatureTypedDataForPayloadHash(
+  payloadHash: Buffer32,
+  type: CoordinationSignatureType,
+  context: CoordinationSignatureContext,
+): TypedDataDefinition {
+  return {
+    domain: {
+      name: COORDINATION_SIGNATURE_NAME,
+      version: COORDINATION_SIGNATURE_VERSION,
+      chainId: context.chainId,
+      verifyingContract: context.rollupAddress.toString() as `0x${string}`,
+    },
+    types: COORDINATION_SIGNATURE_TYPES,
+    primaryType: type,
+    message: {
+      payloadHash: payloadHash.toString() as `0x${string}`,
+    },
+  };
+}
+
+export function getCoordinationSignatureTypedData(signable: Signable): TypedDataDefinition {
+  const payloadHash = getHashedSignaturePayload(signable);
+  return getCoordinationSignatureTypedDataForPayloadHash(payloadHash, signable.primaryType, signable.signatureContext);
+}
+
+export function getHashedSignaturePayloadTypedData(signable: Signable): Buffer32 {
+  return Buffer32.fromString(hashTypedData(getCoordinationSignatureTypedData(signable)));
 }
 
 /**
- * Get the hashed payload for the signature of the `Signable` as an Ethereum signed message EIP-712
- * @param s - the `Signable` to sign
- * @returns The hashed payload for the signature of the `Signable` as an Ethereum signed message
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
  */
-export function getHashedSignaturePayloadEthSignedMessage(
-  s: Signable,
-  domainSeparator: SignatureDomainSeparator,
-): Buffer32 {
-  const payload = getHashedSignaturePayload(s, domainSeparator);
-  return makeEthSignDigest(payload);
+export function recoverCoordinationSigner(signable: Signable, signature: Signature): EthAddress | undefined {
+  const digest = getHashedSignaturePayloadTypedData(signable);
+  return tryRecoverAddress(digest, signature, { allowYParityAsV: true });
+}
+
+export function getHashedSignaturePayload(s: Signable): Buffer32 {
+  return Buffer32.fromBuffer(keccak256(s.getPayloadToSign()));
 }

package/src/p2p/signed_txs.ts

@@ -0,0 +1,106 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import type { TypedDataDefinition } from 'viem';
+
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { Tx } from '../tx/tx.js';
+import {
+  type CoordinationSignatureContext,
+  type CoordinationSignatureType,
+  EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+  type Signable,
+  getCoordinationSignatureTypedData,
+  readCoordinationSignatureContext,
+  recoverCoordinationSigner,
+  serializeCoordinationSignatureContext,
+} from './signature_utils.js';
+
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */
+export class SignedTxs implements Signable {
+  readonly primaryType: CoordinationSignatureType = 'SignedTxs';
+
+  private cachedSender: EthAddress | undefined | null = undefined;
+
+  constructor(
+    /** The transactions */
+    public readonly txs: Tx[],
+    /** The proposer's signature over the transactions */
+    public readonly signature: Signature,
+    /** The signing domain (chainId + rollupAddress) the signature is bound to */
+    public readonly signatureContext: CoordinationSignatureContext,
+  ) {}
+
+  getPayloadToSign(): Buffer {
+    return serializeToBuffer([this.txs.length, this.txs]);
+  }
+
+  /**
+   * Lazily evaluate the sender of the signed txs; result is cached.
+   * @returns The sender address, or undefined if signature recovery fails
+   */
+  getSender(): EthAddress | undefined {
+    if (this.cachedSender === undefined) {
+      this.cachedSender = recoverCoordinationSigner(this, this.signature) ?? null;
+    }
+    return this.cachedSender ?? undefined;
+  }
+
+  /**
+   * Create SignedTxs from a typed-data signer function
+   */
+  static async createFromSigner(
+    txs: Tx[],
+    signatureContext: CoordinationSignatureContext,
+    typedDataSigner: (typedData: TypedDataDefinition) => Promise<Signature>,
+  ): Promise<SignedTxs> {
+    const tempSignedTxs = new SignedTxs(txs, Signature.empty(), signatureContext);
+    const typedData = getCoordinationSignatureTypedData(tempSignedTxs);
+    const signature = await typedDataSigner(typedData);
+    return new SignedTxs(txs, signature, signatureContext);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.txs.length,
+      this.txs,
+      this.signature,
+      serializeCoordinationSignatureContext(this.signatureContext),
+    ]);
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
+    const reader = BufferReader.asReader(buf);
+    const txCount = reader.readNumber();
+    if (txCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txs = reader.readArray(txCount, Tx);
+    const signature = reader.readObject(Signature);
+    const signatureContext = readCoordinationSignatureContext(reader);
+    return new SignedTxs(txs, signature, signatureContext);
+  }
+
+  getSize(): number {
+    return (
+      4 /* txs.length */ +
+      this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) +
+      this.signature.getSize() +
+      4 /* chainId */ +
+      20 /* rollupAddress */
+    );
+  }
+
+  static empty(): SignedTxs {
+    return new SignedTxs([], Signature.empty(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
+  }
+
+  static random(): SignedTxs {
+    return new SignedTxs([Tx.random(), Tx.random()], Signature.random(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
+  }
+}

package/src/p2p/topic_type.ts

@@ -1,5 +1,3 @@
-import { P2PClientType } from './client_type.js';
-
 /**
  * Creates the topic channel identifier string from a given topic type
  */
@@ -23,22 +21,18 @@ export function getTopicFromString(topicStr: string): TopicType | undefined {
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',
-  block_attestation = 'block_attestation',
-}
-
-export function getTopicTypeForClientType(clientType: P2PClientType) {
-  if (clientType === P2PClientType.Full) {
-    return Object.values(TopicType);
-  } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal];
-  } else {
-    const _: never = clientType;
-    return [TopicType.tx];
-  }
+  checkpoint_proposal = 'checkpoint_proposal',
+  checkpoint_attestation = 'checkpoint_attestation',
 }
 
-export function getTopicsForClientAndConfig(clientType: P2PClientType, disableTransactions: boolean) {
-  const topics = getTopicTypeForClientType(clientType);
+/** Returns all gossip topics, optionally filtering out transactions. */
+export function getTopicsForConfig(disableTransactions: boolean) {
+  const topics = [
+    TopicType.tx,
+    TopicType.block_proposal,
+    TopicType.checkpoint_proposal,
+    TopicType.checkpoint_attestation,
+  ];
   if (disableTransactions) {
     return topics.filter(topic => topic !== TopicType.tx);
   }

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';
@@ -10,9 +10,11 @@ export class ParityBasePrivateInputs {
     public readonly msgs: Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>,
     /** Root of the VK tree */
     public readonly vkTreeRoot: Fr,
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    public readonly proverId: Fr,
   ) {}
 
-  public static fromSlice(array: Fr[], index: number, vkTreeRoot: Fr): ParityBasePrivateInputs {
+  public static fromSlice(array: Fr[], index: number, vkTreeRoot: Fr, proverId: Fr): ParityBasePrivateInputs {
     // Can't use Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP> due to length
     if (array.length !== NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) {
       throw new Error(
@@ -22,12 +24,12 @@ export class ParityBasePrivateInputs {
     const start = index * NUM_MSGS_PER_BASE_PARITY;
     const end = start + NUM_MSGS_PER_BASE_PARITY;
     const msgs = array.slice(start, end);
-    return new ParityBasePrivateInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
+    return new ParityBasePrivateInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot, proverId);
   }
 
   /** Serializes the inputs to a buffer. */
   toBuffer() {
-    return serializeToBuffer(this.msgs, this.vkTreeRoot);
+    return serializeToBuffer(this.msgs, this.vkTreeRoot, this.proverId);
   }
 
   /** Serializes the inputs to a hex string. */
@@ -41,7 +43,11 @@ export class ParityBasePrivateInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ParityBasePrivateInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+    return new ParityBasePrivateInputs(
+      reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
   }
 
   /**

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';
@@ -12,6 +12,8 @@ export class ParityPublicInputs {
     public convertedRoot: Fr,
     /** Root of the VK tree */
     public vkTreeRoot: Fr,
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    public proverId: Fr,
   ) {
     if (shaRoot.toBuffer()[0] != 0) {
       throw new Error(`shaRoot buffer must be 31 bytes. Got 32 bytes`);
@@ -54,7 +56,7 @@ export class ParityPublicInputs {
    * @returns The instance fields.
    */
   static getFields(fields: FieldsOf<ParityPublicInputs>) {
-    return [fields.shaRoot, fields.convertedRoot, fields.vkTreeRoot] as const;
+    return [fields.shaRoot, fields.convertedRoot, fields.vkTreeRoot, fields.proverId] as const;
   }
 
   /**
@@ -64,7 +66,12 @@ export class ParityPublicInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ParityPublicInputs(reader.readObject(Fr), reader.readObject(Fr), Fr.fromBuffer(reader));
+    return new ParityPublicInputs(
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
   }
 
   /**

package/src/proofs/chonk_proof.ts

@@ -1,20 +1,45 @@
+import { BarretenbergSync, flattenChonkProofFields } from '@aztec/bb.js';
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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, BufferSink } from '@aztec/foundation/serialize';
+
+/**
+ * Serialization format detection for ChonkProof is value-based on the leading uint32:
+ *   - EMPTY:                 [0: uint32]                              → total = 4 bytes
+ *   - UNCOMPRESSED (legacy): [field_count=1632: uint32] [fields...]  → total ≈ 52KB (>= 40KB)
+ *   - COMPRESSED:            [byte_count: uint32] [compressed_bytes] → total ≈ 35KB (< 40KB)
+ *
+ * Detection from the first uint32: 0 means an empty proof (no fields); CHONK_PROOF_LENGTH
+ * (1632) means legacy format (field count); any other value is the compressed byte count.
+ * A real compressed proof always has a non-zero byte count, so 0 is an unambiguous sentinel
+ * for the empty case. 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) {
+    // An empty proof (no fields) is a valid placeholder; see ChonkProof.empty().
+    if (fields.length !== 0 && fields.length !== CHONK_PROOF_LENGTH) {
       throw new Error(`Invalid ChonkProof length: ${fields.length}`);
     }
+    this.compressedProof = compressedProof;
   }
 
   public attachPublicInputs(publicInputs: Fr[]) {
@@ -26,17 +51,20 @@ export class ChonkProof {
   }
 
   static empty() {
-    return new ChonkProof(new Array(CHONK_PROOF_LENGTH).fill(Fr.ZERO));
+    return new ChonkProof([]);
   }
 
   static random() {
     // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+    // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
     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)),
-    );
+    const nonZeroFields = Math.floor((3 * CHONK_PROOF_LENGTH) / 4);
+    const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+    const proof = [
+      ...times(nonZeroFields, i => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+      ...times(CHONK_PROOF_LENGTH - nonZeroFields, () => Fr.ZERO),
+    ];
     return new ChonkProof(proof);
   }
 
@@ -49,37 +77,127 @@ export class ChonkProof {
     return this.toBuffer();
   }
 
+  /**
+   * Deserialize a ChonkProof from a buffer.
+   * Supports both legacy (field elements) and compressed (chonk compression) formats.
+   *
+   * Value-based format detection on the leading uint32:
+   *   - First uint32 == 0: empty proof (no fields), total = 4 bytes
+   *   - 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 === 0) {
+      // Empty format: a zero length encodes an empty proof.
+      return ChonkProof.empty();
+    }
+
+    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);
   }
 
-  public toBuffer() {
-    return serializeToBuffer(this.fields.length, this.fields);
+  /**
+   * 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(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    if (this.compressedProof) {
+      // Compressed format: [compressed_byte_count: uint32] [compressed_bytes]
+      sink.writeNumber(this.compressedProof.length);
+      sink.writeBytes(this.compressedProof);
+      return;
+    }
+    // Legacy / empty format: [field_count: uint32] [fields...]. fields.length === 0 emits the empty
+    // sentinel (a lone zero uint32) that ChonkProof.fromBuffer detects; fields.length === CHONK_PROOF_LENGTH
+    // is the full legacy form. The writeFields fast path skips per-element sinkable dispatch on the 1632
+    // leaves and is a no-op when the array is empty.
+    sink.writeNumber(this.fields.length);
+    sink.writeFields(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()`.
     public fieldsWithPublicInputs: Fr[],
   ) {
-    if (fieldsWithPublicInputs.length < CHONK_PROOF_LENGTH) {
+    // An empty proof (no fields) is a valid placeholder; see ChonkProofWithPublicInputs.empty().
+    if (fieldsWithPublicInputs.length !== 0 && fieldsWithPublicInputs.length < CHONK_PROOF_LENGTH) {
       throw new Error(`Invalid ChonkProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
     }
   }
 
   public getPublicInputs() {
+    if (this.fieldsWithPublicInputs.length === 0) {
+      return [];
+    }
     const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
     return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
   }
 
   public removePublicInputs() {
+    if (this.fieldsWithPublicInputs.length === 0) {
+      return new ChonkProof([], this.compressedProof);
+    }
     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() {
@@ -106,8 +224,14 @@ export class ChonkProofWithPublicInputs {
     return new ChonkProofWithPublicInputs(proof);
   }
 
-  public toBuffer() {
-    return serializeToBuffer(this.fieldsWithPublicInputs.length, this.fieldsWithPublicInputs);
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    sink.writeNumber(this.fieldsWithPublicInputs.length);
+    sink.writeFields(this.fieldsWithPublicInputs);
   }
 
   // Called when constructing from bb proving results.