dubs-server 1.0.0

package/scripts/important/check-game-status.js

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+/**
+ * Check Game Status Script
+ * Shows all players, their picks, win/loss status, and claim status
+ *
+ * Usage:
+ *   node scripts/check-game-status.js <gameId>
+ *
+ * Examples:
+ *   node scripts/check-game-status.js sport-1769329525013-mmekk2qqd
+ *
+ * Environment:
+ *   DATABASE_URL - PostgreSQL connection string (uses Heroku if not set)
+ */
+
+const { Pool } = require('pg');
+
+// Get database URL from environment or use Heroku
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  console.error('❌ DATABASE_URL not set. Run with:');
+  console.error('   heroku config:get DATABASE_URL -a dubs-server-prod | xargs -I {} DATABASE_URL={} node scripts/check-game-status.js <gameId>');
+  console.error('');
+  console.error('Or for a one-liner:');
+  console.error('   DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/check-game-status.js <gameId>');
+  process.exit(1);
+}
+
+const pool = new Pool({
+  connectionString: DATABASE_URL,
+  ssl: { rejectUnauthorized: false }
+});
+
+async function checkGameStatus(gameId) {
+  console.log('');
+  console.log('🎮 Game Status Check');
+  console.log('====================');
+  console.log(`Game ID: ${gameId}`);
+  console.log('');
+
+  try {
+    // Get game data
+    const gameResult = await pool.query(`
+      SELECT
+        g.game_id,
+        g.buy_in,
+        g.is_resolved,
+        g.home_team_players,
+        g.away_team_players,
+        g.draw_team_players,
+        g.player_amounts,
+        g.sports_event->>'strHomeTeam' as home_team,
+        g.sports_event->>'strAwayTeam' as away_team,
+        g.sports_event->'finalScore'->>'winner' as winner,
+        g.sports_event->'finalScore'->>'homeScore' as home_score,
+        g.sports_event->'finalScore'->>'awayScore' as away_score
+      FROM games g
+      WHERE g.game_id = $1
+    `, [gameId]);
+
+    if (gameResult.rows.length === 0) {
+      console.error('❌ Game not found');
+      process.exit(1);
+    }
+
+    const game = gameResult.rows[0];
+
+    // Display game info
+    const homeTeam = game.home_team || 'Home';
+    const awayTeam = game.away_team || 'Away';
+
+    console.log('📊 Game Info');
+    console.log('------------');
+    console.log(`${homeTeam} vs ${awayTeam}`);
+    if (game.is_resolved && !game.winner) {
+      console.log(`Score: ${game.home_score || 0} - ${game.away_score || 0}`);
+      console.log('Result: REFUND 💰 (no competition)');
+    } else if (game.winner) {
+      console.log(`Score: ${game.home_score} - ${game.away_score}`);
+      console.log(`Winner: ${game.winner === 'home' ? homeTeam : game.winner === 'away' ? awayTeam : 'Draw'}`);
+    } else {
+      console.log('Status: Not resolved yet');
+    }
+    console.log(`Buy-in: ${parseFloat(game.buy_in).toFixed(4)} SOL`);
+    console.log(`Resolved: ${game.is_resolved ? 'Yes ✅' : 'No ⏳'}`);
+    console.log('');
+
+    // Get all participants with their claim status + promo code info
+    const participantsResult = await pool.query(`
+      SELECT
+        ugr.wallet_address,
+        u.username,
+        ugr.team_choice,
+        ugr.claimed_at,
+        ugr.claim_signature,
+        ugr.amount_claimed,
+        pc.code as promo_code
+      FROM user_game_refs ugr
+      LEFT JOIN users u ON ugr.wallet_address = u.wallet_address
+      LEFT JOIN promo_codes pc ON pc.used_by = ugr.wallet_address AND pc.used_in_game = ugr.game_id
+      WHERE ugr.game_id = $1
+      ORDER BY ugr.team_choice, ugr.joined_at
+    `, [gameId]);
+
+    if (participantsResult.rows.length === 0) {
+      console.log('❌ No participants found');
+      process.exit(1);
+    }
+
+    // Calculate totals - support both legacy and pari-mutuel
+    const totalPlayers = participantsResult.rows.length;
+    const buyIn = parseFloat(game.buy_in);
+    const playerAmounts = game.player_amounts || {};
+
+    // Check if pari-mutuel (has player_amounts entries)
+    const isPariMutuel = Object.keys(playerAmounts).length > 0;
+
+    // Get player's bet amount (from player_amounts if pari-mutuel, else buy_in)
+    const getPlayerAmount = (wallet) => {
+      if (playerAmounts[wallet] !== undefined) {
+        return parseFloat(playerAmounts[wallet]);
+      }
+      return buyIn; // Legacy player
+    };
+
+    // Calculate actual total pot from all players
+    const allPlayers = [
+      ...(game.home_team_players || []),
+      ...(game.away_team_players || []),
+      ...(game.draw_team_players || []),
+    ];
+    const totalPot = allPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+    // 6% total fee (5% platform + 1% oracle), 5% if user has referrer
+    const platformFee = totalPot * 0.06;
+    const winnerPool = totalPot - platformFee;
+
+    // Calculate team pools for pari-mutuel payout calculation
+    const homePlayers = game.home_team_players || [];
+    const awayPlayers = game.away_team_players || [];
+    const homeTeamPool = homePlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+    const awayTeamPool = awayPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+
+    // Determine winners
+    const winningTeam = game.winner; // 'home', 'away', or 'draw'
+    const winners = participantsResult.rows.filter(p => p.team_choice === winningTeam);
+
+    // Calculate winner pool by team for pari-mutuel payout calculation
+    const winnerTeamPool = winners.reduce((sum, p) => sum + getPlayerAmount(p.wallet_address), 0);
+
+    console.log('💰 Pot Breakdown');
+    console.log('----------------');
+    console.log(`Mode: ${isPariMutuel ? 'Pari-Mutuel 🎰' : 'Legacy (equal split)'}`);
+    console.log(`Total Players: ${totalPlayers}`);
+    console.log(`Total Pot: ${totalPot.toFixed(4)} SOL`);
+    console.log(`Platform Fee (6%): ${platformFee.toFixed(4)} SOL`);
+    console.log(`Winner Pool: ${winnerPool.toFixed(4)} SOL`);
+
+    const isRefund = game.is_resolved && !winningTeam;
+
+    if (isRefund) {
+      // Refund scenario — show team breakdown
+      console.log('');
+      console.log(`📊 Team Pools:`);
+      console.log(`   ${homeTeam}: ${homeTeamPool.toFixed(4)} SOL (${homePlayers.length} players)`);
+      console.log(`   ${awayTeam}: ${awayTeamPool.toFixed(4)} SOL (${awayPlayers.length} players)`);
+      const refundPerPlayer = (totalPot - platformFee) / totalPlayers;
+      console.log(`Refund per player: ~${refundPerPlayer.toFixed(4)} SOL (after 6% fee)`);
+    } else if (!game.is_resolved) {
+      // Show team breakdown for pending games
+      console.log('');
+      console.log(`📊 Team Pools:`);
+      console.log(`   ${homeTeam}: ${homeTeamPool.toFixed(4)} SOL (${homePlayers.length} players)`);
+      console.log(`   ${awayTeam}: ${awayTeamPool.toFixed(4)} SOL (${awayPlayers.length} players)`);
+      if (isPariMutuel) {
+        // Show potential odds
+        const homeOdds = homeTeamPool > 0 ? (winnerPool / homeTeamPool).toFixed(2) : '∞';
+        const awayOdds = awayTeamPool > 0 ? (winnerPool / awayTeamPool).toFixed(2) : '∞';
+        console.log(`   ${homeTeam} odds: ${homeOdds}x | ${awayTeam} odds: ${awayOdds}x`);
+      }
+    } else {
+      console.log(`Winners: ${winners.length}`);
+      if (isPariMutuel && winners.length > 0) {
+        console.log(`Winners' Total Bets: ${winnerTeamPool.toFixed(4)} SOL`);
+        console.log(`Payout: ${winnerPool.toFixed(4)} SOL split proportionally by bet size`);
+      } else if (winners.length > 0) {
+        const perWinnerAmount = winnerPool / winners.length;
+        console.log(`Per Winner: ${perWinnerAmount.toFixed(4)} SOL`);
+      }
+    }
+    console.log('');
+
+    // Display participants table
+    console.log('👥 Players');
+    console.log('----------');
+    console.log('');
+
+    // Table header
+    const header = '| Username       | Team Picked    | Bet      | Result   | Claimed  | Payout       |';
+    const divider = '|----------------|----------------|----------|----------|----------|--------------|';
+    console.log(header);
+    console.log(divider);
+
+    for (const p of participantsResult.rows) {
+      const username = (p.username || p.wallet_address.slice(0, 8) + '...').padEnd(14);
+      const teamName = p.team_choice === 'home' ? (game.home_team || 'Home') :
+                       p.team_choice === 'away' ? (game.away_team || 'Away') : 'Draw';
+      const teamDisplay = teamName.slice(0, 14).padEnd(14);
+      const playerBet = getPlayerAmount(p.wallet_address);
+      const betDisplay = playerBet.toFixed(2).padStart(6) + ' ';
+
+      let result, claimStatus, payout;
+
+      if (isRefund) {
+        // Refund scenario
+        if (p.promo_code) {
+          // Sponsored player — refund goes to treasury, not player
+          result = 'PROMO 🎟️';
+          claimStatus = 'N/A      ';
+          payout = '  → treasury  ';
+        } else {
+          result = 'REFUND 💰';
+          claimStatus = p.claimed_at ? 'Yes ✅   ' : 'No ⏳    ';
+          const refundAmount = (totalPot - platformFee) / totalPlayers;
+          payout = refundAmount.toFixed(4).padStart(10) + ' SOL';
+        }
+      } else if (!game.is_resolved) {
+        // Game not resolved yet - calculate "if win" payout
+        result = 'PENDING ⏳';
+        claimStatus = 'N/A      ';
+
+        // Calculate expected payout if this player's team wins
+        const playerTeamPool = p.team_choice === 'home' ? homeTeamPool : awayTeamPool;
+        let expectedIfWin;
+        if (isPariMutuel && playerTeamPool > 0) {
+          const share = playerBet / playerTeamPool;
+          expectedIfWin = winnerPool * share;
+        } else {
+          // Legacy: equal split among team members
+          const teamCount = p.team_choice === 'home' ? homePlayers.length : awayPlayers.length;
+          expectedIfWin = teamCount > 0 ? winnerPool / teamCount : 0;
+        }
+        payout = `~${expectedIfWin.toFixed(4)} SOL`;
+      } else {
+        const isWinner = p.team_choice === winningTeam;
+        result = isWinner ? 'WON ✅  ' : 'LOST ❌ ';
+
+        if (isWinner) {
+          claimStatus = p.claimed_at ? 'Yes ✅   ' : 'No ⏳    ';
+          // Always calculate expected payout (don't trust DB amount_claimed which may be wrong)
+          let expectedPayout;
+          if (isPariMutuel && winnerTeamPool > 0) {
+            // Pari-mutuel: proportional payout
+            const share = playerBet / winnerTeamPool;
+            expectedPayout = winnerPool * share;
+          } else {
+            // Legacy: equal split
+            expectedPayout = winnerPool / winners.length;
+          }
+          payout = expectedPayout.toFixed(4).padStart(10) + ' SOL';
+        } else {
+          claimStatus = 'N/A      ';
+          payout = '      0 SOL   ';
+        }
+      }
+
+      console.log(`| ${username} | ${teamDisplay} | ${betDisplay} | ${result} | ${claimStatus} | ${payout} |`);
+    }
+
+    console.log('');
+
+    // Claim transactions section
+    const claimedPlayers = participantsResult.rows.filter(p => p.claim_signature);
+    if (claimedPlayers.length > 0) {
+      console.log('🔗 Claim Transactions');
+      console.log('---------------------');
+      for (const p of claimedPlayers) {
+        const username = p.username || p.wallet_address.slice(0, 8) + '...';
+        const dbAmount = p.amount_claimed ? parseFloat(p.amount_claimed) : null;
+        const playerBet = getPlayerAmount(p.wallet_address);
+
+        // Calculate expected payout
+        let expectedPayout;
+        if (isPariMutuel && winnerTeamPool > 0) {
+          const share = playerBet / winnerTeamPool;
+          expectedPayout = winnerPool * share;
+        } else {
+          expectedPayout = winnerPool / winners.length;
+        }
+
+        const explorerUrl = `https://explorer.solana.com/tx/${p.claim_signature}`;
+
+        // Check for discrepancy (>1% difference)
+        const hasDiscrepancy = dbAmount && Math.abs(dbAmount - expectedPayout) / expectedPayout > 0.01;
+
+        console.log(`${username}:`);
+        console.log(`   Expected: ${expectedPayout.toFixed(4)} SOL`);
+        if (dbAmount) {
+          console.log(`   DB Stored: ${dbAmount.toFixed(4)} SOL${hasDiscrepancy ? ' ⚠️  MISMATCH' : ''}`);
+        }
+        console.log(`   Signature: ${p.claim_signature}`);
+        console.log(`   Explorer:  ${explorerUrl}`);
+        console.log('');
+      }
+    }
+
+    // Summary
+    console.log('📋 Summary');
+    console.log('----------');
+
+    if (isRefund) {
+      const sponsoredPlayers = participantsResult.rows.filter(p => p.promo_code);
+      const regularPlayers = participantsResult.rows.filter(p => !p.promo_code);
+      const claimedCount = regularPlayers.filter(p => p.claimed_at).length;
+
+      console.log(`💰 REFUND — ${regularPlayers.length} player(s) eligible for refund`);
+      if (sponsoredPlayers.length > 0) {
+        console.log(`🎟️  ${sponsoredPlayers.length} sponsored player(s) — refund goes to treasury`);
+        for (const p of sponsoredPlayers) {
+          console.log(`   - ${p.username || p.wallet_address.slice(0, 8) + '...'} (code: ${p.promo_code})`);
+        }
+      }
+      console.log(`Claimed: ${claimedCount}/${regularPlayers.length}`);
+
+      const unclaimed = regularPlayers.filter(p => !p.claimed_at);
+      if (unclaimed.length > 0) {
+        console.log('');
+        console.log('⏳ Pending refund claims:');
+        for (const p of unclaimed) {
+          console.log(`   - ${p.username || p.wallet_address.slice(0, 8) + '...'}`);
+        }
+      } else if (regularPlayers.length > 0) {
+        console.log('✅ All players have claimed their refund!');
+      }
+    } else if (!game.is_resolved) {
+      console.log('⏳ Game not yet resolved - waiting for final score');
+      console.log(`   ${totalPlayers} players waiting for result`);
+    } else {
+      const claimedCount = winners.filter(w => w.claimed_at).length;
+      console.log(`Winners claimed: ${claimedCount}/${winners.length}`);
+
+      if (claimedCount < winners.length) {
+        console.log('');
+        console.log('⏳ Pending claims:');
+        for (const w of winners.filter(w => !w.claimed_at)) {
+          console.log(`   - ${w.username || w.wallet_address.slice(0, 8) + '...'}`);
+        }
+      } else if (winners.length > 0) {
+        console.log('✅ All winners have claimed!');
+      }
+    }
+
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+// Main
+const gameId = process.argv[2];
+if (!gameId) {
+  console.log('Usage: node scripts/check-game-status.js <gameId>');
+  console.log('');
+  console.log('Example:');
+  console.log('  DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/check-game-status.js sport-1769329525013-mmekk2qqd');
+  process.exit(1);
+}
+
+checkGameStatus(gameId);

package/scripts/important/list-pending-games-by-version.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+/**
+ * List Pending Games by Version (V1 Legacy vs V2 Pari-Mutuel)
+ *
+ * Shows all pending games in production with full player details:
+ * - V1 (Legacy): Equal split payouts, no player_amounts
+ * - V2 (Pari-Mutuel): Proportional payouts based on bet amounts
+ *
+ * Usage:
+ *   DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/list-pending-games-by-version.js
+ */
+
+const { Pool } = require('pg');
+
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  console.error('❌ DATABASE_URL not set. Run with:');
+  console.error('   DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/list-pending-games-by-version.js');
+  process.exit(1);
+}
+
+const pool = new Pool({
+  connectionString: DATABASE_URL,
+  ssl: { rejectUnauthorized: false }
+});
+
+async function getGameDetails(game) {
+  const playerAmounts = game.player_amounts || {};
+  const buyIn = parseFloat(game.buy_in);
+
+  // Count total players
+  const homePlayers = game.home_team_players || [];
+  const awayPlayers = game.away_team_players || [];
+  const drawPlayers = game.draw_team_players || [];
+  const totalPlayerCount = homePlayers.length + awayPlayers.length + drawPlayers.length;
+
+  // V2 (pure pari-mutuel) = ALL players are in player_amounts
+  // V1/Hybrid = some players are NOT in player_amounts (legacy mode)
+  const playerAmountsCount = Object.keys(playerAmounts).length;
+  const isPariMutuel = totalPlayerCount > 0 && playerAmountsCount === totalPlayerCount;
+
+  const getPlayerAmount = (wallet) => {
+    if (playerAmounts[wallet] !== undefined) {
+      return parseFloat(playerAmounts[wallet]);
+    }
+    return buyIn;
+  };
+
+  // Get participants
+  const participantsResult = await pool.query(`
+    SELECT
+      ugr.wallet_address,
+      u.username,
+      ugr.team_choice
+    FROM user_game_refs ugr
+    LEFT JOIN users u ON ugr.wallet_address = u.wallet_address
+    WHERE ugr.game_id = $1
+    ORDER BY ugr.team_choice, ugr.joined_at
+  `, [game.game_id]);
+
+  // Calculate pools
+  const homeTeamPool = homePlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+  const awayTeamPool = awayPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+  const drawTeamPool = drawPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+  const totalPot = homeTeamPool + awayTeamPool + drawTeamPool;
+  const platformFee = totalPot * 0.06;
+  const winnerPool = totalPot - platformFee;
+
+  // Calculate odds
+  const homeOdds = homeTeamPool > 0 ? (winnerPool / homeTeamPool).toFixed(2) : '∞';
+  const awayOdds = awayTeamPool > 0 ? (winnerPool / awayTeamPool).toFixed(2) : '∞';
+  const drawOdds = drawTeamPool > 0 ? (winnerPool / drawTeamPool).toFixed(2) : '∞';
+
+  // Build player details
+  const players = participantsResult.rows.map(p => {
+    const playerBet = getPlayerAmount(p.wallet_address);
+    const playerTeamPool = p.team_choice === 'home' ? homeTeamPool :
+                           p.team_choice === 'away' ? awayTeamPool : drawTeamPool;
+
+    let expectedIfWin;
+    if (isPariMutuel && playerTeamPool > 0) {
+      const share = playerBet / playerTeamPool;
+      expectedIfWin = winnerPool * share;
+    } else {
+      // Legacy: equal split among team members
+      const teamCount = p.team_choice === 'home' ? homePlayers.length :
+                        p.team_choice === 'away' ? awayPlayers.length : drawPlayers.length;
+      expectedIfWin = teamCount > 0 ? winnerPool / teamCount : 0;
+    }
+
+    return {
+      username: p.username || p.wallet_address.slice(0, 8) + '...',
+      wallet: p.wallet_address,
+      team: p.team_choice,
+      teamName: p.team_choice === 'home' ? game.home_team :
+                p.team_choice === 'away' ? game.away_team : 'Draw',
+      bet: playerBet,
+      expectedPayout: expectedIfWin
+    };
+  });
+
+  return {
+    id: game.game_id,
+    matchup: `${game.home_team || 'Unknown'} vs ${game.away_team || 'Unknown'}`,
+    homeTeam: game.home_team || 'Home',
+    awayTeam: game.away_team || 'Away',
+    type: game.game_type || 'sports',
+    eventTime: game.event_time ? new Date(game.event_time + 'Z').toLocaleString() : 'N/A',
+    isPariMutuel,
+    buyIn,
+    totalPot,
+    winnerPool,
+    homeTeamPool,
+    awayTeamPool,
+    drawTeamPool,
+    homeOdds,
+    awayOdds,
+    drawOdds,
+    homePlayers: homePlayers.length,
+    awayPlayers: awayPlayers.length,
+    drawPlayers: drawPlayers.length,
+    players
+  };
+}
+
+function printGameDetails(game) {
+  const homeTeam = game.homeTeam || 'Home';
+  const awayTeam = game.awayTeam || 'Away';
+
+  console.log(`   ┌─────────────────────────────────────────────────────────────────`);
+  console.log(`   │ 🎯 ${game.id}`);
+  console.log(`   │    ${game.matchup}`);
+  console.log(`   │    Type: ${game.type} | Event: ${game.eventTime}`);
+  console.log(`   │`);
+  console.log(`   │    💰 Pot: ${game.totalPot.toFixed(4)} SOL → Winner Pool: ${game.winnerPool.toFixed(4)} SOL (after 6% fee)`);
+  console.log(`   │`);
+  console.log(`   │    📊 Team Pools:`);
+  console.log(`   │       ${homeTeam}: ${game.homeTeamPool.toFixed(4)} SOL (${game.homePlayers} players) → ${game.homeOdds}x if win`);
+  console.log(`   │       ${awayTeam}: ${game.awayTeamPool.toFixed(4)} SOL (${game.awayPlayers} players) → ${game.awayOdds}x if win`);
+  if (game.drawPlayers > 0) {
+    console.log(`   │       Draw: ${game.drawTeamPool.toFixed(4)} SOL (${game.drawPlayers} players) → ${game.drawOdds}x if win`);
+  }
+  console.log(`   │`);
+  console.log(`   │    👥 Players:`);
+  console.log(`   │    ┌──────────────────┬────────────────┬──────────┬──────────────┐`);
+  console.log(`   │    │ Username         │ Team           │ Bet      │ If Win       │`);
+  console.log(`   │    ├──────────────────┼────────────────┼──────────┼──────────────┤`);
+
+  for (const p of game.players) {
+    const username = (p.username || 'Unknown').slice(0, 16).padEnd(16);
+    const team = (p.teamName || p.team || 'Unknown').slice(0, 14).padEnd(14);
+    const bet = p.bet.toFixed(4).padStart(8);
+    const payout = p.expectedPayout.toFixed(4).padStart(10) + ' SOL';
+    console.log(`   │    │ ${username} │ ${team} │ ${bet} │ ${payout} │`);
+  }
+
+  console.log(`   │    └──────────────────┴────────────────┴──────────┴──────────────┘`);
+  console.log(`   └─────────────────────────────────────────────────────────────────`);
+  console.log('');
+}
+
+async function listPendingGamesByVersion() {
+  console.log('');
+  console.log('╔═══════════════════════════════════════════════════════════════════╗');
+  console.log('║           🎮 PENDING GAMES BY VERSION (V1 vs V2)                  ║');
+  console.log('╚═══════════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  try {
+    // Get all pending games
+    const result = await pool.query(`
+      SELECT
+        g.game_id,
+        g.buy_in,
+        g.player_amounts,
+        g.home_team_players,
+        g.away_team_players,
+        g.draw_team_players,
+        g.sports_event->>'strHomeTeam' as home_team,
+        g.sports_event->>'strAwayTeam' as away_team,
+        g.sports_event->>'strTimestamp' as event_time,
+        g.game_type,
+        g.created_at
+      FROM games g
+      WHERE g.is_resolved = false
+      ORDER BY g.created_at DESC
+    `);
+
+    if (result.rows.length === 0) {
+      console.log('✅ No pending games found');
+      process.exit(0);
+    }
+
+    const v1Games = [];
+    const v2Games = [];
+
+    // Process all games
+    for (const game of result.rows) {
+      const details = await getGameDetails(game);
+      if (details.isPariMutuel) {
+        v2Games.push(details);
+      } else {
+        v1Games.push(details);
+      }
+    }
+
+    // Display V1 (Legacy/Hybrid) games
+    console.log('┌───────────────────────────────────────────────────────────────────┐');
+    console.log('│  📦 V1 (LEGACY/HYBRID) - Equal Split Payouts                      │');
+    console.log('│     Detection: player_amounts.length != total_players             │');
+    console.log('└───────────────────────────────────────────────────────────────────┘');
+    console.log('');
+
+    if (v1Games.length === 0) {
+      console.log('   (none)');
+      console.log('');
+    } else {
+      console.log(`   Total: ${v1Games.length} games`);
+      console.log('');
+      for (const game of v1Games) {
+        printGameDetails(game);
+      }
+    }
+
+    // Display V2 (Pari-Mutuel) games
+    console.log('┌───────────────────────────────────────────────────────────────────┐');
+    console.log('│  🎰 V2 (PARI-MUTUEL) - Proportional Payouts                       │');
+    console.log('│     Detection: player_amounts has entries                         │');
+    console.log('└───────────────────────────────────────────────────────────────────┘');
+    console.log('');
+
+    if (v2Games.length === 0) {
+      console.log('   (none)');
+      console.log('');
+    } else {
+      console.log(`   Total: ${v2Games.length} games`);
+      console.log('');
+      for (const game of v2Games) {
+        printGameDetails(game);
+      }
+    }
+
+    // Summary
+    console.log('╔═══════════════════════════════════════════════════════════════════╗');
+    console.log('║                          📊 SUMMARY                               ║');
+    console.log('╠═══════════════════════════════════════════════════════════════════╣');
+
+    const v1Pot = v1Games.reduce((sum, g) => sum + g.totalPot, 0);
+    const v2Pot = v2Games.reduce((sum, g) => sum + g.totalPot, 0);
+    const v1Players = v1Games.reduce((sum, g) => sum + g.players.length, 0);
+    const v2Players = v2Games.reduce((sum, g) => sum + g.players.length, 0);
+
+    console.log(`║  V1 (Legacy/Hybrid): ${String(v1Games.length).padStart(3)} games | ${String(v1Players).padStart(4)} players | ${v1Pot.toFixed(4).padStart(10)} SOL  ║`);
+    console.log(`║  V2 (Pari-Mutuel): ${String(v2Games.length).padStart(3)} games | ${String(v2Players).padStart(4)} players | ${v2Pot.toFixed(4).padStart(10)} SOL    ║`);
+    console.log(`║  ─────────────────────────────────────────────────────────────   ║`);
+    console.log(`║  TOTAL:            ${String(result.rows.length).padStart(3)} games | ${String(v1Players + v2Players).padStart(4)} players | ${(v1Pot + v2Pot).toFixed(4).padStart(10)} SOL    ║`);
+    console.log('╚═══════════════════════════════════════════════════════════════════╝');
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+listPendingGamesByVersion();