@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/src/slashing/helpers.ts

@@ -1,21 +1,24 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
 import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
 
 /** Returns the voting round number and voting slot within the round for a given L2 slot. */
 export function getRoundForSlot(
-  slot: bigint,
+  slot: SlotNumber,
   constants: { slashingRoundSize: number },
-): { round: bigint; votingSlot: bigint } {
+): { round: bigint; votingSlot: SlotNumber } {
   const roundSize = BigInt(constants.slashingRoundSize);
-  const round = slot / roundSize;
-  const votingSlot = slot % roundSize;
+  const slotBigInt = BigInt(slot);
+  const round = slotBigInt / roundSize;
+  const votingSlot = SlotNumber.fromBigInt(slotBigInt % roundSize);
   return { round, votingSlot };
 }
 
 /** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
 export function getRoundsForEpoch(
-  epoch: bigint,
+  epoch: EpochNumber,
   constants: { slashingRoundSize: number; epochDuration: number },
 ): [bigint, bigint] {
   const [start, end] = getSlotRangeForEpoch(epoch, constants);
@@ -28,13 +31,13 @@ export function getRoundsForEpoch(
 export function getEpochsForRound(
   round: bigint,
   constants: { slashingRoundSize: number; epochDuration: number },
-): bigint[] {
-  const epochs: bigint[] = [];
-  const firstSlot = round * BigInt(constants.slashingRoundSize);
-  const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
+): EpochNumber[] {
+  const epochs: EpochNumber[] = [];
+  const firstSlot = SlotNumber.fromBigInt(round * BigInt(constants.slashingRoundSize));
+  const lastSlot = SlotNumber(firstSlot + constants.slashingRoundSize - 1);
   const startEpoch = getEpochAtSlot(firstSlot, constants);
   const endEpoch = getEpochAtSlot(lastSlot, constants);
-  for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+  for (let epoch = startEpoch; epoch <= endEpoch; epoch = EpochNumber(epoch + 1)) {
     epochs.push(epoch);
   }
   return epochs;
@@ -47,6 +50,8 @@ export function getPenaltyForOffense(
     SlasherConfig,
     | 'slashAttestDescendantOfInvalidPenalty'
     | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashDuplicateProposalPenalty'
+    | 'slashDuplicateAttestationPenalty'
     | 'slashPrunePenalty'
     | 'slashDataWithholdingPenalty'
     | 'slashUnknownPenalty'
@@ -68,6 +73,10 @@ export function getPenaltyForOffense(
       return config.slashAttestDescendantOfInvalidPenalty;
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
       return config.slashBroadcastedInvalidBlockPenalty;
+    case OffenseType.DUPLICATE_PROPOSAL:
+      return config.slashDuplicateProposalPenalty;
+    case OffenseType.DUPLICATE_ATTESTATION:
+      return config.slashDuplicateAttestationPenalty;
     case OffenseType.UNKNOWN:
       return config.slashUnknownPenalty;
     default: {
@@ -82,6 +91,8 @@ export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
   switch (offense) {
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
     case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.DUPLICATE_PROPOSAL:
+    case OffenseType.DUPLICATE_ATTESTATION:
     case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
     case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
       return 'slot';
@@ -101,9 +112,11 @@ export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
 export function getSlotForOffense(
   offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
-): bigint {
+): SlotNumber {
   const { epochOrSlot, offenseType } = offense;
-  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
+  return getTimeUnitForOffense(offenseType) === 'epoch'
+    ? SlotNumber.fromBigInt(epochOrSlot * BigInt(constants.epochDuration))
+    : SlotNumber.fromBigInt(epochOrSlot);
 }
 
 /** Returns the epoch for a given offense. If the offense type or epoch is not defined, returns undefined. */

package/src/slashing/interfaces.ts

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

package/src/slashing/tally.ts

@@ -1,4 +1,5 @@
 import { sumBigint } from '@aztec/foundation/bigint';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { PartialBy } from '@aztec/foundation/types';
 
@@ -20,9 +21,10 @@ export function getSlashConsensusVotesFromOffenses(
   settings: {
     slashingAmounts: [bigint, bigint, bigint];
     epochDuration: number;
+    targetCommitteeSize: number;
   },
 ): ValidatorSlashVote[] {
-  const { slashingAmounts } = settings;
+  const { slashingAmounts, targetCommitteeSize } = settings;
 
   if (committees.length !== epochsForCommittees.length) {
     throw new Error('committees and epochsForCommittees must have the same length');
@@ -31,7 +33,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,6 +49,8 @@ export function getSlashConsensusVotesFromOffenses(
       const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
       return Number(slashUnits);
     });
+
+    return padArrayEnd(votes, 0, targetCommitteeSize);
   });
 
   return votes;

package/src/slashing/types.ts

@@ -2,7 +2,7 @@ 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,
@@ -20,6 +20,10 @@ export enum OffenseType {
   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 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,
 }
 
 export function getOffenseTypeName(offense: OffenseType) {
@@ -40,6 +44,10 @@ export function getOffenseTypeName(offense: OffenseType) {
       return 'proposed_incorrect_attestations';
     case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
       return 'attested_descendant_of_invalid';
+    case OffenseType.DUPLICATE_PROPOSAL:
+      return 'duplicate_proposal';
+    case OffenseType.DUPLICATE_ATTESTATION:
+      return 'duplicate_attestation';
     default:
       throw new Error(`Unknown offense type: ${offense}`);
   }
@@ -56,6 +64,8 @@ export const OffenseToBigInt: Record<OffenseType, bigint> = {
   [OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS]: 5n,
   [OffenseType.PROPOSED_INCORRECT_ATTESTATIONS]: 6n,
   [OffenseType.ATTESTED_DESCENDANT_OF_INVALID]: 7n,
+  [OffenseType.DUPLICATE_PROPOSAL]: 8n,
+  [OffenseType.DUPLICATE_ATTESTATION]: 9n,
 };
 
 export function bigIntToOffense(offense: bigint): OffenseType {
@@ -76,6 +86,10 @@ export function bigIntToOffense(offense: bigint): OffenseType {
       return OffenseType.PROPOSED_INCORRECT_ATTESTATIONS;
     case 7n:
       return OffenseType.ATTESTED_DESCENDANT_OF_INVALID;
+    case 8n:
+      return OffenseType.DUPLICATE_PROPOSAL;
+    case 9n:
+      return OffenseType.DUPLICATE_ATTESTATION;
     default:
       throw new Error(`Unknown offense: ${offense}`);
   }
@@ -90,12 +104,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 = {
@@ -120,19 +136,21 @@ export type SlashPayload = {
 /** 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>;
+export const SlashPayloadRoundSchema = zodFor<SlashPayloadRound>()(
+  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 })),
+      }),
+    ),
+  }),
+);
 
 /** Votes for a validator slash in the consensus slash proposer */
 export type ValidatorSlashVote = number;

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,
+  }),
+);

package/src/stats/stats.ts

@@ -20,6 +20,13 @@ export type L2BlockStats = {
   publicLogCount?: number;
 };
 
+export type CheckpointStats = {
+  /** Number of transactions in the checkpoint */
+  txCount: number;
+  /** Number of blocks in the checkpoint */
+  blockCount: number;
+};
+
 /** Stats logged for each L1 publish tx.*/
 export type L1PublishStats = {
   /** Address of the sender. */
@@ -45,11 +52,11 @@ export type L1PublishStats = {
 };
 
 /** Stats logged for each L1 rollup publish tx.*/
-export type L1PublishBlockStats = {
+export type L1PublishCheckpointStats = {
   /** Name of the event for metrics purposes */
   eventName: 'rollup-published-to-l1';
 } & L1PublishStats &
-  L2BlockStats;
+  CheckpointStats;
 
 /** Stats logged for each L1 rollup publish tx.*/
 export type L1PublishProofStats = {
@@ -189,16 +196,12 @@ export type CircuitVerificationStats = {
 
 /** Stats for an L2 block built by a sequencer. */
 export type L2BlockBuiltStats = {
-  /** The creator of the block */
-  creator: string;
   /** Name of the event. */
   eventName: 'l2-block-built';
   /** Total duration in ms. */
   duration: number;
   /** Time for processing public txs in ms. */
   publicProcessDuration: number;
-  /** Time for running rollup circuits in ms.  */
-  rollupCircuitsDuration: number;
 } & L2BlockStats;
 
 /** Stats for an L2 block processed by the world state synchronizer. */
@@ -272,7 +275,7 @@ export type Stats =
   | CircuitSimulationStats
   | CircuitWitnessGenerationStats
   | PublicDBAccessStats
-  | L1PublishBlockStats
+  | L1PublishCheckpointStats
   | L1PublishProofStats
   | L2BlockBuiltStats
   | L2BlockHandledStats