dubs-server 1.0.0

package/services/keeperStateService.js

@@ -0,0 +1,355 @@
+/**
+ * Keeper State Service
+ * 
+ * Manages keeper state in PostgreSQL for:
+ * - Round lifecycle tracking
+ * - Recovery after crashes
+ * - Multi-keeper coordination
+ * - Monitoring and alerting
+ * 
+ * NOTE: Gracefully degrades to no-op when DATABASE_URL is not set (local dev)
+ */
+
+const { pool } = require('./db'); // Shared database pool
+
+class KeeperStateService {
+  constructor() {
+    // Check if database is configured
+    this.enabled = !!process.env.DATABASE_URL;
+    
+    if (this.enabled) {
+      // Use shared pool from services/db.js
+      this.pool = pool;
+      console.log('📊 Keeper state service: Database enabled');
+    } else {
+      console.log('⚠️  Keeper state service: No DATABASE_URL set - running without state persistence (local dev mode)');
+      this.pool = null;
+    }
+  }
+  
+  // Helper to check if DB operations should run
+  _shouldRun() {
+    return this.enabled && this.pool;
+  }
+
+  /**
+   * Initialize a new round in the database
+   */
+  async createRound(roundId, initialStatus = 'open') {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query(
+        `INSERT INTO keeper_rounds (round_id, status) 
+         VALUES ($1, $2) 
+         ON CONFLICT (round_id) DO NOTHING
+         RETURNING *`,
+        [roundId, initialStatus]
+      );
+      console.log(`📝 Created round ${roundId} in DB with status: ${initialStatus}`);
+      return result.rows[0];
+    } catch (error) {
+      console.error(`❌ Failed to create round ${roundId}:`, error.message);
+      return null; // Don't throw - allow keeper to continue
+    }
+  }
+
+  /**
+   * Get round state from database
+   */
+  async getRound(roundId) {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query(
+        'SELECT * FROM keeper_rounds WHERE round_id = $1',
+        [roundId]
+      );
+      return result.rows[0] || null;
+    } catch (error) {
+      console.error(`❌ Failed to get round ${roundId}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Update round status and metadata
+   */
+  async updateRound(roundId, updates) {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const fields = [];
+      const values = [roundId];
+      let paramIndex = 2;
+
+      // Build dynamic UPDATE query
+      if (updates.status) {
+        fields.push(`status = $${paramIndex++}`);
+        values.push(updates.status);
+      }
+      if (updates.locked_at) {
+        fields.push(`locked_at = $${paramIndex++}`);
+        values.push(updates.locked_at);
+      }
+      if (updates.revealed_at) {
+        fields.push(`revealed_at = $${paramIndex++}`);
+        values.push(updates.revealed_at);
+      }
+      if (updates.resolved_at) {
+        fields.push(`resolved_at = $${paramIndex++}`);
+        values.push(updates.resolved_at);
+      }
+      if (updates.reset_at) {
+        fields.push(`reset_at = $${paramIndex++}`);
+        values.push(updates.reset_at);
+      }
+      if (updates.retry_count !== undefined) {
+        fields.push(`retry_count = $${paramIndex++}`);
+        values.push(updates.retry_count);
+      }
+      if (updates.last_error !== undefined) {
+        fields.push(`last_error = $${paramIndex++}`);
+        values.push(updates.last_error);
+      }
+      if (updates.last_attempt_at) {
+        fields.push(`last_attempt_at = $${paramIndex++}`);
+        values.push(updates.last_attempt_at);
+      }
+      if (updates.total_pot !== undefined) {
+        fields.push(`total_pot = $${paramIndex++}`);
+        values.push(updates.total_pot);
+      }
+      if (updates.entry_count !== undefined) {
+        fields.push(`entry_count = $${paramIndex++}`);
+        values.push(updates.entry_count);
+      }
+      if (updates.winner_pubkey) {
+        fields.push(`winner_pubkey = $${paramIndex++}`);
+        values.push(updates.winner_pubkey);
+      }
+      if (updates.win_amount !== undefined) {
+        fields.push(`win_amount = $${paramIndex++}`);
+        values.push(updates.win_amount);
+      }
+      if (updates.lock_signature) {
+        fields.push(`lock_signature = $${paramIndex++}`);
+        values.push(updates.lock_signature);
+      }
+      if (updates.reveal_signature) {
+        fields.push(`reveal_signature = $${paramIndex++}`);
+        values.push(updates.reveal_signature);
+      }
+      if (updates.resolve_signature) {
+        fields.push(`resolve_signature = $${paramIndex++}`);
+        values.push(updates.resolve_signature);
+      }
+      if (updates.reset_signature) {
+        fields.push(`reset_signature = $${paramIndex++}`);
+        values.push(updates.reset_signature);
+      }
+
+      if (fields.length === 0) {
+        console.warn(`⚠️ No fields to update for round ${roundId}`);
+        return null;
+      }
+
+      const query = `
+        UPDATE keeper_rounds 
+        SET ${fields.join(', ')}
+        WHERE round_id = $1
+        RETURNING *
+      `;
+
+      const result = await this.pool.query(query, values);
+      return result.rows[0];
+    } catch (error) {
+      console.error(`❌ Failed to update round ${roundId}:`, error.message);
+      return null; // Don't throw - allow keeper to continue
+    }
+  }
+
+  /**
+   * Log a keeper action for debugging
+   */
+  async logAction(roundId, action, success, errorMessage = null, signature = null, durationMs = null) {
+    if (!this._shouldRun()) return;
+    
+    try {
+      await this.pool.query(
+        `INSERT INTO keeper_actions (round_id, action, success, error_message, signature, duration_ms)
+         VALUES ($1, $2, $3, $4, $5, $6)`,
+        [roundId, action, success, errorMessage, signature, durationMs]
+      );
+    } catch (error) {
+      // Don't throw - logging failures shouldn't break the keeper
+      console.error(`⚠️ Failed to log action:`, error.message);
+    }
+  }
+
+  /**
+   * Find rounds that are stuck (not completed after 5 minutes)
+   */
+  async getStuckRounds() {
+    if (!this._shouldRun()) return [];
+    
+    try {
+      const result = await this.pool.query(
+        `SELECT * FROM stuck_rounds`
+      );
+      return result.rows;
+    } catch (error) {
+      console.error(`❌ Failed to get stuck rounds:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Get the current round that needs processing
+   * Returns the round with highest round_id that's not resolved
+   */
+  async getCurrentActiveRound() {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query(
+        `SELECT * FROM keeper_rounds 
+         WHERE status != 'resolved' 
+         ORDER BY round_id DESC 
+         LIMIT 1`
+      );
+      return result.rows[0] || null;
+    } catch (error) {
+      console.error(`❌ Failed to get active round:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Increment retry count for a round
+   */
+  async incrementRetry(roundId, errorMessage) {
+    if (!this._shouldRun()) return;
+    
+    try {
+      await this.pool.query(
+        `UPDATE keeper_rounds 
+         SET retry_count = retry_count + 1,
+             last_error = $2,
+             last_attempt_at = NOW()
+         WHERE round_id = $1`,
+        [roundId, errorMessage]
+      );
+    } catch (error) {
+      console.error(`❌ Failed to increment retry:`, error.message);
+    }
+  }
+
+  /**
+   * Get health summary
+   */
+  async getHealthSummary() {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query('SELECT * FROM keeper_health_summary');
+      return result.rows[0];
+    } catch (error) {
+      console.error(`❌ Failed to get health summary:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Record health check
+   */
+  async recordHealth(metrics) {
+    if (!this._shouldRun()) return;
+    
+    try {
+      await this.pool.query(
+        `INSERT INTO keeper_health (rounds_completed, consecutive_failures, last_success_round, last_error, uptime_seconds)
+         VALUES ($1, $2, $3, $4, $5)`,
+        [
+          metrics.roundsCompleted,
+          metrics.consecutiveFailures,
+          metrics.lastSuccessRound,
+          metrics.lastError,
+          metrics.uptimeSeconds
+        ]
+      );
+    } catch (error) {
+      console.error(`⚠️ Failed to record health:`, error.message);
+    }
+  }
+
+  /**
+   * Clean up old action logs (keep last 1000 or last 7 days)
+   */
+  async cleanupOldLogs() {
+    if (!this._shouldRun()) return;
+    
+    try {
+      await this.pool.query(
+        `DELETE FROM keeper_actions 
+         WHERE id NOT IN (
+           SELECT id FROM keeper_actions 
+           ORDER BY timestamp DESC 
+           LIMIT 1000
+         )
+         AND timestamp < NOW() - INTERVAL '7 days'`
+      );
+    } catch (error) {
+      console.error(`⚠️ Failed to cleanup logs:`, error.message);
+    }
+  }
+
+  /**
+   * Get recent actions for a round
+   */
+  async getRoundActions(roundId, limit = 20) {
+    if (!this._shouldRun()) return [];
+    
+    try {
+      const result = await this.pool.query(
+        `SELECT * FROM keeper_actions 
+         WHERE round_id = $1 
+         ORDER BY timestamp DESC 
+         LIMIT $2`,
+        [roundId, limit]
+      );
+      return result.rows;
+    } catch (error) {
+      console.error(`❌ Failed to get round actions:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Check if round is stuck (based on status and last update time)
+   */
+  isRoundStuck(dbRound) {
+    if (!dbRound) return false;
+    
+    const stuckStatuses = ['locking', 'revealing', 'resolving', 'resetting'];
+    if (!stuckStatuses.includes(dbRound.status)) return false;
+    
+    const updatedAt = new Date(dbRound.updated_at);
+    const now = new Date();
+    const minutesStuck = (now - updatedAt) / 1000 / 60;
+    
+    return minutesStuck > 5; // Stuck if no update in 5 minutes
+  }
+
+  /**
+   * Close database connection
+   */
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+    }
+  }
+}
+
+module.exports = KeeperStateService;
+