dubs-server 1.0.0

package/services/survivorOracle.js

@@ -0,0 +1,469 @@
+/**
+ * Survivor Pool Oracle Service
+ * Monitors tournament games and resolves rounds based on ESPN results
+ */
+
+const axios = require('axios');
+const { pool } = require('./db');
+
+// ESPN NCAAB scoreboard URL
+const ESPN_NCAAB_URL = 'https://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/scoreboard';
+
+// Round names for logging
+const ROUND_NAMES = {
+  1: 'First Four',
+  2: 'Round of 64',
+  3: 'Round of 32',
+  4: 'Sweet 16',
+  5: 'Elite 8',
+  6: 'Final Four',
+  7: 'Championship'
+};
+
+class SurvivorOracle {
+  constructor(config = {}) {
+    this.checkIntervalMs = config.checkIntervalMs || 5 * 60 * 1000; // 5 minutes default
+    this.isRunning = false;
+    this.intervalId = null;
+  }
+
+  /**
+   * Start the oracle monitor
+   */
+  start() {
+    if (this.isRunning) {
+      console.log('[SurvivorOracle] Already running');
+      return;
+    }
+
+    console.log('[SurvivorOracle] Starting...');
+    console.log(`   Check interval: ${this.checkIntervalMs / 1000}s`);
+
+    this.isRunning = true;
+
+    // Run immediately
+    this.checkActivePools();
+
+    // Then run on interval
+    this.intervalId = setInterval(() => {
+      this.checkActivePools();
+    }, this.checkIntervalMs);
+  }
+
+  /**
+   * Stop the oracle
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.isRunning = false;
+    console.log('[SurvivorOracle] Stopped');
+  }
+
+  /**
+   * Check all active survivor pools
+   */
+  async checkActivePools() {
+    try {
+      console.log(`\n[SurvivorOracle] [${new Date().toISOString()}] Checking active pools...`);
+
+      // Get all active pools
+      const result = await pool.query(
+        "SELECT * FROM survivor_pools WHERE status = 'active'"
+      );
+
+      const activePools = result.rows;
+      console.log(`[SurvivorOracle] Found ${activePools.length} active pool(s)`);
+
+      for (const survivorPool of activePools) {
+        await this.processPool(survivorPool);
+      }
+    } catch (error) {
+      console.error('[SurvivorOracle] Error checking pools:', error.message);
+    }
+  }
+
+  /**
+   * Process a single pool
+   */
+  async processPool(survivorPool) {
+    try {
+      console.log(`[SurvivorOracle] Processing pool ${survivorPool.id}: ${survivorPool.name}`);
+      console.log(`   Current round: ${survivorPool.current_round} (${ROUND_NAMES[survivorPool.current_round]})`);
+
+      // Check if round deadline has passed
+      if (survivorPool.round_deadline && new Date() < new Date(survivorPool.round_deadline)) {
+        console.log(`   Deadline not yet passed, skipping`);
+        return;
+      }
+
+      // Get unresolved games for current round
+      const gamesResult = await pool.query(
+        `SELECT * FROM survivor_tournament_games
+         WHERE pool_id = $1 AND round = $2 AND status != 'final'`,
+        [survivorPool.id, survivorPool.current_round]
+      );
+
+      const unresolvedGames = gamesResult.rows;
+      console.log(`   Unresolved games: ${unresolvedGames.length}`);
+
+      if (unresolvedGames.length > 0) {
+        // Fetch ESPN scores and update games
+        await this.updateGameScores(survivorPool.id, unresolvedGames);
+      }
+
+      // Check if all games in current round are final
+      const allGamesResult = await pool.query(
+        `SELECT
+          COUNT(*) as total,
+          COUNT(*) FILTER (WHERE status = 'final') as final_count
+         FROM survivor_tournament_games
+         WHERE pool_id = $1 AND round = $2`,
+        [survivorPool.id, survivorPool.current_round]
+      );
+
+      const { total, final_count } = allGamesResult.rows[0];
+      console.log(`   Games status: ${final_count}/${total} final`);
+
+      if (parseInt(total) > 0 && parseInt(final_count) === parseInt(total)) {
+        // All games final - resolve the round
+        console.log(`   All games final - resolving round`);
+        await this.resolveCurrentRound(survivorPool.id);
+      }
+    } catch (error) {
+      console.error(`[SurvivorOracle] Error processing pool ${survivorPool.id}:`, error.message);
+    }
+  }
+
+  /**
+   * Fetch ESPN scores and update tournament games
+   */
+  async updateGameScores(poolId, games) {
+    try {
+      console.log(`[SurvivorOracle] Fetching ESPN scores...`);
+
+      const { data } = await axios.get(ESPN_NCAAB_URL);
+
+      if (!data.events) {
+        console.log('[SurvivorOracle] No events in ESPN response');
+        return;
+      }
+
+      // Create a map of ESPN game IDs to results
+      const espnResults = new Map();
+
+      for (const event of data.events) {
+        const competition = event.competitions?.[0];
+        if (!competition) continue;
+
+        const gameId = event.id;
+        const status = event.status?.type?.description;
+        const competitors = competition.competitors || [];
+
+        if (competitors.length !== 2) continue;
+
+        const team1 = competitors.find(c => c.homeAway === 'home') || competitors[0];
+        const team2 = competitors.find(c => c.homeAway === 'away') || competitors[1];
+
+        espnResults.set(gameId, {
+          status,
+          isFinal: status === 'Final' || event.status?.type?.completed === true,
+          team1Score: parseInt(team1.score) || 0,
+          team2Score: parseInt(team2.score) || 0,
+          team1Id: team1.team?.id,
+          team2Id: team2.team?.id,
+          winnerId: team1.winner ? team1.team?.id : (team2.winner ? team2.team?.id : null)
+        });
+      }
+
+      // Update each tournament game with ESPN results
+      for (const game of games) {
+        const result = espnResults.get(game.espn_game_id);
+
+        if (!result) {
+          console.log(`   Game ${game.espn_game_id}: Not found in ESPN data`);
+          continue;
+        }
+
+        if (result.isFinal) {
+          console.log(`   Game ${game.espn_game_id}: FINAL - ${result.team1Score} vs ${result.team2Score}`);
+
+          // Determine winner
+          let winnerId = result.winnerId;
+          if (!winnerId) {
+            // Fallback: higher score wins
+            winnerId = result.team1Score > result.team2Score ? game.team1_id : game.team2_id;
+          }
+
+          await pool.query(
+            `UPDATE survivor_tournament_games
+             SET winner_id = $3, team1_score = $4, team2_score = $5, status = 'final', updated_at = NOW()
+             WHERE pool_id = $1 AND espn_game_id = $2`,
+            [poolId, game.espn_game_id, winnerId, result.team1Score, result.team2Score]
+          );
+        } else {
+          console.log(`   Game ${game.espn_game_id}: ${result.status || 'In Progress'}`);
+
+          // Update live scores
+          const newStatus = result.status === 'In Progress' ? 'live' : 'scheduled';
+          await pool.query(
+            `UPDATE survivor_tournament_games
+             SET team1_score = $3, team2_score = $4, status = $5, updated_at = NOW()
+             WHERE pool_id = $1 AND espn_game_id = $2`,
+            [poolId, game.espn_game_id, result.team1Score, result.team2Score, newStatus]
+          );
+        }
+      }
+    } catch (error) {
+      console.error('[SurvivorOracle] Error fetching ESPN scores:', error.message);
+    }
+  }
+
+  /**
+   * Resolve the current round - update picks and eliminate losers
+   */
+  async resolveCurrentRound(poolId) {
+    const client = await pool.connect();
+
+    try {
+      await client.query('BEGIN');
+
+      // Get pool info
+      const poolResult = await client.query(
+        'SELECT * FROM survivor_pools WHERE id = $1 FOR UPDATE',
+        [poolId]
+      );
+
+      if (poolResult.rows.length === 0) {
+        throw new Error('Pool not found');
+      }
+
+      const survivorPool = poolResult.rows[0];
+      const currentRound = survivorPool.current_round;
+
+      console.log(`[SurvivorOracle] Resolving round ${currentRound} for pool ${poolId}`);
+
+      // Get all final games for this round
+      const gamesResult = await client.query(
+        `SELECT * FROM survivor_tournament_games
+         WHERE pool_id = $1 AND round = $2 AND status = 'final'`,
+        [poolId, currentRound]
+      );
+
+      const finalGames = gamesResult.rows;
+      const winnerMap = new Map();
+
+      for (const game of finalGames) {
+        // Map both team IDs to whether they won
+        winnerMap.set(game.team1_id, game.winner_id === game.team1_id);
+        winnerMap.set(game.team2_id, game.winner_id === game.team2_id);
+      }
+
+      // Get all picks for this round
+      const picksResult = await client.query(
+        `SELECT sp.*, se.id as entry_id, se.user_id
+         FROM survivor_picks sp
+         JOIN survivor_entries se ON se.id = sp.entry_id
+         WHERE se.pool_id = $1 AND sp.round = $2 AND se.is_alive = true`,
+        [poolId, currentRound]
+      );
+
+      const picks = picksResult.rows;
+      let eliminatedCount = 0;
+      let survivedCount = 0;
+
+      // Process each pick
+      for (const pick of picks) {
+        const teamWon = winnerMap.get(pick.team_id);
+
+        if (teamWon === true) {
+          // Team won - mark pick as won
+          await client.query(
+            `UPDATE survivor_picks SET result = 'won', updated_at = NOW() WHERE id = $1`,
+            [pick.id]
+          );
+          survivedCount++;
+          console.log(`   Entry ${pick.entry_id}: ${pick.team_name} WON - survived`);
+        } else if (teamWon === false) {
+          // Team lost - mark pick as lost and eliminate entry
+          await client.query(
+            `UPDATE survivor_picks SET result = 'lost', updated_at = NOW() WHERE id = $1`,
+            [pick.id]
+          );
+          await client.query(
+            `UPDATE survivor_entries
+             SET is_alive = false, eliminated_at_round = $2, updated_at = NOW()
+             WHERE id = $1`,
+            [pick.entry_id, currentRound]
+          );
+          eliminatedCount++;
+          console.log(`   Entry ${pick.entry_id}: ${pick.team_name} LOST - ELIMINATED`);
+        } else {
+          // Game result not found (shouldn't happen if all games are final)
+          console.warn(`   Entry ${pick.entry_id}: Team ${pick.team_id} result not found`);
+        }
+      }
+
+      // Eliminate entries that didn't submit a pick (auto-elimination)
+      const missingPicksResult = await client.query(
+        `UPDATE survivor_entries
+         SET is_alive = false, eliminated_at_round = $2, updated_at = NOW()
+         WHERE pool_id = $1
+         AND is_alive = true
+         AND id NOT IN (
+           SELECT entry_id FROM survivor_picks WHERE round = $2
+         )
+         RETURNING id`,
+        [poolId, currentRound]
+      );
+
+      const autoEliminatedCount = missingPicksResult.rowCount;
+      if (autoEliminatedCount > 0) {
+        console.log(`   Auto-eliminated ${autoEliminatedCount} entries (no pick submitted)`);
+      }
+
+      // Check remaining survivors
+      const aliveResult = await client.query(
+        'SELECT COUNT(*) as count FROM survivor_entries WHERE pool_id = $1 AND is_alive = true',
+        [poolId]
+      );
+      const aliveCount = parseInt(aliveResult.rows[0].count);
+
+      console.log(`[SurvivorOracle] Round ${currentRound} resolved:`);
+      console.log(`   Survived: ${survivedCount}`);
+      console.log(`   Eliminated: ${eliminatedCount}`);
+      console.log(`   Auto-eliminated: ${autoEliminatedCount}`);
+      console.log(`   Still alive: ${aliveCount}`);
+
+      // Determine next action
+      if (currentRound === 7 || aliveCount === 0) {
+        // Championship finished or everyone eliminated - complete the pool
+        await client.query(
+          `UPDATE survivor_pools SET status = 'complete', updated_at = NOW() WHERE id = $1`,
+          [poolId]
+        );
+        console.log(`[SurvivorOracle] Pool ${poolId} COMPLETE`);
+
+        // TODO: Trigger payout distribution
+        // This will call the Solana contract to distribute winnings
+
+      } else if (aliveCount === 1) {
+        // Only one survivor - they win!
+        await client.query(
+          `UPDATE survivor_pools SET status = 'complete', updated_at = NOW() WHERE id = $1`,
+          [poolId]
+        );
+        console.log(`[SurvivorOracle] Pool ${poolId} COMPLETE - Single winner!`);
+
+        // TODO: Trigger payout to single winner
+
+      } else {
+        // Advance to next round
+        const nextRound = currentRound + 1;
+        await client.query(
+          `UPDATE survivor_pools
+           SET current_round = $2, round_deadline = NULL, updated_at = NOW()
+           WHERE id = $1`,
+          [poolId, nextRound]
+        );
+        console.log(`[SurvivorOracle] Pool ${poolId} advanced to round ${nextRound} (${ROUND_NAMES[nextRound]})`);
+      }
+
+      await client.query('COMMIT');
+
+      return {
+        poolId,
+        round: currentRound,
+        survived: survivedCount,
+        eliminated: eliminatedCount,
+        autoEliminated: autoEliminatedCount,
+        stillAlive: aliveCount,
+        isComplete: currentRound === 7 || aliveCount <= 1
+      };
+    } catch (error) {
+      await client.query('ROLLBACK');
+      console.error('[SurvivorOracle] Error resolving round:', error.message);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Get survivors for payout (called when pool is complete)
+   */
+  async getSurvivorsForPayout(poolId) {
+    const result = await pool.query(
+      `SELECT se.*, u.wallet_address, u.username
+       FROM survivor_entries se
+       JOIN users u ON u.id = se.user_id
+       WHERE se.pool_id = $1 AND se.is_alive = true`,
+      [poolId]
+    );
+
+    return result.rows;
+  }
+
+  /**
+   * Calculate payouts for survivors
+   */
+  async calculatePayouts(poolId) {
+    // Get pool info
+    const poolResult = await pool.query(
+      'SELECT * FROM survivor_pools WHERE id = $1',
+      [poolId]
+    );
+
+    if (poolResult.rows.length === 0) {
+      throw new Error('Pool not found');
+    }
+
+    const survivorPool = poolResult.rows[0];
+
+    // Get all entries for total pot
+    const entriesResult = await pool.query(
+      'SELECT COUNT(*) as count FROM survivor_entries WHERE pool_id = $1',
+      [poolId]
+    );
+    const totalEntries = parseInt(entriesResult.rows[0].count);
+
+    // Get survivors
+    const survivors = await this.getSurvivorsForPayout(poolId);
+    const survivorCount = survivors.length;
+
+    // Calculate payouts
+    const buyInLamports = BigInt(survivorPool.buy_in_lamports);
+    const totalPotLamports = buyInLamports * BigInt(totalEntries);
+    const feePercentage = 6; // 6% total
+    const feeLamports = totalPotLamports * BigInt(feePercentage) / BigInt(100);
+    const netPotLamports = totalPotLamports - feeLamports;
+    const perSurvivorLamports = survivorCount > 0
+      ? netPotLamports / BigInt(survivorCount)
+      : BigInt(0);
+
+    return {
+      poolId,
+      totalEntries,
+      survivorCount,
+      totalPotLamports: totalPotLamports.toString(),
+      feeLamports: feeLamports.toString(),
+      netPotLamports: netPotLamports.toString(),
+      perSurvivorLamports: perSurvivorLamports.toString(),
+      survivors: survivors.map(s => ({
+        entryId: s.id,
+        userId: s.user_id,
+        walletAddress: s.wallet_address,
+        username: s.username,
+        payoutLamports: perSurvivorLamports.toString()
+      }))
+    };
+  }
+}
+
+// Export singleton instance
+const survivorOracle = new SurvivorOracle();
+
+module.exports = survivorOracle;
+module.exports.SurvivorOracle = SurvivorOracle;