@aztec/stdlib 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/rollup/block_rollup_public_inputs.ts

@@ -43,17 +43,13 @@ export class BlockRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * Timestamp of the first block in this block range.
+     * Timestamp of the blocks in this block range.
      */
-    public startTimestamp: UInt64,
-    /**
-     * Timestamp of the last block in this block range.
-     */
-    public endTimestamp: UInt64,
+    public timestamp: UInt64,
     /**
      * Hash of the headers of all blocks in this block range. It will be combined with the `blockHeadersHash` from
-     * other blocks in the same checkpoint to form a wonky tree. The root of that tree becomes the final hash stored in
-     * the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
+     * other blocks in the same checkpoint to form an unbalanced tree. The root of that tree becomes the final hash
+     * stored in the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
      */
     public blockHeadersHash: Fr,
     /**
@@ -85,7 +81,6 @@ export class BlockRollupPublicInputs {
       reader.readObject(SpongeBlob),
       reader.readObject(SpongeBlob),
       reader.readUInt64(),
-      reader.readUInt64(),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -103,8 +98,7 @@ export class BlockRollupPublicInputs {
       this.endState,
       this.startSpongeBlob,
       this.endSpongeBlob,
-      bigintToUInt64BE(this.startTimestamp),
-      bigintToUInt64BE(this.endTimestamp),
+      bigintToUInt64BE(this.timestamp),
       this.blockHeadersHash,
       this.inHash,
       this.outHash,
@@ -125,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_header.ts

@@ -14,12 +14,13 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/index.js';
 import { schemas } from '../schemas/index.js';
-import { ContentCommitment } from '../tx/content_commitment.js';
+import type { GlobalVariables } from '../tx/global_variables.js';
 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?
+ * 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(
@@ -27,8 +28,18 @@ export class CheckpointHeader {
     public lastArchiveRoot: Fr,
     /** Hash of the headers of all blocks in this checkpoint. */
     public blockHeadersHash: Fr,
-    /** Content commitment of the L2 block. */
-    public contentCommitment: ContentCommitment,
+    /** Hash of the blobs in the checkpoint. */
+    public blobsHash: Fr,
+    /** Root of the l1 to l2 messages subtree. */
+    public inHash: Fr,
+    /**
+     * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
+     * index 0, the second at index 1, and so on.
+     * Note: This is not necessarily the final epoch out hash. It includes only the out hashes of checkpoints up to and
+     * including the current checkpoint. Any subsequent checkpoints added to the same epoch are not reflected in this
+     * value.
+     */
+    public epochOutHash: Fr,
     /** Slot number of the L2 block */
     public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
@@ -48,7 +59,9 @@ export class CheckpointHeader {
       .object({
         lastArchiveRoot: schemas.Fr,
         blockHeadersHash: schemas.Fr,
-        contentCommitment: ContentCommitment.schema,
+        blobsHash: schemas.Fr,
+        inHash: schemas.Fr,
+        epochOutHash: schemas.Fr,
         slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
@@ -63,7 +76,9 @@ export class CheckpointHeader {
     return [
       fields.lastArchiveRoot,
       fields.blockHeadersHash,
-      fields.contentCommitment,
+      fields.blobsHash,
+      fields.inHash,
+      fields.epochOutHash,
       fields.slotNumber,
       fields.timestamp,
       fields.coinbase,
@@ -83,7 +98,9 @@ export class CheckpointHeader {
     return new CheckpointHeader(
       reader.readObject(Fr),
       reader.readObject(Fr),
-      reader.readObject(ContentCommitment),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
       SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
@@ -97,7 +114,9 @@ export class CheckpointHeader {
     return (
       this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
       this.blockHeadersHash.equals(other.blockHeadersHash) &&
-      this.contentCommitment.equals(other.contentCommitment) &&
+      this.blobsHash.equals(other.blobsHash) &&
+      this.inHash.equals(other.inHash) &&
+      this.epochOutHash.equals(other.epochOutHash) &&
       this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
@@ -107,12 +126,25 @@ export class CheckpointHeader {
     );
   }
 
+  /** Returns true if the global variables match those in the checkpoint header. */
+  matchesGlobalVariables(other: GlobalVariables) {
+    return (
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp
+    );
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer([
       this.lastArchiveRoot,
       this.blockHeadersHash,
-      this.contentCommitment,
+      this.blobsHash,
+      this.inHash,
+      this.epochOutHash,
       new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
       this.coinbase,
@@ -130,7 +162,9 @@ export class CheckpointHeader {
     return CheckpointHeader.from({
       lastArchiveRoot: Fr.ZERO,
       blockHeadersHash: Fr.ZERO,
-      contentCommitment: ContentCommitment.empty(),
+      blobsHash: Fr.ZERO,
+      inHash: Fr.ZERO,
+      epochOutHash: Fr.ZERO,
       slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       coinbase: EthAddress.ZERO,
@@ -141,13 +175,13 @@ export class CheckpointHeader {
     });
   }
 
-  static random(
-    overrides: Partial<FieldsOf<CheckpointHeader>> & Partial<FieldsOf<ContentCommitment>> = {},
-  ): CheckpointHeader {
+  static random(overrides: Partial<FieldsOf<CheckpointHeader>> = {}): CheckpointHeader {
     return CheckpointHeader.from({
       lastArchiveRoot: Fr.random(),
       blockHeadersHash: Fr.random(),
-      contentCommitment: ContentCommitment.random(overrides),
+      blobsHash: Fr.random(),
+      inHash: Fr.random(),
+      epochOutHash: Fr.random(),
       slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
       timestamp: BigInt(Math.floor(Date.now() / 1000)),
       coinbase: EthAddress.random(),
@@ -162,7 +196,9 @@ export class CheckpointHeader {
     return (
       this.lastArchiveRoot.isZero() &&
       this.blockHeadersHash.isZero() &&
-      this.contentCommitment.isEmpty() &&
+      this.blobsHash.isZero() &&
+      this.inHash.isZero() &&
+      this.epochOutHash.isZero() &&
       this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
@@ -188,7 +224,9 @@ export class CheckpointHeader {
     return new CheckpointHeader(
       Fr.fromString(header.lastArchiveRoot),
       Fr.fromString(header.blockHeadersHash),
-      ContentCommitment.fromViem(header.contentCommitment),
+      Fr.fromString(header.blobsHash),
+      Fr.fromString(header.inHash),
+      Fr.fromString(header.outHash),
       SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
       new EthAddress(hexToBuffer(header.coinbase)),
@@ -210,7 +248,9 @@ export class CheckpointHeader {
     return {
       lastArchiveRoot: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
-      contentCommitment: this.contentCommitment.toViem(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      outHash: this.epochOutHash.toString(),
       slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
@@ -227,7 +267,9 @@ export class CheckpointHeader {
     return {
       lastArchive: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
-      contentCommitment: this.contentCommitment.toInspect(),
+      blobsHash: this.blobsHash.toString(),
+      inHash: this.inHash.toString(),
+      epochOutHash: this.epochOutHash.toString(),
       slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
@@ -238,16 +280,17 @@ export class CheckpointHeader {
   }
 
   [inspect.custom]() {
-    const gasfees = `da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas}`;
     return `Header {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
   blockHeadersHash: ${this.blockHeadersHash.toString()},
-  contentCommitment: ${inspect(this.contentCommitment)},
+  blobsHash: ${inspect(this.blobsHash)},
+  inHash: ${inspect(this.inHash)},
+  epochOutHash: ${inspect(this.epochOutHash)},
   slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},
   feeRecipient: ${this.feeRecipient.toString()},
-  gasFees: ${gasfees},
+  gasFees: { da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas} },
   totalManaUsed: ${this.totalManaUsed.toBigInt()},
 }`;
   }

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';
@@ -27,14 +27,22 @@ export class CheckpointRollupPublicInputs {
      * Archive tree after adding this checkpoint range.
      */
     public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint range.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * The out hash tree snapshot after applying this checkpoint range.
+     */
+    public newOutHash: AppendOnlyTreeSnapshot,
     /**
      * 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.
      */
@@ -55,8 +63,10 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       reader.readObject(BlobAccumulator),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),
@@ -68,6 +78,8 @@ export class CheckpointRollupPublicInputs {
       this.constants,
       this.previousArchive,
       this.newArchive,
+      this.previousOutHash,
+      this.newOutHash,
       this.checkpointHeaderHashes,
       this.fees,
       this.startBlobAccumulator,
@@ -89,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/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -1,5 +1,5 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { BLS12Point } from '@aztec/foundation/curves/bls12';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -8,6 +8,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
 
@@ -21,6 +22,14 @@ export class CheckpointRootRollupHints {
      * Hint for checking the hash of previous_block_header is the last leaf of the previous archive.
      */
     public previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * Hint for inserting the new out hash into the out hash tree.
+     */
+    public newOutHashSiblingPath: Tuple<Fr, typeof OUT_HASH_TREE_HEIGHT>,
     /**
      * The current blob accumulation state across the epoch.
      */
@@ -54,6 +63,8 @@ export class CheckpointRootRollupHints {
     return [
       fields.previousBlockHeader,
       fields.previousArchiveSiblingPath,
+      fields.previousOutHash,
+      fields.newOutHashSiblingPath,
       fields.startBlobAccumulator,
       fields.finalBlobChallenges,
       fields.blobFields,
@@ -71,6 +82,8 @@ export class CheckpointRootRollupHints {
     return new CheckpointRootRollupHints(
       BlockHeader.fromBuffer(reader),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readArray(OUT_HASH_TREE_HEIGHT, Fr),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),
       // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'

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';
@@ -21,8 +21,14 @@ export class RootRollupPublicInputs {
     public previousArchiveRoot: Fr,
     /** Root of the archive tree after this rollup is processed */
     public endArchiveRoot: Fr,
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    /**
+     * Root of the balanced merkle tree consisting of the out hashes of all checkpoints in this epoch.
+     * The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on.
+     */
+    public outHash: Fr,
+    /** Hashes of checkpoint headers for this rollup. */
+    public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
+    public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     public constants: EpochConstantData,
     public blobPublicInputs: FinalBlobAccumulator,
   ) {}
@@ -31,6 +37,7 @@ export class RootRollupPublicInputs {
     return [
       fields.previousArchiveRoot,
       fields.endArchiveRoot,
+      fields.outHash,
       fields.checkpointHeaderHashes,
       fields.fees,
       fields.constants,
@@ -60,8 +67,9 @@ export class RootRollupPublicInputs {
     return new RootRollupPublicInputs(
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      Fr.fromBuffer(reader),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       EpochConstantData.fromBuffer(reader),
       reader.readObject(FinalBlobAccumulator),
     );
@@ -90,8 +98,9 @@ export class RootRollupPublicInputs {
     return new RootRollupPublicInputs(
       Fr.random(),
       Fr.random(),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      Fr.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/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,9 +48,12 @@ export function getPenaltyForOffense(
   offense: OffenseType,
   config: Pick<
     SlasherConfig,
-    | 'slashAttestDescendantOfInvalidPenalty'
+    | 'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty'
     | 'slashBroadcastedInvalidBlockPenalty'
-    | 'slashPrunePenalty'
+    | 'slashBroadcastedInvalidCheckpointProposalPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
+    | 'slashAttestInvalidCheckpointProposalPenalty'
     | 'slashDataWithholdingPenalty'
     | 'slashUnknownPenalty'
     | 'slashInactivityPenalty'
@@ -58,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:
@@ -67,10 +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: {
@@ -83,15 +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/index.ts

@@ -1,6 +1,5 @@
 export * from './types.js';
 export * from './interfaces.js';
 export * from './helpers.js';
-export * from './empire.js';
-export * from './tally.js';
+export * from './votes.js';
 export * from './serialization.js';

package/src/slashing/serialization.ts

@@ -1,15 +1,7 @@
-import { times } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BufferReader, bigintToUInt64BE, bigintToUInt128BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type {
-  Offense,
-  OffenseType,
-  SlashPayload,
-  SlashPayloadRound,
-  ValidatorSlash,
-  ValidatorSlashOffense,
-} from './types.js';
+import type { Offense, OffenseType } from './types.js';
 
 export function serializeOffense(offense: Offense): Buffer {
   return serializeToBuffer(
@@ -29,75 +21,3 @@ export function deserializeOffense(buffer: Buffer): Offense {
 
   return { validator, amount, offenseType: offense, epochOrSlot };
 }
-
-function serializeValidatorSlashOffense(offense: ValidatorSlashOffense): Buffer {
-  return serializeToBuffer(bigintToUInt64BE(offense.epochOrSlot), offense.offenseType);
-}
-
-function deserializeValidatorSlashOffense(buffer: Buffer | BufferReader): ValidatorSlashOffense {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    epochOrSlot: reader.readUInt64(),
-    offenseType: reader.readNumber() as OffenseType,
-  };
-}
-
-function serializeValidatorSlash(slash: ValidatorSlash): Buffer {
-  return serializeToBuffer(
-    slash.validator,
-    bigintToUInt128BE(slash.amount),
-    slash.offenses.length,
-    slash.offenses.map(serializeValidatorSlashOffense),
-  );
-}
-
-function deserializeValidatorSlash(buffer: Buffer | BufferReader): ValidatorSlash {
-  const reader = BufferReader.asReader(buffer);
-  const validator = reader.readObject(EthAddress);
-  const amount = reader.readUInt128();
-  const offensesCount = reader.readNumber();
-  const offenses = times(offensesCount, () => deserializeValidatorSlashOffense(reader));
-
-  return { validator, amount, offenses };
-}
-
-export function serializeSlashPayload(payload: SlashPayload): Buffer {
-  return serializeToBuffer(
-    payload.address,
-    payload.slashes.length,
-    payload.slashes.map(serializeValidatorSlash),
-    bigintToUInt64BE(payload.timestamp),
-  );
-}
-
-export function deserializeSlashPayload(buffer: Buffer): SlashPayload {
-  const reader = BufferReader.asReader(buffer);
-  const address = reader.readObject(EthAddress);
-  const slashesCount = reader.readNumber();
-  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
-  const timestamp = reader.readUInt64();
-  return { address, slashes, timestamp };
-}
-
-export function serializeSlashPayloadRound(payload: SlashPayloadRound): Buffer {
-  return serializeToBuffer(
-    payload.address,
-    payload.slashes.length,
-    payload.slashes.map(serializeValidatorSlash),
-    bigintToUInt64BE(payload.timestamp),
-    Number(payload.votes),
-    bigintToUInt64BE(payload.round),
-  );
-}
-
-export function deserializeSlashPayloadRound(buffer: Buffer): SlashPayloadRound {
-  const reader = BufferReader.asReader(buffer);
-  const address = reader.readObject(EthAddress);
-  const slashesCount = reader.readNumber();
-  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
-  const timestamp = reader.readUInt64();
-  const votes = BigInt(reader.readNumber());
-  const round = reader.readUInt64();
-
-  return { address, slashes, timestamp, votes, round };
-}