@aztec/stdlib 0.0.1-fake-ceab37513c → 0.0.1-private.5d121bfd

package/src/rollup/root_rollup_public_inputs.ts

@@ -0,0 +1,108 @@
+import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
+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';
+import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { FeeRecipient } from './checkpoint_rollup_public_inputs.js';
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Represents public inputs of the root rollup circuit.
+ *
+ * NOTE: in practice, we'll hash all of this up into a single public input, for cheap onchain verification.
+ */
+export class RootRollupPublicInputs {
+  constructor(
+    /** Root of the archive tree before this rollup is processed */
+    public previousArchiveRoot: Fr,
+    /** Root of the archive tree after this rollup is processed */
+    public endArchiveRoot: Fr,
+    /**
+     * 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,
+  ) {}
+
+  static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
+    return [
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
+      fields.outHash,
+      fields.checkpointHeaderHashes,
+      fields.fees,
+      fields.constants,
+      fields.blobPublicInputs,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...RootRollupPublicInputs.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...RootRollupPublicInputs.getFields(this));
+  }
+
+  static from(fields: FieldsOf<RootRollupPublicInputs>): RootRollupPublicInputs {
+    return new RootRollupPublicInputs(...RootRollupPublicInputs.getFields(fields));
+  }
+
+  /**
+   * Deserializes a buffer into a `RootRollupPublicInputs` object.
+   * @param buffer - The buffer to deserialize.
+   * @returns The deserialized `RootRollupPublicInputs` object.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupPublicInputs(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
+      EpochConstantData.fromBuffer(reader),
+      reader.readObject(FinalBlobAccumulator),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return RootRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupPublicInputs);
+  }
+
+  /** Creates a random instance. Used for testing only - will not prove/verify. */
+  static random() {
+    return new RootRollupPublicInputs(
+      Fr.random(),
+      Fr.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/rollup/{state_diff_hints.ts → tree_snapshot_diff_hints.ts}

@@ -1,23 +1,27 @@
 import {
   MAX_NULLIFIERS_PER_TX,
-  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
-  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
+  NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
+import { NullifierLeafPreimage } from '../trees/index.js';
 
 /**
  * Hints used while proving state diff validity for the private base rollup.
  */
-export class PrivateBaseStateDiffHints {
+export class TreeSnapshotDiffHints {
   constructor(
+    /**
+     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
+     */
+    public noteHashSubtreeRootSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * The nullifiers which need to be updated to perform the batch insertion of the new nullifiers.
      * See `StandardIndexedTree.batchInsert` function for more details.
@@ -39,44 +43,29 @@ export class PrivateBaseStateDiffHints {
      * The indexes of the sorted nullifiers to the original ones.
      */
     public sortedNullifierIndexes: Tuple<number, typeof MAX_NULLIFIERS_PER_TX>,
-    /**
-     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
-     */
-    public noteHashSubtreeSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH>,
     /**
      * Sibling path "pointing to" where the new nullifiers subtree should be inserted into the nullifier tree.
      */
-    public nullifierSubtreeSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH>,
-
-    /**
-     * Low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafPreimage: PublicDataTreeLeafPreimage,
-    /**
-     * Membership witness for the low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public nullifierSubtreeRootSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
-     * Sibling path "pointing to" where the fee write should be inserted into the public data tree.
+     * Membership witness for the fee payer's balance leaf in the public data tree.
      */
-    public feeWriteSiblingPath: Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public feePayerBalanceMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
   ) {}
 
-  static from(fields: FieldsOf<PrivateBaseStateDiffHints>): PrivateBaseStateDiffHints {
-    return new PrivateBaseStateDiffHints(...PrivateBaseStateDiffHints.getFields(fields));
+  static from(fields: FieldsOf<TreeSnapshotDiffHints>): TreeSnapshotDiffHints {
+    return new TreeSnapshotDiffHints(...TreeSnapshotDiffHints.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PrivateBaseStateDiffHints>) {
+  static getFields(fields: FieldsOf<TreeSnapshotDiffHints>) {
     return [
+      fields.noteHashSubtreeRootSiblingPath,
       fields.nullifierPredecessorPreimages,
       fields.nullifierPredecessorMembershipWitnesses,
       fields.sortedNullifiers,
       fields.sortedNullifierIndexes,
-      fields.noteHashSubtreeSiblingPath,
-      fields.nullifierSubtreeSiblingPath,
-      fields.feeWriteLowLeafPreimage,
-      fields.feeWriteLowLeafMembershipWitness,
-      fields.feeWriteSiblingPath,
+      fields.nullifierSubtreeRootSiblingPath,
+      fields.feePayerBalanceMembershipWitness,
     ] as const;
   }
 
@@ -85,42 +74,38 @@ export class PrivateBaseStateDiffHints {
    * @returns A buffer of the serialized state diff hints.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(...PrivateBaseStateDiffHints.getFields(this));
+    return serializeToBuffer(...TreeSnapshotDiffHints.getFields(this));
   }
 
   /**
    * Deserializes the state diff hints from a buffer.
    * @param buffer - A buffer to deserialize from.
-   * @returns A new PrivateBaseStateDiffHints instance.
+   * @returns A new TreeSnapshotDiffHints instance.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseStateDiffHints {
+  static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshotDiffHints {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      reader.readArray(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage),
       reader.readArray(MAX_NULLIFIERS_PER_TX, {
         fromBuffer: buffer => MembershipWitness.fromBuffer(buffer, NULLIFIER_TREE_HEIGHT),
       }),
       reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readNumbers(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readObject(PublicDataTreeLeafPreimage),
+      reader.readArray(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       MembershipWitness.fromBuffer(reader, PUBLIC_DATA_TREE_HEIGHT),
-      reader.readArray(PUBLIC_DATA_TREE_HEIGHT, Fr),
     );
   }
 
   static empty() {
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage.empty),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => MembershipWitness.empty(NULLIFIER_TREE_HEIGHT)),
       makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => 0),
-      makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      PublicDataTreeLeafPreimage.empty(),
+      makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT),
-      makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero),
     );
   }
 }

package/src/rollup/{merge_rollup.ts → tx_merge_rollup_private_inputs.ts}

@@ -2,17 +2,18 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { PreviousRollupData } from './previous_rollup_data.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js';
 
 /**
  * Represents inputs of the merge rollup circuit.
  */
-export class MergeRollupInputs {
+export class TxMergeRollupPrivateInputs {
   constructor(
     /**
      * Previous rollup data from the 2 merge or base rollup circuits that preceded this merge rollup circuit.
      */
-    public previousRollupData: [PreviousRollupData, PreviousRollupData],
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
   ) {}
 
   /**
@@ -20,7 +21,7 @@ export class MergeRollupInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousRollupData);
+    return serializeToBuffer(this.previousRollups);
   }
 
   /**
@@ -34,20 +35,23 @@ export class MergeRollupInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new MergeRollupInputs([reader.readObject(PreviousRollupData), reader.readObject(PreviousRollupData)]);
+    return new TxMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+    ]);
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromString(str: string) {
-    return MergeRollupInputs.fromBuffer(hexToBuffer(str));
+    return TxMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -57,6 +61,6 @@ export class MergeRollupInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(MergeRollupInputs);
+    return bufferSchemaFor(TxMergeRollupPrivateInputs);
   }
 }

package/src/rollup/{base_or_merge_rollup_public_inputs.ts → tx_rollup_public_inputs.ts}

@@ -1,5 +1,5 @@
-import { SpongeBlob } from '@aztec/blob-lib';
-import { Fr } from '@aztec/foundation/fields';
+import { SpongeBlob } from '@aztec/blob-lib/types';
+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';
@@ -10,7 +10,7 @@ import { BlockConstantData } from './block_constant_data.js';
 /**
  * Output of the base and merge rollup circuits.
  */
-export class BaseOrMergeRollupPublicInputs {
+export class TxRollupPublicInputs {
   constructor(
     /**
      * Number of txs in this rollup.
@@ -23,11 +23,11 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Partial state reference at the start of the rollup circuit.
      */
-    public start: PartialStateReference,
+    public startTreeSnapshots: PartialStateReference,
     /**
      * Partial state reference at the end of the rollup circuit.
      */
-    public end: PartialStateReference,
+    public endTreeSnapshots: PartialStateReference,
     /**
      * Sponge state to absorb blob inputs at the start of the rollup circuit.
      */
@@ -37,7 +37,7 @@ export class BaseOrMergeRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened onchain).
      * Note: Truncated to 31 bytes to fit in Fr.
      */
     public outHash: Fr,
@@ -53,7 +53,7 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Returns an empty instance. */
   static empty() {
-    return new BaseOrMergeRollupPublicInputs(
+    return new TxRollupPublicInputs(
       0,
       BlockConstantData.empty(),
       PartialStateReference.empty(),
@@ -72,9 +72,9 @@ export class BaseOrMergeRollupPublicInputs {
    * @param buffer - Buffer or reader to read from.
    * @returns The deserialized public inputs.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): TxRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
-    return new BaseOrMergeRollupPublicInputs(
+    return new TxRollupPublicInputs(
       reader.readNumber(),
       reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
@@ -96,8 +96,8 @@ export class BaseOrMergeRollupPublicInputs {
       this.numTxs,
       this.constants,
 
-      this.start,
-      this.end,
+      this.startTreeSnapshots,
+      this.endTreeSnapshots,
 
       this.startSpongeBlob,
       this.endSpongeBlob,
@@ -120,10 +120,10 @@ export class BaseOrMergeRollupPublicInputs {
   /**
    * Deserializes from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new BaseOrMergeRollupPublicInputs instance.
+   * @returns A new TxRollupPublicInputs instance.
    */
   static fromString(str: string) {
-    return BaseOrMergeRollupPublicInputs.fromBuffer(hexToBuffer(str));
+    return TxRollupPublicInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -133,6 +133,6 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseOrMergeRollupPublicInputs);
+    return bufferSchemaFor(TxRollupPublicInputs);
   }
 }

package/src/schemas/schemas.ts

@@ -1,6 +1,8 @@
+import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Buffer32 } from '@aztec/foundation/buffer';
+import type { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fq, Fr, Point } from '@aztec/foundation/fields';
 import { type ZodFor, schemas as foundationSchemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
@@ -10,6 +12,7 @@ import { EventSelector } from '../abi/event_selector.js';
 import { FunctionSelector } from '../abi/function_selector.js';
 import { NoteSelector } from '../abi/note_selector.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { Gas } from '../gas/gas.js';
 
 /**
  * Validation schemas for common types. Every schema must match its toJSON.
@@ -37,6 +40,9 @@ export const schemas = {
   /** Coerces input to UInt32. */
   UInt32: foundationSchemas.UInt32,
 
+  /** Coerces input to UInt64. */
+  UInt64: foundationSchemas.UInt64,
+
   /** Accepts a hex string as a Buffer32 type. */
   Buffer32: foundationSchemas.Buffer32 as ZodFor<Buffer32>,
 
@@ -63,6 +69,19 @@ export const schemas = {
 
   /** Accepts a hex string. */
   EventSelector: EventSelector.schema,
+
+  /** Accepts a number, bigint, or string and coerces to SlotNumber. */
+  SlotNumber: foundationSchemas.SlotNumber as ZodFor<SlotNumber>,
+
+  /** Accepts a number, bigint, or string and coerces to EpochNumber. */
+  EpochNumber: foundationSchemas.EpochNumber as ZodFor<EpochNumber>,
+
+  GasUsed: z.object({
+    totalGas: Gas.schema,
+    teardownGas: Gas.schema,
+    publicGas: Gas.schema,
+    billedGas: Gas.schema,
+  }),
 };
 
 export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
@@ -70,16 +89,25 @@ 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.
+export const NullishToUndefined = (schema: ZodFor<any>) => schema.nullish().transform(x => x ?? undefined);
+
 export {
   type ZodFor,
+  zodFor,
   bufferSchema,
   hexSchema,
   hexSchemaFor,
   bufferSchemaFor,
   type ApiSchemaFor,
+  getSchemaParameters,
+  getSchemaReturnType,
   optional,
   mapSchema,
   pickFromSchema,

package/src/slashing/helpers.ts

@@ -1,21 +1,24 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
 import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
 
 /** Returns the voting round number and voting slot within the round for a given L2 slot. */
 export function getRoundForSlot(
-  slot: bigint,
+  slot: SlotNumber,
   constants: { slashingRoundSize: number },
-): { round: bigint; votingSlot: bigint } {
+): { round: bigint; votingSlot: SlotNumber } {
   const roundSize = BigInt(constants.slashingRoundSize);
-  const round = slot / roundSize;
-  const votingSlot = slot % roundSize;
+  const slotBigInt = BigInt(slot);
+  const round = slotBigInt / roundSize;
+  const votingSlot = SlotNumber.fromBigInt(slotBigInt % roundSize);
   return { round, votingSlot };
 }
 
 /** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
 export function getRoundsForEpoch(
-  epoch: bigint,
+  epoch: EpochNumber,
   constants: { slashingRoundSize: number; epochDuration: number },
 ): [bigint, bigint] {
   const [start, end] = getSlotRangeForEpoch(epoch, constants);
@@ -28,13 +31,13 @@ export function getRoundsForEpoch(
 export function getEpochsForRound(
   round: bigint,
   constants: { slashingRoundSize: number; epochDuration: number },
-): bigint[] {
-  const epochs: bigint[] = [];
-  const firstSlot = round * BigInt(constants.slashingRoundSize);
-  const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
+): EpochNumber[] {
+  const epochs: EpochNumber[] = [];
+  const firstSlot = SlotNumber.fromBigInt(round * BigInt(constants.slashingRoundSize));
+  const lastSlot = SlotNumber(firstSlot + constants.slashingRoundSize - 1);
   const startEpoch = getEpochAtSlot(firstSlot, constants);
   const endEpoch = getEpochAtSlot(lastSlot, constants);
-  for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+  for (let epoch = startEpoch; epoch <= endEpoch; epoch = EpochNumber(epoch + 1)) {
     epochs.push(epoch);
   }
   return epochs;
@@ -45,9 +48,12 @@ export function getPenaltyForOffense(
   offense: OffenseType,
   config: Pick<
     SlasherConfig,
-    | 'slashAttestDescendantOfInvalidPenalty'
+    | 'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty'
     | 'slashBroadcastedInvalidBlockPenalty'
-    | 'slashPrunePenalty'
+    | 'slashBroadcastedInvalidCheckpointProposalPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
+    | 'slashAttestInvalidCheckpointProposalPenalty'
     | 'slashDataWithholdingPenalty'
     | 'slashUnknownPenalty'
     | 'slashInactivityPenalty'
@@ -55,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:
@@ -64,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: {
@@ -80,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;
@@ -101,9 +116,11 @@ export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
 export function getSlotForOffense(
   offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
-): bigint {
+): SlotNumber {
   const { epochOrSlot, offenseType } = offense;
-  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
+  return getTimeUnitForOffense(offenseType) === 'epoch'
+    ? SlotNumber.fromBigInt(epochOrSlot * BigInt(constants.epochDuration))
+    : SlotNumber.fromBigInt(epochOrSlot);
 }
 
 /** Returns the epoch for a given offense. If the offense type or epoch is not defined, returns undefined. */

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/interfaces.ts

@@ -1,3 +1,5 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+
 import type { ProposerSlashAction } from './types.js';
 
 export interface ProposerSlashActionProvider {
@@ -7,5 +9,5 @@ export interface ProposerSlashActionProvider {
    * @param slotNumber - The current slot number
    * @returns The actions to take
    */
-  getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
 }