@aztec-labs/validator-ha-signer 6.0.0-nightly.20260829

package/README.md

@@ -0,0 +1,195 @@
+# Validator HA Signer
+
+Distributed locking and slashing protection for Aztec validators running in high-availability configurations.
+
+## Features
+
+- **Distributed Locking**: Prevents multiple validator nodes from signing the same duty
+- **Slashing Protection**: Blocks attempts to sign conflicting data for the same slot
+- **Automatic Retry**: Failed signing attempts are cleared, allowing other nodes to retry
+- **PostgreSQL Backend**: Shared database for coordination across nodes
+
+## Integration with Validator Client
+
+The HA signer is automatically integrated into the validator client when `VALIDATOR_HA_SIGNING_ENABLED=true` is set. The validator client will:
+
+1. Create the HA signer using `createHASigner()` from the factory
+2. Wrap the base keystore with `HAKeyStore` to provide HA-protected signing
+3. Automatically start/stop the signer lifecycle
+
+No manual integration is required when using the validator client.
+
+## Manual Usage
+
+For advanced use cases or testing, you can use the HA signer directly. **Note**: Database migrations must be run separately before creating the signer (see [Database Migrations](#database-migrations) below).
+
+### Basic Usage
+
+```bash
+# 1. Run migrations separately (once per deployment)
+aztec migrate-ha-db up --database-url postgresql://user:pass@host:port/db
+```
+
+```typescript
+// 2. Create signer (migrations already applied)
+import { createHASigner } from '@aztec-labs/validator-ha-signer/factory';
+
+const { signer, db } = await createHASigner({
+  databaseUrl: process.env.DATABASE_URL,
+  nodeId: 'validator-node-1',
+  pollingIntervalMs: 100,
+  peerSigningTimeoutMs: 3000,
+});
+
+// Start background cleanup tasks
+signer.start();
+
+// Sign with protection
+const signature = await signer.signWithProtection(
+  validatorAddress,
+  messageHash,
+  { slot: 100n, blockNumber: 50n, blockIndexWithinCheckpoint: 0, dutyType: 'BLOCK_PROPOSAL' },
+  async root => localSigner.signMessage(root),
+);
+
+// On shutdown
+await signer.stop();
+await db.close();
+```
+
+### Advanced: Custom Connection Pool
+
+If you need custom pool configuration (e.g., max connections, idle timeout) or want to share a connection pool across multiple components:
+
+> **Note**: You still need to run migrations separately before using this approach.
+> See [Database Migrations](#database-migrations) below.
+
+```typescript
+import { PostgresSlashingProtectionDatabase } from '@aztec-labs/validator-ha-signer/db';
+import { ValidatorHASigner } from '@aztec-labs/validator-ha-signer/validator-ha-signer';
+
+import { Pool } from 'pg';
+
+// Custom pool configuration
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 20, // Maximum connections
+  idleTimeoutMillis: 30000,
+});
+const db = new PostgresSlashingProtectionDatabase(pool);
+await db.initialize();
+
+const signer = new ValidatorHASigner(db, {
+  nodeId: 'validator-node-1',
+  pollingIntervalMs: 100,
+  peerSigningTimeoutMs: 3000,
+  maxStuckDutiesAgeMs: 144000,
+});
+
+// Start background cleanup tasks
+signer.start();
+
+// On shutdown
+await signer.stop();
+await pool.end(); // You manage the pool lifecycle
+```
+
+## Configuration
+
+Set via environment variables or config object:
+
+- `VALIDATOR_HA_DATABASE_URL`: PostgreSQL connection string (e.g., `postgresql://user:pass@host:port/db`)
+- `VALIDATOR_HA_SIGNING_ENABLED`: Whether HA signing / slashing protection is enabled (default: false)
+- `VALIDATOR_HA_NODE_ID`: Unique identifier for this validator node (required when enabled)
+- `VALIDATOR_HA_POLLING_INTERVAL_MS`: How often to check duty status (default: 100)
+- `VALIDATOR_HA_SIGNING_TIMEOUT_MS`: Max wait for in-progress signing (default: 3000)
+- `VALIDATOR_HA_MAX_STUCK_DUTIES_AGE_MS`: Max age of stuck duties before cleanup (default: 2 \* aztecSlotDuration)
+- `VALIDATOR_HA_POOL_MAX`: Maximum number of connections in the pool (default: 10)
+- `VALIDATOR_HA_POOL_MIN`: Minimum number of connections in the pool (default: 0)
+- `VALIDATOR_HA_POOL_IDLE_TIMEOUT_MS`: Idle timeout for pool connections (default: 10000)
+- `VALIDATOR_HA_POOL_CONNECTION_TIMEOUT_MS`: Connection timeout (default: 0, no timeout)
+
+## Database Migrations
+
+This package uses `node-pg-migrate` for database schema management.
+
+### Migration Commands
+
+```bash
+# Run pending migrations
+aztec migrate-ha-db up --database-url postgresql://...
+
+# Rollback last migration
+aztec migrate-ha-db down --database-url postgresql://...
+```
+
+### Creating New Migrations
+
+```bash
+# Generate a new migration file
+npx node-pg-migrate create my-migration-name
+```
+
+### Production Deployment
+
+Run migrations before starting your application:
+
+```yaml
+# Kubernetes example
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: validator-db-migrate
+spec:
+  template:
+    spec:
+      containers:
+        - name: migrate
+          image: azteclabs/aztec:<image_tag>
+          command: ['node', '--no-warnings', '/usr/src/yarn-project/aztec/dest/bin/index.js', 'migrate-ha-db', 'up']
+          env:
+            - name: DATABASE_URL
+              valueFrom:
+                secretKeyRef:
+                  name: db-secret
+                  key: url
+      restartPolicy: OnFailure
+```
+
+## How It Works
+
+When multiple validator nodes attempt to sign:
+
+1. First node acquires lock and signs
+2. Other nodes receive `DutyAlreadySignedError` (expected)
+3. If different data detected: `SlashingProtectionError` (prevents slashing)
+4. Failed attempts are auto-cleaned, allowing retry
+
+### Signing Context
+
+All signing operations require a `SigningContext` that includes:
+
+- `slot`: The slot number
+- `blockNumber`: The block number within the checkpoint
+- `blockIndexWithinCheckpoint`: The index of the block within the checkpoint (use `-1` for N/A contexts)
+- `dutyType`: The type of duty (e.g., `BLOCK_PROPOSAL`, `CHECKPOINT_ATTESTATION`, `AUTH_REQUEST`)
+
+Note: `AUTH_REQUEST` duties bypass HA protection since signing multiple times is safe for authentication requests.
+
+## Important Limitations
+
+### Database Isolation Per Rollup Version
+
+**You cannot use the same database to provide slashing protection for validator nodes running on different rollup versions** (e.g., current rollup and old rollup simultaneously).
+
+When the HA signer performs background cleanup via `cleanupOutdatedRollupDuties()`, it removes all duties where the rollup address doesn't match the current rollup address. If two validators running on different rollup versions share the same database, they will delete each other's duties during cleanup.
+
+**Solution**: Use separate databases for validators running on different rollup versions. Each rollup version requires its own isolated slashing protection database.
+
+## Development
+
+```bash
+yarn build    # Build package
+yarn test     # Run tests
+yarn clean    # Clean build artifacts
+```

package/dest/db/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './schema.js';
+export * from './postgres.js';
+export * from './lmdb.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC"}

package/dest/db/index.js

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

package/dest/db/lmdb.d.ts

@@ -0,0 +1,70 @@
+/**
+ * LMDB implementation of SlashingProtectionDatabase
+ *
+ * Provides local (single-node) double-signing protection using LMDB as the backend.
+ * Suitable for nodes that do NOT run in a high-availability multi-node setup.
+ *
+ * The LMDB store is single-writer, making setIfNotExists inherently atomic.
+ * This means we get crash-restart protection without needing an external database.
+ */
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { SlashingProtectionDatabase, TryInsertOrGetResult } from '../types.js';
+import { type CheckAndRecordParams, DutyType } from './types.js';
+/**
+ * Migrates local slashing-protection duties from schema 1 to schema 2.
+ */
+export declare function migrateLmdbSlashingProtectionDatabase(dataDirectory: string, currentVersion: number, latestVersion: number, dbMapSizeKb?: number): Promise<void>;
+/**
+ * LMDB-backed implementation of SlashingProtectionDatabase.
+ *
+ * Provides single-node double-signing protection that survives crashes and restarts.
+ * Does not provide cross-node coordination (that requires the PostgreSQL implementation).
+ */
+export declare class LmdbSlashingProtectionDatabase implements SlashingProtectionDatabase {
+    private readonly store;
+    private readonly dateProvider;
+    static readonly SCHEMA_VERSION = 2;
+    private readonly duties;
+    private readonly log;
+    constructor(store: AztecAsyncKVStore, dateProvider: DateProvider);
+    /**
+     * Atomically try to insert a new duty record, or get the existing one if present.
+     *
+     * LMDB is single-writer so the read-then-write inside transactionAsync is naturally atomic.
+     */
+    tryInsertOrGetExisting(params: CheckAndRecordParams): Promise<TryInsertOrGetResult>;
+    /**
+     * Update a duty to 'signed' status with the signature.
+     * Only succeeds if the lockToken matches.
+     */
+    updateDutySigned(rollupAddress: EthAddress, validatorAddress: EthAddress, slot: SlotNumber, dutyType: DutyType, signature: string, lockToken: string, blockIndexWithinCheckpoint: number): Promise<boolean>;
+    /**
+     * Delete a duty record.
+     * Only succeeds if the lockToken matches.
+     */
+    deleteDuty(rollupAddress: EthAddress, validatorAddress: EthAddress, slot: SlotNumber, dutyType: DutyType, lockToken: string, blockIndexWithinCheckpoint: number): Promise<boolean>;
+    /**
+     * Cleanup own stuck duties (SIGNING status older than maxAgeMs).
+     */
+    cleanupOwnStuckDuties(nodeId: string, maxAgeMs: number): Promise<number>;
+    /**
+     * Cleanup duties with outdated rollup address.
+     *
+     * This is always a no-op for the LMDB implementation: the underlying store is created via
+     * DatabaseVersionManager (in factory.ts), which already resets the entire data directory at
+     * startup whenever the rollup address changes.
+     */
+    cleanupOutdatedRollupDuties(_currentRollupAddress: EthAddress): Promise<number>;
+    /**
+     * Cleanup old signed duties older than maxAgeMs.
+     */
+    cleanupOldDuties(maxAgeMs: number): Promise<number>;
+    /**
+     * Close the underlying LMDB store.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"lmdb.d.ts","sourceRoot":"","sources":["../../src/db/lmdb.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAElE,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,sBAAsB,CAAC;AAG7E,OAAO,KAAK,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACpF,OAAO,EACL,KAAK,oBAAoB,EAEzB,QAAQ,EAIT,MAAM,YAAY,CAAC;AAYpB;;GAEG;AACH,wBAAsB,qCAAqC,CACzD,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAYD;;;;;GAKG;AACH,qBAAa,8BAA+B,YAAW,0BAA0B;IAO7E,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAP/B,gBAAuB,cAAc,KAAK;IAE1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IACjE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,KAAK,EAAE,iBAAiB,EACxB,YAAY,EAAE,YAAY,EAI5C;IAED;;;;OAIG;IACU,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA6C/F;IAED;;;OAGG;IACI,gBAAgB,CACrB,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,CA0ClB;IAED;;;OAGG;IACI,UAAU,CACf,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,CAyBlB;IAED;;OAEG;IACI,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAe9E;IAED;;;;;;OAMG;IACI,2BAA2B,CAAC,qBAAqB,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAErF;IAED;;OAEG;IACI,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBzD;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAGlC;CACF"}

package/dest/db/lmdb.js

@@ -0,0 +1,223 @@
+/**
+ * LMDB implementation of SlashingProtectionDatabase
+ *
+ * Provides local (single-node) double-signing protection using LMDB as the backend.
+ * Suitable for nodes that do NOT run in a high-availability multi-node setup.
+ *
+ * The LMDB store is single-writer, making setIfNotExists inherently atomic.
+ * This means we get crash-restart protection without needing an external database.
+ */ import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { openStoreAt } from '@aztec-labs/kv-store/lmdb-v2';
+import { DutyStatus, getBlockIndexFromDutyIdentifier, recordFromFields } from './types.js';
+const DUTIES_MAP_NAME = 'signing-protection-duties';
+const LEGACY_CHECKPOINT_NUMBER = '0';
+function needsCheckpointNumberMigration(record) {
+    return record.checkpointNumber === undefined;
+}
+/**
+ * Migrates local slashing-protection duties from schema 1 to schema 2.
+ */ export async function migrateLmdbSlashingProtectionDatabase(dataDirectory, currentVersion, latestVersion, dbMapSizeKb) {
+    if (currentVersion !== 1 || latestVersion !== LmdbSlashingProtectionDatabase.SCHEMA_VERSION) {
+        throw new Error(`Unsupported LMDB slashing-protection migration ${currentVersion} -> ${latestVersion}`);
+    }
+    const store = await openStoreAt(dataDirectory, dbMapSizeKb);
+    try {
+        const duties = store.openMap(DUTIES_MAP_NAME);
+        const migratedRecords = [];
+        for await (const [key, record] of duties.entriesAsync()){
+            if (needsCheckpointNumberMigration(record)) {
+                migratedRecords.push({
+                    key,
+                    value: {
+                        ...record,
+                        checkpointNumber: LEGACY_CHECKPOINT_NUMBER
+                    }
+                });
+            }
+        }
+        if (migratedRecords.length > 0) {
+            await duties.setMany(migratedRecords);
+        }
+    } finally{
+        await store.close();
+    }
+}
+function dutyKey(rollupAddress, validatorAddress, slot, dutyType, blockIndexWithinCheckpoint) {
+    return `${rollupAddress}:${validatorAddress}:${slot}:${dutyType}:${blockIndexWithinCheckpoint}`;
+}
+/**
+ * LMDB-backed implementation of SlashingProtectionDatabase.
+ *
+ * Provides single-node double-signing protection that survives crashes and restarts.
+ * Does not provide cross-node coordination (that requires the PostgreSQL implementation).
+ */ export class LmdbSlashingProtectionDatabase {
+    store;
+    dateProvider;
+    static SCHEMA_VERSION = 2;
+    duties;
+    log;
+    constructor(store, dateProvider){
+        this.store = store;
+        this.dateProvider = dateProvider;
+        this.log = createLogger('slashing-protection:lmdb');
+        this.duties = store.openMap(DUTIES_MAP_NAME);
+    }
+    /**
+   * Atomically try to insert a new duty record, or get the existing one if present.
+   *
+   * LMDB is single-writer so the read-then-write inside transactionAsync is naturally atomic.
+   */ async tryInsertOrGetExisting(params) {
+        const blockIndexWithinCheckpoint = getBlockIndexFromDutyIdentifier(params);
+        const key = dutyKey(params.rollupAddress.toString(), params.validatorAddress.toString(), params.slot.toString(), params.dutyType, blockIndexWithinCheckpoint);
+        const lockToken = randomBytes(16).toString('hex');
+        const now = this.dateProvider.now();
+        const result = await this.store.transactionAsync(async ()=>{
+            const existing = await this.duties.getAsync(key);
+            if (existing) {
+                return {
+                    isNew: false,
+                    record: {
+                        ...existing,
+                        lockToken: ''
+                    }
+                };
+            }
+            const newRecord = {
+                rollupAddress: params.rollupAddress.toString(),
+                validatorAddress: params.validatorAddress.toString(),
+                slot: params.slot.toString(),
+                blockNumber: params.blockNumber.toString(),
+                checkpointNumber: params.checkpointNumber.toString(),
+                blockIndexWithinCheckpoint,
+                dutyType: params.dutyType,
+                status: DutyStatus.SIGNING,
+                messageHash: params.messageHash,
+                nodeId: params.nodeId,
+                lockToken,
+                startedAtMs: now
+            };
+            await this.duties.set(key, newRecord);
+            return {
+                isNew: true,
+                record: newRecord
+            };
+        });
+        if (result.isNew) {
+            this.log.debug(`Acquired lock for duty ${params.dutyType} at slot ${params.slot}`, {
+                validatorAddress: params.validatorAddress.toString(),
+                nodeId: params.nodeId
+            });
+        }
+        return {
+            isNew: result.isNew,
+            record: recordFromFields(result.record)
+        };
+    }
+    /**
+   * Update a duty to 'signed' status with the signature.
+   * Only succeeds if the lockToken matches.
+   */ updateDutySigned(rollupAddress, validatorAddress, slot, dutyType, signature, lockToken, blockIndexWithinCheckpoint) {
+        const key = dutyKey(rollupAddress.toString(), validatorAddress.toString(), slot.toString(), dutyType, blockIndexWithinCheckpoint);
+        return this.store.transactionAsync(async ()=>{
+            const existing = await this.duties.getAsync(key);
+            if (!existing) {
+                this.log.warn('Failed to update duty to signed: duty not found', {
+                    rollupAddress: rollupAddress.toString(),
+                    validatorAddress: validatorAddress.toString(),
+                    slot: slot.toString(),
+                    dutyType,
+                    blockIndexWithinCheckpoint
+                });
+                return false;
+            }
+            if (existing.lockToken !== lockToken) {
+                this.log.warn('Failed to update duty to signed: invalid token', {
+                    rollupAddress: rollupAddress.toString(),
+                    validatorAddress: validatorAddress.toString(),
+                    slot: slot.toString(),
+                    dutyType,
+                    blockIndexWithinCheckpoint
+                });
+                return false;
+            }
+            await this.duties.set(key, {
+                ...existing,
+                status: DutyStatus.SIGNED,
+                signature,
+                completedAtMs: this.dateProvider.now()
+            });
+            return true;
+        });
+    }
+    /**
+   * Delete a duty record.
+   * Only succeeds if the lockToken matches.
+   */ deleteDuty(rollupAddress, validatorAddress, slot, dutyType, lockToken, blockIndexWithinCheckpoint) {
+        const key = dutyKey(rollupAddress.toString(), validatorAddress.toString(), slot.toString(), dutyType, blockIndexWithinCheckpoint);
+        return this.store.transactionAsync(async ()=>{
+            const existing = await this.duties.getAsync(key);
+            if (!existing || existing.lockToken !== lockToken) {
+                this.log.warn('Failed to delete duty: invalid token or duty not found', {
+                    rollupAddress: rollupAddress.toString(),
+                    validatorAddress: validatorAddress.toString(),
+                    slot: slot.toString(),
+                    dutyType,
+                    blockIndexWithinCheckpoint
+                });
+                return false;
+            }
+            await this.duties.delete(key);
+            return true;
+        });
+    }
+    /**
+   * Cleanup own stuck duties (SIGNING status older than maxAgeMs).
+   */ cleanupOwnStuckDuties(nodeId, maxAgeMs) {
+        const cutoffMs = this.dateProvider.now() - maxAgeMs;
+        return this.store.transactionAsync(async ()=>{
+            const keysToDelete = [];
+            for await (const [key, record] of this.duties.entriesAsync()){
+                if (record.nodeId === nodeId && record.status === DutyStatus.SIGNING && record.startedAtMs < cutoffMs) {
+                    keysToDelete.push(key);
+                }
+            }
+            for (const key of keysToDelete){
+                await this.duties.delete(key);
+            }
+            return keysToDelete.length;
+        });
+    }
+    /**
+   * Cleanup duties with outdated rollup address.
+   *
+   * This is always a no-op for the LMDB implementation: the underlying store is created via
+   * DatabaseVersionManager (in factory.ts), which already resets the entire data directory at
+   * startup whenever the rollup address changes.
+   */ cleanupOutdatedRollupDuties(_currentRollupAddress) {
+        return Promise.resolve(0);
+    }
+    /**
+   * Cleanup old signed duties older than maxAgeMs.
+   */ cleanupOldDuties(maxAgeMs) {
+        const cutoffMs = this.dateProvider.now() - maxAgeMs;
+        return this.store.transactionAsync(async ()=>{
+            const keysToDelete = [];
+            for await (const [key, record] of this.duties.entriesAsync()){
+                if (record.status === DutyStatus.SIGNED && record.completedAtMs !== undefined && record.completedAtMs < cutoffMs) {
+                    keysToDelete.push(key);
+                }
+            }
+            for (const key of keysToDelete){
+                await this.duties.delete(key);
+            }
+            return keysToDelete.length;
+        });
+    }
+    /**
+   * Close the underlying LMDB store.
+   */ async close() {
+        await this.store.close();
+        this.log.debug('LMDB slashing protection database closed');
+    }
+}

package/dest/db/migrations/1_initial-schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Initial schema for validator HA slashing protection
+ *
+ * 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';
+export declare function up(pgm: MigrationBuilder): void;
+export declare function down(pgm: MigrationBuilder): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMV9pbml0aWFsLXNjaGVtYS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RiL21pZ3JhdGlvbnMvMV9pbml0aWFsLXNjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBaUN4RCx3QkFBZ0IsRUFBRSxDQUFDLEdBQUcsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLENBVzlDO0FBRUQsd0JBQWdCLElBQUksQ0FBQyxHQUFHLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSSxDQUdoRCJ9

package/dest/db/migrations/1_initial-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_initial-schema.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/1_initial-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAiCxD,wBAAgB,EAAE,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAW9C;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAGhD"}

package/dest/db/migrations/1_initial-schema.js

@@ -0,0 +1,50 @@
+/**
+ * Initial schema for validator HA slashing protection
+ *
+ * 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 { 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);`
+];
+export function up(pgm) {
+    for (const statement of INITIAL_SCHEMA_SETUP){
+        pgm.sql(statement);
+    }
+    // Insert initial schema version
+    pgm.sql(`
+    INSERT INTO schema_version (version)
+    VALUES (1)
+    ON CONFLICT (version) DO NOTHING;
+  `);
+}
+export function down(pgm) {
+    pgm.sql(DROP_VALIDATOR_DUTIES_TABLE);
+    pgm.sql(DROP_SCHEMA_VERSION_TABLE);
+}

package/dest/db/migrations/2_add-checkpoint-number.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Add checkpoint_number column to validator_duties table
+ */
+import type { MigrationBuilder } from 'node-pg-migrate';
+export declare function up(pgm: MigrationBuilder): void;
+export declare function down(pgm: MigrationBuilder): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMl9hZGQtY2hlY2twb2ludC1udW1iZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kYi9taWdyYXRpb25zLzJfYWRkLWNoZWNrcG9pbnQtbnVtYmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV4RCx3QkFBZ0IsRUFBRSxDQUFDLEdBQUcsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLENBTzlDO0FBRUQsd0JBQWdCLElBQUksQ0FBQyxHQUFHLEVBQUUsZ0JBQWdCLEdBQUcsSUFBSSxDQUloRCJ9

package/dest/db/migrations/2_add-checkpoint-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"2_add-checkpoint-number.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/2_add-checkpoint-number.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,wBAAgB,EAAE,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAO9C;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAIhD"}

package/dest/db/migrations/2_add-checkpoint-number.js

@@ -0,0 +1,17 @@
+/**
+ * Add checkpoint_number column to validator_duties table
+ */ export function up(pgm) {
+    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) {
+    pgm.dropColumn('validator_duties', 'checkpoint_number');
+    pgm.sql(`UPDATE schema_version SET version = 1 WHERE version = 2`);
+}