@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.001888fc

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,22 +1,17 @@
-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';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { RollupTypes } from '../types/shared.js';
-import { ConstantRollupData } from './constant_rollup_data.js';
+import { BlockConstantData } from './block_constant_data.js';
 
 /**
  * Output of the base and merge rollup circuits.
  */
-export class BaseOrMergeRollupPublicInputs {
+export class TxRollupPublicInputs {
   constructor(
-    /**
-     * Specifies from which type of rollup circuit these inputs are from.
-     */
-    public rollupType: RollupTypes,
     /**
      * Number of txs in this rollup.
      */
@@ -24,15 +19,15 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Data which is forwarded through the rollup circuits unchanged.
      */
-    public constants: ConstantRollupData,
+    public constants: BlockConstantData,
     /**
      * 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.
      */
@@ -42,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,
@@ -58,10 +53,9 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Returns an empty instance. */
   static empty() {
-    return new BaseOrMergeRollupPublicInputs(
-      RollupTypes.Base,
+    return new TxRollupPublicInputs(
       0,
-      ConstantRollupData.empty(),
+      BlockConstantData.empty(),
       PartialStateReference.empty(),
       PartialStateReference.empty(),
       SpongeBlob.empty(),
@@ -78,12 +72,11 @@ 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(
-      reader.readNumber(),
+    return new TxRollupPublicInputs(
       reader.readNumber(),
-      reader.readObject(ConstantRollupData),
+      reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),
@@ -100,12 +93,11 @@ export class BaseOrMergeRollupPublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
-      this.rollupType,
       this.numTxs,
       this.constants,
 
-      this.start,
-      this.end,
+      this.startTreeSnapshots,
+      this.endTreeSnapshots,
 
       this.startSpongeBlob,
       this.endSpongeBlob,
@@ -128,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. */
@@ -141,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>,
 
@@ -49,6 +55,9 @@ export const schemas = {
   /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
   HexString: foundationSchemas.HexString,
 
+  /** Schema for secret config value */
+  SecretValue: foundationSchemas.SecretValue,
+
   /** Accepts a hex string. */
   AztecAddress: AztecAddress.schema,
 
@@ -60,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,8 +92,12 @@ export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
   z.record(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,

package/src/slashing/empire.ts

@@ -0,0 +1,104 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
+import { getRoundForSlot, getRoundsForEpoch } from './helpers.js';
+import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
+import { OffenseType } from './types.js';
+
+/**
+ * Returns true if the offense is uncontroversial as in it can be verified via L1 data alone,
+ * and does not depend on the local view of the node of the L2 p2p network.
+ * @param offense - The offense type to check
+ */
+export function isOffenseUncontroversial(offense: OffenseType): boolean {
+  return (
+    offense === OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS ||
+    offense === OffenseType.PROPOSED_INCORRECT_ATTESTATIONS ||
+    offense === OffenseType.ATTESTED_DESCENDANT_OF_INVALID
+  );
+}
+
+/** Extracts offense identifiers (validator, epoch, offense type) from an Empire-based SlashPayload */
+export function getOffenseIdentifiersFromPayload(payload: SlashPayload | SlashPayloadRound): OffenseIdentifier[] {
+  return payload.slashes.flatMap((slash: ValidatorSlash) =>
+    slash.offenses.map(o => ({
+      validator: slash.validator,
+      offenseType: o.offenseType,
+      epochOrSlot: o.epochOrSlot,
+    })),
+  );
+}
+
+/** Creates ValidatorSlashes used to create an Empire-based SlashPayload from a set of Offenses */
+export function offensesToValidatorSlash(offenses: Offense[]): ValidatorSlash[] {
+  return offenses.map(offense => ({
+    validator: offense.validator,
+    amount: offense.amount,
+    offenses: [{ epochOrSlot: offense.epochOrSlot, offenseType: offense.offenseType }],
+  }));
+}
+
+/**
+ * Sorts offense data by:
+ * - Uncontroversial offenses first
+ * - Slash amount (descending)
+ * - Epoch or slot (ascending, ie oldest first)
+ * - Validator address (ascending)
+ * - Offense type (descending)
+ */
+export function offenseDataComparator(a: Offense, b: Offense): number {
+  return (
+    Number(isOffenseUncontroversial(b.offenseType)) - Number(isOffenseUncontroversial(a.offenseType)) ||
+    Number(b.amount - a.amount) ||
+    Number(a.epochOrSlot - b.epochOrSlot) ||
+    a.validator.toString().localeCompare(b.validator.toString()) ||
+    Number(b.offenseType) - Number(a.offenseType)
+  );
+}
+
+/**
+ * Returns the first round in which the offense is eligible for being included in an Empire-based slash payload.
+ * Should be equal to to the first round that starts strictly after the offense becomes detectable.
+ */
+export function getFirstEligibleRoundForOffense(
+  offense: OffenseIdentifier,
+  constants: { slashingRoundSize: number; epochDuration: number; proofSubmissionEpochs: number },
+): bigint {
+  // TODO(palla/slash): Check for off-by-ones
+  switch (offense.offenseType) {
+    // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
+    case OffenseType.INACTIVITY: {
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    // These offenses are detected once an epoch is pruned, which happens after the proof submission window
+    case OffenseType.VALID_EPOCH_PRUNED:
+    case OffenseType.DATA_WITHHOLDING: {
+      // TODO(palla/slash): Check for off-by-ones especially here
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + BigInt(constants.proofSubmissionEpochs));
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+    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;
+    }
+    // Assume these are epoch-based offenses, even though we should never have to process these
+    case OffenseType.UNKNOWN: {
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    default: {
+      const _: never = offense.offenseType;
+      throw new Error(`Unknown offense type: ${offense.offenseType}`);
+    }
+  }
+}