@aztec/validator-ha-signer 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/types.ts

@@ -1,38 +1,51 @@
-import {
-  BlockNumber,
-  type CheckpointNumber,
-  type IndexWithinCheckpoint,
-  type SlotNumber,
-} from '@aztec/foundation/branded-types';
+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';
 
 import type { Pool } from 'pg';
 
-import type { ValidatorHASignerConfig } from './config.js';
-import {
-  type BlockProposalDutyIdentifier,
-  type CheckAndRecordParams,
-  type DeleteDutyParams,
-  type DutyIdentifier,
-  type DutyRow,
-  DutyType,
-  type OtherDutyIdentifier,
-  type RecordSuccessParams,
-  type ValidatorDutyRecord,
+import type {
+  BlockProposalDutyIdentifier,
+  CheckAndRecordParams,
+  DeleteDutyParams,
+  DutyIdentifier,
+  DutyRow,
+  OtherDutyIdentifier,
+  RecordSuccessParams,
+  ValidatorDutyRecord,
 } from './db/types.js';
 
 export type {
+  AttestationSigningContext,
   BlockProposalDutyIdentifier,
   CheckAndRecordParams,
+  CheckpointProposalSigningContext,
   DeleteDutyParams,
   DutyIdentifier,
   DutyRow,
+  HAProtectedSigningContext,
   OtherDutyIdentifier,
   RecordSuccessParams,
+  SigningContext,
   ValidatorDutyRecord,
   ValidatorHASignerConfig,
 };
 export { DutyStatus, DutyType, getBlockIndexFromDutyIdentifier, normalizeBlockIndex } from './db/types.js';
+export { isHAProtectedContext };
+export { getBlockNumberFromSigningContextFromStdlib as getBlockNumberFromSigningContext };
+export { getCheckpointNumberFromSigningContextFromStdlib as getCheckpointNumberFromSigningContext };
 
 /**
  * Result of tryInsertOrGetExisting operation
@@ -53,99 +66,20 @@ export interface CreateHASignerDeps {
    * If provided, databaseUrl and poolConfig are ignored
    */
   pool?: Pool;
-}
-
-/**
- * Base context for signing operations
- */
-interface BaseSigningContext {
-  /** Slot number for this duty */
-  slot: SlotNumber;
   /**
-   * Block or checkpoint number for this duty.
-   * For block proposals, this is the block number.
-   * For checkpoint proposals, this is the checkpoint number.
+   * Optional telemetry client for metrics
    */
-  blockNumber: BlockNumber | CheckpointNumber;
-}
-
-/**
- * Signing context for block proposals.
- * blockIndexWithinCheckpoint is REQUIRED and must be >= 0.
- */
-export interface BlockProposalSigningContext extends BaseSigningContext {
-  /** Block index within checkpoint (0, 1, 2...). Required for block proposals. */
-  blockIndexWithinCheckpoint: IndexWithinCheckpoint;
-  dutyType: DutyType.BLOCK_PROPOSAL;
-}
-
-/**
- * Signing context for non-block-proposal duties that require HA protection.
- * blockIndexWithinCheckpoint is not applicable (internally always -1).
- */
-export interface OtherSigningContext extends BaseSigningContext {
-  dutyType: DutyType.CHECKPOINT_PROPOSAL | DutyType.ATTESTATION | DutyType.ATTESTATIONS_AND_SIGNERS;
-}
-
-/**
- * Signing context for governance/slashing votes which only need slot for HA protection.
- * blockNumber is not applicable (internally always 0).
- */
-export interface VoteSigningContext {
-  slot: SlotNumber;
-  dutyType: DutyType.GOVERNANCE_VOTE | DutyType.SLASHING_VOTE;
-}
-
-/**
- * Signing context for duties which don't require slot/blockNumber
- * as they don't need HA protection (AUTH_REQUEST, TXS).
- */
-export interface NoHAProtectionSigningContext {
-  dutyType: DutyType.AUTH_REQUEST | DutyType.TXS;
-}
-
-/**
- * Signing contexts that require HA protection (excludes AUTH_REQUEST).
- * Used by the HA signer's signWithProtection method.
- */
-export type HAProtectedSigningContext = BlockProposalSigningContext | OtherSigningContext | VoteSigningContext;
-
-/**
- * Type guard to check if a SigningContext requires HA protection.
- * Returns true for contexts that need HA protection, false for AUTH_REQUEST and TXS.
- */
-export function isHAProtectedContext(context: SigningContext): context is HAProtectedSigningContext {
-  return context.dutyType !== DutyType.AUTH_REQUEST && context.dutyType !== DutyType.TXS;
-}
-
-/**
- * Gets the block number from a signing context.
- * - Vote duties (GOVERNANCE_VOTE, SLASHING_VOTE): returns BlockNumber(0)
- * - Other duties: returns the blockNumber from the context
- */
-export function getBlockNumberFromSigningContext(context: HAProtectedSigningContext): BlockNumber | CheckpointNumber {
-  // Check for duty types that have blockNumber
-  if (
-    context.dutyType === DutyType.BLOCK_PROPOSAL ||
-    context.dutyType === DutyType.CHECKPOINT_PROPOSAL ||
-    context.dutyType === DutyType.ATTESTATION ||
-    context.dutyType === DutyType.ATTESTATIONS_AND_SIGNERS
-  ) {
-    return context.blockNumber;
-  }
-  // Vote duties (GOVERNANCE_VOTE, SLASHING_VOTE) don't have blockNumber
-  return BlockNumber(0);
+  telemetryClient?: TelemetryClient;
+  /**
+   * Optional date provider for timestamps
+   */
+  dateProvider?: DateProvider;
 }
 
 /**
- * Context required for slashing protection during signing operations.
- * Uses discriminated union to enforce type safety:
- * - BLOCK_PROPOSAL duties MUST have blockIndexWithinCheckpoint >= 0
- * - Other duty types do NOT have blockIndexWithinCheckpoint (internally -1)
- * - Vote duties only need slot (blockNumber is internally 0)
- * - AUTH_REQUEST and TXS duties don't need slot/blockNumber (no HA protection needed)
+ * deps for creating a local signing protection signer
  */
-export type SigningContext = HAProtectedSigningContext | NoHAProtectionSigningContext;
+export type CreateLocalSignerWithProtectionDeps = Omit<CreateHASignerDeps, 'pool'>;
 
 /**
  * Database interface for slashing protection operations

package/src/validator_ha_signer.ts

@@ -9,15 +9,28 @@ 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 { ValidatorHASignerConfig } from './config.js';
-import { type DutyIdentifier, DutyType } from './db/types.js';
-import { SlashingProtectionService } from './slashing_protection_service.js';
+import { type DateProvider, executeTimeout } from '@aztec/foundation/timer';
 import {
+  type BaseSignerConfig,
+  DutyType,
   type HAProtectedSigningContext,
-  type SlashingProtectionDatabase,
   getBlockNumberFromSigningContext,
-} from './types.js';
+  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 { DEFAULT_MAX_STUCK_DUTIES_AGE_MS, SlashingProtectionService } from './slashing_protection_service.js';
+import type { SlashingProtectionDatabase } from './types.js';
+
+export interface ValidatorHASignerDeps {
+  metrics: HASignerMetrics;
+  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
@@ -43,25 +56,45 @@ export class ValidatorHASigner {
   private readonly slashingProtection: SlashingProtectionService;
   private readonly rollupAddress: EthAddress;
 
+  private readonly dateProvider: DateProvider;
+  private readonly metrics: HASignerMetrics;
+  private readonly signerCallTimeoutMs: number;
+
   constructor(
     db: SlashingProtectionDatabase,
-    private readonly config: ValidatorHASignerConfig,
+    private readonly config: BaseSignerConfig,
+    deps: ValidatorHASignerDeps,
   ) {
     this.log = createLogger('validator-ha-signer');
 
-    if (!config.haSigningEnabled) {
-      // this shouldn't happen, the validator should use different signer for non-HA setups
-      throw new Error('Validator HA Signer is not enabled in config');
-    }
+    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.slashingProtection = new SlashingProtectionService(db, config);
+    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,
     });
   }
 
@@ -88,6 +121,9 @@ export class ValidatorHASigner {
     context: HAProtectedSigningContext,
     signFn: (messageHash: Buffer32) => Promise<Signature>,
   ): Promise<Signature> {
+    const startTime = this.dateProvider.now();
+    const dutyType = context.dutyType;
+
     let dutyIdentifier: DutyIdentifier;
     if (context.dutyType === DutyType.BLOCK_PROPOSAL) {
       dutyIdentifier = {
@@ -107,31 +143,56 @@ 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 });
+      this.metrics.recordSigningError(dutyType);
       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);
 
     return signature;
   }

package/dest/config.d.ts

@@ -1,101 +0,0 @@
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
-import { type ConfigMappingsType } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-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 declare const validatorHASignerConfigMappings: ConfigMappingsType<ValidatorHASignerConfig>;
-export declare const defaultValidatorHASignerConfig: ValidatorHASignerConfig;
-/**
- * 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 declare function getConfigEnvVars(): ValidatorHASignerConfig;
-export declare const ValidatorHASignerConfigSchema: z.ZodObject<{
-    haSigningEnabled: z.ZodBoolean;
-    l1Contracts: z.ZodObject<{
-        rollupAddress: z.ZodType<EthAddress, z.ZodTypeDef, EthAddress>;
-    }, "strip", z.ZodTypeAny, {
-        rollupAddress: EthAddress;
-    }, {
-        rollupAddress: EthAddress;
-    }>;
-    nodeId: z.ZodString;
-    pollingIntervalMs: z.ZodNumber;
-    signingTimeoutMs: z.ZodNumber;
-    maxStuckDutiesAgeMs: z.ZodOptional<z.ZodNumber>;
-    cleanupOldDutiesAfterHours: z.ZodOptional<z.ZodNumber>;
-    databaseUrl: z.ZodOptional<z.ZodString>;
-    poolMaxCount: z.ZodOptional<z.ZodNumber>;
-    poolMinCount: z.ZodOptional<z.ZodNumber>;
-    poolIdleTimeoutMs: z.ZodOptional<z.ZodNumber>;
-    poolConnectionTimeoutMs: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    haSigningEnabled: boolean;
-    l1Contracts: {
-        rollupAddress: EthAddress;
-    };
-    nodeId: string;
-    pollingIntervalMs: number;
-    signingTimeoutMs: number;
-    maxStuckDutiesAgeMs?: number | undefined;
-    cleanupOldDutiesAfterHours?: number | undefined;
-    databaseUrl?: string | undefined;
-    poolMaxCount?: number | undefined;
-    poolMinCount?: number | undefined;
-    poolIdleTimeoutMs?: number | undefined;
-    poolConnectionTimeoutMs?: number | undefined;
-}, {
-    haSigningEnabled: boolean;
-    l1Contracts: {
-        rollupAddress: EthAddress;
-    };
-    nodeId: string;
-    pollingIntervalMs: number;
-    signingTimeoutMs: number;
-    maxStuckDutiesAgeMs?: number | undefined;
-    cleanupOldDutiesAfterHours?: number | undefined;
-    databaseUrl?: string | undefined;
-    poolMaxCount?: number | undefined;
-    poolMinCount?: number | undefined;
-    poolIdleTimeoutMs?: number | undefined;
-    poolConnectionTimeoutMs?: number | undefined;
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDakYsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBTXhCLE1BQU0sMEJBQTBCLENBQUM7QUFDbEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRzNELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEI7Ozs7O0dBS0c7QUFDSCxNQUFNLFdBQVcsdUJBQXVCO0lBQ3RDLDBEQUEwRDtJQUMxRCxnQkFBZ0IsRUFBRSxPQUFPLENBQUM7SUFDMUIsc0RBQXNEO0lBQ3RELFdBQVcsRUFBRSxJQUFJLENBQUMsbUJBQW1CLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDeEQsc0NBQXNDO0lBQ3RDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZixzRUFBc0U7SUFDdEUsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO0lBQzFCLG9FQUFvRTtJQUNwRSxnQkFBZ0IsRUFBRSxNQUFNLENBQUM7SUFDekIsa0dBQWtHO0lBQ2xHLG1CQUFtQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzdCLGdGQUFnRjtJQUNoRiwwQkFBMEIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNwQzs7O09BR0c7SUFDSCxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckI7O09BRUc7SUFDSCwwREFBMEQ7SUFDMUQsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLHlEQUF5RDtJQUN6RCxZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsb0RBQW9EO0lBQ3BELGlCQUFpQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzNCLGtFQUFrRTtJQUNsRSx1QkFBdUIsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNsQztBQUVELGVBQU8sTUFBTSwrQkFBK0IsRUFBRSxrQkFBa0IsQ0FBQyx1QkFBdUIsQ0FpRXZGLENBQUM7QUFFRixlQUFPLE1BQU0sOEJBQThCLEVBQUUsdUJBRTVDLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLHVCQUF1QixDQUUxRDtBQUVELGVBQU8sTUFBTSw2QkFBNkI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFlRSxDQUFDIn0=

package/dest/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,0DAA0D;IAC1D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,sDAAsD;IACtD,WAAW,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC;IACxD,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,gBAAgB,EAAE,MAAM,CAAC;IACzB,kGAAkG;IAClG,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,gFAAgF;IAChF,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,eAAO,MAAM,+BAA+B,EAAE,kBAAkB,CAAC,uBAAuB,CAiEvF,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,uBAE5C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,uBAAuB,CAE1D;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAeE,CAAC"}

package/dest/config.js

@@ -1,92 +0,0 @@
-import { booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper } from '@aztec/foundation/config';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { z } from 'zod';
-export const validatorHASignerConfigMappings = {
-    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)=>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 = 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() {
-    return getConfigFromMappings(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()
-});

package/dest/db/in_memory.d.ts

@@ -1,20 +0,0 @@
-/**
- * In-memory implementation of SlashingProtectionDatabase for testing.
- * Used to simulate shared slashing protection in HA test setups without requiring PostgreSQL.
- */
-import type { SlotNumber } from '@aztec/foundation/branded-types';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { SlashingProtectionDatabase, TryInsertOrGetResult } from '../types.js';
-import type { CheckAndRecordParams, DutyType } from './types.js';
-/** In-memory slashing protection database for testing HA setups. */
-export declare class InMemorySlashingProtectionDatabase implements SlashingProtectionDatabase {
-    private duties;
-    tryInsertOrGetExisting(params: CheckAndRecordParams): Promise<TryInsertOrGetResult>;
-    updateDutySigned(rollupAddress: EthAddress, validatorAddress: EthAddress, slot: SlotNumber, dutyType: DutyType, signature: string, lockToken: string, blockIndexWithinCheckpoint: number): Promise<boolean>;
-    deleteDuty(rollupAddress: EthAddress, validatorAddress: EthAddress, slot: SlotNumber, dutyType: DutyType, lockToken: string, blockIndexWithinCheckpoint: number): Promise<boolean>;
-    cleanupOwnStuckDuties(_nodeId: string, _maxAgeMs: number): Promise<number>;
-    cleanupOutdatedRollupDuties(_currentRollupAddress: EthAddress): Promise<number>;
-    cleanupOldDuties(_maxAgeMs: number): Promise<number>;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5fbWVtb3J5LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGIvaW5fbWVtb3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE9BQU8sS0FBSyxFQUFlLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQy9FLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRWhFLE9BQU8sS0FBSyxFQUFFLDBCQUEwQixFQUFFLG9CQUFvQixFQUF1QixNQUFNLGFBQWEsQ0FBQztBQUN6RyxPQUFPLEtBQUssRUFBRSxvQkFBb0IsRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFjakUsb0VBQW9FO0FBQ3BFLHFCQUFhLGtDQUFtQyxZQUFXLDBCQUEwQjtJQUNuRixPQUFPLENBQUMsTUFBTSxDQUEwQztJQUV4RCxzQkFBc0IsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLEdBQUcsT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBeUJsRjtJQUVELGdCQUFnQixDQUNkLGFBQWEsRUFBRSxVQUFVLEVBQ3pCLGdCQUFnQixFQUFFLFVBQVUsRUFDNUIsSUFBSSxFQUFFLFVBQVUsRUFDaEIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsU0FBUyxFQUFFLE1BQU0sRUFDakIsU0FBUyxFQUFFLE1BQU0sRUFDakIsMEJBQTBCLEVBQUUsTUFBTSxHQUNqQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBVWxCO0lBRUQsVUFBVSxDQUNSLGFBQWEsRUFBRSxVQUFVLEVBQ3pCLGdCQUFnQixFQUFFLFVBQVUsRUFDNUIsSUFBSSxFQUFFLFVBQVUsRUFDaEIsUUFBUSxFQUFFLFFBQVEsRUFDbEIsU0FBUyxFQUFFLE1BQU0sRUFDakIsMEJBQTBCLEVBQUUsTUFBTSxHQUNqQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBUWxCO0lBRUQscUJBQXFCLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FFekU7SUFFRCwyQkFBMkIsQ0FBQyxxQkFBcUIsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUU5RTtJQUVELGdCQUFnQixDQUFDLFNBQVMsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUVuRDtJQUVELEtBQUssSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBR3JCO0NBQ0YifQ==

package/dest/db/in_memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in_memory.d.ts","sourceRoot":"","sources":["../../src/db/in_memory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,0BAA0B,EAAE,oBAAoB,EAAuB,MAAM,aAAa,CAAC;AACzG,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAcjE,oEAAoE;AACpE,qBAAa,kCAAmC,YAAW,0BAA0B;IACnF,OAAO,CAAC,MAAM,CAA0C;IAExD,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBlF;IAED,gBAAgB,CACd,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,UAAU,EAC5B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,0BAA0B,EAAE,MAAM,GACjC,OAAO,CAAC,OAAO,CAAC,CAUlB;IAED,UAAU,CACR,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,UAAU,EAC5B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EACjB,0BAA0B,EAAE,MAAM,GACjC,OAAO,CAAC,OAAO,CAAC,CAQlB;IAED,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEzE;IAED,2BAA2B,CAAC,qBAAqB,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAE9E;IAED,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnD;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAGrB;CACF"}

package/dest/db/in_memory.js

@@ -1,73 +0,0 @@
-/**
- * In-memory implementation of SlashingProtectionDatabase for testing.
- * Used to simulate shared slashing protection in HA test setups without requiring PostgreSQL.
- */ import { DutyStatus, getBlockIndexFromDutyIdentifier } from './types.js';
-/** Creates a unique key for a duty based on its identifying fields. */ function dutyKey(rollupAddress, validatorAddress, slot, dutyType, blockIndexWithinCheckpoint) {
-    return `${rollupAddress}:${validatorAddress}:${slot}:${dutyType}:${blockIndexWithinCheckpoint}`;
-}
-/** In-memory slashing protection database for testing HA setups. */ export class InMemorySlashingProtectionDatabase {
-    duties = new Map();
-    tryInsertOrGetExisting(params) {
-        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 = {
-            rollupAddress: params.rollupAddress,
-            validatorAddress: params.validatorAddress,
-            slot: params.slot,
-            blockNumber: params.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, validatorAddress, slot, dutyType, signature, lockToken, blockIndexWithinCheckpoint) {
-        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, validatorAddress, slot, dutyType, lockToken, blockIndexWithinCheckpoint) {
-        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, _maxAgeMs) {
-        return Promise.resolve(0);
-    }
-    cleanupOutdatedRollupDuties(_currentRollupAddress) {
-        return Promise.resolve(0);
-    }
-    cleanupOldDuties(_maxAgeMs) {
-        return Promise.resolve(0);
-    }
-    close() {
-        this.duties.clear();
-        return Promise.resolve();
-    }
-}