@aztec/stdlib 0.0.1-commit.f146247c → 0.0.1-commit.f1b29a41e

package/src/p2p/checkpoint_attestation.ts

@@ -96,7 +96,12 @@ export class CheckpointAttestation extends Gossipable {
       // Create a temporary CheckpointProposal to recover the proposer address.
       // We need to use CheckpointProposal because it has a different getPayloadToSign()
       // implementation than ConsensusPayload (uses serializeToBuffer vs ABI encoding).
-      const proposal = new CheckpointProposal(this.payload.header, this.payload.archive, this.proposerSignature);
+      const proposal = new CheckpointProposal(
+        this.payload.header,
+        this.payload.archive,
+        this.payload.feeAssetPriceModifier,
+        this.proposerSignature,
+      );
       // Cache the proposer for later use
       this.proposer = proposal.getSender();
     }

package/src/p2p/checkpoint_proposal.ts

@@ -5,11 +5,11 @@ 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 { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
+import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { DutyType, type SigningContext } from '../ha-signing/index.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -81,7 +81,10 @@ export class CheckpointProposal extends Gossipable {
     /** Archive root after this checkpoint is applied */
     public readonly archive: Fr,
 
-    /** The proposer's signature over the checkpoint payload (checkpointHeader + archive) */
+    /** The fee asset price modifier in basis points (from oracle) */
+    public readonly feeAssetPriceModifier: bigint,
+
+    /** The proposer's signature over the checkpoint payload (checkpointHeader + archive + feeAssetPriceModifier) */
     public readonly signature: Signature,
 
     /** Optional last block info, including its own signature for BlockProposal extraction */
@@ -98,23 +101,6 @@ export class CheckpointProposal extends Gossipable {
     return this.checkpointHeader.slotNumber;
   }
 
-  get blockNumber(): BlockNumber {
-    if (!this.lastBlock) {
-      throw new Error('Cannot get blockNumber without lastBlock');
-    }
-    return this.lastBlock.blockHeader.getBlockNumber();
-  }
-
-  /** Convenience getter for txHashes from lastBlock */
-  get txHashes(): TxHash[] {
-    return this.lastBlock?.txHashes ?? [];
-  }
-
-  /** Convenience getter for txs from lastBlock */
-  get txs(): Tx[] | undefined {
-    return this.lastBlock?.signedTxs?.txs;
-  }
-
   /**
    * Extract a BlockProposal from the last block info.
    * Uses inHash from checkpointHeader.contentCommitment.inHash
@@ -148,22 +134,43 @@ export class CheckpointProposal extends Gossipable {
     };
   }
 
+  toCheckpointInfo() {
+    return {
+      slotNumber: this.slotNumber,
+      archive: this.archive,
+      lastBlockNumber: this.lastBlock?.blockHeader.getBlockNumber(),
+      lastBlockIndex: this.lastBlock?.indexWithinCheckpoint,
+      blockHeadersHash: this.checkpointHeader.blockHeadersHash,
+    };
+  }
+
   /**
    * Get the payload to sign for this checkpoint proposal.
-   * The signature is over the checkpoint header + archive root (for consensus).
+   * The signature is over the checkpoint header + archive root + feeAssetPriceModifier (for consensus).
    */
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
-    return serializeToBuffer([domainSeparator, this.checkpointHeader, this.archive]);
+    return serializeToBuffer([
+      domainSeparator,
+      this.checkpointHeader,
+      this.archive,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+    ]);
   }
 
   static async createProposalFromSigner(
     checkpointHeader: CheckpointHeader,
     archiveRoot: Fr,
+    feeAssetPriceModifier: bigint,
     lastBlockInfo: CheckpointLastBlockData | undefined,
     payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<CheckpointProposal> {
     // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
-    const tempProposal = new CheckpointProposal(checkpointHeader, archiveRoot, Signature.empty(), undefined);
+    const tempProposal = new CheckpointProposal(
+      checkpointHeader,
+      archiveRoot,
+      feeAssetPriceModifier,
+      Signature.empty(),
+    );
     const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
 
     const checkpointContext: SigningContext = {
@@ -171,29 +178,32 @@ export class CheckpointProposal extends Gossipable {
       blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
       dutyType: DutyType.CHECKPOINT_PROPOSAL,
     };
-    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
-    if (!lastBlockInfo) {
-      return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature);
+    if (lastBlockInfo) {
+      // Sign block proposal before signing checkpoint proposal to ensure HA protection
+      const lastBlockProposal = await BlockProposal.createProposalFromSigner(
+        lastBlockInfo.blockHeader,
+        lastBlockInfo.indexWithinCheckpoint,
+        checkpointHeader.inHash,
+        archiveRoot,
+        lastBlockInfo.txHashes,
+        lastBlockInfo.txs,
+        payloadSigner,
+      );
+
+      const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
+
+      return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature, {
+        blockHeader: lastBlockInfo.blockHeader,
+        indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+        txHashes: lastBlockInfo.txHashes,
+        signature: lastBlockProposal.signature,
+        signedTxs: lastBlockProposal.signedTxs,
+      });
     }
 
-    const lastBlockProposal = await BlockProposal.createProposalFromSigner(
-      lastBlockInfo.blockHeader,
-      lastBlockInfo.indexWithinCheckpoint,
-      checkpointHeader.inHash,
-      archiveRoot,
-      lastBlockInfo.txHashes,
-      lastBlockInfo.txs,
-      payloadSigner,
-    );
-
-    return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature, {
-      blockHeader: lastBlockInfo.blockHeader,
-      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
-      txHashes: lastBlockInfo.txHashes,
-      signature: lastBlockProposal.signature,
-      signedTxs: lastBlockProposal.signedTxs,
-    });
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
+    return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature);
   }
 
   /**
@@ -227,7 +237,12 @@ export class CheckpointProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.checkpointHeader, this.archive, this.signature];
+    const buffer: any[] = [
+      this.checkpointHeader,
+      this.archive,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+      this.signature,
+    ];
 
     if (this.lastBlock) {
       buffer.push(1); // hasLastBlock = true
@@ -254,6 +269,7 @@ export class CheckpointProposal extends Gossipable {
 
     const checkpointHeader = reader.readObject(CheckpointHeader);
     const archive = reader.readObject(Fr);
+    const feeAssetPriceModifier = reader.readInt256();
     const signature = reader.readObject(Signature);
 
     const hasLastBlock = reader.readNumber();
@@ -276,7 +292,7 @@ export class CheckpointProposal extends Gossipable {
         }
       }
 
-      return new CheckpointProposal(checkpointHeader, archive, signature, {
+      return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature, {
         blockHeader,
         indexWithinCheckpoint,
         txHashes,
@@ -285,7 +301,7 @@ export class CheckpointProposal extends Gossipable {
       });
     }
 
-    return new CheckpointProposal(checkpointHeader, archive, signature);
+    return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature);
   }
 
   getSize(): number {
@@ -293,6 +309,7 @@ export class CheckpointProposal extends Gossipable {
       this.checkpointHeader.toBuffer().length +
       this.archive.size +
       this.signature.getSize() +
+      8 /* feeAssetPriceModifier */ +
       4; /* hasLastBlock flag */
 
     if (this.lastBlock) {
@@ -310,11 +327,11 @@ export class CheckpointProposal extends Gossipable {
   }
 
   static empty(): CheckpointProposal {
-    return new CheckpointProposal(CheckpointHeader.empty(), Fr.ZERO, Signature.empty());
+    return new CheckpointProposal(CheckpointHeader.empty(), Fr.ZERO, 0n, Signature.empty());
   }
 
   static random(): CheckpointProposal {
-    return new CheckpointProposal(CheckpointHeader.random(), Fr.random(), Signature.random(), {
+    return new CheckpointProposal(CheckpointHeader.random(), Fr.random(), 0n, Signature.random(), {
       blockHeader: BlockHeader.random(),
       indexWithinCheckpoint: IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
       txHashes: [TxHash.random(), TxHash.random()],
@@ -327,6 +344,7 @@ export class CheckpointProposal extends Gossipable {
       checkpointHeader: this.checkpointHeader.toInspect(),
       archive: this.archive.toString(),
       signature: this.signature.toString(),
+      feeAssetPriceModifier: this.feeAssetPriceModifier.toString(),
       lastBlock: this.lastBlock
         ? {
             blockHeader: this.lastBlock.blockHeader.toInspect(),
@@ -343,7 +361,7 @@ export class CheckpointProposal extends Gossipable {
    * Used when the lastBlock has been extracted and stored separately.
    */
   toCore(): CheckpointProposalCore {
-    return new CheckpointProposal(this.checkpointHeader, this.archive, this.signature);
+    return new CheckpointProposal(this.checkpointHeader, this.archive, this.feeAssetPriceModifier, this.signature);
   }
 }
 

package/src/p2p/client_type.ts

@@ -1,6 +0,0 @@
-export enum P2PClientType {
-  // Full p2p clients will subscribe to all gossip topics
-  Full,
-  // Prove p2p clients will only subscribe to transaction and proving topics
-  Prover,
-}

package/src/p2p/consensus_payload.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -21,6 +21,8 @@ export class ConsensusPayload implements Signable {
     public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
+    /** The fee asset price modifier in basis points (from oracle) */
+    public readonly feeAssetPriceModifier: bigint = 0n,
   ) {}
 
   static get schema() {
@@ -28,12 +30,13 @@ export class ConsensusPayload implements Signable {
       .object({
         header: CheckpointHeader.schema,
         archive: schemas.Fr,
+        feeAssetPriceModifier: schemas.BigInt,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.feeAssetPriceModifier));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive] as const;
+    return [fields.header, fields.archive, fields.feeAssetPriceModifier] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -50,41 +53,50 @@ export class ConsensusPayload implements Signable {
     const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, [0n] /* @todo See #9963 */, headerHash],
+      [archiveRoot, [this.feeAssetPriceModifier], headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.header, this.archive]);
+    return serializeToBuffer([this.header, this.archive, serializeSignedBigInt(this.feeAssetPriceModifier)]);
   }
 
   public equals(other: ConsensusPayload | CheckpointProposal | CheckpointProposalCore): boolean {
     const otherHeader = 'checkpointHeader' in other ? other.checkpointHeader : other.header;
-    return this.header.equals(otherHeader) && this.archive.equals(other.archive);
+    const otherModifier = 'feeAssetPriceModifier' in other ? other.feeAssetPriceModifier : 0n;
+    return (
+      this.header.equals(otherHeader) &&
+      this.archive.equals(other.archive) &&
+      this.feeAssetPriceModifier === otherModifier
+    );
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr));
+    const payload = new ConsensusPayload(
+      reader.readObject(CheckpointHeader),
+      reader.readObject(Fr),
+      reader.readInt256(),
+    );
     return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive);
+    return new ConsensusPayload(fields.header, fields.archive, fields.feeAssetPriceModifier);
   }
 
   static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
-    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root, checkpoint.feeAssetPriceModifier);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO);
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, 0n);
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.random(), Fr.random());
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), 0n);
   }
 
   /**
@@ -104,10 +116,11 @@ export class ConsensusPayload implements Signable {
     return {
       header: this.header.toInspect(),
       archive: this.archive.toString(),
+      feeAssetPriceModifier: this.feeAssetPriceModifier.toString(),
     };
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, feeAssetPriceModifier: ${this.feeAssetPriceModifier}}`;
   }
 }

package/src/p2p/constants.ts

@@ -1,3 +1,6 @@
 export const MAX_TX_SIZE_KB: number = 512;
 
 export const MAX_MESSAGE_SIZE_KB: number = 10 * 1024;
+
+/** Maximum size for L2Block response (contains TxEffects, not full Txs with proofs) */
+export const MAX_L2_BLOCK_SIZE_KB: number = 3 * 1024; // 3 MB

package/src/p2p/index.ts

@@ -8,7 +8,6 @@ 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/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/topic_type.ts

@@ -1,5 +1,3 @@
-import { P2PClientType } from './client_type.js';
-
 /**
  * Creates the topic channel identifier string from a given topic type
  */
@@ -27,19 +25,14 @@ export enum TopicType {
   checkpoint_attestation = 'checkpoint_attestation',
 }
 
-export function getTopicTypeForClientType(clientType: P2PClientType) {
-  if (clientType === P2PClientType.Full) {
-    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal, TopicType.checkpoint_attestation];
-  } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal];
-  } else {
-    const _: never = clientType;
-    return [TopicType.tx];
-  }
-}
-
-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/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/checkpoint_header.ts

@@ -19,8 +19,8 @@ import type { UInt64 } from '../types/shared.js';
 
 /**
  * Header of a checkpoint. A checkpoint is a collection of blocks submitted to L1 all within the same slot.
- * TODO(palla/mbps): Should this include chainId and version as well? Is this used just in circuits?
- * TODO(palla/mbps): What about CheckpointNumber?
+ * This header is verified as-is in the rollup circuits, posted to the L1 rollup contract, stored in the archiver,
+ * and exposed via the Aztec Node API. See `CheckpointData` for a struct that includes the header plus extra metadata.
  */
 export class CheckpointHeader {
   constructor(

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -38,11 +38,11 @@ export class CheckpointRollupPublicInputs {
     /**
      * The hashes of the headers of the constituent checkpoints.
      */
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     /**
      * The summed transaction fees and recipients of the constituent checkpoints.
      */
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     /**
      * Accumulated opening proofs for all blobs before this checkpoint range.
      */
@@ -65,8 +65,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       reader.readObject(BlobAccumulator),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),

package/src/rollup/root_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
-import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -27,8 +27,8 @@ export class RootRollupPublicInputs {
      */
     public outHash: Fr,
     /** Hashes of checkpoint headers for this rollup. */
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     public constants: EpochConstantData,
     public blobPublicInputs: FinalBlobAccumulator,
   ) {}
@@ -68,8 +68,8 @@ export class RootRollupPublicInputs {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       EpochConstantData.fromBuffer(reader),
       reader.readObject(FinalBlobAccumulator),
     );
@@ -99,8 +99,8 @@ export class RootRollupPublicInputs {
       Fr.random(),
       Fr.random(),
       Fr.random(),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      makeTuple(MAX_CHECKPOINTS_PER_EPOCH, Fr.random),
+      makeTuple(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient.random),
       new EpochConstantData(Fr.random(), Fr.random(), Fr.random(), Fr.random(), Fr.random()),
       FinalBlobAccumulator.random(),
     );

package/src/slashing/empire.ts

@@ -83,7 +83,9 @@ export function getFirstEligibleRoundForOffense(
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL: {
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.DUPLICATE_PROPOSAL:
+    case OffenseType.DUPLICATE_ATTESTATION: {
       const slot = offense.epochOrSlot;
       const detectedSlot = SlotNumber.fromBigInt(slot + 1n);
       return getRoundForSlot(detectedSlot, constants).round + 1n;