@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/rollup/root_rollup_public_inputs.ts

@@ -1,7 +1,7 @@
 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/fields';
+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';
@@ -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/rollup/tree_snapshot_diff_hints.ts

@@ -6,7 +6,7 @@ import {
   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';

package/src/rollup/tx_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { SpongeBlob } from '@aztec/blob-lib/types';
-import { Fr } from '@aztec/foundation/fields';
+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';

package/src/schemas/schemas.ts

@@ -1,7 +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';
@@ -39,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>,
 
@@ -85,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.
@@ -93,11 +100,14 @@ export const NullishToUndefined = (schema: ZodFor<any>) => schema.nullish().tran
 
 export {
   type ZodFor,
+  zodFor,
   bufferSchema,
   hexSchema,
   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 };
-}

package/src/slashing/types.ts

@@ -2,14 +2,12 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 
 export enum OffenseType {
   UNKNOWN = 0,
-  /** The data for proving an epoch was not publicly available, we slash its committee */
+  /** The data for the txs in a published checkpoint was not available within the tolerance window, we slash the checkpoint's attesters */
   DATA_WITHHOLDING = 1,
-  /** An epoch was not successfully proven in time, we slash its committee */
-  VALID_EPOCH_PRUNED = 2,
   /** A proposer failed to attest or propose during an epoch according to the Sentinel */
   INACTIVITY = 3,
   /** A proposer sent an invalid block proposal over the p2p network to the committee */
@@ -18,8 +16,16 @@ export enum OffenseType {
   PROPOSED_INSUFFICIENT_ATTESTATIONS = 5,
   /** A proposer pushed to L1 a block with incorrect committee attestations (ie signature from a non-committee member) */
   PROPOSED_INCORRECT_ATTESTATIONS = 6,
-  /** A committee member attested to a block that was built as a descendent of an invalid block (as in a block with invalid attestations) */
-  ATTESTED_DESCENDANT_OF_INVALID = 7,
+  /** A proposer published a checkpoint to L1 that builds on an invalid checkpoint (as in a checkpoint with invalid or insufficient attestations) */
+  PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS = 7,
+  /** A proposer sent duplicate proposals for the same position (slot, indexWithinCheckpoint for blocks or slot for checkpoints) */
+  DUPLICATE_PROPOSAL = 8,
+  /** A validator signed attestations for different proposals at the same slot (equivocation) */
+  DUPLICATE_ATTESTATION = 9,
+  /** A committee member attested to a checkpoint proposal in a slot with an invalid block proposal */
+  ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL = 10,
+  /** A proposer broadcast an invalid checkpoint proposal, detected by retained evidence or deterministic recomputation */
+  BROADCASTED_INVALID_CHECKPOINT_PROPOSAL = 11,
 }
 
 export function getOffenseTypeName(offense: OffenseType) {
@@ -28,8 +34,6 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'unknown';
     case OffenseType.DATA_WITHHOLDING:
       return 'data_withholding';
-    case OffenseType.VALID_EPOCH_PRUNED:
-      return 'valid_epoch_pruned';
     case OffenseType.INACTIVITY:
       return 'inactivity';
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
@@ -38,8 +42,16 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'proposed_insufficient_attestations';
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
       return 'proposed_incorrect_attestations';
-    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
-      return 'attested_descendant_of_invalid';
+    case OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS:
+      return 'proposed_descendant_of_checkpoint_with_invalid_attestations';
+    case OffenseType.DUPLICATE_PROPOSAL:
+      return 'duplicate_proposal';
+    case OffenseType.DUPLICATE_ATTESTATION:
+      return 'duplicate_attestation';
+    case OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL:
+      return 'attested_to_invalid_checkpoint_proposal';
+    case OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL:
+      return 'broadcasted_invalid_checkpoint_proposal';
     default:
       throw new Error(`Unknown offense type: ${offense}`);
   }
@@ -50,12 +62,15 @@ export const OffenseTypeSchema = z.nativeEnum(OffenseType);
 export const OffenseToBigInt: Record<OffenseType, bigint> = {
   [OffenseType.UNKNOWN]: 0n,
   [OffenseType.DATA_WITHHOLDING]: 1n,
-  [OffenseType.VALID_EPOCH_PRUNED]: 2n,
   [OffenseType.INACTIVITY]: 3n,
   [OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL]: 4n,
   [OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
   [OffenseType.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
-  [OffenseType.ATTESTED_DESCENDANT_OF_INVALID]: 7n,
+  [OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS]: 7n,
+  [OffenseType.DUPLICATE_PROPOSAL]: 8n,
+  [OffenseType.DUPLICATE_ATTESTATION]: 9n,
+  [OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL]: 10n,
+  [OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL]: 11n,
 };
 
 export function bigIntToOffense(offense: bigint): OffenseType {
@@ -64,8 +79,6 @@ export function bigIntToOffense(offense: bigint): OffenseType {
       return OffenseType.UNKNOWN;
     case 1n:
       return OffenseType.DATA_WITHHOLDING;
-    case 2n:
-      return OffenseType.VALID_EPOCH_PRUNED;
     case 3n:
       return OffenseType.INACTIVITY;
     case 4n:
@@ -75,7 +88,15 @@ export function bigIntToOffense(offense: bigint): OffenseType {
     case 6n:
       return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
     case 7n:
-      return OffenseType.ATTESTED_DESCENDANT_OF_INVALID;
+      return OffenseType.PROPOSED_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS;
+    case 8n:
+      return OffenseType.DUPLICATE_PROPOSAL;
+    case 9n:
+      return OffenseType.DUPLICATE_ATTESTATION;
+    case 10n:
+      return OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL;
+    case 11n:
+      return OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL;
     default:
       throw new Error(`Unknown offense: ${offense}`);
   }
@@ -90,12 +111,14 @@ export type Offense = {
 
 export type OffenseIdentifier = Pick<Offense, 'validator' | 'offenseType' | 'epochOrSlot'>;
 
-export const OffenseSchema = z.object({
-  validator: schemas.EthAddress,
-  amount: schemas.BigInt,
-  offenseType: OffenseTypeSchema,
-  epochOrSlot: schemas.BigInt,
-}) satisfies ZodFor<Offense>;
+export const OffenseSchema = zodFor<Offense>()(
+  z.object({
+    validator: schemas.EthAddress,
+    amount: schemas.BigInt,
+    offenseType: OffenseTypeSchema,
+    epochOrSlot: schemas.BigInt,
+  }),
+);
 
 /** Offense by a validator in the context of a slash payload */
 export type ValidatorSlashOffense = {
@@ -110,43 +133,13 @@ export type ValidatorSlash = {
   offenses: ValidatorSlashOffense[];
 };
 
-/** Slash payload as published by the empire slash proposer */
-export type SlashPayload = {
-  address: EthAddress;
-  slashes: ValidatorSlash[];
-  timestamp: bigint;
-};
-
-/** Slash payload with round information from empire slash proposer */
-export type SlashPayloadRound = SlashPayload & { votes: bigint; round: bigint };
-
-export const SlashPayloadRoundSchema = z.object({
-  address: schemas.EthAddress,
-  timestamp: schemas.BigInt,
-  votes: schemas.BigInt,
-  round: schemas.BigInt,
-  slashes: z.array(
-    z.object({
-      validator: schemas.EthAddress,
-      amount: schemas.BigInt,
-      offenses: z.array(z.object({ offenseType: OffenseTypeSchema, epochOrSlot: schemas.BigInt })),
-    }),
-  ),
-}) satisfies ZodFor<SlashPayloadRound>;
-
-/** Votes for a validator slash in the consensus slash proposer */
+/** Votes for a validator slash in the slashing proposer */
 export type ValidatorSlashVote = number;
 
 export type ProposerSlashAction =
-  /** Create a new slash payload on an empire-based slash proposer */
-  | { type: 'create-empire-payload'; data: ValidatorSlash[] }
-  /** Vote for a slashing payload on an empire-based slash proposer */
-  | { type: 'vote-empire-payload'; payload: EthAddress }
-  /** Execute a slashing payload on an empire-based slash proposer */
-  | { type: 'execute-empire-payload'; round: bigint }
-  /** Vote for offenses on a consensus slashing proposer */
+  /** Vote for offenses on the slashing proposer */
   | { type: 'vote-offenses'; votes: ValidatorSlashVote[]; committees: EthAddress[][]; round: bigint }
-  /** Execute a slashing round on a consensus slashing proposer */
+  /** Execute a slashing round on the slashing proposer */
   | { type: 'execute-slash'; committees: EthAddress[][]; round: bigint };
 
 export type ProposerSlashActionType = ProposerSlashAction['type'];

package/src/slashing/{tally.ts → votes.ts}

@@ -1,5 +1,7 @@
 import { sumBigint } from '@aztec/foundation/bigint';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { PartialBy } from '@aztec/foundation/types';
 
 import { getEpochForOffense } from './helpers.js';
@@ -11,6 +13,9 @@ import type { Offense, ValidatorSlashVote } from './types.js';
  * @param committees - Array of committees (each containing array of validator addresses)
  * @param epochsForCommittees - Array of epochs corresponding to each committee
  * @param settings - Settings including slashingAmounts and optional validator override lists
+ * @param settings.maxSlashedValidators - If set, limits the total number of [validator, epoch] pairs
+ *   with non-zero votes. The lowest-vote pairs are zeroed out to stay within the limit.
+ * @param logger - Logger, logs which validators were dropped.
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */
 export function getSlashConsensusVotesFromOffenses(
@@ -20,9 +25,12 @@ export function getSlashConsensusVotesFromOffenses(
   settings: {
     slashingAmounts: [bigint, bigint, bigint];
     epochDuration: number;
+    targetCommitteeSize: number;
+    maxSlashedValidators?: number;
   },
+  logger: Logger = createLogger('slasher:votes'),
 ): ValidatorSlashVote[] {
-  const { slashingAmounts } = settings;
+  const { slashingAmounts, targetCommitteeSize, maxSlashedValidators } = settings;
 
   if (committees.length !== epochsForCommittees.length) {
     throw new Error('committees and epochsForCommittees must have the same length');
@@ -31,7 +39,9 @@ export function getSlashConsensusVotesFromOffenses(
   const votes = committees.flatMap((committee, committeeIndex) => {
     const committeeEpoch = epochsForCommittees[committeeIndex];
 
-    return committee.map(validator => {
+    // Map over actual committee members, then pad to targetCommitteeSize.
+    // Padding handles cases where committees may be empty (e.g., when there aren't enough validators to fill the committee size during network startup).
+    const votes = committee.map(validator => {
       // Find offenses for this validator in this specific epoch.
       // If an offense has no epoch, it is considered for all epochs due to a slashAlways setting.
       const validatorOffenses = offenses.filter(
@@ -45,8 +55,37 @@ export function getSlashConsensusVotesFromOffenses(
       const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
       return Number(slashUnits);
     });
+
+    return padArrayEnd(votes, 0, targetCommitteeSize);
   });
 
+  // if a cap is set, zero out the lowest-vote [validator, epoch] pairs so that the most severe slashes stay.
+  if (maxSlashedValidators === undefined) {
+    return votes;
+  }
+
+  const nonZeroByDescendingVote = [...votes.entries()].filter(([, vote]) => vote > 0).sort(([, a], [, b]) => b - a);
+
+  const toTruncate = nonZeroByDescendingVote.slice(maxSlashedValidators);
+  for (const [idx] of toTruncate) {
+    votes[idx] = 0;
+  }
+
+  if (toTruncate.length > 0) {
+    const truncated = toTruncate.map(([idx]) => {
+      const committeeIndex = Math.floor(idx / targetCommitteeSize);
+      const positionInCommittee = idx % targetCommitteeSize;
+      return {
+        validator: committees[committeeIndex][positionInCommittee].toString(),
+        epoch: epochsForCommittees[committeeIndex],
+      };
+    });
+    logger.warn(
+      `Truncated ${toTruncate.length} validator-epoch pairs to stay within limit of ${maxSlashedValidators}`,
+      { truncated },
+    );
+  }
+
   return votes;
 }
 

package/src/snapshots/types.ts

@@ -1,5 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -38,33 +38,37 @@ export type SnapshotsIndex = SnapshotsIndexMetadata & {
 export type UploadSnapshotMetadata = Pick<SnapshotMetadata, 'l2BlockNumber' | 'l2BlockHash' | 'l1BlockNumber'> &
   Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>;
 
-export const SnapshotsIndexSchema = z.object({
-  l1ChainId: z.number(),
-  rollupVersion: z.number(),
-  rollupAddress: schemas.EthAddress,
-  snapshots: z.array(
-    z.object({
-      l2BlockNumber: z.number(),
-      l2BlockHash: z.string(),
-      l1BlockNumber: z.number(),
-      timestamp: z.number(),
-      schemaVersions: z.object({
-        archiver: z.number(),
-        worldState: z.number(),
+export const SnapshotsIndexSchema = zodFor<SnapshotsIndex>()(
+  z.object({
+    l1ChainId: z.number(),
+    rollupVersion: z.number(),
+    rollupAddress: schemas.EthAddress,
+    snapshots: z.array(
+      z.object({
+        l2BlockNumber: z.number(),
+        l2BlockHash: z.string(),
+        l1BlockNumber: z.number(),
+        timestamp: z.number(),
+        schemaVersions: z.object({
+          archiver: z.number(),
+          worldState: z.number(),
+        }),
+        dataUrls: z
+          .record(z.enum(SnapshotDataKeys), z.string())
+          // See https://stackoverflow.com/questions/77958464/zod-record-with-required-keys
+          .refine((obj): obj is Required<typeof obj> => SnapshotDataKeys.every(key => !!obj[key])),
       }),
-      dataUrls: z
-        .record(z.enum(SnapshotDataKeys), z.string())
-        // See https://stackoverflow.com/questions/77958464/zod-record-with-required-keys
-        .refine((obj): obj is Required<typeof obj> => SnapshotDataKeys.every(key => !!obj[key])),
-    }),
-  ),
-}) satisfies ZodFor<SnapshotsIndex>;
+    ),
+  }),
+);
 
-export const UploadSnapshotMetadataSchema = z.object({
-  l2BlockNumber: z.number(),
-  l2BlockHash: z.string(),
-  l1BlockNumber: z.number(),
-  l1ChainId: z.number(),
-  rollupVersion: z.number(),
-  rollupAddress: schemas.EthAddress,
-}) satisfies ZodFor<UploadSnapshotMetadata>;
+export const UploadSnapshotMetadataSchema = zodFor<UploadSnapshotMetadata>()(
+  z.object({
+    l2BlockNumber: z.number(),
+    l2BlockHash: z.string(),
+    l1BlockNumber: z.number(),
+    l1ChainId: z.number(),
+    rollupVersion: z.number(),
+    rollupAddress: schemas.EthAddress,
+  }),
+);