dubs-server 1.0.0

package/scripts/jackpot/keeper.js

@@ -0,0 +1,742 @@
+#!/usr/bin/env node
+
+/**
+ * 🤖 Complete Jackpot Keeper Bot
+ * 
+ * Manages full round lifecycle:
+ * 1. Lock round when timer expires
+ * 2. Submit oracle randomness
+ * 3. Resolve and pay winner
+ * 4. Open new round
+ */
+
+const { Connection, Keypair, Transaction, PublicKey } = require('@solana/web3.js');
+const axios = require('axios');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { instance: historyInstance } = require('../../services/jackpotHistory');
+const KeeperStateService = require('../../services/keeperStateService');
+
+const RPC_URL = process.env.SOLANA_RPC_URL || process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+const API_BASE = process.env.API_BASE_URL || 'http://localhost:3001';
+
+class JackpotKeeper {
+  constructor(io = null) {
+    this.connection = new Connection(RPC_URL, 'confirmed');
+    this.history = historyInstance; // Use shared singleton instance
+    this.state = new KeeperStateService();
+    this.programId = new PublicKey(process.env.JACKPOT_PROGRAM_ID || 'BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+    this.startTime = Date.now();
+    this.roundsCompleted = 0;
+    this.consecutiveFailures = 0;
+    this.io = io; // WebSocket server instance
+    this.lastEntryCount = {}; // Track entry count per round for change detection
+    this.vrfDataPath = path.join(__dirname, '..', '..', '.vrf-data.json'); // Persists VRF seeds across restarts
+    
+    // Load wallet - Priority: ENV var > oracle wallet file > main wallet file
+    let secretKey;
+    
+    if (process.env.KEEPER_PRIVATE_KEY) {
+      // For Heroku - use environment variable
+      console.log('📂 Using wallet from KEEPER_PRIVATE_KEY environment variable');
+      secretKey = JSON.parse(process.env.KEEPER_PRIVATE_KEY);
+    } else {
+      // For local development - use wallet files
+      let walletPath;
+      const oracleWalletPath = path.join(__dirname, '..', '..', 'wallets', 'jackpot_oracle.json');
+    const mainWalletPath = path.join(require('os').homedir(), '.config/solana/id.json');
+      
+      if (fs.existsSync(oracleWalletPath)) {
+        walletPath = oracleWalletPath;
+        console.log('📂 Using oracle wallet from wallets directory');
+      } else if (fs.existsSync(mainWalletPath)) {
+        walletPath = mainWalletPath;
+        console.log('📂 Using main wallet from home directory');
+      } else {
+        throw new Error('❌ No wallet found! Set KEEPER_PRIVATE_KEY env var or add wallet file');
+      }
+      
+      secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+    }
+    
+    this.wallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    
+    console.log('🤖 Complete Jackpot Keeper Bot');
+    console.log('   RPC:', RPC_URL.includes('devnet') ? 'Devnet' : RPC_URL.slice(0, 40) + '...');
+    console.log('   Program:', this.programId.toString());
+    console.log('   Wallet:', this.wallet.publicKey.toString());
+    console.log();
+  }
+
+  // Persist VRF data to disk so it survives keeper restarts
+  _saveVrfData() {
+    try {
+      if (this.currentRoundData) {
+        fs.writeFileSync(this.vrfDataPath, JSON.stringify(this.currentRoundData));
+      }
+    } catch (e) {
+      console.warn('⚠️ Could not persist VRF data:', e.message);
+    }
+  }
+
+  _loadVrfData() {
+    try {
+      if (fs.existsSync(this.vrfDataPath)) {
+        return JSON.parse(fs.readFileSync(this.vrfDataPath, 'utf-8'));
+      }
+    } catch (e) {
+      console.warn('⚠️ Could not load VRF data:', e.message);
+    }
+    return null;
+  }
+
+  _clearVrfData() {
+    try {
+      if (fs.existsSync(this.vrfDataPath)) {
+        fs.unlinkSync(this.vrfDataPath);
+      }
+    } catch (e) { /* ignore */ }
+  }
+
+  // Polling-based tx confirmation (Alchemy doesn't support signatureSubscribe websocket)
+  async confirmTx(signature, timeout = 60000) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const statuses = await this.connection.getSignatureStatuses([signature]);
+      const status = statuses?.value?.[0];
+      if (status?.err) {
+        throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+      }
+      if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    throw new Error('Transaction confirmation timeout');
+  }
+
+  async getCurrentRound() {
+    try {
+      const { data } = await axios.get(`${API_BASE}/jackpot/round/current`);
+      
+      // ALSO fetch entries to get REAL entry count
+      if (data.round) {
+        const entriesRes = await axios.get(`${API_BASE}/jackpot/round/${data.round.roundId}/entries`);
+        data.round.entryCount = entriesRes.data.entries?.length || 0;
+      }
+      
+      return data.round;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async lockRound(roundId) {
+    console.log(`🔒 Locking round ${roundId}...`);
+    const startTime = Date.now();
+    
+    try {
+      // Update state: locking
+      await this.state.updateRound(roundId, { 
+        status: 'locking',
+        last_attempt_at: new Date()
+      });
+      
+      const { data } = await axios.post(`${API_BASE}/jackpot/build/lock-round`, {
+        keeperAddress: this.wallet.publicKey.toString(),
+        roundId,
+      });
+      
+      const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+      tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+      tx.feePayer = this.wallet.publicKey;
+      tx.sign(this.wallet);
+      
+      const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: true,
+      });
+      await this.confirmTx(signature);
+      
+      const duration = Date.now() - startTime;
+      
+      // Update state: locked
+      await this.state.updateRound(roundId, {
+        status: 'locked',
+        locked_at: new Date(),
+        lock_signature: signature
+      });
+      
+      // Log action
+      await this.state.logAction(roundId, 'lock', true, null, signature, duration);
+      
+      // Store server seed data for verification later (memory + disk)
+      this.currentRoundData = {
+        serverSeed: data.serverSeed,
+        serverSeedHash: data.serverSeedHash,
+      };
+      this._saveVrfData();
+
+      console.log(`✅ Round ${roundId} locked! Sig: ${signature.slice(0, 8)}...`);
+      console.log(`📍 Server seed hash: ${data.serverSeedHash?.slice(0, 16)}...`);
+      
+      // Trigger WebSocket broadcast via webhook
+      axios.post(`${API_BASE}/api/keeper-webhook/round-locked`, {
+        roundId
+      }).catch(err => console.warn('Webhook broadcast failed:', err.message));
+      
+      return true;
+    } catch (error) {
+      console.error('❌ Lock failed:', error.message);
+      
+      // Log failure
+      await this.state.incrementRetry(roundId, error.message);
+      await this.state.logAction(roundId, 'lock', false, error.message, null, Date.now() - startTime);
+      
+      return false;
+    }
+  }
+
+  async revealRandomness(roundId) {
+    console.log(`🎲 Revealing randomness for round ${roundId}...`);
+    const startTime = Date.now();
+    
+    try {
+      // Update state: revealing
+      await this.state.updateRound(roundId, { 
+        status: 'revealing',
+        last_attempt_at: new Date()
+      });
+      
+      // Generate oracle seed (in production, fetch from Random.org)
+      const oracleSeed = crypto.randomBytes(32).toString('hex');
+      
+      const { data } = await axios.post(`${API_BASE}/jackpot/oracle/reveal`, {
+        roundId: roundId.toString(),
+        oracleSeed,
+      });
+      
+      const duration = Date.now() - startTime;
+      
+      // Update state: revealed
+      await this.state.updateRound(roundId, {
+        status: 'revealed',
+        revealed_at: new Date(),
+        reveal_signature: data.signature
+      });
+      
+      // Log action
+      await this.state.logAction(roundId, 'reveal', true, null, data.signature, duration);
+      
+      console.log(`✅ Randomness revealed! Sig: ${data.signature.slice(0, 8)}...`);
+      console.log(`📍 Oracle seed: ${oracleSeed.slice(0, 16)}...`);
+      
+      // Store oracle seed for verification (memory + disk)
+      if (this.currentRoundData) {
+        this.currentRoundData.oracleSeed = oracleSeed;
+      } else {
+        // Recover from disk if memory was lost
+        this.currentRoundData = this._loadVrfData() || {};
+        this.currentRoundData.oracleSeed = oracleSeed;
+      }
+      this._saveVrfData();
+
+      // VRF is written INSTANTLY when transaction confirms - no need to poll!
+      console.log('✅ VRF result written on-chain! Ready to resolve immediately!');
+      
+      return true;
+    } catch (error) {
+      // Error 6014 = RandomnessAlreadyConsumed - this is OK, skip to resolve
+      if (error.message && error.message.includes('6014')) {
+        console.log('ℹ️  Randomness already revealed, proceeding to resolve');
+        return true;
+      }
+      console.error('❌ Reveal failed:', error.message);
+      
+      // Log failure
+      await this.state.incrementRetry(roundId, error.message);
+      await this.state.logAction(roundId, 'reveal', false, error.message, null, Date.now() - startTime);
+      
+      return false;
+    }
+  }
+
+  async waitForVrfResult() {
+    const [roundPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from('round'), Buffer.alloc(8, 1)],
+      this.programId
+    );
+    
+    // Poll for up to 20 seconds
+    for (let i = 0; i < 40; i++) {
+      try {
+        const accountInfo = await this.connection.getAccountInfo(roundPda);
+        if (accountInfo) {
+          // Check if VRF result exists (Option<u128> discriminant at offset 51)
+          const hasVrf = accountInfo.data[51] === 1;
+          if (hasVrf) {
+            return true;
+          }
+        }
+      } catch (e) {
+        // Ignore errors, keep polling
+      }
+      await new Promise(resolve => setTimeout(resolve, 500)); // Check every 0.5s
+    }
+    return false;
+  }
+
+  async resolveRound(roundId) {
+    console.log(`💰 Resolving round ${roundId}...`);
+    const startTime = Date.now();
+    
+    try {
+      // Update state: resolving
+      await this.state.updateRound(roundId, { 
+        status: 'resolving',
+        last_attempt_at: new Date()
+      });
+      
+      // ALWAYS use Round 1 PDAs (account reuse!)
+      const [roundPda] = PublicKey.findProgramAddressSync([Buffer.from('round'), Buffer.from([1,0,0,0,0,0,0,0])], this.programId);
+      const [entriesPda] = PublicKey.findProgramAddressSync([Buffer.from('entries'), Buffer.from([1,0,0,0,0,0,0,0])], this.programId);
+      
+      const roundAccountBefore = await this.connection.getAccountInfo(roundPda);
+      const totalPot = roundAccountBefore.data.readBigUInt64LE(33);
+      
+      // Get entries
+      const entriesAccount = await this.connection.getAccountInfo(entriesPda);
+      const entryCount = entriesAccount.data.readUInt32LE(16);
+      
+      const { data } = await axios.post(`${API_BASE}/jackpot/build/resolve`, {
+        keeperAddress: this.wallet.publicKey.toString(),
+        roundId,
+      });
+      
+      const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+      tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+      tx.feePayer = this.wallet.publicKey;
+      tx.sign(this.wallet);
+      
+      const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: true,
+      });
+      await this.confirmTx(signature);
+      
+      const winner = data.winner;
+      const winAmount = Number(totalPot) * 0.95; // 95% after 5% fee
+      
+      const duration = Date.now() - startTime;
+      
+      // Update state: resolved
+      await this.state.updateRound(roundId, {
+        status: 'resolved',
+        resolved_at: new Date(),
+        resolve_signature: signature,
+        winner_pubkey: winner,
+        win_amount: winAmount.toString(),
+        total_pot: totalPot.toString(),
+        entry_count: entryCount
+      });
+      
+      // Log action
+      await this.state.logAction(roundId, 'resolve', true, null, signature, duration);
+      
+      console.log(`🏆 Round ${roundId} resolved!`);
+      console.log(`   Winner: ${winner.slice(0, 8)}...`);
+      console.log(`   Prize: ${(winAmount / 1e9).toFixed(4)} SOL`);
+      console.log(`   Sig: ${signature.slice(0, 8)}...`);
+      
+      // Recover VRF data from disk if memory was lost (e.g. keeper restarted)
+      if (!this.currentRoundData) {
+        this.currentRoundData = this._loadVrfData();
+        if (this.currentRoundData) {
+          console.log('📂 Recovered VRF data from disk');
+        }
+      }
+
+      // Capture VRF data before clearing
+      const vrfServerSeed = this.currentRoundData?.serverSeed || null;
+      const vrfServerSeedHash = this.currentRoundData?.serverSeedHash || null;
+      const vrfOracleSeed = this.currentRoundData?.oracleSeed || null;
+
+      // Clear current round data (memory + disk)
+      this.currentRoundData = null;
+      this._clearVrfData();
+
+      // Increment success counter
+      this.roundsCompleted++;
+      this.consecutiveFailures = 0;
+
+      // Trigger WebSocket broadcast + save history via webhook
+      // The SERVER process has DATABASE_URL, so its addRound writes to PostgreSQL
+      axios.post(`${API_BASE}/api/keeper-webhook/winner-selected`, {
+        roundId,
+        winner,
+        winAmount: winAmount.toString(),
+        totalPot: totalPot.toString(),
+        entryCount,
+        signature,
+        // Provably fair verification data
+        serverSeed: vrfServerSeed,
+        serverSeedHash: vrfServerSeedHash,
+        oracleSeed: vrfOracleSeed,
+      }).then(() => {
+        console.log(`⚡ Webhook called: winner_selected (${winner.slice(0,8)}...)`);
+      }).catch(err => console.warn('Webhook broadcast failed:', err.message));
+      
+      return true;
+    } catch (error) {
+      console.error('❌ Resolve failed:', error.message);
+      
+      // Log failure
+      await this.state.incrementRetry(roundId, error.message);
+      await this.state.logAction(roundId, 'resolve', false, error.message, null, Date.now() - startTime);
+      
+      this.consecutiveFailures++;
+      
+      return false;
+    }
+  }
+
+  async openOrResetRound(previousRoundId = null) {
+    console.log(`📂 Opening/resetting round...`);
+    const startTime = Date.now();
+    
+    try {
+      // Check if round 1 accounts exist - if so, use reset (account reuse like Solpot!)
+      const roundIdBuf = Buffer.alloc(8);
+      roundIdBuf.writeBigUInt64LE(1n);
+      const [round1Pda] = PublicKey.findProgramAddressSync([Buffer.from('round'), roundIdBuf], this.programId);
+      
+      const round1Exists = await this.connection.getAccountInfo(round1Pda);
+      
+      if (round1Exists) {
+        // RESET (reuse accounts - FREE!)
+        console.log(`♻️  Resetting round (reusing accounts - Solpot style)...`);
+        
+        // Update state: resetting (if we have previous round ID)
+        if (previousRoundId) {
+          await this.state.updateRound(previousRoundId, { 
+            status: 'resetting',
+            last_attempt_at: new Date()
+          });
+        }
+        
+        const { data } = await axios.post(`${API_BASE}/jackpot/build/reset-round`, {
+          keeperAddress: this.wallet.publicKey.toString(),
+        });
+        
+        const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+        tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+        tx.feePayer = this.wallet.publicKey;
+        tx.sign(this.wallet);
+        
+        const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+          skipPreflight: true,
+        });
+        await this.confirmTx(signature);
+        
+        const duration = Date.now() - startTime;
+        const newRoundId = data.roundId;
+        
+        // Update previous round: reset complete
+        if (previousRoundId) {
+          await this.state.updateRound(previousRoundId, {
+            reset_at: new Date(),
+            reset_signature: signature
+          });
+          await this.state.logAction(previousRoundId, 'reset', true, null, signature, duration);
+        }
+        
+        // Create new round in DB
+        await this.state.createRound(newRoundId, 'open');
+        
+        // Trigger WebSocket broadcast via webhook
+        axios.post(`${API_BASE}/api/keeper-webhook/round-opened`, {
+          roundId: newRoundId
+        }).catch(err => console.warn('Webhook broadcast failed:', err.message));
+        
+        console.log(`♻️  Round ${newRoundId} opened! (Cost: ~$0.01 gas only!) Sig: ${signature.slice(0, 8)}...`);
+        
+        // Wait for RPC to sync (prevents stale data loop)
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        return true;
+        
+      } else {
+        // OPEN (first time only - pay rent)
+        console.log(`🆕 Opening FIRST round (one-time rent cost)...`);
+        const { data } = await axios.post(`${API_BASE}/jackpot/build/open-round`, {
+          keeperAddress: this.wallet.publicKey.toString(),
+        });
+        
+        const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+        tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+        tx.feePayer = this.wallet.publicKey;
+        tx.sign(this.wallet);
+        
+        const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+          skipPreflight: true,
+        });
+        await this.confirmTx(signature);
+        
+        const duration = Date.now() - startTime;
+        const newRoundId = data.roundId;
+        
+        // Create new round in DB
+        await this.state.createRound(newRoundId, 'open');
+        await this.state.logAction(newRoundId, 'open', true, null, signature, duration);
+        
+        console.log(`🎉 Round ${newRoundId} opened! (Paid rent once) Sig: ${signature.slice(0, 8)}...`);
+        return true;
+      }
+    } catch (error) {
+      console.error('❌ Open/reset failed:', error.message || error);
+      if (error.response) {
+        console.error('API Error:', error.response.data);
+      }
+      if (error.logs) {
+        console.error('Transaction logs:', error.logs);
+      }
+      
+      // Log failure
+      if (previousRoundId) {
+        await this.state.logAction(previousRoundId, 'reset', false, error.message, null, Date.now() - startTime);
+      }
+      
+      return false;
+    }
+  }
+
+  async processRound(round) {
+    const roundId = round.roundId;
+    const entryCount = round.entryCount || 0;
+    
+    // Ensure round exists in database
+    let dbRound = await this.state.getRound(roundId);
+    if (!dbRound) {
+      await this.state.createRound(roundId, round.status.toLowerCase());
+    }
+    
+    if (round.status === 'Open') {
+      // Check if time expired
+      if (round.timeRemainingSlots <= 0) {
+        console.log(`\n⏰ Round ${roundId} timer expired! (${entryCount} entries)`);
+        
+        // Skip if no entries - just reset/open new round
+        if (entryCount === 0) {
+          console.log(`⚠️  Round ${roundId} has no entries, resetting...`);
+          await this.openOrResetRound(roundId);
+          return;
+        }
+        
+        // Lock → Reveal Randomness → Resolve → Open (3-step VRF flow)
+        if (await this.lockRound(roundId)) {
+          if (await this.revealRandomness(roundId)) {
+            if (await this.resolveRound(roundId)) {
+              // Wait 5s for carousel animation + user to see winner
+              console.log('⏳ Waiting 5s for winner animation...');
+              await new Promise(resolve => setTimeout(resolve, 5000));
+              await this.openOrResetRound(roundId);
+            }
+          }
+        }
+      } else {
+        const secsLeft = Math.floor(round.timeRemainingSlots * 0.4);
+        console.log(`⏳ Round ${roundId} - ${secsLeft}s left, ${entryCount} entries, pot: ${(Number(round.totalPotLamports)/1e9).toFixed(3)} SOL`);
+        
+        // CRITICAL: Broadcast timer update to all clients every check
+        axios.post(`${API_BASE}/api/keeper-webhook/timer-update`, {
+          roundId,
+          timeRemaining: secsLeft,
+          entryCount,
+          totalPot: round.totalPotLamports,
+          status: round.status
+        }).catch(err => console.warn('Timer broadcast failed:', err.message));
+        
+        // Also track entry count changes for logging
+        if (this.lastEntryCount[roundId] !== entryCount) {
+          this.lastEntryCount[roundId] = entryCount;
+        }
+      }
+    } else if (round.status === 'Locked') {
+      // Check if we already resolved this round (prevent loops)
+      if (this.lastResolvedRound === roundId) {
+        console.log(`⚠️ Already resolved round ${roundId}, forcing reset...`);
+        await this.openOrResetRound();
+        return;
+      }
+      
+      console.log(`🔒 Round ${roundId} locked, paying out...`);
+      
+      // Track consecutive failures for this locked round
+      this.lockedRoundFailures = this.lockedRoundFailures || {};
+      this.lockedRoundFailures[roundId] = this.lockedRoundFailures[roundId] || 0;
+      
+      // Try to resolve once
+      if (await this.resolveRound(roundId)) {
+        this.lastResolvedRound = roundId; // Track it
+        this.lockedRoundFailures[roundId] = 0; // Reset counter
+        await new Promise(resolve => setTimeout(resolve, 5000)); // Same 5s delay
+        await this.openOrResetRound();
+      } else {
+        this.lockedRoundFailures[roundId]++;
+        console.log(`❌ Resolve failed (attempt ${this.lockedRoundFailures[roundId]}), will retry next cycle`);
+        
+        // After 5 consecutive failures, try to force reset (round is stuck without VRF)
+        if (this.lockedRoundFailures[roundId] >= 5) {
+          console.log(`🚨 Round ${roundId} stuck after 5 attempts! VRF may not have been consumed.`);
+          console.log(`♻️ Forcing reset to start fresh round...`);
+          this.lockedRoundFailures[roundId] = 0;
+          await this.openOrResetRound(roundId);
+        }
+      }
+    } else if (round.status === 'Resolved') {
+      console.log(`✅ Round ${roundId} resolved, resetting...`);
+      await this.openOrResetRound();
+    }
+  }
+
+  async recoverStuckRounds() {
+    console.log('🔧 Checking for stuck rounds...');
+    
+    try {
+      const stuckRounds = await this.state.getStuckRounds();
+      
+      if (stuckRounds.length === 0) {
+        console.log('✅ No stuck rounds found');
+        return;
+      }
+      
+      console.log(`⚠️  Found ${stuckRounds.length} stuck round(s)!`);
+      
+      for (const stuck of stuckRounds) {
+        console.log(`\n🔧 Recovering round ${stuck.round_id} stuck in '${stuck.status}' for ${Math.floor(stuck.seconds_stuck)}s`);
+        console.log(`   Retries so far: ${stuck.retry_count}`);
+        console.log(`   Last error: ${stuck.last_error || 'none'}`);
+        
+        // Get current on-chain state
+        const round = await this.getCurrentRound();
+        
+        if (!round || round.roundId !== stuck.round_id) {
+          console.log(`   Round ${stuck.round_id} no longer active on-chain, marking resolved in DB`);
+          await this.state.updateRound(stuck.round_id, { status: 'resolved', resolved_at: new Date() });
+          continue;
+        }
+        
+        // Resume based on current state
+        console.log(`   On-chain status: ${round.status}, DB status: ${stuck.status}`);
+        
+        if (stuck.status === 'locking' || stuck.status === 'locked') {
+          if (round.status === 'Locked') {
+            console.log(`   ✓ Lock completed, moving to reveal`);
+            await this.state.updateRound(stuck.round_id, { status: 'locked' });
+            await this.revealRandomness(round.roundId);
+          } else {
+            console.log(`   Retrying lock...`);
+            await this.lockRound(round.roundId);
+          }
+        }
+        
+        else if (stuck.status === 'revealing' || stuck.status === 'revealed') {
+          if (round.status === 'Locked') {
+            console.log(`   Retrying reveal...`);
+            await this.revealRandomness(round.roundId);
+          } else {
+            console.log(`   Status mismatch, skipping to resolve`);
+          }
+        }
+        
+        else if (stuck.status === 'resolving') {
+          console.log(`   Retrying resolve...`);
+          await this.resolveRound(round.roundId);
+        }
+        
+        else if (stuck.status === 'resetting') {
+          console.log(`   Retrying reset...`);
+          await this.openOrResetRound(stuck.round_id);
+        }
+      }
+      
+      console.log('\n✅ Recovery complete\n');
+      
+    } catch (error) {
+      console.error('❌ Recovery failed:', error.message);
+    }
+  }
+
+  async recordHealthMetrics() {
+    const uptime = Math.floor((Date.now() - this.startTime) / 1000);
+    
+    await this.state.recordHealth({
+      roundsCompleted: this.roundsCompleted,
+      consecutiveFailures: this.consecutiveFailures,
+      lastSuccessRound: this.lastResolvedRound || 0,
+      lastError: this.lastError || null,
+      uptimeSeconds: uptime
+    });
+  }
+
+  async run() {
+    console.log('🚀 Keeper bot started!\n');
+    
+    // Run recovery on startup
+    await this.recoverStuckRounds();
+    
+    // Check if round exists, if not open/reset one
+    let round = await this.getCurrentRound();
+    if (!round) {
+      console.log('No active round, opening/resetting...');
+      await this.openOrResetRound();
+    }
+    
+    let healthCheckCounter = 0;
+    let lastHealthTime = Date.now();
+    let lastRecoveryTime = Date.now();
+
+    // Main loop
+    while (true) {
+      try {
+        round = await this.getCurrentRound();
+
+        if (round) {
+          await this.processRound(round);
+        } else {
+          console.log('No round found, opening/resetting...');
+          await this.openOrResetRound();
+        }
+
+        // Health check every ~60 seconds
+        if (Date.now() - lastHealthTime >= 60000) {
+          await this.recordHealthMetrics();
+          lastHealthTime = Date.now();
+        }
+
+        // Check for stuck rounds every ~5 minutes
+        if (Date.now() - lastRecoveryTime >= 300000) {
+          await this.recoverStuckRounds();
+          lastRecoveryTime = Date.now();
+        }
+
+        // Adaptive poll interval based on time remaining
+        const secsLeft = round ? Math.floor(round.timeRemainingSlots * 0.4) : 0;
+        const pollMs = secsLeft > 86400 ? 300000  // > 1 day  → 5 minutes
+                     : secsLeft > 3600  ? 60000   // > 1 hour → 60 seconds
+                     : secsLeft > 300   ? 5000    // > 5 min  → 5 seconds
+                     :                    2000;   // ≤ 5 min  → 2 seconds (action imminent)
+
+        await new Promise(resolve => setTimeout(resolve, pollMs));
+
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+        this.lastError = error.message;
+        await new Promise(resolve => setTimeout(resolve, 10000));
+      }
+    }
+  }
+}
+
+const keeper = new JackpotKeeper();
+keeper.run().catch(console.error);
+