dubs-server 1.0.0

package/services/playerStatsService.js

@@ -0,0 +1,389 @@
+/**
+ * 📊 Player Stats Service
+ * 
+ * Tracks player PNL, win/loss history, and provides chart data
+ */
+
+const { pool } = require('./db'); // Shared database pool
+const { LAMPORTS_PER_SOL } = require('@solana/web3.js');
+
+class PlayerStatsService {
+  constructor() {
+    // Use shared pool from services/db.js
+    this.pool = pool;
+    
+    this.initializeTables();
+  }
+
+  async initializeTables() {
+    try {
+      // Player stats table - overall performance with streak tracking
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS player_stats (
+          wallet_address VARCHAR(100) PRIMARY KEY,
+          total_wagered NUMERIC(20, 9) DEFAULT 0,
+          total_won NUMERIC(20, 9) DEFAULT 0,
+          net_pnl NUMERIC(20, 9) DEFAULT 0,
+          rounds_played INTEGER DEFAULT 0,
+          rounds_won INTEGER DEFAULT 0,
+          biggest_win NUMERIC(20, 9) DEFAULT 0,
+          biggest_win_round INTEGER,
+          current_win_streak INTEGER DEFAULT 0,
+          longest_win_streak INTEGER DEFAULT 0,
+          last_win_round INTEGER,
+          last_played TIMESTAMP,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        CREATE INDEX IF NOT EXISTS idx_player_stats_pnl ON player_stats(net_pnl DESC);
+        CREATE INDEX IF NOT EXISTS idx_player_stats_wagered ON player_stats(total_wagered DESC);
+        CREATE INDEX IF NOT EXISTS idx_player_stats_streak ON player_stats(current_win_streak DESC);
+      `);
+      
+      // Add streak columns if they don't exist (migration for existing tables)
+      await this.pool.query(`
+        DO $$ 
+        BEGIN
+          IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'player_stats' AND column_name = 'current_win_streak') THEN
+            ALTER TABLE player_stats ADD COLUMN current_win_streak INTEGER DEFAULT 0;
+          END IF;
+          IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'player_stats' AND column_name = 'longest_win_streak') THEN
+            ALTER TABLE player_stats ADD COLUMN longest_win_streak INTEGER DEFAULT 0;
+          END IF;
+          IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'player_stats' AND column_name = 'last_win_round') THEN
+            ALTER TABLE player_stats ADD COLUMN last_win_round INTEGER;
+          END IF;
+        END $$;
+      `);
+
+      // Player history table - for chart data
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS player_history (
+          id SERIAL PRIMARY KEY,
+          wallet_address VARCHAR(100) NOT NULL,
+          round_id INTEGER NOT NULL,
+          action VARCHAR(20) NOT NULL,
+          amount NUMERIC(20, 9) NOT NULL,
+          cumulative_pnl NUMERIC(20, 9) NOT NULL,
+          timestamp TIMESTAMP DEFAULT NOW()
+        );
+        
+        CREATE INDEX IF NOT EXISTS idx_player_history_wallet ON player_history(wallet_address, timestamp DESC);
+        CREATE INDEX IF NOT EXISTS idx_player_history_round ON player_history(round_id);
+      `);
+
+      console.log('✅ Player stats tables initialized');
+    } catch (error) {
+      console.error('❌ Failed to initialize player stats tables:', error.message);
+    }
+  }
+
+  /**
+   * Record a player entry (bet)
+   */
+  async recordEntry({ walletAddress, roundId, amount }) {
+    try {
+      const amountSOL = amount / LAMPORTS_PER_SOL;
+
+      // Update or insert player stats
+      await this.pool.query(`
+        INSERT INTO player_stats (
+          wallet_address, 
+          total_wagered, 
+          rounds_played, 
+          net_pnl,
+          last_played
+        )
+        VALUES ($1, $2::NUMERIC, 1, (0 - $2::NUMERIC), NOW())
+        ON CONFLICT (wallet_address) DO UPDATE SET
+          total_wagered = player_stats.total_wagered + $2::NUMERIC,
+          rounds_played = player_stats.rounds_played + 1,
+          net_pnl = player_stats.net_pnl - $2::NUMERIC,
+          last_played = NOW()
+      `, [walletAddress, amountSOL]);
+
+      // Get current cumulative PNL
+      const result = await this.pool.query(
+        'SELECT net_pnl FROM player_stats WHERE wallet_address = $1',
+        [walletAddress]
+      );
+      const cumulativePNL = parseFloat(result.rows[0].net_pnl);
+
+      // Add to history for chart
+      await this.pool.query(`
+        INSERT INTO player_history (
+          wallet_address,
+          round_id,
+          action,
+          amount,
+          cumulative_pnl
+        )
+        VALUES ($1, $2, 'entry', $3, $4)
+      `, [walletAddress, roundId, amountSOL, cumulativePNL]);
+
+      console.log(`📊 Entry recorded: ${walletAddress.slice(0, 8)}... wagered ◎${amountSOL}`);
+    } catch (error) {
+      console.error('Error recording entry:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Record a player win with streak tracking
+   */
+  async recordWin({ walletAddress, roundId, winAmount }) {
+    try {
+      const winSOL = winAmount / LAMPORTS_PER_SOL;
+      const roundIdNum = parseInt(roundId);
+
+      // First, get current player stats to calculate streak
+      const existingStats = await this.pool.query(
+        'SELECT current_win_streak, last_win_round FROM player_stats WHERE wallet_address = $1',
+        [walletAddress]
+      );
+      
+      let newStreak = 1;
+      if (existingStats.rows.length > 0) {
+        const { current_win_streak, last_win_round } = existingStats.rows[0];
+        // If they won the previous round, continue streak; otherwise reset to 1
+        if (last_win_round && roundIdNum === last_win_round + 1) {
+          newStreak = (current_win_streak || 0) + 1;
+        }
+      }
+
+      // Update player stats with streak tracking
+      await this.pool.query(`
+        INSERT INTO player_stats (
+          wallet_address, 
+          total_won, 
+          rounds_won,
+          net_pnl,
+          biggest_win,
+          biggest_win_round,
+          current_win_streak,
+          longest_win_streak,
+          last_win_round,
+          last_played
+        )
+        VALUES ($1, $2, 1, $2, $2, $3, $4, $4, $3, NOW())
+        ON CONFLICT (wallet_address) DO UPDATE SET
+          total_won = player_stats.total_won + $2,
+          rounds_won = player_stats.rounds_won + 1,
+          net_pnl = player_stats.net_pnl + $2,
+          biggest_win = GREATEST(player_stats.biggest_win, $2),
+          biggest_win_round = CASE 
+            WHEN $2 > player_stats.biggest_win THEN $3 
+            ELSE player_stats.biggest_win_round 
+          END,
+          current_win_streak = $4,
+          longest_win_streak = GREATEST(COALESCE(player_stats.longest_win_streak, 0), $4),
+          last_win_round = $3,
+          last_played = NOW()
+      `, [walletAddress, winSOL, roundIdNum, newStreak]);
+
+      // Get current cumulative PNL
+      const result = await this.pool.query(
+        'SELECT net_pnl FROM player_stats WHERE wallet_address = $1',
+        [walletAddress]
+      );
+      const cumulativePNL = parseFloat(result.rows[0].net_pnl);
+
+      // Add to history for chart
+      await this.pool.query(`
+        INSERT INTO player_history (
+          wallet_address,
+          round_id,
+          action,
+          amount,
+          cumulative_pnl
+        )
+        VALUES ($1, $2, 'win', $3, $4)
+      `, [walletAddress, roundIdNum, winSOL, cumulativePNL]);
+
+      console.log(`🏆 Win recorded: ${walletAddress.slice(0, 8)}... won ◎${winSOL} (streak: ${newStreak}🔥)`);
+      
+      return { newStreak };
+    } catch (error) {
+      console.error('Error recording win:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get player stats
+   */
+  async getPlayerStats(walletAddress) {
+    try {
+      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 {
+        walletAddress: stats.wallet_address,
+        totalWagered: parseFloat(stats.total_wagered),
+        totalWon: parseFloat(stats.total_won),
+        netPNL: parseFloat(stats.net_pnl),
+        roundsPlayed: stats.rounds_played,
+        roundsWon: stats.rounds_won,
+        winRate: stats.rounds_played > 0 ? (stats.rounds_won / stats.rounds_played * 100).toFixed(2) : 0,
+        biggestWin: parseFloat(stats.biggest_win),
+        biggestWinRound: stats.biggest_win_round,
+        currentWinStreak: stats.current_win_streak || 0,
+        longestWinStreak: stats.longest_win_streak || 0,
+        lastWinRound: stats.last_win_round,
+        lastPlayed: stats.last_played,
+        createdAt: stats.created_at,
+      };
+    } catch (error) {
+      console.error('Error getting player stats:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get the luckiest player (highest current winning streak)
+   */
+  async getLuckiestPlayer() {
+    try {
+      const result = await this.pool.query(`
+        SELECT 
+          wallet_address,
+          current_win_streak,
+          longest_win_streak,
+          rounds_won,
+          total_won,
+          last_win_round
+        FROM player_stats 
+        WHERE current_win_streak > 0
+        ORDER BY current_win_streak DESC, total_won DESC
+        LIMIT 1
+      `);
+
+      if (result.rows.length === 0) {
+        return null;
+      }
+
+      const stats = result.rows[0];
+      return {
+        walletAddress: stats.wallet_address,
+        currentStreak: stats.current_win_streak,
+        longestStreak: stats.longest_win_streak,
+        roundsWon: stats.rounds_won,
+        totalWon: parseFloat(stats.total_won),
+        lastWinRound: stats.last_win_round,
+      };
+    } catch (error) {
+      console.error('Error getting luckiest player:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get top streakers (leaderboard by current streak)
+   */
+  async getStreakLeaderboard(limit = 10) {
+    try {
+      const result = await this.pool.query(`
+        SELECT 
+          wallet_address,
+          current_win_streak,
+          longest_win_streak,
+          rounds_won,
+          total_won
+        FROM player_stats 
+        WHERE current_win_streak > 0
+        ORDER BY current_win_streak DESC, total_won DESC
+        LIMIT $1
+      `, [limit]);
+
+      return result.rows.map(stats => ({
+        walletAddress: stats.wallet_address,
+        currentStreak: stats.current_win_streak,
+        longestStreak: stats.longest_win_streak,
+        roundsWon: stats.rounds_won,
+        totalWon: parseFloat(stats.total_won),
+      }));
+    } catch (error) {
+      console.error('Error getting streak leaderboard:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get player history for chart
+   */
+  async getPlayerHistory(walletAddress, limit = 100) {
+    try {
+      const result = await this.pool.query(
+        `SELECT * FROM player_history 
+         WHERE wallet_address = $1 
+         ORDER BY timestamp ASC 
+         LIMIT $2`,
+        [walletAddress, limit]
+      );
+
+      return result.rows.map(row => ({
+        id: row.id,
+        roundId: row.round_id,
+        action: row.action,
+        amount: parseFloat(row.amount),
+        cumulativePNL: parseFloat(row.cumulative_pnl),
+        timestamp: row.timestamp,
+      }));
+    } catch (error) {
+      console.error('Error getting player history:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get leaderboard (top players by PNL)
+   */
+  async getLeaderboard(limit = 10) {
+    try {
+      const result = await this.pool.query(
+        `SELECT * FROM player_stats 
+         ORDER BY net_pnl DESC 
+         LIMIT $1`,
+        [limit]
+      );
+
+      return result.rows.map(stats => ({
+        walletAddress: stats.wallet_address,
+        netPNL: parseFloat(stats.net_pnl),
+        totalWagered: parseFloat(stats.total_wagered),
+        totalWon: parseFloat(stats.total_won),
+        roundsPlayed: stats.rounds_played,
+        roundsWon: stats.rounds_won,
+        winRate: stats.rounds_played > 0 ? (stats.rounds_won / stats.rounds_played * 100).toFixed(2) : 0,
+      }));
+    } catch (error) {
+      console.error('Error getting leaderboard:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Cleanup old history (keep last 30 days)
+   */
+  async cleanup() {
+    try {
+      await this.pool.query(`
+        DELETE FROM player_history
+        WHERE timestamp < NOW() - INTERVAL '30 days'
+      `);
+      console.log('🧹 Cleaned up old player history (30+ days)');
+    } catch (error) {
+      console.error('Error cleaning up player history:', error);
+    }
+  }
+}
+
+module.exports = PlayerStatsService;
+