dubs-server 1.0.0

package/controllers/survivorController.js

@@ -0,0 +1,623 @@
+/**
+ * Survivor Pool Controller
+ * Business logic for March Madness Survivor Pool feature
+ */
+
+const { pool } = require('../services/db');
+
+const LAMPORTS_PER_SOL = 1_000_000_000;
+
+// Round names for display
+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'
+};
+
+/**
+ * Create a new survivor pool
+ */
+async function createPool({
+  name,
+  year,
+  buyInLamports,
+  roundDeadline,
+  allowSameTeamTwice = false,
+  solanaGameId = null,
+  createdBy
+}) {
+  const result = await pool.query(
+    `INSERT INTO survivor_pools
+     (name, year, buy_in_lamports, round_deadline, allow_same_team_twice, solana_game_id, created_by)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     RETURNING *`,
+    [name, year, buyInLamports, roundDeadline, allowSameTeamTwice, solanaGameId, createdBy]
+  );
+  return result.rows[0];
+}
+
+/**
+ * Get all pools with optional status filter
+ */
+async function getPools({ status, year } = {}) {
+  let query = `
+    SELECT
+      sp.*,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = sp.id) as total_entries,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = sp.id AND is_alive = true) as alive_count
+    FROM survivor_pools sp
+    WHERE 1=1
+  `;
+  const params = [];
+
+  if (status) {
+    params.push(status);
+    query += ` AND sp.status = $${params.length}`;
+  }
+
+  if (year) {
+    params.push(year);
+    query += ` AND sp.year = $${params.length}`;
+  }
+
+  query += ' ORDER BY sp.created_at DESC';
+
+  const result = await pool.query(query, params);
+  return result.rows.map(formatPool);
+}
+
+/**
+ * Get a single pool by ID with detailed stats
+ */
+async function getPoolById(poolId) {
+  const result = await pool.query(
+    `SELECT
+      sp.*,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = sp.id) as total_entries,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = sp.id AND is_alive = true) as alive_count,
+      (SELECT SUM(buy_in_lamports) FROM survivor_pools WHERE id = sp.id) *
+        (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = sp.id) as total_pot_lamports
+    FROM survivor_pools sp
+    WHERE sp.id = $1`,
+    [poolId]
+  );
+
+  if (result.rows.length === 0) {
+    return null;
+  }
+
+  return formatPool(result.rows[0]);
+}
+
+/**
+ * Update pool (admin)
+ */
+async function updatePool(poolId, updates) {
+  const allowedFields = ['name', 'current_round', 'round_deadline', 'status', 'solana_game_id'];
+  const setClause = [];
+  const params = [poolId];
+
+  for (const [key, value] of Object.entries(updates)) {
+    const snakeKey = key.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    if (allowedFields.includes(snakeKey)) {
+      params.push(value);
+      setClause.push(`${snakeKey} = $${params.length}`);
+    }
+  }
+
+  if (setClause.length === 0) {
+    throw new Error('No valid fields to update');
+  }
+
+  setClause.push('updated_at = NOW()');
+
+  const result = await pool.query(
+    `UPDATE survivor_pools SET ${setClause.join(', ')} WHERE id = $1 RETURNING *`,
+    params
+  );
+
+  return result.rows[0] ? formatPool(result.rows[0]) : null;
+}
+
+/**
+ * Join a survivor pool
+ */
+async function joinPool({ poolId, userId, walletAddress, txSignature }) {
+  // Check pool exists and is open
+  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];
+
+  // Allow joining when pool is 'open' (before bracket)
+  // Or 'active' but only if no games have been completed yet (tournament hasn't really started)
+  if (survivorPool.status === 'open') {
+    // Always allow when open
+    console.log(`[Survivor] Pool ${poolId} is open, allowing join`);
+  } else if (survivorPool.status === 'active') {
+    // Check if any games have been completed
+    const completedGames = await pool.query(
+      `SELECT COUNT(*) as count FROM survivor_tournament_games
+       WHERE pool_id = $1 AND status = 'final'`,
+      [poolId]
+    );
+
+    const completedCount = parseInt(completedGames.rows[0].count);
+    console.log(`[Survivor] Pool ${poolId} is active, completed games: ${completedCount}`);
+
+    if (completedCount > 0) {
+      throw new Error(`Tournament has started (${completedCount} games completed). Reset the pool to allow new entries.`);
+    }
+  } else {
+    throw new Error(`Pool is ${survivorPool.status}, cannot join`);
+  }
+
+  // Check if user already joined
+  const existingEntry = await pool.query(
+    'SELECT id FROM survivor_entries WHERE pool_id = $1 AND user_id = $2',
+    [poolId, userId]
+  );
+
+  if (existingEntry.rows.length > 0) {
+    throw new Error('Already joined this pool');
+  }
+
+  // Create entry
+  const result = await pool.query(
+    `INSERT INTO survivor_entries (pool_id, user_id, wallet_address, entry_tx_signature)
+     VALUES ($1, $2, $3, $4)
+     RETURNING *`,
+    [poolId, userId, walletAddress, txSignature]
+  );
+
+  return result.rows[0];
+}
+
+/**
+ * Get user's entry in a pool
+ */
+async function getUserEntry(poolId, userId) {
+  const result = await pool.query(
+    `SELECT
+      se.*,
+      u.username,
+      u.avatar
+    FROM survivor_entries se
+    JOIN users u ON u.id = se.user_id
+    WHERE se.pool_id = $1 AND se.user_id = $2`,
+    [poolId, userId]
+  );
+
+  if (result.rows.length === 0) {
+    return null;
+  }
+
+  const entry = result.rows[0];
+
+  // Get all picks for this entry
+  const picksResult = await pool.query(
+    `SELECT * FROM survivor_picks WHERE entry_id = $1 ORDER BY round`,
+    [entry.id]
+  );
+
+  return {
+    ...entry,
+    picks: picksResult.rows.map(formatPick)
+  };
+}
+
+/**
+ * Get available teams for current round
+ * Returns teams playing in the current round, marking previously picked teams as unavailable
+ */
+async function getAvailableTeams(poolId, userId) {
+  // 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];
+  const currentRound = survivorPool.current_round;
+
+  // Get user's entry
+  const entryResult = await pool.query(
+    'SELECT id FROM survivor_entries WHERE pool_id = $1 AND user_id = $2',
+    [poolId, userId]
+  );
+
+  if (entryResult.rows.length === 0) {
+    throw new Error('Not joined this pool');
+  }
+
+  const entryId = entryResult.rows[0].id;
+
+  // Get previously picked teams (to mark as unavailable)
+  const previousPicksResult = await pool.query(
+    'SELECT team_id FROM survivor_picks WHERE entry_id = $1',
+    [entryId]
+  );
+  const pickedTeamIds = new Set(previousPicksResult.rows.map(r => r.team_id));
+
+  // Get all games for current round
+  const gamesResult = await pool.query(
+    `SELECT * FROM survivor_tournament_games
+     WHERE pool_id = $1 AND round = $2
+     ORDER BY game_date, id`,
+    [poolId, currentRound]
+  );
+
+  console.log(`[Survivor] getAvailableTeams: poolId=${poolId}, currentRound=${currentRound}, games found: ${gamesResult.rows.length}`);
+  if (gamesResult.rows.length === 0) {
+    // Debug: check what rounds exist
+    const allGames = await pool.query(
+      `SELECT round, COUNT(*) as count FROM survivor_tournament_games WHERE pool_id = $1 GROUP BY round ORDER BY round`,
+      [poolId]
+    );
+    console.log(`[Survivor] Available rounds in DB:`, allGames.rows);
+  }
+
+  // Build team list with availability
+  const teams = [];
+  for (const game of gamesResult.rows) {
+    const team1Available = !pickedTeamIds.has(game.team1_id) || survivorPool.allow_same_team_twice;
+    const team2Available = !pickedTeamIds.has(game.team2_id) || survivorPool.allow_same_team_twice;
+
+    teams.push({
+      teamId: game.team1_id,
+      teamName: game.team1_name,
+      seed: game.team1_seed,
+      logo: game.team1_logo,
+      available: team1Available,
+      espnGameId: game.espn_game_id,
+      gameDate: game.game_date,
+      opponent: {
+        teamId: game.team2_id,
+        teamName: game.team2_name,
+        seed: game.team2_seed
+      },
+      region: game.region
+    });
+
+    teams.push({
+      teamId: game.team2_id,
+      teamName: game.team2_name,
+      seed: game.team2_seed,
+      logo: game.team2_logo,
+      available: team2Available,
+      espnGameId: game.espn_game_id,
+      gameDate: game.game_date,
+      opponent: {
+        teamId: game.team1_id,
+        teamName: game.team1_name,
+        seed: game.team1_seed
+      },
+      region: game.region
+    });
+  }
+
+  return {
+    round: currentRound,
+    roundName: ROUND_NAMES[currentRound],
+    deadline: survivorPool.round_deadline,
+    teams
+  };
+}
+
+/**
+ * Submit a pick for the current round
+ */
+async function submitPick({ poolId, userId, teamId, teamName, teamSeed, teamLogo, espnGameId, opponentName, opponentSeed }) {
+  // Get pool
+  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];
+
+  // Check pool is active
+  if (survivorPool.status !== 'active' && survivorPool.status !== 'open') {
+    throw new Error(`Pool is ${survivorPool.status}, cannot submit picks`);
+  }
+
+  // Check deadline
+  if (survivorPool.round_deadline && new Date() > new Date(survivorPool.round_deadline)) {
+    throw new Error('Pick deadline has passed');
+  }
+
+  // Get user's entry
+  const entryResult = await pool.query(
+    'SELECT * FROM survivor_entries WHERE pool_id = $1 AND user_id = $2',
+    [poolId, userId]
+  );
+
+  if (entryResult.rows.length === 0) {
+    throw new Error('Not joined this pool');
+  }
+
+  const entry = entryResult.rows[0];
+
+  // Check if eliminated
+  if (!entry.is_alive) {
+    throw new Error('You have been eliminated from this pool');
+  }
+
+  // Check if team was already picked (if not allowed)
+  if (!survivorPool.allow_same_team_twice) {
+    const existingPick = await pool.query(
+      'SELECT id FROM survivor_picks WHERE entry_id = $1 AND team_id = $2',
+      [entry.id, teamId]
+    );
+
+    if (existingPick.rows.length > 0) {
+      throw new Error('You have already picked this team in a previous round');
+    }
+  }
+
+  // Upsert pick for current round (allows changing pick before deadline)
+  const result = await pool.query(
+    `INSERT INTO survivor_picks
+     (entry_id, round, team_id, team_name, team_seed, team_logo, espn_game_id, opponent_name, opponent_seed)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+     ON CONFLICT (entry_id, round)
+     DO UPDATE SET
+       team_id = EXCLUDED.team_id,
+       team_name = EXCLUDED.team_name,
+       team_seed = EXCLUDED.team_seed,
+       team_logo = EXCLUDED.team_logo,
+       espn_game_id = EXCLUDED.espn_game_id,
+       opponent_name = EXCLUDED.opponent_name,
+       opponent_seed = EXCLUDED.opponent_seed,
+       updated_at = NOW()
+     RETURNING *`,
+    [entry.id, survivorPool.current_round, teamId, teamName, teamSeed, teamLogo, espnGameId, opponentName, opponentSeed]
+  );
+
+  return formatPick(result.rows[0]);
+}
+
+/**
+ * Get all picks for a user's entry
+ */
+async function getUserPicks(poolId, userId) {
+  const result = await pool.query(
+    `SELECT sp.*
+     FROM survivor_picks sp
+     JOIN survivor_entries se ON se.id = sp.entry_id
+     WHERE se.pool_id = $1 AND se.user_id = $2
+     ORDER BY sp.round`,
+    [poolId, userId]
+  );
+
+  return result.rows.map(formatPick);
+}
+
+/**
+ * Get leaderboard - surviving entries
+ */
+async function getAliveEntries(poolId) {
+  // Get current round first
+  const poolResult = await pool.query(
+    `SELECT current_round FROM survivor_pools WHERE id = $1`,
+    [poolId]
+  );
+  const currentRound = poolResult.rows[0]?.current_round || 1;
+
+  const result = await pool.query(
+    `SELECT
+      se.*,
+      u.username,
+      u.avatar,
+      (SELECT COUNT(*) FROM survivor_picks WHERE entry_id = se.id AND result = 'won') as wins,
+      sp.team_name as current_pick_team,
+      sp.team_logo as current_pick_logo,
+      sp.team_id as current_pick_team_id
+    FROM survivor_entries se
+    JOIN users u ON u.id = se.user_id
+    LEFT JOIN survivor_picks sp ON sp.entry_id = se.id AND sp.round = $2
+    WHERE se.pool_id = $1 AND se.is_alive = true
+    ORDER BY wins DESC, se.created_at`,
+    [poolId, currentRound]
+  );
+
+  return result.rows;
+}
+
+/**
+ * Get eliminated entries
+ */
+async function getEliminatedEntries(poolId) {
+  const result = await pool.query(
+    `SELECT
+      se.*,
+      u.username,
+      u.avatar,
+      sp.team_name as eliminated_by_pick,
+      sp.team_logo as eliminated_by_logo,
+      sp.team_id as eliminated_by_team_id,
+      (SELECT COUNT(*) FROM survivor_picks WHERE entry_id = se.id AND result = 'won') as wins
+    FROM survivor_entries se
+    JOIN users u ON u.id = se.user_id
+    LEFT JOIN survivor_picks sp ON sp.entry_id = se.id AND sp.round = se.eliminated_at_round
+    WHERE se.pool_id = $1 AND se.is_alive = false
+    ORDER BY se.eliminated_at_round DESC, se.updated_at DESC`,
+    [poolId]
+  );
+
+  return result.rows;
+}
+
+/**
+ * Get pool stats summary
+ */
+async function getPoolStats(poolId) {
+  const result = await pool.query(
+    `SELECT
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1) as total_entries,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1 AND is_alive = true) as alive_count,
+      (SELECT COUNT(*) FROM survivor_entries WHERE pool_id = $1 AND is_alive = false) as eliminated_count,
+      (SELECT buy_in_lamports FROM survivor_pools WHERE id = $1) as buy_in_lamports,
+      (SELECT current_round FROM survivor_pools WHERE id = $1) as current_round,
+      (SELECT status FROM survivor_pools WHERE id = $1) as status
+    `,
+    [poolId]
+  );
+
+  const stats = result.rows[0];
+  const totalPotLamports = BigInt(stats.buy_in_lamports || 0) * BigInt(stats.total_entries || 0);
+  const feePercentage = 6; // 6% total fee
+  const netPotLamports = totalPotLamports - (totalPotLamports * BigInt(feePercentage) / BigInt(100));
+
+  return {
+    totalEntries: parseInt(stats.total_entries) || 0,
+    aliveCount: parseInt(stats.alive_count) || 0,
+    eliminatedCount: parseInt(stats.eliminated_count) || 0,
+    currentRound: stats.current_round,
+    roundName: ROUND_NAMES[stats.current_round],
+    status: stats.status,
+    totalPotLamports: totalPotLamports.toString(),
+    totalPotSol: Number(totalPotLamports) / LAMPORTS_PER_SOL,
+    netPotLamports: netPotLamports.toString(),
+    netPotSol: Number(netPotLamports) / LAMPORTS_PER_SOL,
+    potentialWinningsPerSurvivor: stats.alive_count > 0
+      ? Number(netPotLamports) / LAMPORTS_PER_SOL / parseInt(stats.alive_count)
+      : 0
+  };
+}
+
+/**
+ * Import tournament games from ESPN data
+ */
+async function importTournamentGames(poolId, games) {
+  const insertedGames = [];
+
+  for (const game of games) {
+    const result = await pool.query(
+      `INSERT INTO survivor_tournament_games
+       (pool_id, round, espn_game_id, game_date, team1_id, team1_name, team1_seed, team1_logo,
+        team2_id, team2_name, team2_seed, team2_logo, region, status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+       ON CONFLICT (pool_id, espn_game_id) DO UPDATE SET
+         game_date = EXCLUDED.game_date,
+         team1_name = EXCLUDED.team1_name,
+         team2_name = EXCLUDED.team2_name,
+         status = EXCLUDED.status,
+         updated_at = NOW()
+       RETURNING *`,
+      [
+        poolId,
+        game.round,
+        game.espnGameId,
+        game.gameDate,
+        game.team1Id,
+        game.team1Name,
+        game.team1Seed,
+        game.team1Logo,
+        game.team2Id,
+        game.team2Name,
+        game.team2Seed,
+        game.team2Logo,
+        game.region,
+        game.status || 'scheduled'
+      ]
+    );
+
+    insertedGames.push(result.rows[0]);
+  }
+
+  return insertedGames;
+}
+
+/**
+ * Update tournament game result
+ */
+async function updateGameResult(poolId, espnGameId, { winnerId, team1Score, team2Score, status }) {
+  const result = await pool.query(
+    `UPDATE survivor_tournament_games
+     SET winner_id = $3, team1_score = $4, team2_score = $5, status = $6, updated_at = NOW()
+     WHERE pool_id = $1 AND espn_game_id = $2
+     RETURNING *`,
+    [poolId, espnGameId, winnerId, team1Score, team2Score, status]
+  );
+
+  return result.rows[0];
+}
+
+// Helper function to format pick for API response
+function formatPick(row) {
+  return {
+    id: row.id,
+    entryId: row.entry_id,
+    round: row.round,
+    teamId: row.team_id,
+    teamName: row.team_name,
+    teamLogo: row.team_logo,
+    espnGameId: row.espn_game_id,
+    opponentName: row.opponent_name,
+    opponentSeed: row.opponent_seed,
+    result: row.result,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// Helper function to format pool for API response
+function formatPool(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    year: row.year,
+    buyInLamports: row.buy_in_lamports,
+    buyInSol: Number(row.buy_in_lamports) / LAMPORTS_PER_SOL,
+    currentRound: row.current_round,
+    roundName: ROUND_NAMES[row.current_round],
+    roundDeadline: row.round_deadline,
+    status: row.status,
+    allowSameTeamTwice: row.allow_same_team_twice,
+    solanaGameId: row.solana_game_id,
+    createdBy: row.created_by,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    entryCount: parseInt(row.total_entries) || 0,
+    aliveCount: parseInt(row.alive_count) || 0,
+    totalPotLamports: row.total_pot_lamports,
+    totalPotSol: row.total_pot_lamports ? Number(row.total_pot_lamports) / LAMPORTS_PER_SOL : undefined
+  };
+}
+
+module.exports = {
+  createPool,
+  getPools,
+  getPoolById,
+  updatePool,
+  joinPool,
+  getUserEntry,
+  getAvailableTeams,
+  submitPick,
+  getUserPicks,
+  getAliveEntries,
+  getEliminatedEntries,
+  getPoolStats,
+  importTournamentGames,
+  updateGameResult,
+  ROUND_NAMES
+};

package/cron/oracleMonitor.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Oracle Monitor - Cron job for automatic sports game resolution
+ * Checks pending games every 1 minute and resolves completed ones
+ */
+
+require('dotenv').config();
+const { Keypair } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+const AutomaticGameOracle = require('../services/automaticGameOracle');
+
+// Load oracle wallet
+function loadOracleWallet() {
+  // Try environment variable first (for Heroku)
+  if (process.env.ORACLE_WALLET_JSON) {
+    console.log('🔑 Loading oracle wallet from environment variable');
+    const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+  
+  // Fallback to file (for local development)
+  const oracleWalletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, '../wallets/oracle.json');
+  
+  if (!fs.existsSync(oracleWalletPath)) {
+    console.error(`❌ Oracle wallet not found at: ${oracleWalletPath}`);
+    console.log('💡 Create one with: solana-keygen new -o wallets/oracle.json');
+    console.log('💡 Or set ORACLE_WALLET_JSON environment variable');
+    process.exit(1);
+  }
+  
+  console.log('🔑 Loading oracle wallet from file:', oracleWalletPath);
+  const secretKey = JSON.parse(fs.readFileSync(oracleWalletPath, 'utf-8'));
+  return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+}
+
+// Configuration
+const config = {
+  rpcUrl: process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com',
+  programId: process.env.PROGRAM_ID || '8DJTkgk6MDr6tPtw4v2VzYAz9WWvmCg6786vZrEK3o5q',
+  oracleKeypair: loadOracleWallet(),
+  liveScoresApiUrl: process.env.LIVE_SCORES_API_URL || 'http://localhost:3002',
+  // PostgreSQL dubs-server URL - Use PORT-based URL for local dev, explicit URL for production
+  dubsServerUrl: process.env.DUBS_SERVER_URL || `http://localhost:${process.env.PORT || 3001}`,
+  checkIntervalMs: parseInt(process.env.ORACLE_CHECK_INTERVAL || '60000'), // 1 minute
+  notifyBeforeMinutes: parseInt(process.env.NOTIFY_BEFORE_MINUTES || '10'), // Notify 10 minutes before
+};
+
+console.log('🤖 Initializing Oracle Monitor...');
+console.log(`   RPC: ${config.rpcUrl}`);
+console.log(`   Program ID: ${config.programId}`);
+console.log(`   Oracle: ${config.oracleKeypair.publicKey.toString()}`);
+console.log(`   PostgreSQL: ${config.dubsServerUrl}`);
+console.log(`   Live Scores API: ${config.liveScoresApiUrl}`);
+console.log(`   Check interval: ${config.checkIntervalMs / 1000}s`);
+console.log(`   Notify before: ${config.notifyBeforeMinutes} minutes`);
+
+// Create and start oracle
+const oracle = new AutomaticGameOracle(config);
+oracle.start();
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n👋 Shutting down oracle monitor...');
+  oracle.stop();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log('\n👋 Shutting down oracle monitor...');
+  oracle.stop();
+  process.exit(0);
+});
+
+console.log('✅ Oracle monitor started successfully!');
+console.log('   Press Ctrl+C to stop\n');
+