@aztec/validator-ha-signer 0.0.1-commit.6d3c34e → 0.0.1-commit.7035c9bd6

package/src/slashing_protection_service.ts

@@ -7,10 +7,24 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { BaseSignerConfig } from '@aztec/stdlib/ha-signing';
 
-import { type CheckAndRecordParams, type DeleteDutyParams, DutyStatus, type RecordSuccessParams } from './db/types.js';
+import {
+  type CheckAndRecordParams,
+  type DeleteDutyParams,
+  DutyStatus,
+  type RecordSuccessParams,
+  getBlockIndexFromDutyIdentifier,
+} from './db/types.js';
 import { DutyAlreadySignedError, SlashingProtectionError } from './errors.js';
-import type { SlashingProtectionConfig, SlashingProtectionDatabase } from './types.js';
+import type { HASignerMetrics } from './metrics.js';
+import type { SlashingProtectionDatabase } from './types.js';
+
+export interface SlashingProtectionServiceDeps {
+  metrics: HASignerMetrics;
+  dateProvider: DateProvider;
+}
 
 /**
  * Slashing Protection Service
@@ -31,22 +45,28 @@ export class SlashingProtectionService {
   private readonly log: Logger;
   private readonly pollingIntervalMs: number;
   private readonly signingTimeoutMs: number;
+  private readonly maxStuckDutiesAgeMs: number;
+
+  private readonly metrics: HASignerMetrics;
+  private readonly dateProvider: DateProvider;
 
   private cleanupRunningPromise: RunningPromise;
+  private lastOldDutiesCleanupAtMs?: number;
 
   constructor(
     private readonly db: SlashingProtectionDatabase,
-    private readonly config: SlashingProtectionConfig,
+    private readonly config: BaseSignerConfig,
+    deps: SlashingProtectionServiceDeps,
   ) {
     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.cleanupRunningPromise = new RunningPromise(
-      this.cleanupStuckDuties.bind(this),
-      this.log,
-      this.config.maxStuckDutiesAgeMs,
-    );
+    this.cleanupRunningPromise = new RunningPromise(this.cleanup.bind(this), this.log, this.maxStuckDutiesAgeMs);
+    this.metrics = deps.metrics;
+    this.dateProvider = deps.dateProvider;
   }
 
   /**
@@ -58,7 +78,6 @@ export class SlashingProtectionService {
    * 2. If insert succeeds, we acquired the lock - return the lockToken
    * 3. If a record exists, handle based on status:
    *    - SIGNED: Throw appropriate error (already signed or slashing protection)
-   *    - FAILED: Delete the failed record
    *    - SIGNING: Wait and poll until status changes, then handle result
    *
    * @returns The lockToken that must be used for recordSuccess/deleteDuty
@@ -67,7 +86,7 @@ export class SlashingProtectionService {
    */
   async checkAndRecord(params: CheckAndRecordParams): Promise<string> {
     const { validatorAddress, slot, dutyType, messageHash, nodeId } = params;
-    const startTime = Date.now();
+    const startTime = this.dateProvider.now();
 
     this.log.debug(`Checking duty: ${dutyType} for slot ${slot}`, {
       validatorAddress: validatorAddress.toString(),
@@ -80,10 +99,11 @@ export class SlashingProtectionService {
 
       if (isNew) {
         // We successfully acquired the lock
-        this.log.info(`Acquired lock for duty ${dutyType} at slot ${slot}`, {
+        this.log.verbose(`Acquired lock for duty ${dutyType} at slot ${slot}`, {
           validatorAddress: validatorAddress.toString(),
           nodeId,
         });
+        this.metrics.recordLockAcquire(true);
         return record.lockToken;
       }
 
@@ -98,18 +118,28 @@ export class SlashingProtectionService {
             existingNodeId: record.nodeId,
             attemptingNodeId: nodeId,
           });
-          throw new SlashingProtectionError(slot, dutyType, record.messageHash, messageHash);
+          this.metrics.recordSlashingProtection(dutyType);
+          throw new SlashingProtectionError(
+            slot,
+            dutyType,
+            record.blockIndexWithinCheckpoint,
+            record.messageHash,
+            messageHash,
+            record.nodeId,
+          );
         }
-        throw new DutyAlreadySignedError(slot, dutyType, record.nodeId);
+        this.metrics.recordDutyAlreadySigned(dutyType);
+        throw new DutyAlreadySignedError(slot, dutyType, record.blockIndexWithinCheckpoint, record.nodeId);
       } else if (record.status === DutyStatus.SIGNING) {
         // Another node is currently signing - check for timeout
-        if (Date.now() - startTime > this.signingTimeoutMs) {
+        if (this.dateProvider.now() - startTime > this.signingTimeoutMs) {
           this.log.warn(`Timeout waiting for signing to complete for duty ${dutyType} at slot ${slot}`, {
             validatorAddress: validatorAddress.toString(),
             timeoutMs: this.signingTimeoutMs,
             signingNodeId: record.nodeId,
           });
-          throw new DutyAlreadySignedError(slot, dutyType, 'unknown (timeout)');
+          this.metrics.recordDutyAlreadySigned(dutyType);
+          throw new DutyAlreadySignedError(slot, dutyType, record.blockIndexWithinCheckpoint, 'unknown (timeout)');
         }
 
         // Wait and poll
@@ -133,12 +163,21 @@ export class SlashingProtectionService {
    * @returns true if the update succeeded, false if token didn't match
    */
   async recordSuccess(params: RecordSuccessParams): Promise<boolean> {
-    const { validatorAddress, slot, dutyType, signature, nodeId, lockToken } = params;
+    const { rollupAddress, validatorAddress, slot, dutyType, signature, nodeId, lockToken } = params;
+    const blockIndexWithinCheckpoint = getBlockIndexFromDutyIdentifier(params);
 
-    const success = await this.db.updateDutySigned(validatorAddress, slot, dutyType, signature.toString(), lockToken);
+    const success = await this.db.updateDutySigned(
+      rollupAddress,
+      validatorAddress,
+      slot,
+      dutyType,
+      signature.toString(),
+      lockToken,
+      blockIndexWithinCheckpoint,
+    );
 
     if (success) {
-      this.log.info(`Recorded successful signing for duty ${dutyType} at slot ${slot}`, {
+      this.log.verbose(`Recorded successful signing for duty ${dutyType} at slot ${slot}`, {
         validatorAddress: validatorAddress.toString(),
         nodeId,
       });
@@ -160,9 +199,17 @@ export class SlashingProtectionService {
    * @returns true if the delete succeeded, false if token didn't match
    */
   async deleteDuty(params: DeleteDutyParams): Promise<boolean> {
-    const { validatorAddress, slot, dutyType, lockToken } = params;
+    const { rollupAddress, validatorAddress, slot, dutyType, lockToken } = params;
+    const blockIndexWithinCheckpoint = getBlockIndexFromDutyIdentifier(params);
 
-    const success = await this.db.deleteDuty(validatorAddress, slot, dutyType, lockToken);
+    const success = await this.db.deleteDuty(
+      rollupAddress,
+      validatorAddress,
+      slot,
+      dutyType,
+      lockToken,
+      blockIndexWithinCheckpoint,
+    );
 
     if (success) {
       this.log.info(`Deleted duty ${dutyType} at slot ${slot} to allow retry`, {
@@ -188,7 +235,20 @@ export class SlashingProtectionService {
    * Start running tasks.
    * Cleanup runs immediately on start to recover from any previous crashes.
    */
-  start() {
+  /**
+   * Start the background cleanup task.
+   * Also performs one-time cleanup of duties with outdated rollup addresses.
+   */
+  async start() {
+    // One-time cleanup at startup: remove duties from previous rollup versions
+    const numOutdatedRollupDuties = await this.db.cleanupOutdatedRollupDuties(this.config.l1Contracts.rollupAddress);
+    if (numOutdatedRollupDuties > 0) {
+      this.log.info(`Cleaned up ${numOutdatedRollupDuties} duties with outdated rollup address at startup`, {
+        currentRollupAddress: this.config.l1Contracts.rollupAddress.toString(),
+      });
+      this.metrics.recordCleanup('outdated_rollup', numOutdatedRollupDuties);
+    }
+
     this.cleanupRunningPromise.start();
     this.log.info('Slashing protection service started', { nodeId: this.config.nodeId });
   }
@@ -202,15 +262,47 @@ export class SlashingProtectionService {
   }
 
   /**
-   * Cleanup own stuck duties
+   * Close the database connection.
+   * Should be called after stop() during graceful shutdown.
+   */
+  async close() {
+    await this.db.close();
+    this.log.info('Slashing protection database connection closed');
+  }
+
+  /**
+   * Periodic cleanup of stuck duties and optionally old signed duties.
+   * Runs in the background via RunningPromise.
    */
-  private async cleanupStuckDuties() {
-    const numDuties = await this.db.cleanupOwnStuckDuties(this.config.nodeId, this.config.maxStuckDutiesAgeMs);
-    if (numDuties > 0) {
-      this.log.info(`Cleaned up ${numDuties} stuck duties`, {
+  private async cleanup() {
+    // 1. Clean up stuck duties (our own node's duties that got stuck in 'signing' status)
+    const numStuckDuties = await this.db.cleanupOwnStuckDuties(this.config.nodeId, this.maxStuckDutiesAgeMs);
+    if (numStuckDuties > 0) {
+      this.log.verbose(`Cleaned up ${numStuckDuties} stuck duties`, {
         nodeId: this.config.nodeId,
-        maxStuckDutiesAgeMs: this.config.maxStuckDutiesAgeMs,
+        maxStuckDutiesAgeMs: this.maxStuckDutiesAgeMs,
       });
+      this.metrics.recordCleanup('stuck', numStuckDuties);
+    }
+
+    // 2. Clean up old signed duties if configured
+    // we shouldn't run this as often as stuck duty cleanup.
+    if (this.config.cleanupOldDutiesAfterHours !== undefined) {
+      const maxAgeMs = this.config.cleanupOldDutiesAfterHours * 60 * 60 * 1000;
+      const nowMs = this.dateProvider.now();
+      const shouldRun =
+        this.lastOldDutiesCleanupAtMs === undefined || nowMs - this.lastOldDutiesCleanupAtMs >= maxAgeMs;
+      if (shouldRun) {
+        const numOldDuties = await this.db.cleanupOldDuties(maxAgeMs);
+        this.lastOldDutiesCleanupAtMs = nowMs;
+        if (numOldDuties > 0) {
+          this.log.verbose(`Cleaned up ${numOldDuties} old signed duties`, {
+            cleanupOldDutiesAfterHours: this.config.cleanupOldDutiesAfterHours,
+            maxAgeMs,
+          });
+          this.metrics.recordCleanup('old', numOldDuties);
+        }
+      }
     }
   }
 }

package/src/test/pglite_pool.ts

@@ -0,0 +1,256 @@
+/**
+ * Vendored pg-compatible Pool/Client wrapper for PGlite.
+ *
+ * Copied from @middle-management/pglite-pg-adapter v0.0.3
+ * https://www.npmjs.com/package/@middle-management/pglite-pg-adapter
+ *
+ * Modifications:
+ * - Converted to ESM and TypeScript
+ * - Uses PGliteInterface instead of PGlite class to avoid TypeScript
+ *   type mismatches from ESM/CJS dual package resolution with private fields
+ * - Simplified rowCount calculation to handle CTEs properly
+ */
+import type { PGliteInterface } from '@electric-sql/pglite';
+import { EventEmitter } from 'events';
+import type { QueryResult, QueryResultRow } from 'pg';
+import { Readable, Writable } from 'stream';
+
+export interface PoolConfig {
+  pglite: PGliteInterface;
+  max?: number;
+  min?: number;
+}
+
+interface ClientConfig {
+  pglite: PGliteInterface;
+  host?: string;
+  port?: number;
+  ssl?: boolean;
+}
+
+export class Client extends EventEmitter {
+  protected pglite: PGliteInterface;
+  protected _connected = false;
+  readonly host: string;
+  readonly port: number;
+  readonly ssl: boolean;
+  readonly connection: object;
+
+  // Stub implementations for pg compatibility
+  readonly copyFrom = (): Writable => new Writable();
+  readonly copyTo = (): Readable => new Readable();
+  readonly pauseDrain = (): void => {};
+  readonly resumeDrain = (): void => {};
+  readonly escapeLiteral = (str: string): string => `'${str.replace(/'/g, "''")}'`;
+  readonly escapeIdentifier = (str: string): string => `"${str.replace(/"/g, '""')}"`;
+  readonly setTypeParser = (): void => {};
+  readonly getTypeParser = (): ((value: string) => unknown) => (value: string) => value;
+
+  constructor(config: ClientConfig) {
+    super();
+    this.pglite = config.pglite;
+    this.host = config.host || 'localhost';
+    this.port = config.port || 5432;
+    this.ssl = typeof config.ssl === 'boolean' ? config.ssl : !!config.ssl;
+    this.connection = {};
+  }
+
+  connect(): Promise<void> {
+    if (this._connected) {
+      return Promise.resolve();
+    }
+    this._connected = true;
+    this.emit('connect');
+    return Promise.resolve();
+  }
+
+  end(): Promise<void> {
+    if (!this._connected) {
+      return Promise.resolve();
+    }
+    this._connected = false;
+    this.emit('end');
+    return Promise.resolve();
+  }
+
+  async query<R extends QueryResultRow = any>(text: string, values?: any[]): Promise<QueryResult<R>> {
+    if (!this._connected) {
+      throw new Error('Client is not connected');
+    }
+    const result = await this.pglite.query<R>(text, values);
+    return this.convertPGliteResult(result);
+  }
+
+  protected convertPGliteResult<R extends QueryResultRow>(result: {
+    rows: R[];
+    fields: Array<{ name: string; dataTypeID: number }>;
+    affectedRows?: number;
+  }): QueryResult<R> {
+    return {
+      command: '',
+      rowCount: 'affectedRows' in result ? (result.affectedRows ?? 0) : result.rows.length,
+      oid: 0,
+      fields: result.fields.map(field => ({
+        name: field.name,
+        tableID: 0,
+        columnID: 0,
+        dataTypeID: field.dataTypeID,
+        dataTypeSize: -1,
+        dataTypeModifier: -1,
+        format: 'text',
+      })),
+      rows: result.rows,
+    };
+  }
+
+  get connected(): boolean {
+    return this._connected;
+  }
+}
+
+export class Pool extends EventEmitter {
+  private clients: PoolClient[] = [];
+  private availableClients: PoolClient[] = [];
+  private waitingQueue: Array<(client: PoolClient) => void> = [];
+  private _ended = false;
+  private pglite: PGliteInterface;
+  private _config: PoolConfig;
+
+  readonly expiredCount = 0;
+  readonly options: PoolConfig;
+
+  constructor(config: PoolConfig) {
+    super();
+    this._config = { max: 10, min: 0, ...config };
+    this.pglite = config.pglite;
+    this.options = config;
+  }
+
+  get totalCount(): number {
+    return this.clients.length;
+  }
+
+  get idleCount(): number {
+    return this.availableClients.length;
+  }
+
+  get waitingCount(): number {
+    return this.waitingQueue.length;
+  }
+
+  get ending(): boolean {
+    return this._ended;
+  }
+
+  get ended(): boolean {
+    return this._ended;
+  }
+
+  connect(): Promise<PoolClient> {
+    if (this._ended) {
+      return Promise.reject(new Error('Pool is ended'));
+    }
+
+    if (this.availableClients.length > 0) {
+      const client = this.availableClients.pop()!;
+      client._markInUse();
+      return Promise.resolve(client);
+    }
+
+    if (this.clients.length < (this._config.max || 10)) {
+      const client = new PoolClient(this.pglite, this);
+      this.clients.push(client);
+      return Promise.resolve(client);
+    }
+
+    return new Promise(resolve => {
+      this.waitingQueue.push(resolve);
+    });
+  }
+
+  async query<R extends QueryResultRow = any>(text: string, values?: any[]): Promise<QueryResult<R>> {
+    const client = await this.connect();
+    try {
+      return await client.query<R>(text, values);
+    } finally {
+      client.release();
+    }
+  }
+
+  releaseClient(client: PoolClient): void {
+    const index = this.clients.indexOf(client);
+    if (index !== -1) {
+      client._markAvailable();
+      if (this.waitingQueue.length > 0) {
+        const resolve = this.waitingQueue.shift()!;
+        client._markInUse();
+        resolve(client);
+      } else {
+        this.availableClients.push(client);
+      }
+    }
+  }
+
+  end(): Promise<void> {
+    this._ended = true;
+    this.clients.forEach(client => client._markReleased());
+    this.clients = [];
+    this.availableClients = [];
+    this.emit('end');
+    return Promise.resolve();
+  }
+}
+
+export class PoolClient extends Client {
+  private pool: Pool;
+  private _released = false;
+  private _inUse = true;
+  private _userReleased = false;
+
+  constructor(pglite: PGliteInterface, pool: Pool) {
+    super({ pglite });
+    this.pool = pool;
+    this._connected = true;
+  }
+
+  override async query<R extends QueryResultRow = any>(text: string, values?: any[]): Promise<QueryResult<R>> {
+    if (this._userReleased && !this._inUse) {
+      throw new Error('Client has been released back to the pool');
+    }
+    const result = await this.pglite.query<R>(text, values);
+    return this.convertPGliteResult(result);
+  }
+
+  release(): void {
+    if (this._released || this._userReleased) {
+      return;
+    }
+    this._userReleased = true;
+    this.pool.releaseClient(this);
+  }
+
+  override end(): Promise<void> {
+    this.release();
+    return Promise.resolve();
+  }
+
+  _markInUse(): void {
+    this._inUse = true;
+    this._userReleased = false;
+  }
+
+  _markAvailable(): void {
+    this._inUse = false;
+    this._userReleased = false;
+  }
+
+  _markReleased(): void {
+    this._released = true;
+    this._inUse = false;
+    this._userReleased = true;
+  }
+
+  override get connected(): boolean {
+    return this._connected && !this._released;
+  }
+}

package/src/types.ts

@@ -1,27 +1,45 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import { DateProvider } from '@aztec/foundation/timer';
+import {
+  DutyType,
+  type HAProtectedSigningContext,
+  type SigningContext,
+  type ValidatorHASignerConfig,
+  getBlockNumberFromSigningContext as getBlockNumberFromSigningContextFromStdlib,
+  isHAProtectedContext,
+} from '@aztec/stdlib/ha-signing';
+import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import type { Pool } from 'pg';
 
-import type { CreateHASignerConfig, SlashingProtectionConfig } from './config.js';
 import type {
+  BlockProposalDutyIdentifier,
   CheckAndRecordParams,
   DeleteDutyParams,
   DutyIdentifier,
-  DutyType,
+  DutyRow,
+  OtherDutyIdentifier,
   RecordSuccessParams,
   ValidatorDutyRecord,
 } from './db/types.js';
 
 export type {
+  BlockProposalDutyIdentifier,
   CheckAndRecordParams,
-  CreateHASignerConfig,
   DeleteDutyParams,
   DutyIdentifier,
+  DutyRow,
+  HAProtectedSigningContext,
+  OtherDutyIdentifier,
   RecordSuccessParams,
-  SlashingProtectionConfig,
+  SigningContext,
   ValidatorDutyRecord,
+  ValidatorHASignerConfig,
 };
-export { DutyStatus, DutyType } from './db/types.js';
+export { DutyStatus, DutyType, getBlockIndexFromDutyIdentifier, normalizeBlockIndex } from './db/types.js';
+export { isHAProtectedContext };
+export { getBlockNumberFromSigningContextFromStdlib as getBlockNumberFromSigningContext };
 
 /**
  * Result of tryInsertOrGetExisting operation
@@ -42,19 +60,20 @@ export interface CreateHASignerDeps {
    * If provided, databaseUrl and poolConfig are ignored
    */
   pool?: Pool;
+  /**
+   * Optional telemetry client for metrics
+   */
+  telemetryClient?: TelemetryClient;
+  /**
+   * Optional date provider for timestamps
+   */
+  dateProvider?: DateProvider;
 }
 
 /**
- * Context required for slashing protection during signing operations
+ * deps for creating a local signing protection signer
  */
-export interface SigningContext {
-  /** Slot number for this duty */
-  slot: bigint;
-  /** Block number for this duty */
-  blockNumber: bigint;
-  /** Type of duty being performed */
-  dutyType: DutyType;
-}
+export type CreateLocalSignerWithProtectionDeps = Omit<CreateHASignerDeps, 'pool'>;
 
 /**
  * Database interface for slashing protection operations
@@ -81,11 +100,13 @@ export interface SlashingProtectionDatabase {
    * @returns true if the update succeeded, false if token didn't match or duty not found
    */
   updateDutySigned(
+    rollupAddress: EthAddress,
     validatorAddress: EthAddress,
-    slot: bigint,
+    slot: SlotNumber,
     dutyType: DutyType,
     signature: string,
     lockToken: string,
+    blockIndexWithinCheckpoint: number,
   ): Promise<boolean>;
 
   /**
@@ -95,11 +116,39 @@ export interface SlashingProtectionDatabase {
    *
    * @returns true if the delete succeeded, false if token didn't match or duty not found
    */
-  deleteDuty(validatorAddress: EthAddress, slot: bigint, dutyType: DutyType, lockToken: string): Promise<boolean>;
+  deleteDuty(
+    rollupAddress: EthAddress,
+    validatorAddress: EthAddress,
+    slot: SlotNumber,
+    dutyType: DutyType,
+    lockToken: string,
+    blockIndexWithinCheckpoint: number,
+  ): Promise<boolean>;
 
   /**
    * Cleanup own stuck duties
    * @returns the number of duties cleaned up
    */
   cleanupOwnStuckDuties(nodeId: string, maxAgeMs: number): Promise<number>;
+
+  /**
+   * Cleanup duties with outdated rollup address.
+   * Removes all duties where the rollup address doesn't match the current one.
+   * Used after a rollup upgrade to clean up duties for the old rollup.
+   * @returns the number of duties cleaned up
+   */
+  cleanupOutdatedRollupDuties(currentRollupAddress: EthAddress): Promise<number>;
+
+  /**
+   * Cleanup old signed duties.
+   * Removes only signed duties older than the specified age.
+   * @returns the number of duties cleaned up
+   */
+  cleanupOldDuties(maxAgeMs: number): Promise<number>;
+
+  /**
+   * Close the database connection.
+   * Should be called during graceful shutdown.
+   */
+  close(): Promise<void>;
 }