@aztec/stdlib 2.0.0-nightly.20250902 → 2.0.0-rc.1

package/src/interfaces/server.ts

@@ -21,4 +21,5 @@ export * from './server_circuit_prover.js';
 export * from './service.js';
 export * from './slasher.js';
 export * from './tx_provider.js';
+export * from './validator.js';
 export * from './world_state.js';

package/src/interfaces/slasher.ts

@@ -13,6 +13,7 @@ export interface SlasherConfig {
   slashValidatorsAlways: EthAddress[]; // Array of validator addresses
   slashValidatorsNever: EthAddress[]; // Array of validator addresses
   slashInactivityTargetPercentage: number; // 0-1, 0.9 means 90%. Must be greater than 0
+  slashInactivityConsecutiveEpochThreshold: number; // Number of consecutive epochs a validator must be inactive before slashing
   slashPrunePenalty: bigint;
   slashDataWithholdingPenalty: bigint;
   slashInactivityPenalty: bigint;
@@ -34,6 +35,7 @@ export const SlasherConfigSchema = z.object({
   slashPrunePenalty: schemas.BigInt,
   slashDataWithholdingPenalty: schemas.BigInt,
   slashInactivityTargetPercentage: z.number(),
+  slashInactivityConsecutiveEpochThreshold: z.number(),
   slashInactivityPenalty: schemas.BigInt,
   slashProposeInvalidAttestationsPenalty: schemas.BigInt,
   slashAttestDescendantOfInvalidPenalty: schemas.BigInt,

package/src/interfaces/validator.ts

@@ -0,0 +1,70 @@
+import type { SecretValue } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+import { z } from 'zod';
+
+/**
+ * Validator client configuration
+ */
+export interface ValidatorClientConfig {
+  /** The private keys of the validators participating in attestation duties */
+  validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
+
+  /** The addresses of the validators to use with remote signers */
+  validatorAddresses?: EthAddress[];
+
+  /** Do not run the validator */
+  disableValidator: boolean;
+
+  /** Temporarily disable these specific validator addresses */
+  disabledValidators: EthAddress[];
+
+  /** Interval between polling for new attestations from peers */
+  attestationPollingIntervalMs: number;
+
+  /** Re-execute transactions before attesting */
+  validatorReexecute: boolean;
+
+  /** Will re-execute until this many milliseconds are left in the slot */
+  validatorReexecuteDeadlineMs: number;
+}
+
+export type ValidatorClientFullConfig = ValidatorClientConfig &
+  Pick<SequencerConfig, 'txPublicSetupAllowList'> &
+  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>;
+
+export const ValidatorClientConfigSchema = z.object({
+  validatorAddresses: z.array(schemas.EthAddress).optional(),
+  disableValidator: z.boolean(),
+  disabledValidators: z.array(schemas.EthAddress),
+  attestationPollingIntervalMs: z.number().min(0),
+  validatorReexecute: z.boolean(),
+  validatorReexecuteDeadlineMs: z.number().min(0),
+}) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
+
+export interface Validator {
+  start(): Promise<void>;
+  registerBlockProposalHandler(): void;
+  updateConfig(config: Partial<ValidatorClientFullConfig>): void;
+
+  // Block validation responsibilities
+  createBlockProposal(
+    blockNumber: number,
+    header: ProposedBlockHeader,
+    archive: Fr,
+    stateReference: StateReference,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal | undefined>;
+  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation[] | undefined>;
+
+  broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
+  collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+}

package/src/rollup/block_constant_data.ts

@@ -12,8 +12,8 @@ export class BlockConstantData {
   constructor(
     /** Archive tree snapshot at the very beginning of the entire rollup. */
     public lastArchive: AppendOnlyTreeSnapshot,
-    /** L1 to L2 message tree snapshot at the very beginning of the entire rollup. */
-    public lastL1ToL2: AppendOnlyTreeSnapshot,
+    /** L1 to L2 message tree snapshot after this block lands. */
+    public newL1ToL2: AppendOnlyTreeSnapshot,
     /** Root of the verification key tree. */
     public vkTreeRoot: Fr,
     /** Root of the protocol contract tree. */
@@ -40,7 +40,7 @@ export class BlockConstantData {
   static getFields(fields: FieldsOf<BlockConstantData>) {
     return [
       fields.lastArchive,
-      fields.lastL1ToL2,
+      fields.newL1ToL2,
       fields.vkTreeRoot,
       fields.protocolContractTreeRoot,
       fields.globalVariables,

package/src/slashing/helpers.ts

@@ -106,12 +106,23 @@ export function getSlotForOffense(
   return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
 }
 
-/** Returns the epoch for a given offense. */
+/** 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 {
+): 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);
 }
 

package/src/slashing/tally.ts

@@ -1,43 +1,52 @@
 import { sumBigint } from '@aztec/foundation/bigint';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import type { PartialBy } from '@aztec/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
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */
 export function getSlashConsensusVotesFromOffenses(
-  offenses: Pick<Offense, 'validator' | 'amount'>[],
+  offenses: PartialBy<Offense, 'epochOrSlot'>[],
   committees: EthAddress[][],
+  epochsForCommittees: bigint[],
   settings: {
     slashingAmounts: [bigint, bigint, bigint];
+    epochDuration: number;
   },
 ): ValidatorSlashVote[] {
   const { slashingAmounts } = settings;
 
-  const slashedSet: Set<string> = new Set();
+  if (committees.length !== epochsForCommittees.length) {
+    throw new Error('committees and epochsForCommittees must have the same length');
+  }
 
-  const votes = committees.flatMap(committee =>
-    committee.map(validator => {
-      const validatorStr = validator.toString();
+  const votes = committees.flatMap((committee, committeeIndex) => {
+    const committeeEpoch = epochsForCommittees[committeeIndex];
 
-      // If already voted for slashing this validator, skip
-      if (slashedSet.has(validatorStr)) {
-        return 0;
-      }
+    return 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),
+      );
 
-      // Normal offense-based slashing logic
-      const validatorOffenses = offenses.filter(o => o.validator.equals(validator));
+      // Sum up the penalties for this validator in this epoch
       const slashAmount = sumBigint(validatorOffenses.map(o => o.amount));
       const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
-      slashedSet.add(validatorStr);
       return Number(slashUnits);
-    }),
-  );
+    });
+  });
+
   return votes;
 }
 

package/src/tests/factories.ts

@@ -1607,6 +1607,7 @@ export async function makeBloatedProcessedTx({
   vkTreeRoot = Fr.ZERO,
   protocolContractTreeRoot = Fr.ZERO,
   globalVariables = GlobalVariables.empty(),
+  newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
   feePayer,
   feePaymentPublicDataWrite,
   privateOnly = false,
@@ -1619,6 +1620,7 @@ export async function makeBloatedProcessedTx({
   gasSettings?: GasSettings;
   vkTreeRoot?: Fr;
   globalVariables?: GlobalVariables;
+  newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
   protocolContractTreeRoot?: Fr;
   feePayer?: AztecAddress;
   feePaymentPublicDataWrite?: PublicDataWrite;
@@ -1672,6 +1674,9 @@ export async function makeBloatedProcessedTx({
 
     // Create avm output.
     const avmOutput = AvmCircuitPublicInputs.empty();
+    // Assign data from hints.
+    avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+    avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
     // Assign data from private.
     avmOutput.globalVariables = globalVariables;
     avmOutput.startGasUsed = tx.data.gasUsed;
@@ -1715,6 +1720,7 @@ export async function makeBloatedProcessedTx({
     avmOutput.gasSettings = gasSettings;
 
     const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
+    avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
 
     const gasUsed = {
       totalGas: Gas.empty(),

package/src/tx/tree_snapshots.ts

@@ -12,10 +12,10 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
  */
 export class TreeSnapshots {
   constructor(
-    public readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot,
-    public readonly noteHashTree: AppendOnlyTreeSnapshot,
-    public readonly nullifierTree: AppendOnlyTreeSnapshot,
-    public readonly publicDataTree: AppendOnlyTreeSnapshot,
+    public l1ToL2MessageTree: AppendOnlyTreeSnapshot,
+    public noteHashTree: AppendOnlyTreeSnapshot,
+    public nullifierTree: AppendOnlyTreeSnapshot,
+    public publicDataTree: AppendOnlyTreeSnapshot,
   ) {}
 
   static get schema() {

package/src/validators/schemas.ts

@@ -4,6 +4,7 @@ import { z } from 'zod';
 
 import type {
   SingleValidatorStats,
+  ValidatorMissedStats,
   ValidatorStats,
   ValidatorStatusHistory,
   ValidatorStatusInSlot,
@@ -35,19 +36,20 @@ const ValidatorTimeStatSchema = z.object({
   date: z.string(),
 });
 
-const ValidatorFilteredHistorySchema = z.object({
+const ValidatorMissedStatsSchema = z.object({
   currentStreak: schemas.Integer,
   rate: z.number().optional(),
   count: schemas.Integer,
-});
+  total: schemas.Integer,
+}) satisfies ZodFor<ValidatorMissedStats>;
 
 export const ValidatorStatsSchema = z.object({
   address: schemas.EthAddress,
   lastProposal: ValidatorTimeStatSchema.optional(),
   lastAttestation: ValidatorTimeStatSchema.optional(),
   totalSlots: schemas.Integer,
-  missedProposals: ValidatorFilteredHistorySchema,
-  missedAttestations: ValidatorFilteredHistorySchema,
+  missedProposals: ValidatorMissedStatsSchema,
+  missedAttestations: ValidatorMissedStatsSchema,
   history: ValidatorStatusHistorySchema,
 }) satisfies ZodFor<ValidatorStats>;
 

package/src/validators/types.ts

@@ -11,21 +11,20 @@ export type ValidatorStatusInSlot =
 
 export type ValidatorStatusHistory = { slot: bigint; status: ValidatorStatusInSlot }[];
 
+export type ValidatorMissedStats = {
+  currentStreak: number;
+  rate?: number;
+  count: number;
+  total: number;
+};
+
 export type ValidatorStats = {
   address: EthAddress;
   lastProposal?: { timestamp: bigint; slot: bigint; date: string };
   lastAttestation?: { timestamp: bigint; slot: bigint; date: string };
   totalSlots: number;
-  missedProposals: {
-    currentStreak: number;
-    rate?: number;
-    count: number;
-  };
-  missedAttestations: {
-    currentStreak: number;
-    rate?: number;
-    count: number;
-  };
+  missedProposals: ValidatorMissedStats;
+  missedAttestations: ValidatorMissedStats;
   history: ValidatorStatusHistory;
 };