dubs-server 1.0.0

package/services/userProfileStatsService.js

@@ -0,0 +1,1185 @@
+/**
+ * 📊 User Profile Stats Service
+ * 
+ * High-performance service for fetching comprehensive user statistics
+ * including PNL from jackpot games AND sports betting games.
+ * 
+ * Optimized with:
+ * - Single efficient SQL query joining all relevant tables
+ * - In-memory caching with TTL
+ * - Batch-friendly design for leaderboards
+ */
+
+const { pool } = require('./db'); // Shared database pool
+
+class UserProfileStatsService {
+  constructor() {
+    // Use shared pool from services/db.js
+    this.pool = pool;
+
+    // Simple in-memory cache with TTL (30 seconds)
+    this.cache = new Map();
+    this.CACHE_TTL = 30 * 1000; // 30 seconds
+
+    this.initializeTables();
+  }
+
+  async initializeTables() {
+    try {
+      // Create sports_betting_stats table for aggregated sports stats
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS sports_betting_stats (
+          wallet_address VARCHAR(100) PRIMARY KEY,
+          games_created INTEGER DEFAULT 0,
+          games_joined INTEGER DEFAULT 0,
+          games_won INTEGER DEFAULT 0,
+          games_lost INTEGER DEFAULT 0,
+          total_wagered_sol NUMERIC(20, 9) DEFAULT 0,
+          total_won_sol NUMERIC(20, 9) DEFAULT 0,
+          net_pnl_sol NUMERIC(20, 9) DEFAULT 0,
+          biggest_win_sol NUMERIC(20, 9) DEFAULT 0,
+          biggest_win_game_id VARCHAR(255),
+          current_win_streak INTEGER DEFAULT 0,
+          longest_win_streak INTEGER DEFAULT 0,
+          last_played_at TIMESTAMP,
+          created_at TIMESTAMP DEFAULT NOW(),
+          updated_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        CREATE INDEX IF NOT EXISTS idx_sports_stats_pnl ON sports_betting_stats(net_pnl_sol DESC);
+        CREATE INDEX IF NOT EXISTS idx_sports_stats_wagered ON sports_betting_stats(total_wagered_sol DESC);
+        CREATE INDEX IF NOT EXISTS idx_sports_stats_wins ON sports_betting_stats(games_won DESC);
+      `);
+
+      console.log('✅ User profile stats tables initialized');
+    } catch (error) {
+      console.error('❌ Failed to initialize user profile stats tables:', error.message);
+    }
+  }
+
+  /**
+   * Get comprehensive user profile stats (cached)
+   * @param {string} walletAddress - The user's wallet address
+   * @returns {Object} Complete stats object
+   */
+  async getUserProfileStats(walletAddress) {
+    // Check cache first
+    const cached = this.cache.get(walletAddress);
+    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+      return cached.data;
+    }
+
+    try {
+      const stats = await this._fetchUserStats(walletAddress);
+      
+      // Cache the result
+      this.cache.set(walletAddress, {
+        data: stats,
+        timestamp: Date.now()
+      });
+
+      return stats;
+    } catch (error) {
+      console.error('Error fetching user profile stats:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Internal method to fetch all stats with optimized queries
+   */
+  async _fetchUserStats(walletAddress) {
+    const startTime = Date.now();
+
+    // Run queries in parallel for maximum performance
+    const [userInfo, jackpotStats, sportsStats, billiardsStats, connect4Stats, recentGames, dominantLeagues] = await Promise.all([
+      this._getUserInfo(walletAddress),
+      this._getJackpotStats(walletAddress),
+      this._getSportsStats(walletAddress),
+      this._getBilliardsStats(walletAddress),
+      this._getConnect4Stats(walletAddress),
+      this._getRecentGames(walletAddress, 10),
+      this._getDominantLeagues(walletAddress),
+    ]);
+
+    // Calculate combined stats (now includes billiards and connect4!)
+    const totalWagered = (jackpotStats?.totalWagered || 0) + (sportsStats?.totalWagered || 0) + (billiardsStats?.totalWagered || 0) + (connect4Stats?.totalWagered || 0);
+    const totalWon = (jackpotStats?.totalWon || 0) + (sportsStats?.totalWon || 0) + (billiardsStats?.totalWon || 0) + (connect4Stats?.totalWon || 0);
+    const netPNL = totalWon - totalWagered;
+    const totalGamesPlayed = (jackpotStats?.roundsPlayed || 0) + (sportsStats?.gamesPlayed || 0) + (billiardsStats?.roomsPlayed || 0) + (connect4Stats?.gamesPlayed || 0);
+    const totalGamesWon = (jackpotStats?.roundsWon || 0) + (sportsStats?.gamesWon || 0) + (billiardsStats?.roomsWon || 0) + (connect4Stats?.gamesWon || 0);
+    const winRate = totalGamesPlayed > 0 ? (totalGamesWon / totalGamesPlayed * 100) : 0;
+
+    const elapsed = Date.now() - startTime;
+    console.log(`📊 Fetched profile stats for ${walletAddress.slice(0, 8)}... in ${elapsed}ms (jackpot: ${!!jackpotStats}, sports: ${!!sportsStats}, billiards: ${!!billiardsStats}, connect4: ${!!connect4Stats})`);
+
+    return {
+      // User Info
+      walletAddress,
+      username: userInfo?.username || null,
+      avatar: userInfo?.avatar || null,
+      preferredCurrency: userInfo?.preferred_currency || 'USD',
+      userId: userInfo?.id || null,
+      memberSince: userInfo?.created_at || null,
+      telegramConnected: !!userInfo?.telegram_user_id, // Whether user has Telegram linked
+
+      // Combined Stats
+      summary: {
+        totalWagered: parseFloat(totalWagered.toFixed(4)),
+        totalWon: parseFloat(totalWon.toFixed(4)),
+        netPNL: parseFloat(netPNL.toFixed(4)),
+        totalGamesPlayed,
+        totalGamesWon,
+        winRate: parseFloat(winRate.toFixed(2)),
+        isProfitable: netPNL > 0,
+      },
+
+      // Jackpot Stats (Solpot-style games)
+      jackpot: jackpotStats ? {
+        roundsPlayed: jackpotStats.roundsPlayed,
+        roundsWon: jackpotStats.roundsWon,
+        totalWagered: parseFloat((jackpotStats.totalWagered || 0).toFixed(4)),
+        totalWon: parseFloat((jackpotStats.totalWon || 0).toFixed(4)),
+        netPNL: parseFloat((jackpotStats.netPNL || 0).toFixed(4)),
+        biggestWin: parseFloat((jackpotStats.biggestWin || 0).toFixed(4)),
+        biggestWinRound: jackpotStats.biggestWinRound,
+        winRate: parseFloat(((jackpotStats.roundsPlayed > 0 ? jackpotStats.roundsWon / jackpotStats.roundsPlayed : 0) * 100).toFixed(2)),
+      } : null,
+
+      // Sports Betting Stats
+      sports: sportsStats ? {
+        gamesCreated: sportsStats.gamesCreated,
+        gamesJoined: sportsStats.gamesJoined,
+        gamesPlayed: sportsStats.gamesPlayed,
+        gamesWon: sportsStats.gamesWon,
+        gamesLost: sportsStats.gamesLost,
+        gamesPending: sportsStats.gamesPending,
+        totalWagered: parseFloat((sportsStats.totalWagered || 0).toFixed(4)),
+        pendingWagered: parseFloat((sportsStats.pendingWagered || 0).toFixed(4)),
+        totalWon: parseFloat((sportsStats.totalWon || 0).toFixed(4)),
+        netPNL: parseFloat((sportsStats.netPNL || 0).toFixed(4)),
+        biggestWin: parseFloat((sportsStats.biggestWin || 0).toFixed(4)),
+        currentStreak: sportsStats.currentStreak,
+        longestStreak: sportsStats.longestStreak,
+        winRate: parseFloat(((sportsStats.gamesPlayed > 0 ? sportsStats.gamesWon / sportsStats.gamesPlayed : 0) * 100).toFixed(2)),
+      } : null,
+
+      // 🎱 Billiards/Pool Room Stats
+      billiards: billiardsStats ? {
+        roomsCreated: billiardsStats.roomsCreated,
+        roomsJoined: billiardsStats.roomsJoined,
+        roomsPlayed: billiardsStats.roomsPlayed,
+        roomsWon: billiardsStats.roomsWon,
+        roomsLost: billiardsStats.roomsLost,
+        roomsPending: billiardsStats.roomsPending,
+        totalWagered: parseFloat((billiardsStats.totalWagered || 0).toFixed(4)),
+        pendingWagered: parseFloat((billiardsStats.pendingWagered || 0).toFixed(4)),
+        totalWon: parseFloat((billiardsStats.totalWon || 0).toFixed(4)),
+        netPNL: parseFloat((billiardsStats.netPNL || 0).toFixed(4)),
+        biggestWin: parseFloat((billiardsStats.biggestWin || 0).toFixed(4)),
+        biggestWinRoomId: billiardsStats.biggestWinRoomId,
+        currentStreak: billiardsStats.currentStreak,
+        longestStreak: billiardsStats.longestStreak,
+        winRate: parseFloat((billiardsStats.winRate || 0).toFixed(2)),
+      } : null,
+
+      // 🔴 Connect4 Stats
+      connect4: connect4Stats ? {
+        gamesCreated: connect4Stats.gamesCreated,
+        gamesJoined: connect4Stats.gamesJoined,
+        gamesPlayed: connect4Stats.gamesPlayed,
+        gamesWon: connect4Stats.gamesWon,
+        gamesLost: connect4Stats.gamesLost,
+        gamesPending: connect4Stats.gamesPending,
+        totalWagered: parseFloat((connect4Stats.totalWagered || 0).toFixed(4)),
+        pendingWagered: parseFloat((connect4Stats.pendingWagered || 0).toFixed(4)),
+        totalWon: parseFloat((connect4Stats.totalWon || 0).toFixed(4)),
+        netPNL: parseFloat((connect4Stats.netPNL || 0).toFixed(4)),
+        biggestWin: parseFloat((connect4Stats.biggestWin || 0).toFixed(4)),
+        biggestWinGameId: connect4Stats.biggestWinGameId,
+        currentStreak: connect4Stats.currentStreak,
+        longestStreak: connect4Stats.longestStreak,
+        winRate: parseFloat((connect4Stats.winRate || 0).toFixed(2)),
+      } : null,
+
+      // Recent Games (for history display)
+      recentGames,
+
+      // Badges based on dominant leagues/games
+      badges: dominantLeagues,
+
+      // Metadata
+      _meta: {
+        fetchedAt: new Date().toISOString(),
+        queryTimeMs: elapsed,
+      }
+    };
+  }
+
+  /**
+   * Get basic user info
+   */
+  async _getUserInfo(walletAddress) {
+    const result = await this.pool.query(
+      'SELECT id, wallet_address, username, avatar, preferred_currency, created_at, telegram_user_id FROM users WHERE wallet_address = $1',
+      [walletAddress]
+    );
+    return result.rows[0] || null;
+  }
+
+  /**
+   * Get jackpot/solpot game stats
+   */
+  async _getJackpotStats(walletAddress) {
+    const result = await this.pool.query(
+      'SELECT * FROM player_stats WHERE wallet_address = $1',
+      [walletAddress]
+    );
+
+    if (result.rows.length === 0) return null;
+
+    const stats = result.rows[0];
+    return {
+      totalWagered: parseFloat(stats.total_wagered || 0),
+      totalWon: parseFloat(stats.total_won || 0),
+      netPNL: parseFloat(stats.net_pnl || 0),
+      roundsPlayed: stats.rounds_played || 0,
+      roundsWon: stats.rounds_won || 0,
+      biggestWin: parseFloat(stats.biggest_win || 0),
+      biggestWinRound: stats.biggest_win_round,
+      lastPlayed: stats.last_played,
+    };
+  }
+
+  /**
+   * Get user's dominant leagues/games for badge display
+   * Includes sports leagues, connect4, and billiards
+   */
+  async _getDominantLeagues(walletAddress) {
+    try {
+      // Get sports league counts
+      const sportsResult = await this.pool.query(`
+        SELECT
+          g.sports_event->>'strLeague' as league,
+          COUNT(*) as game_count
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+          AND g.game_type = 'sports'
+          AND g.sports_event->>'strLeague' IS NOT NULL
+        GROUP BY g.sports_event->>'strLeague'
+        ORDER BY game_count DESC
+        LIMIT 5
+      `, [walletAddress]);
+
+      // Get connect4 game count
+      const connect4Result = await this.pool.query(`
+        SELECT COUNT(*) as game_count
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+          AND g.game_type = 'connect4'
+      `, [walletAddress]);
+
+      // Get billiards game count
+      const billiardsResult = await this.pool.query(`
+        SELECT COUNT(*) as game_count
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+          AND g.game_type = 'billiards'
+      `, [walletAddress]);
+
+      // Map leagues to emojis and badges
+      const leagueEmojis = {
+        'NFL': { emoji: '🏈', name: 'Football Fan' },
+        'NBA': { emoji: '🏀', name: 'Hoops Lover' },
+        'NHL': { emoji: '🏒', name: 'Hockey Head' },
+        'MLB': { emoji: '⚾', name: 'Baseball Boss' },
+        'English Premier League': { emoji: '⚽', name: 'Soccer Star' },
+        'La Liga': { emoji: '⚽', name: 'La Liga Legend' },
+        'Bundesliga': { emoji: '⚽', name: 'Bundesliga Beast' },
+        'Serie A': { emoji: '⚽', name: 'Serie A Shark' },
+        'Ligue 1': { emoji: '⚽', name: 'Ligue 1 Lion' },
+        'MLS': { emoji: '⚽', name: 'MLS Maven' },
+        'UFC': { emoji: '🥊', name: 'Fight Fan' },
+        'Boxing': { emoji: '🥊', name: 'Boxing Baron' },
+        'Tennis': { emoji: '🎾', name: 'Tennis Titan' },
+        'Golf': { emoji: '⛳', name: 'Golf Guru' },
+        'Formula 1': { emoji: '🏎️', name: 'F1 Fanatic' },
+        'NASCAR': { emoji: '🏁', name: 'NASCAR Nut' },
+        'connect4': { emoji: '🔴', name: 'Connect4 Pro' },
+        'billiards': { emoji: '🎱', name: 'Pool Shark' },
+      };
+
+      const badges = sportsResult.rows.map(row => {
+        const leagueInfo = leagueEmojis[row.league] || { emoji: '🎮', name: row.league || 'Gamer' };
+        return {
+          league: row.league,
+          emoji: leagueInfo.emoji,
+          name: leagueInfo.name,
+          gamesPlayed: parseInt(row.game_count),
+        };
+      });
+
+      // Add Connect4 badge if user has played
+      const connect4Count = parseInt(connect4Result.rows[0]?.game_count || 0);
+      if (connect4Count > 0) {
+        badges.push({
+          league: 'connect4',
+          emoji: leagueEmojis.connect4.emoji,
+          name: leagueEmojis.connect4.name,
+          gamesPlayed: connect4Count,
+        });
+      }
+
+      // Add Billiards badge if user has played
+      const billiardsCount = parseInt(billiardsResult.rows[0]?.game_count || 0);
+      if (billiardsCount > 0) {
+        badges.push({
+          league: 'billiards',
+          emoji: leagueEmojis.billiards.emoji,
+          name: leagueEmojis.billiards.name,
+          gamesPlayed: billiardsCount,
+        });
+      }
+
+      // Sort by games played and limit to top 5
+      return badges.sort((a, b) => b.gamesPlayed - a.gamesPlayed).slice(0, 5);
+    } catch (error) {
+      console.error('Error getting dominant leagues:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 🎱 Get billiards/pool room stats
+   * 
+   * Billiards uses game_mode = 0 (Manual mode)
+   * Winners are identified by status = 'won' in user_game_refs
+   * PNL is calculated from amount_claimed - buy_in
+   */
+  async _getBilliardsStats(walletAddress) {
+    try {
+      // Get all billiards games the user participated in
+      // Note: winner info is stored in sports_event->'winner'->>'walletAddress' (from billiards settlement)
+      const result = await this.pool.query(`
+        SELECT 
+          ugr.game_id,
+          ugr.role,
+          ugr.status,
+          ugr.claimed_at,
+          ugr.amount_claimed,
+          ugr.joined_at,
+          g.buy_in,
+          g.is_resolved,
+          g.created_by,
+          g.title,
+          g.sports_event->'winner'->>'walletAddress' as winner_wallet
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+          AND g.game_type = 'billiards'
+        ORDER BY ugr.joined_at ASC
+      `, [walletAddress]);
+
+      if (result.rows.length === 0) return null;
+
+      let roomsCreated = 0;
+      let roomsJoined = 0;
+      let roomsWon = 0;
+      let roomsLost = 0;
+      let roomsPending = 0;
+      let totalWagered = 0;      // Only resolved games
+      let pendingWagered = 0;    // Pending games (not yet counted in P&L)
+      let totalWon = 0;
+      let biggestWin = 0;
+      let biggestWinRoomId = null;
+      let currentStreak = 0;
+      let longestStreak = 0;
+      let lastResult = null; // 'win' or 'loss'
+
+      for (const game of result.rows) {
+        const buyIn = parseFloat(game.buy_in) || 0;
+        
+        // Track if user created this room
+        if (game.created_by === walletAddress) {
+          roomsCreated++;
+        } else {
+          roomsJoined++;
+        }
+
+        // Check if game is resolved
+        if (!game.is_resolved) {
+          // Game still pending - DON'T count towards P&L yet
+          roomsPending++;
+          pendingWagered += buyIn;
+          continue;
+        }
+
+        // Only count wagered amount for RESOLVED games
+        totalWagered += buyIn;
+
+        // Determine if user won using status field or winner_wallet
+        const userWon = game.status === 'won' || game.winner_wallet === walletAddress;
+
+        if (userWon) {
+          roomsWon++;
+          
+          // Calculate winnings from amount_claimed if available
+          const amountClaimed = parseFloat(game.amount_claimed) || 0;
+          const winAmount = amountClaimed > 0 ? amountClaimed : 0;
+          
+          totalWon += winAmount;
+          if (winAmount > biggestWin) {
+            biggestWin = winAmount;
+            biggestWinRoomId = game.game_id;
+          }
+
+          // Streak tracking
+          if (lastResult === 'win') {
+            currentStreak++;
+          } else {
+            currentStreak = 1;
+          }
+          lastResult = 'win';
+          if (currentStreak > longestStreak) {
+            longestStreak = currentStreak;
+          }
+        } else if (game.is_resolved) {
+          // Game resolved but user didn't win = loss
+          roomsLost++;
+          
+          // Streak tracking
+          if (lastResult === 'loss') {
+            currentStreak--;
+          } else {
+            currentStreak = -1;
+          }
+          lastResult = 'loss';
+        }
+      }
+
+      const roomsPlayed = roomsWon + roomsLost;
+
+      return {
+        roomsCreated,
+        roomsJoined,
+        roomsPlayed,
+        roomsWon,
+        roomsLost,
+        roomsPending,
+        totalWagered,         // Only from resolved games
+        pendingWagered,       // Amount at stake in pending games
+        totalWon,
+        netPNL: totalWon - totalWagered,
+        biggestWin,
+        biggestWinRoomId,
+        currentStreak,
+        longestStreak,
+        winRate: roomsPlayed > 0 ? (roomsWon / roomsPlayed * 100) : 0,
+      };
+    } catch (error) {
+      console.error('🎱 Error getting billiards stats:', error);
+      return null;
+    }
+  }
+
+  /**
+   * 🔴 Get Connect4 game stats
+   *
+   * Connect4 uses game_type = 'connect4'
+   * Winners are determined by connect4_winner field ('red' or 'yellow')
+   * Red = creator (home), Yellow = joiner (away)
+   */
+  async _getConnect4Stats(walletAddress) {
+    try {
+      // Get all connect4 games the user participated in
+      const result = await this.pool.query(`
+        SELECT
+          ugr.game_id,
+          ugr.role,
+          ugr.team_choice,
+          ugr.status,
+          ugr.claimed_at,
+          ugr.amount_claimed,
+          ugr.joined_at,
+          g.buy_in,
+          g.is_resolved,
+          g.game_status,
+          g.created_by,
+          g.title,
+          g.connect4_winner
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+          AND g.game_type = 'connect4'
+        ORDER BY ugr.joined_at ASC
+      `, [walletAddress]);
+
+      if (result.rows.length === 0) return null;
+
+      let gamesCreated = 0;
+      let gamesJoined = 0;
+      let gamesWon = 0;
+      let gamesLost = 0;
+      let gamesPending = 0;
+      let totalWagered = 0;      // Only resolved games
+      let pendingWagered = 0;    // Pending games (not yet counted in P&L)
+      let totalWon = 0;
+      let biggestWin = 0;
+      let biggestWinGameId = null;
+      let currentStreak = 0;
+      let longestStreak = 0;
+      let lastResult = null; // 'win' or 'loss'
+
+      for (const game of result.rows) {
+        const buyIn = parseFloat(game.buy_in) || 0;
+
+        // Track if user created this game
+        if (game.created_by === walletAddress) {
+          gamesCreated++;
+        } else {
+          gamesJoined++;
+        }
+
+        // Check if game is a valid completed game with a winner (not cancelled, not draw)
+        // Only count games where game_status = 'completed' and connect4_winner is 'home' or 'away'
+        const isValidCompletedGame = game.game_status === 'completed' &&
+                                     game.connect4_winner &&
+                                     (game.connect4_winner === 'home' || game.connect4_winner === 'away');
+
+        if (!isValidCompletedGame) {
+          // Game is pending, cancelled, or a draw - DON'T count towards W/L stats
+          gamesPending++;
+          pendingWagered += buyIn;
+          continue;
+        }
+
+        // Only count wagered amount for RESOLVED games
+        totalWagered += buyIn;
+
+        // Determine if user won
+        // Red = creator plays as 'red', Yellow = joiner plays as 'yellow'
+        // team_choice should be 'red' or 'yellow'
+        const userWon = game.team_choice === game.connect4_winner;
+
+        if (userWon) {
+          gamesWon++;
+
+          // Calculate winnings from amount_claimed if available
+          const amountClaimed = parseFloat(game.amount_claimed) || 0;
+          const winAmount = amountClaimed > 0 ? amountClaimed : 0;
+
+          totalWon += winAmount;
+          if (winAmount > biggestWin) {
+            biggestWin = winAmount;
+            biggestWinGameId = game.game_id;
+          }
+
+          // Streak tracking
+          if (lastResult === 'win') {
+            currentStreak++;
+          } else {
+            currentStreak = 1;
+          }
+          lastResult = 'win';
+          if (currentStreak > longestStreak) {
+            longestStreak = currentStreak;
+          }
+        } else {
+          // Game resolved but user didn't win = loss
+          gamesLost++;
+
+          // Streak tracking
+          if (lastResult === 'loss') {
+            currentStreak--;
+          } else {
+            currentStreak = -1;
+          }
+          lastResult = 'loss';
+        }
+      }
+
+      const gamesPlayed = gamesWon + gamesLost;
+
+      return {
+        gamesCreated,
+        gamesJoined,
+        gamesPlayed,
+        gamesWon,
+        gamesLost,
+        gamesPending,
+        totalWagered,         // Only from resolved games
+        pendingWagered,       // Amount at stake in pending games
+        totalWon,
+        netPNL: totalWon - totalWagered,
+        biggestWin,
+        biggestWinGameId,
+        currentStreak,
+        longestStreak,
+        winRate: gamesPlayed > 0 ? (gamesWon / gamesPlayed * 100) : 0,
+      };
+    } catch (error) {
+      console.error('🔴 Error getting Connect4 stats:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get sports betting stats (calculated from games tables)
+   */
+  async _getSportsStats(walletAddress) {
+    // Get all sports games the user participated in
+    const result = await this.pool.query(`
+      SELECT 
+        ugr.game_id,
+        ugr.role,
+        ugr.team_choice,
+        ugr.claimed_at,
+        ugr.amount_claimed,
+        ugr.joined_at,
+        g.buy_in,
+        g.is_resolved,
+        g.is_locked,
+        g.game_mode,
+        g.sports_event,
+        g.home_team_players,
+        g.away_team_players,
+        g.created_by
+      FROM user_game_refs ugr
+      JOIN games g ON ugr.game_id = g.game_id
+      WHERE ugr.wallet_address = $1
+        AND g.game_mode = 4
+      ORDER BY ugr.joined_at ASC
+    `, [walletAddress]);
+
+    if (result.rows.length === 0) return null;
+
+    let gamesCreated = 0;
+    let gamesJoined = 0;
+    let gamesWon = 0;
+    let gamesLost = 0;
+    let gamesPending = 0;
+    let totalWagered = 0;      // Only resolved games
+    let pendingWagered = 0;    // Pending games (not yet counted in P&L)
+    let totalWon = 0;
+    let biggestWin = 0;
+    let currentStreak = 0;
+    let longestStreak = 0;
+    let lastResult = null; // 'win' or 'loss'
+
+    for (const game of result.rows) {
+      const buyIn = parseFloat(game.buy_in) || 0;
+      
+      // Track if user created this game
+      if (game.created_by === walletAddress) {
+        gamesCreated++;
+      } else {
+        gamesJoined++;
+      }
+
+      if (!game.is_resolved) {
+        // Game still pending - DON'T count towards P&L yet
+        gamesPending++;
+        pendingWagered += buyIn;
+        continue;
+      }
+
+      // Check if both teams have players (if not, it's a refund scenario)
+      const homeCount = game.home_team_players?.length || 0;
+      const awayCount = game.away_team_players?.length || 0;
+
+      // If either side has no players, this is a refund - don't count in win/loss stats
+      if (homeCount === 0 || awayCount === 0) {
+        console.log(`📊 Skipping refund game ${game.game_id} - no competition (home: ${homeCount}, away: ${awayCount})`);
+        continue;
+      }
+
+      // Only count wagered amount for RESOLVED games with actual competition
+      totalWagered += buyIn;
+
+      // Game is resolved - check if user won
+      const finalScore = game.sports_event?.finalScore;
+      if (finalScore && game.team_choice) {
+        const userWon = game.team_choice === finalScore.winner;
+
+        if (userWon) {
+          gamesWon++;
+
+          // Calculate winnings
+          // Total pot = buy_in * total_players
+          // Winner share = pot * (1 - fee) / winners_count
+          const totalPlayers = homeCount + awayCount;
+          const totalPot = buyIn * totalPlayers;
+          const feePercent = 0.12; // 10% operator + 2% oracle
+          const winnersCount = finalScore.winner === 'home' ? homeCount : awayCount;
+          const winShare = winnersCount > 0 ? (totalPot * (1 - feePercent)) / winnersCount : 0;
+
+          totalWon += winShare;
+          if (winShare > biggestWin) {
+            biggestWin = winShare;
+          }
+
+          // Streak tracking
+          if (lastResult === 'win') {
+            currentStreak++;
+          } else {
+            currentStreak = 1;
+          }
+          lastResult = 'win';
+          if (currentStreak > longestStreak) {
+            longestStreak = currentStreak;
+          }
+        } else {
+          gamesLost++;
+          // Lost - streak broken
+          if (lastResult === 'loss') {
+            currentStreak--;
+          } else {
+            currentStreak = -1;
+          }
+          lastResult = 'loss';
+        }
+      }
+    }
+
+    return {
+      gamesCreated,
+      gamesJoined,
+      gamesPlayed: gamesWon + gamesLost,
+      gamesWon,
+      gamesLost,
+      gamesPending,
+      totalWagered,         // Only from resolved games
+      pendingWagered,       // Amount at stake in pending games
+      totalWon,
+      netPNL: totalWon - totalWagered,
+      biggestWin,
+      currentStreak,
+      longestStreak,
+    };
+  }
+
+  /**
+   * Get recent games for display
+   * Handles sports games, billiards/pool rooms, Connect4, AND Jackpot rounds
+   * Supports legacy, hybrid, and pari-mutuel betting modes
+   */
+  async _getRecentGames(walletAddress, limit = 10) {
+    // Fetch regular games and jackpot entries in parallel
+    const [gamesResult, jackpotResult] = await Promise.all([
+      // Note: For billiards, winner is stored in sports_event->'winner'->>'walletAddress'
+      this.pool.query(`
+        SELECT
+          ugr.game_id,
+          ugr.team_choice,
+          ugr.status,
+          ugr.joined_at,
+          ugr.claimed_at,
+          ugr.amount_claimed,
+          g.title,
+          g.buy_in,
+          g.is_resolved,
+          g.sports_event,
+          g.home_team_players,
+          g.away_team_players,
+          g.game_type,
+          g.sports_event->'winner'->>'walletAddress' as billiards_winner_wallet,
+          g.connect4_winner,
+          g.total_pool,
+          g.home_pool,
+          g.away_pool,
+          g.draw_pool,
+          g.player_amounts
+        FROM user_game_refs ugr
+        JOIN games g ON ugr.game_id = g.game_id
+        WHERE ugr.wallet_address = $1
+        ORDER BY ugr.joined_at DESC
+        LIMIT $2
+      `, [walletAddress, limit]),
+      // Jackpot entries joined with round results
+      this.pool.query(`
+        SELECT
+          je.round_id,
+          je.amount as entry_amount,
+          je.created_at as entered_at,
+          jr.winner,
+          jr.win_amount,
+          jr.total_pot,
+          jr.entry_count,
+          jr.timestamp as resolved_at
+        FROM jackpot_entries je
+        LEFT JOIN jackpot_rounds jr ON je.round_id = jr.round_id
+        WHERE je.wallet_address = $1
+        ORDER BY je.created_at DESC
+        LIMIT $2
+      `, [walletAddress, limit]),
+    ]);
+
+    const result = gamesResult;
+
+    // Build jackpot recent games
+    const jackpotGames = jackpotResult.rows.map(entry => {
+      const buyInLamports = parseInt(entry.entry_amount) || 0;
+      const buyInSOL = buyInLamports / 1e9;
+      const isResolved = !!entry.resolved_at;
+      const userWon = isResolved && entry.winner === walletAddress;
+
+      let resultStatus = 'pending';
+      let pnl = 0;
+
+      if (isResolved) {
+        if (userWon) {
+          resultStatus = 'won';
+          const winAmountSOL = (parseInt(entry.win_amount) || 0) / 1e9;
+          pnl = winAmountSOL - buyInSOL;
+        } else {
+          resultStatus = 'lost';
+          pnl = -buyInSOL;
+        }
+      }
+
+      return {
+        gameId: `jackpot_${entry.round_id}`,
+        title: `Jackpot Round #${entry.round_id}`,
+        gameType: 'jackpot',
+        teamChoice: null,
+        buyIn: parseFloat(buyInSOL.toFixed(4)),
+        result: resultStatus,
+        pnl: parseFloat(pnl.toFixed(4)),
+        finalScore: null,
+        playedAt: entry.entered_at,
+        claimed: isResolved,
+      };
+    });
+
+    // Build regular recent games
+    const regularGames = result.rows.map(game => {
+      const defaultBuyIn = parseFloat(game.buy_in) || 0;
+      const finalScore = game.sports_event?.finalScore;
+      const isBilliards = game.game_type === 'billiards';
+      const isConnect4 = game.game_type === 'connect4';
+
+      // Determine user's actual bet amount (pari-mutuel vs legacy)
+      const playerAmounts = game.player_amounts || {};
+      const userBetAmount = playerAmounts[walletAddress] !== undefined
+        ? parseFloat(playerAmounts[walletAddress])
+        : defaultBuyIn;
+
+      let resultStatus = 'pending';
+      let pnl = 0;
+
+      // 🎱 Handle billiards games
+      if (isBilliards) {
+        if (game.is_resolved) {
+          // Check if user won via status field or billiards_winner_wallet (from sports_event JSON)
+          const userWon = game.status === 'won' || game.billiards_winner_wallet === walletAddress;
+
+          if (userWon) {
+            resultStatus = 'won';
+            const amountClaimed = parseFloat(game.amount_claimed) || 0;
+            pnl = amountClaimed > 0 ? amountClaimed - userBetAmount : 0;
+          } else {
+            resultStatus = 'lost';
+            pnl = -userBetAmount;
+          }
+        }
+        // else remains 'pending'
+      }
+      // 🎮 Handle Connect4 games
+      else if (isConnect4) {
+        if (game.is_resolved && game.connect4_winner) {
+          const userWon = game.team_choice === game.connect4_winner;
+
+          if (userWon) {
+            resultStatus = 'won';
+            const amountClaimed = parseFloat(game.amount_claimed) || 0;
+            pnl = amountClaimed > 0 ? amountClaimed - userBetAmount : 0;
+          } else {
+            resultStatus = 'lost';
+            pnl = -userBetAmount;
+          }
+        }
+        // else remains 'pending'
+      }
+      // 🏀 Handle sports games (supports legacy, hybrid, pari-mutuel)
+      else if (game.is_resolved && finalScore && game.team_choice) {
+        const homeCount = game.home_team_players?.length || 0;
+        const awayCount = game.away_team_players?.length || 0;
+
+        // Check for refund scenario (no competition)
+        if (homeCount === 0 || awayCount === 0) {
+          resultStatus = 'refunded';
+          pnl = 0; // No loss, refunded
+        } else {
+          const userWon = game.team_choice === finalScore.winner;
+
+          if (userWon) {
+            resultStatus = 'won';
+
+            // Check if this is a pari-mutuel game (has player_amounts with entries)
+            const isPariMutuel = Object.keys(playerAmounts).length > 0;
+
+            if (isPariMutuel) {
+              // Pari-mutuel: proportional payout based on user's share of winning pool
+              const totalPool = parseFloat(game.total_pool) || 0;
+              const homePool = parseFloat(game.home_pool) || 0;
+              const awayPool = parseFloat(game.away_pool) || 0;
+              const drawPool = parseFloat(game.draw_pool) || 0;
+
+              const winningPool = finalScore.winner === 'home' ? homePool
+                : finalScore.winner === 'away' ? awayPool
+                : drawPool;
+
+              const feePercent = 0.06; // 6% fee (5% platform + 1% oracle)
+              const netPool = totalPool * (1 - feePercent);
+
+              // User's share = (userBet / winningPool) * netPool
+              const userShare = winningPool > 0 ? (userBetAmount / winningPool) * netPool : 0;
+              pnl = userShare - userBetAmount;
+            } else {
+              // Legacy: equal split among winners
+              const totalPlayers = homeCount + awayCount;
+              const totalPot = defaultBuyIn * totalPlayers;
+              const feePercent = 0.06; // 6% fee
+              const winnersCount = finalScore.winner === 'home' ? homeCount : awayCount;
+              const winShare = winnersCount > 0 ? (totalPot * (1 - feePercent)) / winnersCount : 0;
+              pnl = winShare - defaultBuyIn;
+            }
+          } else {
+            resultStatus = 'lost';
+            pnl = -userBetAmount;
+          }
+        }
+      }
+
+      // For pending games, show event date. For resolved, show when user joined.
+      const eventDate = game.sports_event?.strTimestamp;
+      const displayDate = resultStatus === 'pending' && eventDate
+        ? new Date(eventDate + 'Z') // Event date for pending
+        : game.joined_at; // Joined date for resolved
+
+      return {
+        gameId: game.game_id,
+        title: game.title,
+        gameType: game.game_type || 'sports', // Include game type for display
+        teamChoice: game.team_choice,
+        buyIn: parseFloat(userBetAmount.toFixed(4)), // Show user's actual bet, not default
+        result: resultStatus,
+        pnl: parseFloat(pnl.toFixed(4)),
+        finalScore: finalScore ? {
+          winner: finalScore.winner,
+          homeScore: finalScore.homeScore,
+          awayScore: finalScore.awayScore,
+        } : null,
+        playedAt: displayDate,
+        claimed: !!game.claimed_at,
+      };
+    });
+
+    // Merge regular games + jackpot games, sort by date desc, limit
+    const allGames = [...regularGames, ...jackpotGames]
+      .sort((a, b) => new Date(b.playedAt).getTime() - new Date(a.playedAt).getTime())
+      .slice(0, limit);
+
+    return allGames;
+  }
+
+  /**
+   * Record a sports betting win (called when game is resolved)
+   */
+  async recordSportsBetResult({ walletAddress, gameId, buyIn, won, winAmount }) {
+    try {
+      const pnlChange = won ? (winAmount - buyIn) : -buyIn;
+
+      await this.pool.query(`
+        INSERT INTO sports_betting_stats (
+          wallet_address,
+          games_joined,
+          games_won,
+          games_lost,
+          total_wagered_sol,
+          total_won_sol,
+          net_pnl_sol,
+          biggest_win_sol,
+          biggest_win_game_id,
+          current_win_streak,
+          longest_win_streak,
+          last_played_at
+        ) VALUES ($1, 1, $2, $3, $4, $5, $6, $7, $8, $9, $9, NOW())
+        ON CONFLICT (wallet_address) DO UPDATE SET
+          games_joined = sports_betting_stats.games_joined + 1,
+          games_won = sports_betting_stats.games_won + $2,
+          games_lost = sports_betting_stats.games_lost + $3,
+          total_wagered_sol = sports_betting_stats.total_wagered_sol + $4,
+          total_won_sol = sports_betting_stats.total_won_sol + $5,
+          net_pnl_sol = sports_betting_stats.net_pnl_sol + $6,
+          biggest_win_sol = GREATEST(sports_betting_stats.biggest_win_sol, $7),
+          biggest_win_game_id = CASE 
+            WHEN $7 > sports_betting_stats.biggest_win_sol THEN $8 
+            ELSE sports_betting_stats.biggest_win_game_id 
+          END,
+          current_win_streak = CASE 
+            WHEN $2 = 1 THEN sports_betting_stats.current_win_streak + 1 
+            ELSE 0 
+          END,
+          longest_win_streak = GREATEST(
+            sports_betting_stats.longest_win_streak, 
+            CASE WHEN $2 = 1 THEN sports_betting_stats.current_win_streak + 1 ELSE 0 END
+          ),
+          last_played_at = NOW(),
+          updated_at = NOW()
+      `, [
+        walletAddress,
+        won ? 1 : 0,
+        won ? 0 : 1,
+        buyIn,
+        won ? winAmount : 0,
+        pnlChange,
+        won ? winAmount : 0,
+        won ? gameId : null,
+        won ? 1 : 0,
+      ]);
+
+      // Invalidate cache
+      this.cache.delete(walletAddress);
+
+      console.log(`📊 Recorded sports bet result: ${walletAddress.slice(0, 8)}... ${won ? 'WON' : 'LOST'} ◎${buyIn}`);
+    } catch (error) {
+      console.error('Error recording sports bet result:', error);
+    }
+  }
+
+  /**
+   * Get leaderboard with combined stats
+   */
+  async getLeaderboard(limit = 20, sortBy = 'pnl') {
+    try {
+      // Get all users with any stats
+      const result = await this.pool.query(`
+        SELECT DISTINCT wallet_address FROM (
+          SELECT wallet_address FROM player_stats
+          UNION
+          SELECT wallet_address FROM user_game_refs
+        ) combined
+        LIMIT 100
+      `);
+
+      const wallets = result.rows.map(r => r.wallet_address);
+      
+      // Fetch stats for all users in parallel
+      const statsPromises = wallets.map(wallet => this.getUserProfileStats(wallet));
+      const allStats = await Promise.all(statsPromises);
+
+      // Sort based on criteria
+      const sorted = allStats.sort((a, b) => {
+        if (sortBy === 'pnl') {
+          return b.summary.netPNL - a.summary.netPNL;
+        } else if (sortBy === 'wagered') {
+          return b.summary.totalWagered - a.summary.totalWagered;
+        } else if (sortBy === 'wins') {
+          return b.summary.totalGamesWon - a.summary.totalGamesWon;
+        } else if (sortBy === 'winrate') {
+          return b.summary.winRate - a.summary.winRate;
+        }
+        return 0;
+      });
+
+      return sorted.slice(0, limit).map((stats, index) => ({
+        rank: index + 1,
+        walletAddress: stats.walletAddress,
+        username: stats.username,
+        avatar: stats.avatar,
+        netPNL: stats.summary.netPNL,
+        totalWagered: stats.summary.totalWagered,
+        totalGamesPlayed: stats.summary.totalGamesPlayed,
+        totalGamesWon: stats.summary.totalGamesWon,
+        winRate: stats.summary.winRate,
+      }));
+    } catch (error) {
+      console.error('Error fetching leaderboard:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Clear cache for a specific wallet (call after game results)
+   */
+  invalidateCache(walletAddress) {
+    this.cache.delete(walletAddress);
+  }
+
+  /**
+   * Clear all cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Get a user's friends list by wallet address (public)
+   * Returns friends with their basic stats
+   */
+  async getUserFriends(walletAddress, limit = 20) {
+    try {
+      const result = await this.pool.query(`
+        SELECT 
+          u2.wallet_address,
+          u2.username,
+          u2.avatar,
+          ur.created_at as friends_since
+        FROM users u1
+        JOIN user_relationships ur ON u1.id = ur.user_id
+        JOIN users u2 ON ur.target_user_id = u2.id
+        WHERE u1.wallet_address = $1 
+          AND ur.relationship_type = 'friend'
+        ORDER BY ur.created_at DESC
+        LIMIT $2
+      `, [walletAddress, limit]);
+
+      return result.rows.map(row => ({
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        friendsSince: row.friends_since,
+      }));
+    } catch (error) {
+      console.error('Error getting user friends:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get mutual friends between two users
+   */
+  async getMutualFriends(walletAddress1, walletAddress2) {
+    try {
+      const result = await this.pool.query(`
+        SELECT DISTINCT
+          u3.wallet_address,
+          u3.username,
+          u3.avatar
+        FROM users u1
+        JOIN user_relationships ur1 ON u1.id = ur1.user_id AND ur1.relationship_type = 'friend'
+        JOIN users u2 ON u2.wallet_address = $2
+        JOIN user_relationships ur2 ON u2.id = ur2.user_id AND ur2.relationship_type = 'friend'
+        JOIN users u3 ON ur1.target_user_id = u3.id AND ur2.target_user_id = u3.id
+        WHERE u1.wallet_address = $1
+        LIMIT 10
+      `, [walletAddress1, walletAddress2]);
+
+      return result.rows.map(row => ({
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+      }));
+    } catch (error) {
+      console.error('Error getting mutual friends:', error);
+      return [];
+    }
+  }
+}
+
+module.exports = UserProfileStatsService;
+