@aztec/validator-ha-signer 0.0.1-commit.ffe5b04ea → 0.0.1-commit.fff30aa

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "@aztec/validator-ha-signer",
-  "version": "0.0.1-commit.ffe5b04ea",
+  "version": "0.0.1-commit.fff30aa",
   "type": "module",
   "exports": {
+    "./config": "./dest/config.js",
     "./db": "./dest/db/index.js",
     "./errors": "./dest/errors.js",
     "./factory": "./dest/factory.js",
-    "./metrics": "./dest/metrics.js",
     "./migrations": "./dest/migrations.js",
     "./slashing-protection-service": "./dest/slashing_protection_service.js",
     "./types": "./dest/types.js",
     "./validator-ha-signer": "./dest/validator_ha_signer.js",
-    "./test": "./dest/test/pglite_pool.js",
-    "./db/lmdb": "./dest/db/lmdb.js"
+    "./test": "./dest/test/pglite_pool.js"
   },
   "typedocOptions": {
     "entryPoints": [
+      "./src/config.ts",
       "./src/db/index.ts",
       "./src/errors.ts",
       "./src/factory.ts",
-      "./src/metrics.ts",
       "./src/migrations.ts",
       "./src/slashing_protection_service.ts",
       "./src/types.ts",
@@ -75,11 +74,8 @@
     ]
   },
   "dependencies": {
-    "@aztec/ethereum": "0.0.1-commit.ffe5b04ea",
-    "@aztec/foundation": "0.0.1-commit.ffe5b04ea",
-    "@aztec/kv-store": "0.0.1-commit.ffe5b04ea",
-    "@aztec/stdlib": "0.0.1-commit.ffe5b04ea",
-    "@aztec/telemetry-client": "0.0.1-commit.ffe5b04ea",
+    "@aztec/ethereum": "0.0.1-commit.fff30aa",
+    "@aztec/foundation": "0.0.1-commit.fff30aa",
     "node-pg-migrate": "^8.0.4",
     "pg": "^8.11.3",
     "tslib": "^2.4.0",

package/src/config.ts

@@ -0,0 +1,149 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  getDefaultConfig,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+/**
+ * Configuration for the Validator HA Signer
+ *
+ * This config is used for distributed locking and slashing protection
+ * when running multiple validator nodes in a high-availability setup.
+ */
+export interface ValidatorHASignerConfig {
+  /** Whether HA signing / slashing protection is enabled */
+  haSigningEnabled: boolean;
+  /** L1 contract addresses (rollup address required) */
+  l1Contracts: Pick<L1ContractAddresses, 'rollupAddress'>;
+  /** Unique identifier for this node */
+  nodeId: string;
+  /** How long to wait between polls when a duty is being signed (ms) */
+  pollingIntervalMs: number;
+  /** Maximum time to wait for a duty being signed to complete (ms) */
+  signingTimeoutMs: number;
+  /** Maximum age of a stuck duty in ms (defaults to 2x hardcoded Aztec slot duration if not set) */
+  maxStuckDutiesAgeMs?: number;
+  /** Optional: clean up old duties after this many hours (disabled if not set) */
+  cleanupOldDutiesAfterHours?: number;
+  /**
+   * PostgreSQL connection string
+   * Format: postgresql://user:password@host:port/database
+   */
+  databaseUrl?: string;
+  /**
+   * PostgreSQL connection pool configuration
+   */
+  /** Maximum number of clients in the pool (default: 10) */
+  poolMaxCount?: number;
+  /** Minimum number of clients in the pool (default: 0) */
+  poolMinCount?: number;
+  /** Idle timeout in milliseconds (default: 10000) */
+  poolIdleTimeoutMs?: number;
+  /** Connection timeout in milliseconds (default: 0, no timeout) */
+  poolConnectionTimeoutMs?: number;
+}
+
+export const validatorHASignerConfigMappings: ConfigMappingsType<ValidatorHASignerConfig> = {
+  haSigningEnabled: {
+    env: 'VALIDATOR_HA_SIGNING_ENABLED',
+    description: 'Whether HA signing / slashing protection is enabled',
+    ...booleanConfigHelper(false),
+  },
+  l1Contracts: {
+    description: 'L1 contract addresses (rollup address required)',
+    nested: {
+      rollupAddress: {
+        description: 'The Ethereum address of the rollup contract (must be set programmatically)',
+        parseEnv: (val: string) => EthAddress.fromString(val),
+      },
+    },
+  },
+  nodeId: {
+    env: 'VALIDATOR_HA_NODE_ID',
+    description: 'The unique identifier for this node',
+    defaultValue: '',
+  },
+  pollingIntervalMs: {
+    env: 'VALIDATOR_HA_POLLING_INTERVAL_MS',
+    description: 'The number of ms to wait between polls when a duty is being signed',
+    ...numberConfigHelper(100),
+  },
+  signingTimeoutMs: {
+    env: 'VALIDATOR_HA_SIGNING_TIMEOUT_MS',
+    description: 'The maximum time to wait for a duty being signed to complete',
+    ...numberConfigHelper(3_000),
+  },
+  maxStuckDutiesAgeMs: {
+    env: 'VALIDATOR_HA_MAX_STUCK_DUTIES_AGE_MS',
+    description: 'The maximum age of a stuck duty in ms (defaults to 2x Aztec slot duration)',
+    ...optionalNumberConfigHelper(),
+  },
+  cleanupOldDutiesAfterHours: {
+    env: 'VALIDATOR_HA_OLD_DUTIES_MAX_AGE_H',
+    description: 'Optional: clean up old duties after this many hours (disabled if not set)',
+    ...optionalNumberConfigHelper(),
+  },
+  databaseUrl: {
+    env: 'VALIDATOR_HA_DATABASE_URL',
+    description:
+      'PostgreSQL connection string for validator HA signer (format: postgresql://user:password@host:port/database)',
+  },
+  poolMaxCount: {
+    env: 'VALIDATOR_HA_POOL_MAX',
+    description: 'Maximum number of clients in the pool',
+    ...numberConfigHelper(10),
+  },
+  poolMinCount: {
+    env: 'VALIDATOR_HA_POOL_MIN',
+    description: 'Minimum number of clients in the pool',
+    ...numberConfigHelper(0),
+  },
+  poolIdleTimeoutMs: {
+    env: 'VALIDATOR_HA_POOL_IDLE_TIMEOUT_MS',
+    description: 'Idle timeout in milliseconds',
+    ...numberConfigHelper(10_000),
+  },
+  poolConnectionTimeoutMs: {
+    env: 'VALIDATOR_HA_POOL_CONNECTION_TIMEOUT_MS',
+    description: 'Connection timeout in milliseconds (0 means no timeout)',
+    ...numberConfigHelper(0),
+  },
+};
+
+export const defaultValidatorHASignerConfig: ValidatorHASignerConfig = getDefaultConfig(
+  validatorHASignerConfigMappings,
+);
+
+/**
+ * Returns the validator HA signer configuration from environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator HA signer configuration.
+ */
+export function getConfigEnvVars(): ValidatorHASignerConfig {
+  return getConfigFromMappings<ValidatorHASignerConfig>(validatorHASignerConfigMappings);
+}
+
+export const ValidatorHASignerConfigSchema = z.object({
+  haSigningEnabled: z.boolean(),
+  l1Contracts: z.object({
+    rollupAddress: z.instanceof(EthAddress),
+  }),
+  nodeId: z.string(),
+  pollingIntervalMs: z.number().min(0),
+  signingTimeoutMs: z.number().min(0),
+  maxStuckDutiesAgeMs: z.number().min(0).optional(),
+  cleanupOldDutiesAfterHours: z.number().min(0).optional(),
+  databaseUrl: z.string().optional(),
+  poolMaxCount: z.number().min(0).optional(),
+  poolMinCount: z.number().min(0).optional(),
+  poolIdleTimeoutMs: z.number().min(0).optional(),
+  poolConnectionTimeoutMs: z.number().min(0).optional(),
+}) satisfies ZodFor<ValidatorHASignerConfig>;

package/src/db/in_memory.ts

@@ -0,0 +1,107 @@
+/**
+ * In-memory implementation of SlashingProtectionDatabase for testing.
+ * Used to simulate shared slashing protection in HA test setups without requiring PostgreSQL.
+ */
+import type { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import type { SlashingProtectionDatabase, TryInsertOrGetResult, ValidatorDutyRecord } from '../types.js';
+import type { CheckAndRecordParams, DutyType } from './types.js';
+import { DutyStatus, getBlockIndexFromDutyIdentifier } from './types.js';
+
+/** Creates a unique key for a duty based on its identifying fields. */
+function dutyKey(
+  rollupAddress: EthAddress,
+  validatorAddress: EthAddress,
+  slot: SlotNumber,
+  dutyType: DutyType,
+  blockIndexWithinCheckpoint: number,
+): string {
+  return `${rollupAddress}:${validatorAddress}:${slot}:${dutyType}:${blockIndexWithinCheckpoint}`;
+}
+
+/** In-memory slashing protection database for testing HA setups. */
+export class InMemorySlashingProtectionDatabase implements SlashingProtectionDatabase {
+  private duties = new Map<string, ValidatorDutyRecord>();
+
+  tryInsertOrGetExisting(params: CheckAndRecordParams): Promise<TryInsertOrGetResult> {
+    const blockIndex = getBlockIndexFromDutyIdentifier(params);
+    const key = dutyKey(params.rollupAddress, params.validatorAddress, params.slot, params.dutyType, blockIndex);
+
+    const existing = this.duties.get(key);
+    if (existing) {
+      return Promise.resolve({ isNew: false, record: existing });
+    }
+
+    const lockToken = `lock-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const record: ValidatorDutyRecord = {
+      rollupAddress: params.rollupAddress,
+      validatorAddress: params.validatorAddress,
+      slot: params.slot,
+      blockNumber: params.blockNumber as BlockNumber,
+      blockIndexWithinCheckpoint: blockIndex,
+      dutyType: params.dutyType,
+      status: DutyStatus.SIGNING,
+      messageHash: params.messageHash,
+      nodeId: params.nodeId,
+      lockToken,
+      startedAt: new Date(),
+    };
+    this.duties.set(key, record);
+    return Promise.resolve({ isNew: true, record });
+  }
+
+  updateDutySigned(
+    rollupAddress: EthAddress,
+    validatorAddress: EthAddress,
+    slot: SlotNumber,
+    dutyType: DutyType,
+    signature: string,
+    lockToken: string,
+    blockIndexWithinCheckpoint: number,
+  ): Promise<boolean> {
+    const key = dutyKey(rollupAddress, validatorAddress, slot, dutyType, blockIndexWithinCheckpoint);
+    const record = this.duties.get(key);
+    if (!record || record.lockToken !== lockToken) {
+      return Promise.resolve(false);
+    }
+    record.status = DutyStatus.SIGNED;
+    record.signature = signature;
+    record.completedAt = new Date();
+    return Promise.resolve(true);
+  }
+
+  deleteDuty(
+    rollupAddress: EthAddress,
+    validatorAddress: EthAddress,
+    slot: SlotNumber,
+    dutyType: DutyType,
+    lockToken: string,
+    blockIndexWithinCheckpoint: number,
+  ): Promise<boolean> {
+    const key = dutyKey(rollupAddress, validatorAddress, slot, dutyType, blockIndexWithinCheckpoint);
+    const record = this.duties.get(key);
+    if (!record || record.lockToken !== lockToken) {
+      return Promise.resolve(false);
+    }
+    this.duties.delete(key);
+    return Promise.resolve(true);
+  }
+
+  cleanupOwnStuckDuties(_nodeId: string, _maxAgeMs: number): Promise<number> {
+    return Promise.resolve(0);
+  }
+
+  cleanupOutdatedRollupDuties(_currentRollupAddress: EthAddress): Promise<number> {
+    return Promise.resolve(0);
+  }
+
+  cleanupOldDuties(_maxAgeMs: number): Promise<number> {
+    return Promise.resolve(0);
+  }
+
+  close(): Promise<void> {
+    this.duties.clear();
+    return Promise.resolve();
+  }
+}

package/src/db/index.ts

@@ -1,4 +1,3 @@
 export * from './types.js';
 export * from './schema.js';
 export * from './postgres.js';
-export * from './lmdb.js';

package/src/db/postgres.ts

@@ -1,7 +1,7 @@
 /**
  * PostgreSQL implementation of SlashingProtectionDatabase
  */
-import { SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -20,7 +20,7 @@ import {
   UPDATE_DUTY_SIGNED,
 } from './schema.js';
 import type { CheckAndRecordParams, DutyRow, DutyType, InsertOrGetRow, ValidatorDutyRecord } from './types.js';
-import { getBlockIndexFromDutyIdentifier, recordFromFields } from './types.js';
+import { getBlockIndexFromDutyIdentifier } from './types.js';
 
 /**
  * Minimal pool interface for database operations.
@@ -220,16 +220,14 @@ export class PostgresSlashingProtectionDatabase implements SlashingProtectionDat
   }
 
   /**
-   * Convert a database row to a ValidatorDutyRecord.
-   * Maps snake_case column names to StoredDutyRecord (camelCase, ms timestamps),
-   * then delegates to the shared recordFromFields() converter.
+   * Convert a database row to a ValidatorDutyRecord
    */
   private rowToRecord(row: DutyRow): ValidatorDutyRecord {
-    return recordFromFields({
-      rollupAddress: row.rollup_address,
-      validatorAddress: row.validator_address,
-      slot: row.slot,
-      blockNumber: row.block_number,
+    return {
+      rollupAddress: EthAddress.fromString(row.rollup_address),
+      validatorAddress: EthAddress.fromString(row.validator_address),
+      slot: SlotNumber.fromString(row.slot),
+      blockNumber: BlockNumber.fromString(row.block_number),
       blockIndexWithinCheckpoint: row.block_index_within_checkpoint,
       dutyType: row.duty_type,
       status: row.status,
@@ -237,10 +235,10 @@ export class PostgresSlashingProtectionDatabase implements SlashingProtectionDat
       signature: row.signature ?? undefined,
       nodeId: row.node_id,
       lockToken: row.lock_token,
-      startedAtMs: row.started_at.getTime(),
-      completedAtMs: row.completed_at?.getTime(),
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? undefined,
       errorMessage: row.error_message ?? undefined,
-    });
+    };
   }
 
   /**

package/src/db/types.ts

@@ -1,12 +1,6 @@
-import {
-  BlockNumber,
-  type CheckpointNumber,
-  type IndexWithinCheckpoint,
-  SlotNumber,
-} from '@aztec/foundation/branded-types';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import type { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
-import { DutyType } from '@aztec/stdlib/ha-signing';
 
 /**
  * Row type from PostgreSQL query
@@ -29,34 +23,24 @@ export interface DutyRow {
 }
 
 /**
- * Plain-primitive representation of a duty record suitable for serialization
- * (e.g. msgpackr for LMDB). All domain types are stored as their string/number
- * equivalents. Timestamps are Unix milliseconds.
+ * Row type from INSERT_OR_GET_DUTY query (includes is_new flag)
  */
-export interface StoredDutyRecord {
-  rollupAddress: string;
-  validatorAddress: string;
-  slot: string;
-  blockNumber: string;
-  blockIndexWithinCheckpoint: number;
-  dutyType: DutyType;
-  status: DutyStatus;
-  messageHash: string;
-  signature?: string;
-  nodeId: string;
-  lockToken: string;
-  /** Unix timestamp in milliseconds when signing started */
-  startedAtMs: number;
-  /** Unix timestamp in milliseconds when signing completed */
-  completedAtMs?: number;
-  errorMessage?: string;
+export interface InsertOrGetRow extends DutyRow {
+  is_new: boolean;
 }
 
 /**
- * Row type from INSERT_OR_GET_DUTY query (includes is_new flag)
+ * Type of validator duty being performed
  */
-export interface InsertOrGetRow extends DutyRow {
-  is_new: boolean;
+export enum DutyType {
+  BLOCK_PROPOSAL = 'BLOCK_PROPOSAL',
+  CHECKPOINT_PROPOSAL = 'CHECKPOINT_PROPOSAL',
+  ATTESTATION = 'ATTESTATION',
+  ATTESTATIONS_AND_SIGNERS = 'ATTESTATIONS_AND_SIGNERS',
+  GOVERNANCE_VOTE = 'GOVERNANCE_VOTE',
+  SLASHING_VOTE = 'SLASHING_VOTE',
+  AUTH_REQUEST = 'AUTH_REQUEST',
+  TXS = 'TXS',
 }
 
 /**
@@ -67,12 +51,8 @@ export enum DutyStatus {
   SIGNED = 'signed',
 }
 
-// Re-export DutyType from stdlib
-export { DutyType };
-
 /**
- * Rich representation of a validator duty, with branded types and Date objects.
- * This is the common output type returned by all SlashingProtectionDatabase implementations.
+ * Record of a validator duty in the database
  */
 export interface ValidatorDutyRecord {
   /** Ethereum address of the rollup contract */
@@ -105,31 +85,6 @@ export interface ValidatorDutyRecord {
   errorMessage?: string;
 }
 
-/**
- * Convert a {@link StoredDutyRecord} (plain-primitive wire format) to a
- * {@link ValidatorDutyRecord} (rich domain type).
- *
- * Shared by LMDB and any future non-Postgres backend implementations.
- */
-export function recordFromFields(stored: StoredDutyRecord): ValidatorDutyRecord {
-  return {
-    rollupAddress: EthAddress.fromString(stored.rollupAddress),
-    validatorAddress: EthAddress.fromString(stored.validatorAddress),
-    slot: SlotNumber.fromString(stored.slot),
-    blockNumber: BlockNumber.fromString(stored.blockNumber),
-    blockIndexWithinCheckpoint: stored.blockIndexWithinCheckpoint,
-    dutyType: stored.dutyType,
-    status: stored.status,
-    messageHash: stored.messageHash,
-    signature: stored.signature,
-    nodeId: stored.nodeId,
-    lockToken: stored.lockToken,
-    startedAt: new Date(stored.startedAtMs),
-    completedAt: stored.completedAtMs !== undefined ? new Date(stored.completedAtMs) : undefined,
-    errorMessage: stored.errorMessage,
-  };
-}
-
 /**
  * Duty identifier for block proposals.
  * blockIndexWithinCheckpoint is REQUIRED and must be >= 0.

package/src/factory.ts

@@ -1,17 +1,12 @@
 /**
  * Factory functions for creating validator HA signers
  */
-import { DateProvider } from '@aztec/foundation/timer';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
-import type { LocalSignerConfig, ValidatorHASignerConfig } from '@aztec/stdlib/ha-signing';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-
 import { Pool } from 'pg';
 
-import { LmdbSlashingProtectionDatabase } from './db/lmdb.js';
+import type { ValidatorHASignerConfig } from './config.js';
+import { InMemorySlashingProtectionDatabase } from './db/in_memory.js';
 import { PostgresSlashingProtectionDatabase } from './db/postgres.js';
-import { HASignerMetrics } from './metrics.js';
-import type { CreateHASignerDeps, CreateLocalSignerWithProtectionDeps, SlashingProtectionDatabase } from './types.js';
+import type { CreateHASignerDeps, SlashingProtectionDatabase } from './types.js';
 import { ValidatorHASigner } from './validator_ha_signer.js';
 
 /**
@@ -29,6 +24,7 @@ import { ValidatorHASigner } from './validator_ha_signer.js';
  * ```typescript
  * const { signer, db } = await createHASigner({
  *   databaseUrl: process.env.DATABASE_URL,
+ *   haSigningEnabled: true,
  *   nodeId: 'validator-node-1',
  *   pollingIntervalMs: 100,
  *   signingTimeoutMs: 3000,
@@ -60,10 +56,6 @@ export async function createHASigner(
   if (!databaseUrl) {
     throw new Error('databaseUrl is required for createHASigner');
   }
-
-  const telemetryClient = deps?.telemetryClient ?? getTelemetryClient();
-  const dateProvider = deps?.dateProvider ?? new DateProvider();
-
   // Create connection pool (or use provided pool)
   let pool: Pool;
   if (!deps?.pool) {
@@ -84,56 +76,39 @@ export async function createHASigner(
   // Verify database schema is initialized and version matches
   await db.initialize();
 
-  // Create metrics
-  const metrics = new HASignerMetrics(telemetryClient, signerConfig.nodeId);
-
   // Create signer
-  const signer = new ValidatorHASigner(db, signerConfig, { metrics, dateProvider });
+  const signer = new ValidatorHASigner(db, { ...signerConfig, databaseUrl });
 
   return { signer, db };
 }
 
 /**
- * Create a local (single-node) signing protection signer backed by LMDB.
- *
- * This provides double-signing protection for nodes that are NOT running in a
- * 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.
- *
- * @param config - Local signer config
- * @param deps - Optional dependencies (telemetry, date provider).
- * @returns An object containing the signer and database instances.
+ * Create an in-memory SlashingProtectionDatabase that can be shared across
+ * multiple validator nodes in the same process. Used for testing HA setups.
  */
-export async function createLocalSignerWithProtection(
-  config: LocalSignerConfig,
-  deps?: CreateLocalSignerWithProtectionDeps,
-): Promise<{
-  signer: ValidatorHASigner;
-  db: SlashingProtectionDatabase;
-}> {
-  const telemetryClient = deps?.telemetryClient ?? getTelemetryClient();
-  const dateProvider = deps?.dateProvider ?? new DateProvider();
+export function createSharedSlashingProtectionDb(): SlashingProtectionDatabase {
+  return new InMemorySlashingProtectionDatabase();
+}
 
-  const kvStore = await createStore('signing-protection', LmdbSlashingProtectionDatabase.SCHEMA_VERSION, {
-    dataDirectory: config.dataDirectory,
-    dataStoreMapSizeKb: config.signingProtectionMapSizeKb ?? config.dataStoreMapSizeKb,
+/**
+ * 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' | 'signingTimeoutMs' | 'maxStuckDutiesAgeMs' | 'l1Contracts'
+  >,
+): { signer: ValidatorHASigner; db: SlashingProtectionDatabase } {
+  const signerConfig: ValidatorHASignerConfig = {
+    haSigningEnabled: true,
     l1Contracts: config.l1Contracts,
-  });
-
-  const db = new LmdbSlashingProtectionDatabase(kvStore, dateProvider);
-
-  const signerConfig = {
-    ...config,
-    nodeId: config.nodeId || 'local',
+    nodeId: config.nodeId || `shared-${Date.now()}`,
+    pollingIntervalMs: config.pollingIntervalMs ?? 100,
+    signingTimeoutMs: config.signingTimeoutMs ?? 3000,
+    maxStuckDutiesAgeMs: config.maxStuckDutiesAgeMs,
   };
-
-  const metrics = new HASignerMetrics(telemetryClient, signerConfig.nodeId, 'LocalSigningProtectionMetrics');
-
-  const signer = new ValidatorHASigner(db, signerConfig, { metrics, dateProvider });
-
+  const signer = new ValidatorHASigner(db, signerConfig);
   return { signer, db };
 }