@aztec/validator-ha-signer 0.0.1-commit.b64cb54f6 → 0.0.1-commit.b8a057fa

package/src/db/migrations/1_initial-schema.ts

@@ -1,21 +1,52 @@
 /**
  * Initial schema for validator HA slashing protection
  *
- * This migration imports SQL from the schema.ts file to ensure a single source of truth.
+ * Note: this migration contains a fixed snapshot of the schema at the time it was created.
+ * It must NOT import from schema.ts, which evolves over time and would cause this migration
+ * to produce different results on fresh runs vs. re-runs.
  */
 import type { MigrationBuilder } from 'node-pg-migrate';
 
-import { DROP_SCHEMA_VERSION_TABLE, DROP_VALIDATOR_DUTIES_TABLE, SCHEMA_SETUP, SCHEMA_VERSION } from '../schema.js';
+import { DROP_SCHEMA_VERSION_TABLE, DROP_VALIDATOR_DUTIES_TABLE } from '../schema.js';
+
+// Snapshot of the initial schema — does NOT include checkpoint_number (added in migration 2).
+const INITIAL_SCHEMA_SETUP = [
+  `CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );`,
+  `CREATE TABLE IF NOT EXISTS validator_duties (
+    rollup_address VARCHAR(42) NOT NULL,
+    validator_address VARCHAR(42) NOT NULL,
+    slot BIGINT NOT NULL,
+    block_number BIGINT NOT NULL,
+    block_index_within_checkpoint INTEGER NOT NULL DEFAULT 0,
+    duty_type VARCHAR(30) NOT NULL CHECK (duty_type IN ('BLOCK_PROPOSAL', 'CHECKPOINT_PROPOSAL', 'ATTESTATION', 'ATTESTATIONS_AND_SIGNERS', 'GOVERNANCE_VOTE', 'SLASHING_VOTE')),
+    status VARCHAR(20) NOT NULL CHECK (status IN ('signing', 'signed')),
+    message_hash VARCHAR(66) NOT NULL,
+    signature VARCHAR(132),
+    node_id VARCHAR(255) NOT NULL,
+    lock_token VARCHAR(64) NOT NULL,
+    started_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    error_message TEXT,
+
+    PRIMARY KEY (rollup_address, validator_address, slot, duty_type, block_index_within_checkpoint),
+    CHECK (completed_at IS NULL OR completed_at >= started_at)
+  );`,
+  `CREATE INDEX IF NOT EXISTS idx_validator_duties_status ON validator_duties(status, started_at);`,
+  `CREATE INDEX IF NOT EXISTS idx_validator_duties_node ON validator_duties(node_id, started_at);`,
+] as const;
 
 export function up(pgm: MigrationBuilder): void {
-  for (const statement of SCHEMA_SETUP) {
+  for (const statement of INITIAL_SCHEMA_SETUP) {
     pgm.sql(statement);
   }
 
   // Insert initial schema version
   pgm.sql(`
     INSERT INTO schema_version (version)
-    VALUES (${SCHEMA_VERSION})
+    VALUES (1)
     ON CONFLICT (version) DO NOTHING;
   `);
 }

package/src/db/migrations/2_add-checkpoint-number.ts

@@ -0,0 +1,19 @@
+/**
+ * Add checkpoint_number column to validator_duties table
+ */
+import type { MigrationBuilder } from 'node-pg-migrate';
+
+export function up(pgm: MigrationBuilder): void {
+  pgm.addColumn('validator_duties', {
+    // eslint-disable-next-line camelcase
+    checkpoint_number: { type: 'bigint', notNull: true, default: 0 },
+  });
+
+  pgm.sql(`UPDATE schema_version SET version = 2 WHERE version = 1`);
+}
+
+export function down(pgm: MigrationBuilder): void {
+  pgm.dropColumn('validator_duties', 'checkpoint_number');
+
+  pgm.sql(`UPDATE schema_version SET version = 1 WHERE version = 2`);
+}

package/src/db/postgres.ts

@@ -107,6 +107,7 @@ export class PostgresSlashingProtectionDatabase implements SlashingProtectionDat
           params.validatorAddress.toString(),
           params.slot.toString(),
           params.blockNumber.toString(),
+          params.checkpointNumber.toString(),
           blockIndexWithinCheckpoint,
           params.dutyType,
           params.messageHash,
@@ -230,6 +231,7 @@ export class PostgresSlashingProtectionDatabase implements SlashingProtectionDat
       validatorAddress: row.validator_address,
       slot: row.slot,
       blockNumber: row.block_number,
+      checkpointNumber: row.checkpoint_number,
       blockIndexWithinCheckpoint: row.block_index_within_checkpoint,
       dutyType: row.duty_type,
       status: row.status,

package/src/db/schema.ts

@@ -9,7 +9,7 @@
 /**
  * Current schema version
  */
-export const SCHEMA_VERSION = 1;
+export const SCHEMA_VERSION = 2;
 
 /**
  * SQL to create the validator_duties table
@@ -20,6 +20,7 @@ CREATE TABLE IF NOT EXISTS validator_duties (
   validator_address VARCHAR(42) NOT NULL,
   slot BIGINT NOT NULL,
   block_number BIGINT NOT NULL,
+  checkpoint_number BIGINT NOT NULL DEFAULT 0,
   block_index_within_checkpoint INTEGER NOT NULL DEFAULT 0,
   duty_type VARCHAR(30) NOT NULL CHECK (duty_type IN ('BLOCK_PROPOSAL', 'CHECKPOINT_PROPOSAL', 'ATTESTATION', 'ATTESTATIONS_AND_SIGNERS', 'GOVERNANCE_VOTE', 'SLASHING_VOTE')),
   status VARCHAR(20) NOT NULL CHECK (status IN ('signing', 'signed')),
@@ -106,6 +107,7 @@ WITH inserted AS (
     validator_address,
     slot,
     block_number,
+    checkpoint_number,
     block_index_within_checkpoint,
     duty_type,
     status,
@@ -113,13 +115,14 @@ WITH inserted AS (
     node_id,
     lock_token,
     started_at
-  ) VALUES ($1, $2, $3, $4, $5, $6, 'signing', $7, $8, $9, CURRENT_TIMESTAMP)
+  ) VALUES ($1, $2, $3, $4, $5, $6, $7, 'signing', $8, $9, $10, CURRENT_TIMESTAMP)
   ON CONFLICT (rollup_address, validator_address, slot, duty_type, block_index_within_checkpoint) DO NOTHING
   RETURNING
     rollup_address,
     validator_address,
     slot,
     block_number,
+    checkpoint_number,
     block_index_within_checkpoint,
     duty_type,
     status,
@@ -139,6 +142,7 @@ SELECT
   validator_address,
   slot,
   block_number,
+  checkpoint_number,
   block_index_within_checkpoint,
   duty_type,
   status,
@@ -154,8 +158,8 @@ FROM validator_duties
 WHERE rollup_address = $1
   AND validator_address = $2
   AND slot = $3
-  AND duty_type = $6
-  AND block_index_within_checkpoint = $5
+  AND duty_type = $7
+  AND block_index_within_checkpoint = $6
   AND NOT EXISTS (SELECT 1 FROM inserted);
 `;
 
@@ -253,6 +257,7 @@ SELECT
   validator_address,
   slot,
   block_number,
+  checkpoint_number,
   block_index_within_checkpoint,
   duty_type,
   status,

package/src/db/types.ts

@@ -1,9 +1,4 @@
-import {
-  BlockNumber,
-  type CheckpointNumber,
-  type IndexWithinCheckpoint,
-  SlotNumber,
-} from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, type IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
 import { DutyType } from '@aztec/stdlib/ha-signing';
@@ -16,6 +11,7 @@ export interface DutyRow {
   validator_address: string;
   slot: string;
   block_number: string;
+  checkpoint_number: string;
   block_index_within_checkpoint: number;
   duty_type: DutyType;
   status: DutyStatus;
@@ -38,6 +34,7 @@ export interface StoredDutyRecord {
   validatorAddress: string;
   slot: string;
   blockNumber: string;
+  checkpointNumber: string;
   blockIndexWithinCheckpoint: number;
   dutyType: DutyType;
   status: DutyStatus;
@@ -81,8 +78,10 @@ export interface ValidatorDutyRecord {
   validatorAddress: EthAddress;
   /** Slot number for this duty */
   slot: SlotNumber;
-  /** Block number for this duty */
+  /** Block number for this duty (0 for non-block-proposal duties) */
   blockNumber: BlockNumber;
+  /** Checkpoint number for this duty (0 for attestation and vote duties) */
+  checkpointNumber: CheckpointNumber;
   /** Block index within checkpoint (0, 1, 2... for block proposals, -1 for other duty types) */
   blockIndexWithinCheckpoint: number;
   /** Type of duty being performed */
@@ -117,6 +116,7 @@ export function recordFromFields(stored: StoredDutyRecord): ValidatorDutyRecord
     validatorAddress: EthAddress.fromString(stored.validatorAddress),
     slot: SlotNumber.fromString(stored.slot),
     blockNumber: BlockNumber.fromString(stored.blockNumber),
+    checkpointNumber: CheckpointNumber.fromString(stored.checkpointNumber),
     blockIndexWithinCheckpoint: stored.blockIndexWithinCheckpoint,
     dutyType: stored.dutyType,
     status: stored.status,
@@ -208,8 +208,10 @@ export function getBlockIndexFromDutyIdentifier(duty: DutyIdentifier): number {
  * Additional parameters for checking and recording a new duty
  */
 interface CheckAndRecordExtra {
-  /** Block number for this duty */
-  blockNumber: BlockNumber | CheckpointNumber;
+  /** Block number for this duty (0 for non-block-proposal duties) */
+  blockNumber: BlockNumber;
+  /** Checkpoint number for this duty (0 for attestation and vote duties) */
+  checkpointNumber: CheckpointNumber;
   /** The signing root (hash) for this duty */
   messageHash: string;
   /** Identifier for the node that acquired the lock */

package/src/errors.ts

@@ -22,6 +22,27 @@ export class DutyAlreadySignedError extends Error {
   }
 }
 
+/**
+ * Thrown when the slashing-protection record for an in-flight signing operation can no longer be
+ * updated because it is no longer owned by this node - for example, the stuck-duty cleanup loop
+ * deleted the SIGNING row while the remote signer was slow. The produced signature must be
+ * discarded rather than broadcast: with no protection record in place, a later attempt for the
+ * same duty with different data would sign freely, which is slashable equivocation.
+ */
+export class SigningLockLostError extends Error {
+  constructor(
+    public readonly slot: SlotNumber,
+    public readonly dutyType: DutyType,
+    public readonly nodeId: string,
+  ) {
+    super(
+      `Slashing protection record for ${dutyType} at slot ${slot} was lost before signing completed ` +
+        `(node ${nodeId}); discarding signature`,
+    );
+    this.name = 'SigningLockLostError';
+  }
+}
+
 /**
  * Thrown when attempting to sign data that conflicts with an already-signed duty.
  * This means the same validator tried to sign DIFFERENT data for the same slot.

package/src/factory.ts

@@ -1,6 +1,7 @@
 /**
  * Factory functions for creating validator HA signers
  */
+import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import type { LocalSignerConfig, ValidatorHASignerConfig } from '@aztec/stdlib/ha-signing';
@@ -8,7 +9,7 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import { Pool } from 'pg';
 
-import { LmdbSlashingProtectionDatabase } from './db/lmdb.js';
+import { LmdbSlashingProtectionDatabase, migrateLmdbSlashingProtectionDatabase } from './db/lmdb.js';
 import { PostgresSlashingProtectionDatabase } from './db/postgres.js';
 import { HASignerMetrics } from './metrics.js';
 import type { CreateHASignerDeps, CreateLocalSignerWithProtectionDeps, SlashingProtectionDatabase } from './types.js';
@@ -31,7 +32,7 @@ import { ValidatorHASigner } from './validator_ha_signer.js';
  *   databaseUrl: process.env.DATABASE_URL,
  *   nodeId: 'validator-node-1',
  *   pollingIntervalMs: 100,
- *   signingTimeoutMs: 3000,
+ *   peerSigningTimeoutMs: 3000,
  * });
  * signer.start(); // Start background cleanup
  *
@@ -57,7 +58,8 @@ export async function createHASigner(
   const { databaseUrl, poolMaxCount, poolMinCount, poolIdleTimeoutMs, poolConnectionTimeoutMs, ...signerConfig } =
     config;
 
-  if (!databaseUrl) {
+  const databaseUrlValue = databaseUrl?.getValue();
+  if (!databaseUrlValue) {
     throw new Error('databaseUrl is required for createHASigner');
   }
 
@@ -68,7 +70,7 @@ export async function createHASigner(
   let pool: Pool;
   if (!deps?.pool) {
     pool = new Pool({
-      connectionString: databaseUrl,
+      connectionString: databaseUrlValue,
       max: poolMaxCount ?? 10,
       min: poolMinCount ?? 0,
       idleTimeoutMillis: poolIdleTimeoutMs ?? 10_000,
@@ -78,6 +80,16 @@ export async function createHASigner(
     pool = deps.pool;
   }
 
+  // pg re-emits idle-client errors (e.g. a Postgres restart severing an idle connection) on the
+  // pool. Without an 'error' listener, Node escalates these to an uncaughtException and crashes the
+  // process - taking down every HA replica sharing the DB at once. pg destroys and replaces the
+  // errored client itself, so logging is the only action needed. Log just message/code, never the
+  // raw error object (it can carry connection metadata).
+  const log = createLogger('validator-ha-signer:factory');
+  pool.on('error', (err: NodeJS.ErrnoException) => {
+    log.warn('Postgres pool error on idle client', { message: err.message, code: err.code });
+  });
+
   // Create database instance
   const db = new PostgresSlashingProtectionDatabase(pool);
 
@@ -100,9 +112,10 @@ export async function createHASigner(
  * high-availability (multi-node) setup. It prevents a proposer from sending two
  * proposals for the same slot if the node crashes and restarts mid-proposal.
  *
- * When `config.dataDirectory` is set, the protection database is persisted to disk
- * and survives crashes/restarts. When unset, an ephemeral in-memory store is
- * used which protects within a single run but not across restarts.
+ * `config.dataDirectory` is required so the protection database is persisted to disk and survives
+ * crashes/restarts. Booting without it throws, since an ephemeral store silently drops all
+ * double-signing protection across restarts. Set `config.allowEphemeralSigningProtection` to opt
+ * into the ephemeral store anyway (dev/test networks only) — a loud warning is logged in that case.
  *
  * @param config - Local signer config
  * @param deps - Optional dependencies (telemetry, date provider).
@@ -118,11 +131,43 @@ export async function createLocalSignerWithProtection(
   const telemetryClient = deps?.telemetryClient ?? getTelemetryClient();
   const dateProvider = deps?.dateProvider ?? new DateProvider();
 
-  const kvStore = await createStore('signing-protection', LmdbSlashingProtectionDatabase.SCHEMA_VERSION, {
-    dataDirectory: config.dataDirectory,
-    dataStoreMapSizeKb: config.signingProtectionMapSizeKb ?? config.dataStoreMapSizeKb,
-    l1Contracts: config.l1Contracts,
-  });
+  const log = createLogger('validator-ha-signer:factory');
+
+  if (!config.dataDirectory) {
+    if (!config.allowEphemeralSigningProtection) {
+      throw new Error(
+        'Local signing protection requires a persistent data directory, but none was configured. ' +
+          'Set DATA_DIRECTORY so double-signing protection survives restarts, or explicitly opt into an ' +
+          'ephemeral store (dev/test only) with VALIDATOR_ALLOW_EPHEMERAL_SIGNING_PROTECTION=true.',
+      );
+    }
+    log.warn(
+      'Local signing protection is running with an EPHEMERAL store: no data directory is configured. ' +
+        'Double-signing protection will NOT survive a restart. This is unsafe for production validators.',
+    );
+  }
+
+  const kvStore = await createStore(
+    'signing-protection',
+    LmdbSlashingProtectionDatabase.SCHEMA_VERSION,
+    {
+      dataDirectory: config.dataDirectory,
+      dataStoreMapSizeKb: config.signingProtectionMapSizeKb ?? config.dataStoreMapSizeKb,
+      rollupAddress: config.rollupAddress,
+    },
+    undefined,
+    {
+      onUpgrade: (dataDirectory, currentVersion, latestVersion) =>
+        migrateLmdbSlashingProtectionDatabase(
+          dataDirectory,
+          currentVersion,
+          latestVersion,
+          config.signingProtectionMapSizeKb ?? config.dataStoreMapSizeKb,
+        ),
+      schemaVersionMismatchPolicy: 'throw',
+      versionFileReadFailurePolicy: 'throw',
+    },
+  );
 
   const db = new LmdbSlashingProtectionDatabase(kvStore, dateProvider);
 
@@ -137,3 +182,35 @@ export async function createLocalSignerWithProtection(
 
   return { signer, db };
 }
+
+/**
+ * Create an in-memory LMDB-backed SlashingProtectionDatabase that can be shared across
+ * multiple validator nodes in the same process. Used for testing HA setups.
+ */
+export async function createSharedSlashingProtectionDb(
+  dateProvider: DateProvider = new DateProvider(),
+): Promise<SlashingProtectionDatabase> {
+  const kvStore = await createStore('shared-signing-protection', LmdbSlashingProtectionDatabase.SCHEMA_VERSION, {
+    dataStoreMapSizeKb: 1024 * 1024,
+  });
+  return new LmdbSlashingProtectionDatabase(kvStore, dateProvider);
+}
+
+/**
+ * Create a ValidatorHASigner backed by a pre-existing SlashingProtectionDatabase.
+ * Used for testing HA setups where multiple nodes share the same protection database.
+ */
+export function createSignerFromSharedDb(
+  db: SlashingProtectionDatabase,
+  config: Pick<
+    ValidatorHASignerConfig,
+    'nodeId' | 'pollingIntervalMs' | 'peerSigningTimeoutMs' | 'maxStuckDutiesAgeMs' | 'rollupAddress'
+  >,
+  deps?: CreateLocalSignerWithProtectionDeps,
+): { signer: ValidatorHASigner; db: SlashingProtectionDatabase } {
+  const telemetryClient = deps?.telemetryClient ?? getTelemetryClient();
+  const dateProvider = deps?.dateProvider ?? new DateProvider();
+  const metrics = new HASignerMetrics(telemetryClient, config.nodeId, 'SharedSigningProtectionMetrics');
+  const signer = new ValidatorHASigner(db, config, { metrics, dateProvider });
+  return { signer, db };
+}

package/src/slashing_protection_service.ts

@@ -26,6 +26,9 @@ export interface SlashingProtectionServiceDeps {
   dateProvider: DateProvider;
 }
 
+/** Default max age (ms) of a stuck SIGNING duty before cleanup reclaims it: 2x the 72s Aztec slot duration. */
+export const DEFAULT_MAX_STUCK_DUTIES_AGE_MS = 144_000;
+
 /**
  * Slashing Protection Service
  *
@@ -44,7 +47,7 @@ export interface SlashingProtectionServiceDeps {
 export class SlashingProtectionService {
   private readonly log: Logger;
   private readonly pollingIntervalMs: number;
-  private readonly signingTimeoutMs: number;
+  private readonly peerSigningTimeoutMs: number;
   private readonly maxStuckDutiesAgeMs: number;
 
   private readonly metrics: HASignerMetrics;
@@ -60,9 +63,8 @@ export class SlashingProtectionService {
   ) {
     this.log = createLogger('slashing-protection');
     this.pollingIntervalMs = config.pollingIntervalMs;
-    this.signingTimeoutMs = config.signingTimeoutMs;
-    // Default to 144s (2x 72s Aztec slot duration) if not explicitly configured
-    this.maxStuckDutiesAgeMs = config.maxStuckDutiesAgeMs ?? 144_000;
+    this.peerSigningTimeoutMs = config.peerSigningTimeoutMs;
+    this.maxStuckDutiesAgeMs = config.maxStuckDutiesAgeMs ?? DEFAULT_MAX_STUCK_DUTIES_AGE_MS;
 
     this.cleanupRunningPromise = new RunningPromise(this.cleanup.bind(this), this.log, this.maxStuckDutiesAgeMs);
     this.metrics = deps.metrics;
@@ -132,10 +134,10 @@ export class SlashingProtectionService {
         throw new DutyAlreadySignedError(slot, dutyType, record.blockIndexWithinCheckpoint, record.nodeId);
       } else if (record.status === DutyStatus.SIGNING) {
         // Another node is currently signing - check for timeout
-        if (this.dateProvider.now() - startTime > this.signingTimeoutMs) {
+        if (this.dateProvider.now() - startTime > this.peerSigningTimeoutMs) {
           this.log.warn(`Timeout waiting for signing to complete for duty ${dutyType} at slot ${slot}`, {
             validatorAddress: validatorAddress.toString(),
-            timeoutMs: this.signingTimeoutMs,
+            timeoutMs: this.peerSigningTimeoutMs,
             signingNodeId: record.nodeId,
           });
           this.metrics.recordDutyAlreadySigned(dutyType);
@@ -241,10 +243,10 @@ export class SlashingProtectionService {
    */
   async start() {
     // One-time cleanup at startup: remove duties from previous rollup versions
-    const numOutdatedRollupDuties = await this.db.cleanupOutdatedRollupDuties(this.config.l1Contracts.rollupAddress);
+    const numOutdatedRollupDuties = await this.db.cleanupOutdatedRollupDuties(this.config.rollupAddress);
     if (numOutdatedRollupDuties > 0) {
       this.log.info(`Cleaned up ${numOutdatedRollupDuties} duties with outdated rollup address at startup`, {
-        currentRollupAddress: this.config.l1Contracts.rollupAddress.toString(),
+        currentRollupAddress: this.config.rollupAddress.toString(),
       });
       this.metrics.recordCleanup('outdated_rollup', numOutdatedRollupDuties);
     }
@@ -275,7 +277,10 @@ export class SlashingProtectionService {
    * Runs in the background via RunningPromise.
    */
   private async cleanup() {
-    // 1. Clean up stuck duties (our own node's duties that got stuck in 'signing' status)
+    // 1. Clean up stuck duties (our own node's duties that got stuck in 'signing' status).
+    // This cannot race an in-flight signing: every signing operation is hard-bounded by a timeout
+    // clamped below maxStuckDutiesAgeMs / 2 (see ValidatorHASigner), so a live SIGNING row is
+    // always released long before it can be considered stuck.
     const numStuckDuties = await this.db.cleanupOwnStuckDuties(this.config.nodeId, this.maxStuckDutiesAgeMs);
     if (numStuckDuties > 0) {
       this.log.verbose(`Cleaned up ${numStuckDuties} stuck duties`, {

package/src/types.ts

@@ -2,11 +2,14 @@ import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { DateProvider } from '@aztec/foundation/timer';
 import {
+  type AttestationSigningContext,
+  type CheckpointProposalSigningContext,
   DutyType,
   type HAProtectedSigningContext,
   type SigningContext,
   type ValidatorHASignerConfig,
   getBlockNumberFromSigningContext as getBlockNumberFromSigningContextFromStdlib,
+  getCheckpointNumberFromSigningContext as getCheckpointNumberFromSigningContextFromStdlib,
   isHAProtectedContext,
 } from '@aztec/stdlib/ha-signing';
 import type { TelemetryClient } from '@aztec/telemetry-client';
@@ -25,8 +28,10 @@ import type {
 } from './db/types.js';
 
 export type {
+  AttestationSigningContext,
   BlockProposalDutyIdentifier,
   CheckAndRecordParams,
+  CheckpointProposalSigningContext,
   DeleteDutyParams,
   DutyIdentifier,
   DutyRow,
@@ -40,6 +45,7 @@ export type {
 export { DutyStatus, DutyType, getBlockIndexFromDutyIdentifier, normalizeBlockIndex } from './db/types.js';
 export { isHAProtectedContext };
 export { getBlockNumberFromSigningContextFromStdlib as getBlockNumberFromSigningContext };
+export { getCheckpointNumberFromSigningContextFromStdlib as getCheckpointNumberFromSigningContext };
 
 /**
  * Result of tryInsertOrGetExisting operation

package/src/validator_ha_signer.ts

@@ -9,17 +9,19 @@ import type { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { DateProvider } from '@aztec/foundation/timer';
+import { type DateProvider, executeTimeout } from '@aztec/foundation/timer';
 import {
   type BaseSignerConfig,
   DutyType,
   type HAProtectedSigningContext,
   getBlockNumberFromSigningContext,
+  getCheckpointNumberFromSigningContext,
 } from '@aztec/stdlib/ha-signing';
 
 import type { DutyIdentifier } from './db/types.js';
+import { SigningLockLostError } from './errors.js';
 import type { HASignerMetrics } from './metrics.js';
-import { SlashingProtectionService } from './slashing_protection_service.js';
+import { DEFAULT_MAX_STUCK_DUTIES_AGE_MS, SlashingProtectionService } from './slashing_protection_service.js';
 import type { SlashingProtectionDatabase } from './types.js';
 
 export interface ValidatorHASignerDeps {
@@ -27,6 +29,9 @@ export interface ValidatorHASignerDeps {
   dateProvider: DateProvider;
 }
 
+/** Default hard timeout (ms) for a single signer call when not configured. */
+const DEFAULT_SIGNER_CALL_TIMEOUT_MS = 30_000;
+
 /**
  * Validator High Availability Signer
  *
@@ -53,6 +58,7 @@ export class ValidatorHASigner {
 
   private readonly dateProvider: DateProvider;
   private readonly metrics: HASignerMetrics;
+  private readonly signerCallTimeoutMs: number;
 
   constructor(
     db: SlashingProtectionDatabase,
@@ -64,17 +70,31 @@ export class ValidatorHASigner {
     this.metrics = deps.metrics;
     this.dateProvider = deps.dateProvider;
 
+    // Clamp the signer-call timeout below half the stuck-duty max age. This maintains the
+    // invariant that an in-flight signing always times out and releases its SIGNING row well before
+    // stuck-duty cleanup could consider it stuck, so cleanup can never delete a live duty (only
+    // signWithProtection writes SIGNING rows, and every path through it is bounded by this timeout).
+    // If timers misbehave anyway, the recordSuccess-returns-false throw is the backstop: the duty
+    // fails instead of broadcasting an unprotected signature.
+    const maxStuckDutiesAgeMs = config.maxStuckDutiesAgeMs ?? DEFAULT_MAX_STUCK_DUTIES_AGE_MS;
+    this.signerCallTimeoutMs = Math.min(
+      config.signerCallTimeoutMs ?? DEFAULT_SIGNER_CALL_TIMEOUT_MS,
+      maxStuckDutiesAgeMs / 2,
+    );
+
     if (!config.nodeId || config.nodeId === '') {
       throw new Error('NODE_ID is required for high-availability setups');
     }
-    this.rollupAddress = config.l1Contracts.rollupAddress;
+    this.rollupAddress = config.rollupAddress;
     this.slashingProtection = new SlashingProtectionService(db, config, {
       metrics: deps.metrics,
       dateProvider: deps.dateProvider,
     });
+
     this.log.info('Validator HA Signer initialized with slashing protection', {
       nodeId: config.nodeId,
       rollupAddress: this.rollupAddress.toString(),
+      signerCallTimeoutMs: this.signerCallTimeoutMs,
     });
   }
 
@@ -125,17 +145,29 @@ export class ValidatorHASigner {
     // Acquire lock and get the token for ownership verification
     // DutyAlreadySignedError and SlashingProtectionError may be thrown here and are recorded in the service
     const blockNumber = getBlockNumberFromSigningContext(context);
+    const checkpointNumber = getCheckpointNumberFromSigningContext(context);
     const lockToken = await this.slashingProtection.checkAndRecord({
       ...dutyIdentifier,
       blockNumber,
+      checkpointNumber,
       messageHash: messageHash.toString(),
       nodeId: this.config.nodeId,
     });
 
-    // Perform signing
+    // Perform signing under a hard timeout. If the signer hangs, executeTimeout aborts and rejects;
+    // the orphaned signFn promise resolving later is discarded (never broadcast). A timeout takes the
+    // same failure path as any signing error: release the lock so the duty can be retried safely.
     let signature: Signature;
     try {
-      signature = await signFn(messageHash);
+      signature = await executeTimeout(
+        () => signFn(messageHash),
+        this.signerCallTimeoutMs,
+        () =>
+          new Error(
+            `Signing operation for ${dutyType} at slot ${context.slot} timed out after ` +
+              `${this.signerCallTimeoutMs}ms`,
+          ),
+      );
     } catch (error: any) {
       // Delete duty to allow retry (only succeeds if we own the lock)
       await this.slashingProtection.deleteDuty({ ...dutyIdentifier, lockToken });
@@ -143,13 +175,21 @@ export class ValidatorHASigner {
       throw error;
     }
 
-    // Record success (only succeeds if we own the lock)
-    await this.slashingProtection.recordSuccess({
+    // Record success (only succeeds if we still own the lock).
+    // A false result means our SIGNING row is gone or no longer ours (e.g. deleted by stuck-duty
+    // cleanup while signing was slow). We must not broadcast this signature: without a protection
+    // record, a later attempt for the same duty with different data would sign freely (slashable).
+    // Do not delete the duty here - we no longer own it, and another node may legitimately hold it.
+    const recorded = await this.slashingProtection.recordSuccess({
       ...dutyIdentifier,
       signature,
       nodeId: this.config.nodeId,
       lockToken,
     });
+    if (!recorded) {
+      this.metrics.recordSigningError(dutyType);
+      throw new SigningLockLostError(context.slot, dutyType, this.config.nodeId);
+    }
 
     const duration = this.dateProvider.now() - startTime;
     this.metrics.recordSigningSuccess(dutyType, duration);