@aztec/stdlib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/rollup/epoch_constant_data.ts

@@ -0,0 +1,44 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+/**
+ * Constants that are the same for the entire epoch.
+ */
+export class EpochConstantData {
+  constructor(
+    /**
+     * Root of the verification key tree.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * Root of the protocol contract tree.
+     */
+    public protocolContractTreeRoot: Fr,
+    /**
+     * Identifier of the prover of the epoch.
+     */
+    public proverId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<EpochConstantData>): EpochConstantData {
+    return new EpochConstantData(...EpochConstantData.getFields(fields));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): EpochConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new EpochConstantData(Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+  }
+
+  static getFields(fields: FieldsOf<EpochConstantData>) {
+    return [fields.vkTreeRoot, fields.protocolContractTreeRoot, fields.proverId] as const;
+  }
+
+  static empty() {
+    return new EpochConstantData(Fr.ZERO, Fr.ZERO, Fr.ZERO);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...EpochConstantData.getFields(this));
+  }
+}

package/src/rollup/index.ts

@@ -1,12 +1,14 @@
 export * from './avm_proof_data.js';
 export * from './base_or_merge_rollup_public_inputs.js';
 export * from './base_rollup_hints.js';
+export * from './block_constant_data.js';
 export * from './block_merge_rollup.js';
 export * from './block_root_or_block_merge_public_inputs.js';
-export * from './constant_rollup_data.js';
 export * from './empty_block_root_rollup_inputs.js';
+export * from './epoch_constant_data.js';
 export * from './block_root_rollup.js';
 export * from './merge_rollup.js';
+export * from './padding_block_root_rollup_inputs.js';
 export * from './previous_rollup_block_data.js';
 export * from './previous_rollup_data.js';
 export * from './private_base_rollup_inputs.js';

package/src/rollup/padding_block_root_rollup_inputs.ts

@@ -0,0 +1,47 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Inputs of the padding block root rollup circuit.
+ */
+export class PaddingBlockRootRollupInputs {
+  constructor(public readonly constants: EpochConstantData) {}
+
+  static from(fields: FieldsOf<PaddingBlockRootRollupInputs>): PaddingBlockRootRollupInputs {
+    return new PaddingBlockRootRollupInputs(...PaddingBlockRootRollupInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PaddingBlockRootRollupInputs>) {
+    return [fields.constants] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PaddingBlockRootRollupInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PaddingBlockRootRollupInputs(reader.readObject(EpochConstantData));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PaddingBlockRootRollupInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PaddingBlockRootRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PaddingBlockRootRollupInputs);
+  }
+}

package/src/rollup/previous_rollup_block_data.ts

@@ -1,9 +1,8 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { VkData } from '../vks/index.js';
 import { BlockRootOrBlockMergePublicInputs } from './block_root_or_block_merge_public_inputs.js';
 
 /**
@@ -20,13 +19,9 @@ export class PreviousRollupBlockData {
      */
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
     /**
-     * The verification key of the block merge or block root rollup circuit.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public vk: VerificationKeyAsFields,
-    /**
-     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
-     */
-    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -34,7 +29,7 @@ export class PreviousRollupBlockData {
    * @returns The buffer of the serialized previous rollup data.
    */
   public toBuffer(): Buffer {
-    return serializeToBuffer(this.blockRootOrBlockMergePublicInputs, this.proof, this.vk, this.vkWitness);
+    return serializeToBuffer(this.blockRootOrBlockMergePublicInputs, this.proof, this.vkData);
   }
 
   /**
@@ -47,8 +42,7 @@ export class PreviousRollupBlockData {
     return new PreviousRollupBlockData(
       reader.readObject(BlockRootOrBlockMergePublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VerificationKeyAsFields),
-      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+      reader.readObject(VkData),
     );
   }
 }

package/src/rollup/previous_rollup_data.ts

@@ -1,9 +1,8 @@
-import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { VerificationKeyAsFields } from '../vks/verification_key.js';
+import { VkData } from '../vks/index.js';
 import { BaseOrMergeRollupPublicInputs } from './base_or_merge_rollup_public_inputs.js';
 
 /**
@@ -20,13 +19,9 @@ export class PreviousRollupData {
      */
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
     /**
-     * The verification key of the base or merge rollup circuit.
+     * The verification key and the witness of the vk in the vk tree.
      */
-    public vk: VerificationKeyAsFields,
-    /**
-     * Sibling path of the rollup circuit's vk in a big tree of rollup circuit vks.
-     */
-    public vkWitness: MembershipWitness<typeof VK_TREE_HEIGHT>,
+    public vkData: VkData,
   ) {}
 
   /**
@@ -34,7 +29,7 @@ export class PreviousRollupData {
    * @returns The buffer of the serialized previous rollup data.
    */
   public toBuffer(): Buffer {
-    return serializeToBuffer(this.baseOrMergeRollupPublicInputs, this.proof, this.vk, this.vkWitness);
+    return serializeToBuffer(this.baseOrMergeRollupPublicInputs, this.proof, this.vkData);
   }
 
   /**
@@ -47,8 +42,7 @@ export class PreviousRollupData {
     return new PreviousRollupData(
       reader.readObject(BaseOrMergeRollupPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VerificationKeyAsFields),
-      MembershipWitness.fromBuffer(reader, VK_TREE_HEIGHT),
+      reader.readObject(VkData),
     );
   }
 }

package/src/rollup/private_base_rollup_inputs.ts

@@ -7,7 +7,10 @@ import { PrivateBaseRollupHints } from './base_rollup_hints.js';
 import { PrivateTubeData } from './private_tube_data.js';
 
 export class PrivateBaseRollupInputs {
-  constructor(public tubeData: PrivateTubeData, public hints: PrivateBaseRollupHints) {}
+  constructor(
+    public tubeData: PrivateTubeData,
+    public hints: PrivateBaseRollupHints,
+  ) {}
 
   static from(fields: FieldsOf<PrivateBaseRollupInputs>): PrivateBaseRollupInputs {
     return new PrivateBaseRollupInputs(...PrivateBaseRollupInputs.getFields(fields));

package/src/rollup/private_tube_data.ts

@@ -3,20 +3,20 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
 import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/index.js';
 
 export class PrivateTubeData {
   constructor(
     public publicInputs: PrivateToRollupKernelCircuitPublicInputs,
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
-    public vkData: VkWitnessData,
+    public vkData: VkData,
   ) {}
 
   static empty() {
     return new PrivateTubeData(
       PrivateToRollupKernelCircuitPublicInputs.empty(),
       makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      VkWitnessData.empty(),
+      VkData.empty(),
     );
   }
 
@@ -25,7 +25,7 @@ export class PrivateTubeData {
     return new PrivateTubeData(
       reader.readObject(PrivateToRollupKernelCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 

package/src/rollup/public_tube_data.ts

@@ -3,20 +3,20 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
+import { VkData } from '../vks/index.js';
 
 export class PublicTubeData {
   constructor(
     public publicInputs: PrivateToPublicKernelCircuitPublicInputs,
     public proof: RecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
-    public vkData: VkWitnessData,
+    public vkData: VkData,
   ) {}
 
   static empty() {
     return new PublicTubeData(
       PrivateToPublicKernelCircuitPublicInputs.empty(),
       makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      VkWitnessData.empty(),
+      VkData.empty(),
     );
   }
 
@@ -25,7 +25,7 @@ export class PublicTubeData {
     return new PublicTubeData(
       reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
       RecursiveProof.fromBuffer(reader, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-      reader.readObject(VkWitnessData),
+      reader.readObject(VkData),
     );
   }
 

package/src/rollup/root_rollup.ts

@@ -1,4 +1,4 @@
-import { BlockBlobPublicInputs } from '@aztec/blob-lib';
+import { FinalBlobAccumulatorPublicInputs } from '@aztec/blob-lib';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
@@ -7,7 +7,6 @@ import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { FeeRecipient } from './block_root_or_block_merge_public_inputs.js';
 import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
 
@@ -22,8 +21,6 @@ export class RootRollupInputs {
      * from 2 block merge circuits.
      */
     public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
-    /** Identifier of the prover for this root rollup. */
-    public proverId: Fr,
   ) {}
 
   /**
@@ -57,7 +54,7 @@ export class RootRollupInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<RootRollupInputs>) {
-    return [fields.previousRollupData, fields.proverId] as const;
+    return [fields.previousRollupData] as const;
   }
 
   /**
@@ -67,10 +64,10 @@ export class RootRollupInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): RootRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new RootRollupInputs(
-      [reader.readObject(PreviousRollupBlockData), reader.readObject(PreviousRollupBlockData)],
-      Fr.fromBuffer(reader),
-    );
+    return new RootRollupInputs([
+      reader.readObject(PreviousRollupBlockData),
+      reader.readObject(PreviousRollupBlockData),
+    ]);
   }
 
   /**
@@ -100,32 +97,28 @@ export class RootRollupInputs {
  */
 export class RootRollupPublicInputs {
   constructor(
-    /** Snapshot of archive tree before/after this rollup been processed */
-    public previousArchive: AppendOnlyTreeSnapshot,
-    public endArchive: AppendOnlyTreeSnapshot,
-    public previousBlockHash: Fr,
-    public endBlockHash: Fr,
-    // This is a u64 in nr, but GlobalVariables contains this as a u64 and is mapped to ts as a field, so I'm doing the same here
-    public endTimestamp: Fr,
-    public endBlockNumber: Fr,
-    public outHash: Fr,
+    /** 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,
+    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public chainId: Fr,
+    public version: Fr,
     public vkTreeRoot: Fr,
     public protocolContractTreeRoot: Fr,
     public proverId: Fr,
-    public blobPublicInputs: Tuple<BlockBlobPublicInputs, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public blobPublicInputs: FinalBlobAccumulatorPublicInputs,
   ) {}
 
   static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
     return [
-      fields.previousArchive,
-      fields.endArchive,
-      fields.previousBlockHash,
-      fields.endBlockHash,
-      fields.endTimestamp,
-      fields.endBlockNumber,
-      fields.outHash,
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
+      fields.proposedBlockHeaderHashes,
       fields.fees,
+      fields.chainId,
+      fields.version,
       fields.vkTreeRoot,
       fields.protocolContractTreeRoot,
       fields.proverId,
@@ -153,18 +146,16 @@ export class RootRollupPublicInputs {
   public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new RootRollupPublicInputs(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(AppendOnlyTreeSnapshot),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs),
+      reader.readObject(FinalBlobAccumulatorPublicInputs),
     );
   }
 
@@ -186,21 +177,19 @@ export class RootRollupPublicInputs {
     return bufferSchemaFor(RootRollupPublicInputs);
   }
 
-  /** Creates a random instance. */
+  /** Creates a random instance. Used for testing only - will not prove/verify. */
   static random() {
     return new RootRollupPublicInputs(
-      AppendOnlyTreeSnapshot.random(),
-      AppendOnlyTreeSnapshot.random(),
-      Fr.random(),
       Fr.random(),
       Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
       Fr.random(),
       Fr.random(),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
       Fr.random(),
       Fr.random(),
       Fr.random(),
-      makeTuple(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs.empty),
+      FinalBlobAccumulatorPublicInputs.random(),
     );
   }
 }

package/src/rollup/tube_inputs.ts

@@ -5,15 +5,22 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 
+/**
+ * Inputs for the tube circuit, which turns a client IVC proof folding stack into an ultrahonk proof.
+ * 'usePublicTailVk' signifies if we should prove this with the public or private kernel tail client IVC VKs.
+ */
 export class TubeInputs {
-  constructor(public clientIVCData: ClientIvcProof) {}
+  constructor(
+    public usePublicTailVk: boolean,
+    public clientIVCData: ClientIvcProof,
+  ) {}
 
   static from(fields: FieldsOf<TubeInputs>): TubeInputs {
     return new TubeInputs(...TubeInputs.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<TubeInputs>) {
-    return [fields.clientIVCData] as const;
+    return [fields.usePublicTailVk, fields.clientIVCData] as const;
   }
 
   /**
@@ -39,7 +46,7 @@ export class TubeInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): TubeInputs {
     const reader = BufferReader.asReader(buffer);
-    return new TubeInputs(reader.readObject(ClientIvcProof));
+    return new TubeInputs(reader.readBoolean(), reader.readObject(ClientIvcProof));
   }
 
   isEmpty(): boolean {
@@ -55,7 +62,7 @@ export class TubeInputs {
   }
 
   static empty() {
-    return new TubeInputs(ClientIvcProof.empty());
+    return new TubeInputs(false, ClientIvcProof.empty());
   }
 
   /** Returns a hex representation for JSON serialization. */

package/src/schemas/schemas.ts

@@ -49,6 +49,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,
 

package/src/slashing/empire.ts

@@ -0,0 +1,100 @@
+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 = 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 = 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: {
+      const slot = offense.epochOrSlot;
+      const detectedSlot = 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 = epoch + 1n;
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    default: {
+      const _: never = offense.offenseType;
+      throw new Error(`Unknown offense type: ${offense.offenseType}`);
+    }
+  }
+}