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

package/src/p2p/signed_txs.ts

@@ -1,15 +1,20 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 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 {
-  SignatureDomainSeparator,
-  getHashedSignaturePayload,
-  getHashedSignaturePayloadEthSignedMessage,
+  type CoordinationSignatureContext,
+  type CoordinationSignatureType,
+  EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+  type Signable,
+  getCoordinationSignatureTypedData,
+  readCoordinationSignatureContext,
+  recoverCoordinationSigner,
+  serializeCoordinationSignatureContext,
 } from './signature_utils.js';
 
 /**
@@ -17,50 +22,56 @@ import {
  * The signature is over the transaction objects themselves, providing
  * data availability guarantees beyond just the transaction hashes.
  */
-export class SignedTxs {
-  private sender: EthAddress | undefined;
+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,
   ) {}
 
-  /**
-   * Get the payload to sign for this signed txs.
-   */
-  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
-    return serializeToBuffer([domainSeparator, this.txs.length, this.txs]);
+  getPayloadToSign(): Buffer {
+    return serializeToBuffer([this.txs.length, this.txs]);
   }
 
   /**
-   * Lazily evaluate the sender of the signed txs; result is cached
+   * 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.sender) {
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.signedTxs);
-      this.sender = tryRecoverAddress(hashed, this.signature);
+    if (this.cachedSender === undefined) {
+      this.cachedSender = recoverCoordinationSigner(this, this.signature) ?? null;
     }
-    return this.sender;
+    return this.cachedSender ?? undefined;
   }
 
   /**
-   * Create SignedTxs from a signer function
+   * Create SignedTxs from a typed-data signer function
    */
   static async createFromSigner(
     txs: Tx[],
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+    signatureContext: CoordinationSignatureContext,
+    typedDataSigner: (typedData: TypedDataDefinition) => Promise<Signature>,
   ): Promise<SignedTxs> {
-    const tempSignedTxs = new SignedTxs(txs, Signature.empty());
-    const hashed = getHashedSignaturePayload(tempSignedTxs, SignatureDomainSeparator.signedTxs);
-    const signature = await payloadSigner(hashed);
-    return new SignedTxs(txs, signature);
+    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]);
+    return serializeToBuffer([
+      this.txs.length,
+      this.txs,
+      this.signature,
+      serializeCoordinationSignatureContext(this.signatureContext),
+    ]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
@@ -71,18 +82,25 @@ export class SignedTxs {
     }
     const txs = reader.readArray(txCount, Tx);
     const signature = reader.readObject(Signature);
-    return new SignedTxs(txs, 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();
+    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());
+    return new SignedTxs([], Signature.empty(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
   }
 
   static random(): SignedTxs {
-    return new SignedTxs([Tx.random(), Tx.random()], Signature.random());
+    return new SignedTxs([Tx.random(), Tx.random()], Signature.random(), EMPTY_COORDINATION_SIGNATURE_CONTEXT);
   }
 }

package/src/parity/parity_base_private_inputs.ts

@@ -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

@@ -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

@@ -4,16 +4,19 @@ 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, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink } from '@aztec/foundation/serialize';
 
 /**
- * Serialization format detection for ChonkProof is size-based:
+ * 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: 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.
+ * 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.
@@ -32,7 +35,8 @@ export class ChonkProof {
     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;
@@ -47,7 +51,7 @@ export class ChonkProof {
   }
 
   static empty() {
-    return new ChonkProof(new Array(CHONK_PROOF_LENGTH).fill(Fr.ZERO));
+    return new ChonkProof([]);
   }
 
   static random() {
@@ -77,7 +81,8 @@ export class ChonkProof {
    * Deserialize a ChonkProof from a buffer.
    * Supports both legacy (field elements) and compressed (chonk compression) formats.
    *
-   * Size-based format detection:
+   * 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
@@ -87,6 +92,11 @@ export class ChonkProof {
     const reader = BufferReader.asReader(buffer);
     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,
@@ -133,13 +143,24 @@ export class ChonkProof {
    * If compressed bytes are available, uses the compressed format (~1.7x smaller).
    * Otherwise falls back to legacy field element format.
    */
-  public toBuffer() {
+  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]
-      return Buffer.concat([numToUInt32BE(this.compressedProof.length), this.compressedProof]);
+      sink.writeNumber(this.compressedProof.length);
+      sink.writeBytes(this.compressedProof);
+      return;
     }
-    // Legacy format: [field_count=1632: uint32] [fields...]
-    return serializeToBuffer(this.fields.length, this.fields);
+    // 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);
   }
 }
 
@@ -156,17 +177,24 @@ export class ChonkProofWithPublicInputs {
     // 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;
     // Flow compressed proof bytes through so the ChonkProof can serialize efficiently
     return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs), this.compressedProof);
@@ -196,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.

package/src/rollup/block_rollup_public_inputs.ts

@@ -119,6 +119,19 @@ export class BlockRollupPublicInputs {
     return this.toBuffer();
   }
 
+  toInspect() {
+    return {
+      previousArchiveRoot: this.previousArchive.root.toString(),
+      newArchiveRoot: this.newArchive.root.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.outHash.toString(),
+      timestamp: this.timestamp.toString(),
+      accumulatedFees: this.accumulatedFees.toString(),
+      accumulatedManaUsed: this.accumulatedManaUsed.toString(),
+    };
+  }
+
   static get schema() {
     return bufferSchemaFor(BlockRollupPublicInputs);
   }

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -101,6 +101,16 @@ export class CheckpointRollupPublicInputs {
     return this.toBuffer();
   }
 
+  toInspect() {
+    return {
+      checkpointHeaderHash: this.checkpointHeaderHashes[0].toString(),
+      previousArchiveRoot: this.previousArchive.root.toString(),
+      newArchiveRoot: this.newArchive.root.toString(),
+      previousOutHashRoot: this.previousOutHash.root.toString(),
+      newOutHashRoot: this.newOutHash.root.toString(),
+    };
+  }
+
   /** Creates an instance from a hex string. */
   static get schema() {
     return bufferSchemaFor(CheckpointRollupPublicInputs);

package/src/schemas/schemas.ts

@@ -89,7 +89,10 @@ export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
   z.boolean(),
   schemas.AztecAddress,
   z.array(z.lazy(() => AbiDecodedSchema)),
-  z.record(z.lazy(() => AbiDecodedSchema)),
+  z.record(
+    z.string(),
+    z.lazy(() => AbiDecodedSchema),
+  ),
 ]);
 
 // C++ only supports null values, which we want to convert to undefined.
@@ -103,6 +106,8 @@ export {
   hexSchemaFor,
   bufferSchemaFor,
   type ApiSchemaFor,
+  getSchemaParameters,
+  getSchemaReturnType,
   optional,
   mapSchema,
   pickFromSchema,

package/src/slashing/helpers.ts

@@ -48,11 +48,12 @@ export function getPenaltyForOffense(
   offense: OffenseType,
   config: Pick<
     SlasherConfig,
-    | 'slashAttestDescendantOfInvalidPenalty'
+    | 'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty'
     | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashBroadcastedInvalidCheckpointProposalPenalty'
     | 'slashDuplicateProposalPenalty'
     | 'slashDuplicateAttestationPenalty'
-    | 'slashPrunePenalty'
+    | 'slashAttestInvalidCheckpointProposalPenalty'
     | 'slashDataWithholdingPenalty'
     | 'slashUnknownPenalty'
     | 'slashInactivityPenalty'
@@ -60,8 +61,6 @@ export function getPenaltyForOffense(
   >,
 ) {
   switch (offense) {
-    case OffenseType.VALID_EPOCH_PRUNED:
-      return config.slashPrunePenalty;
     case OffenseType.DATA_WITHHOLDING:
       return config.slashDataWithholdingPenalty;
     case OffenseType.INACTIVITY:
@@ -69,14 +68,18 @@ export function getPenaltyForOffense(
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
       return config.slashProposeInvalidAttestationsPenalty;
-    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-      return config.slashAttestDescendantOfInvalidPenalty;
+    case OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS:
+      return config.slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty;
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
       return config.slashBroadcastedInvalidBlockPenalty;
+    case OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL:
+      return config.slashBroadcastedInvalidCheckpointProposalPenalty;
     case OffenseType.DUPLICATE_PROPOSAL:
       return config.slashDuplicateProposalPenalty;
     case OffenseType.DUPLICATE_ATTESTATION:
       return config.slashDuplicateAttestationPenalty;
+    case OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL:
+      return config.slashAttestInvalidCheckpointProposalPenalty;
     case OffenseType.UNKNOWN:
       return config.slashUnknownPenalty;
     default: {
@@ -89,17 +92,18 @@ export function getPenaltyForOffense(
 /** Returns whether the `epochOrSlot` field for an offense references an epoch or a slot */
 export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
   switch (offense) {
-    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+    case OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS:
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.DATA_WITHHOLDING:
+    case OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL:
     case OffenseType.DUPLICATE_PROPOSAL:
     case OffenseType.DUPLICATE_ATTESTATION:
+    case OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
       return 'slot';
     case OffenseType.INACTIVITY:
-    case OffenseType.DATA_WITHHOLDING:
     case OffenseType.UNKNOWN:
-    case OffenseType.VALID_EPOCH_PRUNED:
       return 'epoch';
     default: {
       const _exhaustiveCheck: never = offense;

package/src/slashing/types.ts

@@ -6,10 +6,8 @@ import { schemas, zodFor } from '../schemas/index.js';
 
 export enum OffenseType {
   UNKNOWN = 0,
-  /** The data for proving an epoch was not publicly available, we slash its committee */
+  /** The data for the txs in a published checkpoint was not available within the tolerance window, we slash the checkpoint's attesters */
   DATA_WITHHOLDING = 1,
-  /** An epoch was not successfully proven in time, we slash its committee */
-  VALID_EPOCH_PRUNED = 2,
   /** A proposer failed to attest or propose during an epoch according to the Sentinel */
   INACTIVITY = 3,
   /** A proposer sent an invalid block proposal over the p2p network to the committee */
@@ -18,12 +16,16 @@ export enum OffenseType {
   PROPOSED_INSUFFICIENT_ATTESTATIONS = 5,
   /** A proposer pushed to L1 a block with incorrect committee attestations (ie signature from a non-committee member) */
   PROPOSED_INCORRECT_ATTESTATIONS = 6,
-  /** A committee member attested to a block that was built as a descendent of an invalid block (as in a block with invalid attestations) */
-  ATTESTED_DESCENDANT_OF_INVALID = 7,
+  /** A proposer published a checkpoint to L1 that builds on an invalid checkpoint (as in a checkpoint with invalid or insufficient attestations) */
+  PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS = 7,
   /** A proposer sent duplicate proposals for the same position (slot, indexWithinCheckpoint for blocks or slot for checkpoints) */
   DUPLICATE_PROPOSAL = 8,
   /** A validator signed attestations for different proposals at the same slot (equivocation) */
   DUPLICATE_ATTESTATION = 9,
+  /** A committee member attested to a checkpoint proposal in a slot with an invalid block proposal */
+  ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL = 10,
+  /** A proposer broadcast an invalid checkpoint proposal, detected by retained evidence or deterministic recomputation */
+  BROADCASTED_INVALID_CHECKPOINT_PROPOSAL = 11,
 }
 
 export function getOffenseTypeName(offense: OffenseType) {
@@ -32,8 +34,6 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'unknown';
     case OffenseType.DATA_WITHHOLDING:
       return 'data_withholding';
-    case OffenseType.VALID_EPOCH_PRUNED:
-      return 'valid_epoch_pruned';
     case OffenseType.INACTIVITY:
       return 'inactivity';
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
@@ -42,12 +42,16 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'proposed_insufficient_attestations';
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
       return 'proposed_incorrect_attestations';
-    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-      return 'attested_descendant_of_invalid';
+    case OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS:
+      return 'proposed_descendant_of_checkpoint_with_invalid_attestations';
     case OffenseType.DUPLICATE_PROPOSAL:
       return 'duplicate_proposal';
     case OffenseType.DUPLICATE_ATTESTATION:
       return 'duplicate_attestation';
+    case OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL:
+      return 'attested_to_invalid_checkpoint_proposal';
+    case OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL:
+      return 'broadcasted_invalid_checkpoint_proposal';
     default:
       throw new Error(`Unknown offense type: ${offense}`);
   }
@@ -58,14 +62,15 @@ export const OffenseTypeSchema = z.nativeEnum(OffenseType);
 export const OffenseToBigInt: Record<OffenseType, bigint> = {
   [OffenseType.UNKNOWN]: 0n,
   [OffenseType.DATA_WITHHOLDING]: 1n,
-  [OffenseType.VALID_EPOCH_PRUNED]: 2n,
   [OffenseType.INACTIVITY]: 3n,
   [OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL]: 4n,
   [OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
   [OffenseType.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
-  [OffenseType.ATTESTED_DESCENDANT_OF_INVALID]: 7n,
+  [OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS]: 7n,
   [OffenseType.DUPLICATE_PROPOSAL]: 8n,
   [OffenseType.DUPLICATE_ATTESTATION]: 9n,
+  [OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL]: 10n,
+  [OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL]: 11n,
 };
 
 export function bigIntToOffense(offense: bigint): OffenseType {
@@ -74,8 +79,6 @@ export function bigIntToOffense(offense: bigint): OffenseType {
       return OffenseType.UNKNOWN;
     case 1n:
       return OffenseType.DATA_WITHHOLDING;
-    case 2n:
-      return OffenseType.VALID_EPOCH_PRUNED;
     case 3n:
       return OffenseType.INACTIVITY;
     case 4n:
@@ -85,11 +88,15 @@ export function bigIntToOffense(offense: bigint): OffenseType {
     case 6n:
       return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
     case 7n:
-      return OffenseType.ATTESTED_DESCENDANT_OF_INVALID;
+      return OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS;
     case 8n:
       return OffenseType.DUPLICATE_PROPOSAL;
     case 9n:
       return OffenseType.DUPLICATE_ATTESTATION;
+    case 10n:
+      return OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL;
+    case 11n:
+      return OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL;
     default:
       throw new Error(`Unknown offense: ${offense}`);
   }

package/src/stats/stats.ts

@@ -84,7 +84,11 @@ export type NodeSyncedChainHistoryStats = {
 
 export type ClientCircuitName =
   | 'private-kernel-init'
+  | 'private-kernel-init-2'
+  | 'private-kernel-init-3'
   | 'private-kernel-inner'
+  | 'private-kernel-inner-2'
+  | 'private-kernel-inner-3'
   | 'private-kernel-reset'
   | 'private-kernel-tail'
   | 'private-kernel-tail-to-public'