@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/schemas/schemas.ts

@@ -0,0 +1,113 @@
+import type { EpochNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { Buffer32 } from '@aztec-labs/foundation/buffer';
+import type { Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type ZodFor, schemas as foundationSchemas } from '@aztec-labs/foundation/schemas';
+import { z } from 'zod';
+
+import type { AbiDecoded } from '../abi/decoder.js';
+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.
+ * Foundation schemas are repeated here to aid type inference
+ * */
+export const schemas = {
+  /** Accepts a hex string. */
+  EthAddress: foundationSchemas.EthAddress as ZodFor<EthAddress>,
+
+  /** Accepts a hex string. */
+  Fr: foundationSchemas.Fr as ZodFor<Fr>,
+
+  /** Accepts a hex string. */
+  Fq: foundationSchemas.Fq as ZodFor<Fq>,
+
+  /** Point. Serialized as a hex string. */
+  Point: foundationSchemas.Point as ZodFor<Point>,
+
+  /** Coerces any input to bigint. */
+  BigInt: foundationSchemas.BigInt,
+
+  /** Coerces any input to integer number. */
+  Integer: foundationSchemas.Integer,
+
+  /** 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>,
+
+  /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
+  Buffer: foundationSchemas.Buffer,
+
+  /** Accepts a hex string as a buffer. */
+  BufferHex: foundationSchemas.BufferHex,
+
+  /** 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,
+
+  /** Accepts a hex string. */
+  NoteSelector: NoteSelector.schema,
+
+  /** Accepts a hex string. */
+  FunctionSelector: FunctionSelector.schema,
+
+  /** 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([
+  schemas.BigInt,
+  z.boolean(),
+  schemas.AztecAddress,
+  z.array(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,
+} from '@aztec-labs/foundation/schemas';

package/src/slashing/helpers.ts

@@ -0,0 +1,153 @@
+import { EpochNumber, SlotNumber } from '@aztec-labs/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: SlotNumber,
+  constants: { slashingRoundSize: number },
+): { round: bigint; votingSlot: SlotNumber } {
+  const roundSize = BigInt(constants.slashingRoundSize);
+  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: EpochNumber,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): [bigint, bigint] {
+  const [start, end] = getSlotRangeForEpoch(epoch, constants);
+  const startRound = getRoundForSlot(start, constants).round;
+  const endRound = getRoundForSlot(end, constants).round;
+  return [startRound, endRound];
+}
+
+/** Returns the epochs spanned during a given slashing round */
+export function getEpochsForRound(
+  round: bigint,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): 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 = EpochNumber(epoch + 1)) {
+    epochs.push(epoch);
+  }
+  return epochs;
+}
+
+/** Reads the configured penalty for a given offense type from a slasher config struct */
+export function getPenaltyForOffense(
+  offense: OffenseType,
+  config: Pick<
+    SlasherConfig,
+    | 'slashProposeDescendantOfCheckpointWithInvalidAttestationsPenalty'
+    | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashBroadcastedInvalidCheckpointProposalPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
+    | 'slashAttestInvalidCheckpointProposalPenalty'
+    | 'slashDataWithholdingPenalty'
+    | 'slashUnknownPenalty'
+    | 'slashInactivityPenalty'
+    | 'slashProposeInvalidAttestationsPenalty'
+  >,
+) {
+  switch (offense) {
+    case OffenseType.DATA_WITHHOLDING:
+      return config.slashDataWithholdingPenalty;
+    case OffenseType.INACTIVITY:
+      return config.slashInactivityPenalty;
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return config.slashProposeInvalidAttestationsPenalty;
+    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: {
+      const _exhaustiveCheck: never = offense;
+      throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+    }
+  }
+}
+
+/** 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.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.UNKNOWN:
+      return 'epoch';
+    default: {
+      const _exhaustiveCheck: never = offense;
+      throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+    }
+  }
+}
+
+/** Returns the slot for a given offense. If the offense references an epoch, returns the first slot of the epoch. */
+export function getSlotForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): SlotNumber {
+  const { epochOrSlot, offenseType } = offense;
+  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. */
+export function getEpochForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint;
+export function getEpochForOffense(
+  offense: Partial<Pick<Offense, 'epochOrSlot' | 'offenseType'>>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint | undefined;
+export function getEpochForOffense(
+  offense: Partial<Pick<Offense, 'epochOrSlot' | 'offenseType'>>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint | undefined {
+  const { epochOrSlot, offenseType } = offense;
+  if (epochOrSlot === undefined || offenseType === undefined) {
+    return undefined;
+  }
+  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot : epochOrSlot / BigInt(constants.epochDuration);
+}
+
+/** Returns the slashing round in which a given offense occurred. */
+export function getRoundForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): bigint {
+  const slot = getSlotForOffense(offense, constants);
+  return getRoundForSlot(slot, constants).round;
+}

package/src/slashing/index.ts

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

package/src/slashing/interfaces.ts

@@ -0,0 +1,13 @@
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+
+import type { ProposerSlashAction } from './types.js';
+
+export interface ProposerSlashActionProvider {
+  /**
+   * Returns the actions to take for the proposer in the current slot.
+   * This can include creating a slash payload or other actions.
+   * @param slotNumber - The current slot number
+   * @returns The actions to take
+   */
+  getProposerActions(slotNumber: SlotNumber): Promise<ProposerSlashAction[]>;
+}

package/src/slashing/serialization.ts

@@ -0,0 +1,23 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { BufferReader, bigintToUInt64BE, bigintToUInt128BE, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import type { Offense, OffenseType } from './types.js';
+
+export function serializeOffense(offense: Offense): Buffer {
+  return serializeToBuffer(
+    offense.validator,
+    bigintToUInt128BE(offense.amount),
+    offense.offenseType,
+    bigintToUInt64BE(offense.epochOrSlot),
+  );
+}
+
+export function deserializeOffense(buffer: Buffer): Offense {
+  const reader = BufferReader.asReader(buffer);
+  const validator = reader.readObject(EthAddress);
+  const amount = reader.readUInt128();
+  const offense = reader.readNumber() as OffenseType;
+  const epochOrSlot = reader.readUInt64();
+
+  return { validator, amount, offenseType: offense, epochOrSlot };
+}

package/src/slashing/types.ts

@@ -0,0 +1,144 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { z } from 'zod';
+
+import { schemas, zodFor } from '../schemas/index.js';
+
+export enum OffenseType {
+  UNKNOWN = 0,
+  /** 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,
+  /** 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 */
+  BROADCASTED_INVALID_BLOCK_PROPOSAL = 4,
+  /** A proposer pushed to L1 a block with insufficient committee attestations */
+  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 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) {
+  switch (offense) {
+    case OffenseType.UNKNOWN:
+      return 'unknown';
+    case OffenseType.DATA_WITHHOLDING:
+      return 'data_withholding';
+    case OffenseType.INACTIVITY:
+      return 'inactivity';
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+      return 'broadcasted_invalid_block_proposal';
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+      return 'proposed_insufficient_attestations';
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return 'proposed_incorrect_attestations';
+    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}`);
+  }
+}
+
+export const OffenseTypeSchema = z.nativeEnum(OffenseType);
+
+export const OffenseToBigInt: Record<OffenseType, bigint> = {
+  [OffenseType.UNKNOWN]: 0n,
+  [OffenseType.DATA_WITHHOLDING]: 1n,
+  [OffenseType.INACTIVITY]: 3n,
+  [OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL]: 4n,
+  [OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
+  [OffenseType.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
+  [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 {
+  switch (offense) {
+    case 0n:
+      return OffenseType.UNKNOWN;
+    case 1n:
+      return OffenseType.DATA_WITHHOLDING;
+    case 3n:
+      return OffenseType.INACTIVITY;
+    case 4n:
+      return OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL;
+    case 5n:
+      return OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS;
+    case 6n:
+      return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
+    case 7n:
+      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}`);
+  }
+}
+
+export type Offense = {
+  validator: EthAddress;
+  amount: bigint;
+  offenseType: OffenseType;
+  epochOrSlot: bigint;
+};
+
+export type OffenseIdentifier = Pick<Offense, 'validator' | 'offenseType' | 'epochOrSlot'>;
+
+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 = {
+  epochOrSlot: bigint;
+  offenseType: OffenseType;
+};
+
+/** Slashed amount and total offenses by a validator in the context of a slash payload */
+export type ValidatorSlash = {
+  validator: EthAddress;
+  amount: bigint;
+  offenses: ValidatorSlashOffense[];
+};
+
+/** Votes for a validator slash in the slashing proposer */
+export type ValidatorSlashVote = number;
+
+export type ProposerSlashAction =
+  /** Vote for offenses on the slashing proposer */
+  | { type: 'vote-offenses'; votes: ValidatorSlashVote[]; committees: EthAddress[][]; round: bigint }
+  /** Execute a slashing round on the slashing proposer */
+  | { type: 'execute-slash'; committees: EthAddress[][]; round: bigint };
+
+export type ProposerSlashActionType = ProposerSlashAction['type'];

package/src/slashing/votes.ts

@@ -0,0 +1,126 @@
+import { sumBigint } from '@aztec-labs/foundation/bigint';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import type { PartialBy } from '@aztec-labs/foundation/types';
+
+import { getEpochForOffense } from './helpers.js';
+import type { Offense, ValidatorSlashVote } from './types.js';
+
+/**
+ * Creates a consensus-slash vote for a given set of committees based on a set of Offenses
+ * @param offenses - Array of offenses to consider
+ * @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(
+  offenses: PartialBy<Offense, 'epochOrSlot'>[],
+  committees: EthAddress[][],
+  epochsForCommittees: bigint[],
+  settings: {
+    slashingAmounts: [bigint, bigint, bigint];
+    epochDuration: number;
+    targetCommitteeSize: number;
+    maxSlashedValidators?: number;
+  },
+  logger: Logger = createLogger('slasher:votes'),
+): ValidatorSlashVote[] {
+  const { slashingAmounts, targetCommitteeSize, maxSlashedValidators } = settings;
+
+  if (committees.length !== epochsForCommittees.length) {
+    throw new Error('committees and epochsForCommittees must have the same length');
+  }
+
+  const votes = committees.flatMap((committee, committeeIndex) => {
+    const committeeEpoch = epochsForCommittees[committeeIndex];
+
+    // 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(
+        o =>
+          o.validator.equals(validator) &&
+          (o.epochOrSlot === undefined || getEpochForOffense(o, settings) === committeeEpoch),
+      );
+
+      // Sum up the penalties for this validator in this epoch
+      const slashAmount = sumBigint(validatorOffenses.map(o => o.amount));
+      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;
+}
+
+/** Returns the slash vote for the given amount to slash. */
+function getSlashUnitsForAmount(amountToSlash: bigint, slashingAmounts: [bigint, bigint, bigint]): number {
+  if (amountToSlash >= slashingAmounts[2]) {
+    return 3;
+  } else if (amountToSlash >= slashingAmounts[1]) {
+    return 2;
+  } else if (amountToSlash >= slashingAmounts[0]) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+/**
+ * Encodes a set of slash votes into a Buffer for use in a consensus slashing vote transaction.
+ * Each vote is represented as a 2-bit value, which represents how many slashing units the validator should be slashed.
+ * @param votes - The array of slash votes to encode
+ * @returns A Buffer containing the encoded slash votes
+ */
+export function encodeSlashConsensusVotes(votes: ValidatorSlashVote[]): Buffer {
+  if (votes.length % 4 !== 0) {
+    throw new Error('Votes array must have a length that is a multiple of 4');
+  }
+  const buffer = Buffer.alloc(votes.length / 4);
+  for (let i = 0; i < votes.length; i += 4) {
+    // Encode votes to match Solidity's bit order (LSB to MSB)
+    // Bits 0-1: validator at index i
+    // Bits 2-3: validator at index i+1
+    // Bits 4-5: validator at index i+2
+    // Bits 6-7: validator at index i+3
+    const voteByte = votes[i] | (votes[i + 1] << 2) | (votes[i + 2] << 4) | (votes[i + 3] << 6);
+    buffer.writeUInt8(voteByte, i / 4);
+  }
+  return buffer;
+}