dubs-server 1.0.0

package/services/automaticGameOracle.js

@@ -0,0 +1,1596 @@
+/**
+ * Automatic Sports Game Oracle Service
+ * Monitors pending automatic games and resolves them based on real sports scores
+ */
+
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const promoService = require('./promoService');
+
+// 🔐 HARDCODED OPERATOR WALLET - Must match the contract's hardcoded address!
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+/**
+ * Normalize league names from TheSportsDB to standard codes (MLB, NBA, NFL, NHL, EPL)
+ * TheSportsDB returns full names like "Major League Baseball" instead of "MLB"
+ */
+function normalizeLeague(league) {
+  if (!league) return 'NHL';
+
+  const normalized = league.toUpperCase();
+
+  // Already normalized
+  if (['MLB', 'NBA', 'NFL', 'NHL', 'EPL', 'UFC', 'NCAAB', 'NCAAF'].includes(normalized)) {
+    return normalized;
+  }
+
+  // Map full names to short codes
+  const leagueMap = {
+    'MAJOR LEAGUE BASEBALL': 'MLB',
+    'NATIONAL BASKETBALL ASSOCIATION': 'NBA',
+    'NATIONAL FOOTBALL LEAGUE': 'NFL',
+    'NATIONAL HOCKEY LEAGUE': 'NHL',
+    'ENGLISH PREMIER LEAGUE': 'EPL',
+    'PREMIER LEAGUE': 'EPL',
+    // Also handle common variations
+    'AMERICAN LEAGUE': 'MLB',
+    'NATIONAL LEAGUE': 'MLB',
+    // UFC variations
+    'ULTIMATE FIGHTING CHAMPIONSHIP': 'UFC',
+    'FIGHTING': 'UFC',
+    'MMA': 'UFC',
+  };
+
+  return leagueMap[normalized] || 'NHL';
+}
+
+class AutomaticGameOracle {
+  constructor(config) {
+    this.connection = new Connection(config.rpcUrl, 'confirmed');
+    this.programId = new PublicKey(config.programId);
+    this.oracleKeypair = config.oracleKeypair;
+    this.liveScoresApiUrl = config.liveScoresApiUrl;
+    this.dubsServerUrl = config.dubsServerUrl; // PostgreSQL database (only source now)
+    this.checkIntervalMs = config.checkIntervalMs || 60 * 1000; // 1 minute default
+    this.notifyBeforeMinutes = config.notifyBeforeMinutes || 10; // Notify 10 minutes before by default
+    this.isRunning = false;
+    this.intervalId = null;
+  }
+
+  /**
+   * Start the oracle monitor (cron-like)
+   */
+  start() {
+    if (this.isRunning) {
+      console.log('⚠️  Oracle already running');
+      return;
+    }
+
+    console.log('🤖 Starting Automatic Game Oracle...');
+    console.log(`   Check interval: ${this.checkIntervalMs / 1000}s`);
+    console.log(`   Oracle wallet: ${this.oracleKeypair.publicKey.toString()}`);
+    console.log(`   📊 PostgreSQL Server: ${this.dubsServerUrl}`);
+    console.log(`   🏀 Live Scores API: ${this.liveScoresApiUrl}`);
+    console.log(`   ⏰ Notify before: ${this.notifyBeforeMinutes} minutes`);
+    
+    this.isRunning = true;
+    
+    // Run immediately
+    this.checkPendingGames();
+    
+    // Then run on interval
+    this.intervalId = setInterval(() => {
+      this.checkPendingGames();
+    }, this.checkIntervalMs);
+  }
+
+  /**
+   * Stop the oracle monitor
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.isRunning = false;
+    console.log('🛑 Oracle stopped');
+  }
+
+  /**
+   * Main loop: Check all pending games and resolve if completed
+   */
+  async checkPendingGames() {
+    try {
+      console.log(`\n🔍 [${new Date().toISOString()}] Checking pending automatic games...`);
+      
+      // First check for games approaching lock time (for notifications)
+      console.log('  ⏰ Checking for games approaching lock time...');
+      await this.checkUpcomingGames();
+      
+      // Get pending games from dubs-server (PostgreSQL only)
+      console.log(`  📡 Querying: ${this.dubsServerUrl}/api/games/automatic/pending`);
+      
+      const response = await axios.get(
+        `${this.dubsServerUrl}/api/games/automatic/pending`,
+        { timeout: 10000 }
+      );
+      
+      if (!response.data.success || !response.data.games) {
+        console.log('  ℹ️  No pending games found');
+        return;
+      }
+      
+      const pendingGames = response.data.games;
+      console.log(`  ✅ Found ${pendingGames.length} pending game(s) from PostgreSQL`);
+      
+      // Check each game
+      for (const game of pendingGames) {
+        await this.processGame(game);
+      }
+      
+    } catch (error) {
+      console.error('❌ Error checking pending games:', error.message);
+    }
+  }
+
+  /**
+   * Check for games approaching lock time and send notifications
+   */
+  async checkUpcomingGames() {
+    try {
+      // Get ALL unresolved games from PostgreSQL (not just past lock time)
+      const dubsServerUrl = this.dubsServerUrl;
+      console.log(`     📡 Querying for upcoming games: ${dubsServerUrl}/api/games`);
+      const response = await axios.get(
+        `${dubsServerUrl}/api/games`
+      );
+      
+      // Handle different API response formats
+      let allGames = [];
+      if (response.data.games && Array.isArray(response.data.games)) {
+        allGames = response.data.games;
+      } else if (Array.isArray(response.data)) {
+        allGames = response.data;
+      } else if (response.data.inProgress || response.data.completed || response.data.pending) {
+        // API returns categorized games
+        allGames = [
+          ...(response.data.inProgress || []),
+          ...(response.data.pending || []),
+          ...(response.data.completed || [])
+        ];
+      }
+      
+      console.log(`     API returned ${allGames.length} total game(s)`);
+      
+      // Filter for automatic games that aren't resolved
+      const upcomingGames = allGames.filter(game =>
+        (game.gameMode === 4 || game.gameMode === 5) &&
+        !game.isResolved
+      );
+      
+      console.log(`     Found ${upcomingGames.length} unresolved automatic game(s)`);
+      
+      if (upcomingGames.length === 0) {
+        return;
+      }
+      
+      const now = Date.now();
+      const notifyWindowMs = this.notifyBeforeMinutes * 60 * 1000; // 10 minutes
+      const startWindowMs = 2 * 60 * 1000; // 2 minutes window for "starting now"
+      
+      for (const game of upcomingGames) {
+        if (!game.lockTime) continue;
+        
+        // Parse lock time
+        let lockDate;
+        if (game.lockTime._seconds) {
+          lockDate = new Date(game.lockTime._seconds * 1000);
+        } else if (typeof game.lockTime === 'string') {
+          lockDate = new Date(game.lockTime);
+        } else {
+          lockDate = new Date(game.lockTime);
+        }
+        
+        const timeUntilLock = lockDate.getTime() - now;
+        const minutesUntilLock = Math.ceil(timeUntilLock / 60000);
+        
+        console.log(`     Game ${game.gameId}: ${minutesUntilLock}m until lock (10min notif: ${!!game.lockNotificationSent_10min}, now notif: ${!!game.lockNotificationSent_now})`);
+        
+        // FIRST NOTIFICATION: 10 minutes before
+        if (!game.lockNotificationSent_10min && timeUntilLock > 0 && timeUntilLock <= notifyWindowMs) {
+          console.log(`  ⏰ Game ${game.gameId} starts in ${minutesUntilLock} minutes - sending "starting soon" notification`);
+          await this.sendGameStartingSoonNotification(game, minutesUntilLock);
+        }
+        
+        // SECOND NOTIFICATION: When game is starting (lock time passed)
+        if (!game.lockNotificationSent_now && timeUntilLock <= 0 && Math.abs(timeUntilLock) <= startWindowMs) {
+          console.log(`  🚨 Game ${game.gameId} is starting NOW - sending "starting now" notification`);
+          await this.sendGameStartingNowNotification(game);
+        }
+      }
+      
+    } catch (error) {
+      console.error('  ⚠️ Error checking upcoming games:', error.message);
+    }
+  }
+
+  /**
+   * Send "starting soon" notification (10 min before)
+   */
+  async sendGameStartingSoonNotification(game, minutesUntilStart) {
+    try {
+      // CRITICAL: Mark as notified FIRST to prevent race conditions
+      const dubsServerUrl = this.dubsServerUrl;
+      
+      console.log(`     🔒 Marking game as notified BEFORE sending...`);
+      try {
+        await axios.post(
+          `${dubsServerUrl}/api/games/${game.gameId}/update-notification-flags`,
+          { lockNotificationSent_10min: true },
+          { timeout: 5000 }
+        );
+        console.log(`     ✅ Flag updated successfully`);
+      } catch (flagError) {
+        console.error('     ❌ CRITICAL: Failed to update notification flag:', flagError.message);
+        // If we can't update the flag, DON'T send the notification to avoid infinite duplicates
+        throw new Error(`Cannot send notification - flag update failed: ${flagError.message}`);
+      }
+      
+      // 1. Send to web app users via PostgreSQL + WebSocket
+      if (game.gameMode === 5) {
+        await this.sendEsportsWebAppNotifications(game, 'game_starting_soon', `${minutesUntilStart}m`);
+      } else {
+        await this.sendWebAppNotifications(game, 'game_starting_soon', `${minutesUntilStart}m`);
+      }
+
+      // 2. Send to Telegram (optional)
+      const telegramBotUrl = process.env.TELEGRAM_BOT_URL;
+      console.log(`     📱 TELEGRAM_BOT_URL = ${telegramBotUrl ? telegramBotUrl : 'NOT SET'}`);
+      if (telegramBotUrl) {
+        try {
+          console.log(`     📤 Sending to Telegram: ${telegramBotUrl}/api/notifications/game-starting`);
+          const response = await axios.post(
+            `${telegramBotUrl}/api/notifications/game-starting`,
+            {
+              gameId: game.gameId,
+              minutesUntilStart: minutesUntilStart
+            },
+            {
+              headers: { 'Content-Type': 'application/json' },
+              timeout: 10000
+            }
+          );
+          console.log(`     ✅ Telegram notification sent successfully:`, response.data);
+        } catch (telegramError) {
+          console.log('     ❌ Telegram notification failed:', telegramError.message);
+          console.log('     Error details:', telegramError.response?.data || telegramError);
+        }
+      } else {
+        console.log('     ⏭️  Skipping Telegram - TELEGRAM_BOT_URL not configured');
+      }
+      
+      console.log(`     📱 Sent "starting soon" notifications to all participants (${minutesUntilStart} min)`);
+      
+    } catch (error) {
+      console.error('     ⚠️ Failed to send "starting soon" notification:', error.message);
+      throw error; // Re-throw to prevent silent failures
+    }
+  }
+
+  /**
+   * Send "starting now" notification (at lock time)
+   */
+  async sendGameStartingNowNotification(game) {
+    try {
+      // CRITICAL: Mark as notified FIRST to prevent race conditions
+      const dubsServerUrl = this.dubsServerUrl;
+      
+      console.log(`     🔒 Marking game as notified BEFORE sending...`);
+      try {
+        await axios.post(
+          `${dubsServerUrl}/api/games/${game.gameId}/update-notification-flags`,
+          { lockNotificationSent_now: true },
+          { timeout: 5000 }
+        );
+        console.log(`     ✅ Flag updated successfully`);
+      } catch (flagError) {
+        console.error('     ❌ CRITICAL: Failed to update notification flag:', flagError.message);
+        // If we can't update the flag, DON'T send the notification to avoid infinite duplicates
+        throw new Error(`Cannot send notification - flag update failed: ${flagError.message}`);
+      }
+      
+      // 1. Send to web app users via PostgreSQL + WebSocket
+      if (game.gameMode === 5) {
+        await this.sendEsportsWebAppNotifications(game, 'game_starting_now', 'Match is starting NOW!');
+      } else {
+        await this.sendWebAppNotifications(game, 'game_starting_now', 'Game is starting NOW!');
+      }
+
+      // 2. Send to Telegram group (if available)
+      console.log(`     📱 Telegram chat ID = ${game.telegramChatId ? game.telegramChatId : 'NOT SET'}`);
+      if (game.telegramChatId) {
+        try {
+          console.log(`     📤 Sending "starting now" to Telegram chat ${game.telegramChatId}`);
+          const telegramNotifications = require('./telegramNotifications');
+          await telegramNotifications.notifyGameStartingNow(game);
+          console.log(`     ✅ Telegram "starting now" notification sent`);
+        } catch (telegramError) {
+          console.log(`     ❌ Telegram "starting now" notification failed:`, telegramError.message);
+        }
+      } else {
+        console.log(`     ⏭️  Skipping Telegram - game has no telegramChatId`);
+      }
+      
+      console.log(`     📱 Sent "starting NOW" notifications to all participants`);
+      
+    } catch (error) {
+      console.error('     ⚠️ Failed to send "starting now" notification:', error.message);
+      throw error; // Re-throw to prevent silent failures
+    }
+  }
+
+  /**
+   * Process a single game - check if finished and resolve
+   */
+  async processGame(game) {
+    try {
+      console.log(`\n  📊 Checking game: ${game.gameId}`);
+      console.log(`     Event: ${game.sportsEvent?.strEvent}`);
+      
+      // First, check if game should be locked (start time has passed)
+      if (!game.isLocked && game.sportsEvent?.strTimestamp) {
+        const now = new Date();
+        const gameTime = new Date(game.sportsEvent.strTimestamp + 'Z');
+        const minutesUntilStart = Math.round((gameTime.getTime() - now.getTime()) / 60000);
+        
+        console.log(`     🕐 Game time check: ${gameTime.toISOString()} (in ${minutesUntilStart} minutes)`);
+        console.log(`     🔓 is_locked: ${game.isLocked}`);
+        
+        if (gameTime <= now) {
+          console.log(`     🔒 Game has started - locking game...`);
+          await this.lockGame(game.gameId);
+          console.log(`     ⏭️  Skipping resolution check this iteration - will check again in next cycle after lock confirmed`);
+          return; // Exit early - let the lock propagate, will resolve on next check
+        } else {
+          console.log(`     ⏰ Game not started yet (${minutesUntilStart}m remaining)`);
+        }
+      } else {
+        if (game.isLocked) {
+          console.log(`     ✅ Game already locked, checking for resolution...`);
+        } else {
+          console.log(`     ⚠️  No strTimestamp found for game`);
+        }
+      }
+      
+      // Only check for resolution if game is already locked
+      if (!game.isLocked) {
+        console.log(`     ⏭️  Game not locked yet - skipping resolution check`);
+        return;
+      }
+      
+      // Check if game is finished — route to correct score source
+      let result;
+      if (game.gameMode === 5) {
+        console.log(`     🎮 Fetching PandaScore match status...`);
+        result = await this.checkEsportsGameResult(game.sportsEvent, game);
+      } else {
+        console.log(`     📊 Fetching live scores...`);
+        result = await this.checkSportsGameResult(game.sportsEvent, game);
+      }
+      
+      if (!result) {
+        console.log(`     ⏳ Game not found in live scores or not started yet`);
+        return;
+      }
+      
+      if (!result.isFinal) {
+        console.log(`     ⏳ Game in progress: ${result.status} (waiting for final)`);
+        return;
+      }
+      
+      // Game is finished! Attempt to resolve it
+      console.log(`     🏆 GAME IS FINAL! Winner: ${result.winner === null ? 'REFUND (no competition)' : result.winner} (${result.homeScore}-${result.awayScore})`);
+      console.log(`     🔗 Attempting on-chain resolution...`);
+      
+      try {
+        await this.resolveGame(game, result);
+        console.log(`     ✅ Resolution completed successfully!`);
+      } catch (resolveError) {
+        // Check if it's an "already resolved" error (not actually an error)
+        if (resolveError.message?.includes('AlreadyResolved') ||
+            resolveError.message?.includes('already been resolved')) {
+          console.log(`     ℹ️  Game already resolved on-chain - syncing database...`);
+          // Game is resolved on-chain but database may not be updated - sync it
+          try {
+            await this.updateGameInPostgreSQL(game.gameId, result, null);
+            console.log(`     ✅ Database synced with on-chain state`);
+
+            // Send notifications that were missed during the failed resolution attempt
+            console.log(`     📢 Sending missed notifications...`);
+            if (game.gameMode === 5) {
+              await this.sendEsportsResultNotifications(game, result);
+            } else {
+              await this.sendGameResultNotifications(game, result);
+            }
+            await this.sendTelegramNotifications(game, result);
+            console.log(`     ✅ Notifications sent`);
+          } catch (syncError) {
+            console.error(`     ⚠️ Failed to sync database or send notifications:`, syncError.message);
+          }
+          return;
+        }
+        // Re-throw other errors for logging
+        throw resolveError;
+      }
+      
+    } catch (error) {
+      // Skip logging for already resolved games (reduces noise)
+      if (error.message?.includes('AlreadyResolved') || error.message?.includes('already been resolved')) {
+        // Silent - game already resolved
+        return;
+      }
+      
+      // Skip logging if lock time hasn't passed yet - this is expected
+      if (error.message?.includes('CannotResolveBeforeLockTime') || error.message?.includes('0x179b')) {
+        console.log(`     ⏰ Lock time hasn't passed yet - will retry on next check`);
+        return;
+      }
+      
+      console.error(`  ❌ Error processing game ${game.gameId}:`, error.message);
+    }
+  }
+
+  /**
+   * Lock a game when its start time has passed
+   */
+  async lockGame(gameId) {
+    try {
+      const dubsServerUrl = this.dubsServerUrl;
+      
+      console.log(`     🔒 Calling lock endpoint: ${dubsServerUrl}/api/games/${gameId}/lock`);
+      
+      const response = await axios.post(
+        `${dubsServerUrl}/api/games/${gameId}/lock`,
+        {
+          lockedAt: new Date().toISOString(),
+          lockedBy: 'oracle'
+        },
+        {
+          timeout: 10000,
+          headers: { 'Content-Type': 'application/json' }
+        }
+      );
+      
+      console.log(`     ✅ Game locked in database - Response:`, response.data);
+      console.log(`     📡 WebSocket event should have been emitted to all clients`);
+    } catch (error) {
+      console.error(`     ⚠️ Error locking game:`, error.message);
+      if (error.response) {
+        console.error(`     Status: ${error.response.status}`);
+        console.error(`     Response:`, error.response.data);
+      }
+      // Don't throw - continue with resolution attempt
+    }
+  }
+
+  /**
+   * Check if sports game is finished via live scores API
+   * @param {object} sportsEvent - Sports event data
+   * @param {object} game - Full game object with player arrays (for no-competition check)
+   */
+  async checkSportsGameResult(sportsEvent, game = null) {
+    try {
+      const { strLeague, strHomeTeam, strAwayTeam, dateEvent } = sportsEvent;
+
+      // Normalize league name for API call (TheSportsDB returns full names like "English Premier League")
+      const normalizedLeague = normalizeLeague(strLeague);
+      const liveScoresUrl = `${this.liveScoresApiUrl}/api/livescores/${normalizedLeague}`;
+      
+      console.log(`     🔍 Checking live scores for:`, {
+        league: strLeague,
+        normalizedLeague,
+        home: strHomeTeam,
+        away: strAwayTeam,
+        date: dateEvent
+      });
+      console.log(`     🌐 Live Scores API URL: ${liveScoresUrl}`);
+      console.log(`     🌐 Base URL (this.liveScoresApiUrl): ${this.liveScoresApiUrl}`);
+      
+      // Fetch live scores for the league
+      const response = await axios.get(liveScoresUrl, { timeout: 10000 });
+      
+      // Handle both array format and { success, data } wrapper format
+      let liveScores;
+      if (Array.isArray(response.data)) {
+        liveScores = response.data;
+      } else if (response.data && Array.isArray(response.data.data)) {
+        liveScores = response.data.data;
+      } else {
+        console.log(`     ⚠️ Unexpected response format:`, typeof response.data, Object.keys(response.data || {}));
+        liveScores = [];
+      }
+      console.log(`     📊 Received ${liveScores.length} live score(s) from API`);
+      
+      // Log all available games for debugging
+      if (liveScores.length > 0) {
+        console.log(`     Available games:`);
+        liveScores.forEach((score, idx) => {
+          const home = score.competitors?.find(c => c.homeAway === 'home');
+          const away = score.competitors?.find(c => c.homeAway === 'away');
+          console.log(`       ${idx + 1}. ${away?.name || '?'} @ ${home?.name || '?'} (${score.date}) - ${score.status}`);
+        });
+      }
+      
+      // Find our game by team names and date
+      // IMPORTANT: Filter for ALL matches first, then prefer "Final" status
+      // (ESPN API sometimes returns duplicate entries with different statuses)
+      const matchingGames = liveScores.filter(score => {
+        // Match date
+        if (score.date !== dateEvent) {
+          console.log(`     Date mismatch: ${score.date} !== ${dateEvent}`);
+          return false;
+        }
+
+        // Match teams (normalize names) - check both home/away AND swapped positions
+        // UFC/MMA sometimes swaps home/away between scheduled and final entries
+        const homeExpected = this.normalizeTeamName(strHomeTeam);
+        const awayExpected = this.normalizeTeamName(strAwayTeam);
+
+        const competitors = score.competitors || [];
+        const homeCompetitor = competitors.find(c => c.homeAway === 'home');
+        const awayCompetitor = competitors.find(c => c.homeAway === 'away');
+
+        if (!homeCompetitor || !awayCompetitor) return false;
+
+        const homeActual = this.normalizeTeamName(homeCompetitor.name);
+        const awayActual = this.normalizeTeamName(awayCompetitor.name);
+
+        // Check standard match (home=home, away=away)
+        const standardMatch = homeActual === homeExpected && awayActual === awayExpected;
+
+        // Check swapped match (home=away, away=home) - common in UFC
+        const swappedMatch = homeActual === awayExpected && awayActual === homeExpected;
+
+        if (!standardMatch && !swappedMatch) {
+          console.log(`     Home team mismatch: "${homeActual}" !== "${homeExpected}"`);
+          console.log(`     Away team mismatch: "${awayActual}" !== "${awayExpected}"`);
+        }
+
+        return standardMatch || swappedMatch;
+      });
+
+      if (matchingGames.length === 0) {
+        console.log(`     ❌ Game not found in live scores`);
+        return null; // Game not found in live scores yet
+      }
+
+      // Prefer "Final" status over other statuses (handles duplicate entries)
+      const finalStatuses = ['Final', 'FT', 'Full Time', 'AET', 'FT-Pens'];
+      let gameResult = matchingGames.find(g =>
+        finalStatuses.some(s => g.status?.toLowerCase() === s.toLowerCase())
+      );
+
+      // If no Final entry, use the first match (in-progress or scheduled)
+      if (!gameResult) {
+        gameResult = matchingGames[0];
+      }
+
+      console.log(`     ✅ Found ${matchingGames.length} matching game(s), using: ${gameResult.status}`);
+
+      // Check if game is final (reuse finalStatuses from above)
+      const isFinal = finalStatuses.some(s =>
+        gameResult.status?.toLowerCase() === s.toLowerCase()
+      );
+
+      if (!isFinal) {
+        console.log(`     ⏳ Game in progress: ${gameResult.status}`);
+        return { isFinal: false, status: gameResult.status };
+      }
+      
+      // Determine winner
+      const homeTeam = gameResult.competitors.find(c => c.homeAway === 'home');
+      const awayTeam = gameResult.competitors.find(c => c.homeAway === 'away');
+      
+      if (!homeTeam || !awayTeam) {
+        console.error(`     ❌ Missing team data in game result`);
+        return null;
+      }
+      
+      // 🔐 CRITICAL: Check if there's competition (multiple sides betting)
+      // This MUST match the smart contract's edge case handling!
+      const homePlayerCount = game?.homeTeamPlayers?.length || 0;
+      const awayPlayerCount = game?.awayTeamPlayers?.length || 0;
+      const drawPlayerCount = game?.drawTeamPlayers?.length || 0;
+      const totalPlayerCount = homePlayerCount + awayPlayerCount + drawPlayerCount;
+
+      console.log(`     👥 Player distribution: Home=${homePlayerCount}, Away=${awayPlayerCount}, Draw=${drawPlayerCount}`);
+
+      let winner;
+
+      // Determine winner by score first
+      let scoreBasedWinner;
+      if (homeTeam.score > awayTeam.score) {
+        scoreBasedWinner = 'home';
+      } else if (awayTeam.score > homeTeam.score) {
+        scoreBasedWinner = 'away';
+      } else {
+        scoreBasedWinner = 'draw'; // Tied score
+      }
+
+      // Check for competition: Need at least one winner AND one loser
+      // - If home wins, need at least 1 away or draw bettor
+      // - If away wins, need at least 1 home or draw bettor
+      // - If draw, need at least 1 home or away bettor
+      const winnerCount = scoreBasedWinner === 'home' ? homePlayerCount :
+                          scoreBasedWinner === 'away' ? awayPlayerCount : drawPlayerCount;
+      const loserCount = totalPlayerCount - winnerCount;
+
+      if (winnerCount === 0 || loserCount === 0) {
+        // No competition - either no winners or no losers
+        winner = null; // Refund everyone
+        console.log(`     ⚠️  NO COMPETITION: ${winnerCount === 0 ? 'No bettors on winning side' : 'No bettors on losing side'} - resolving as REFUND`);
+        console.log(`     💰 All ${totalPlayerCount} player(s) will get refunded (minus 6% fees)`);
+      } else {
+        // Normal game with competition
+        winner = scoreBasedWinner;
+      }
+      
+      console.log(`     🏆 Game final! Winner: ${winner === null ? 'REFUND (no competition)' : winner} (${awayTeam.score}-${homeTeam.score})`);
+      
+      return {
+        isFinal: true,
+        status: 'Final',
+        winner,
+        homeScore: homeTeam.score,
+        awayScore: awayTeam.score
+      };
+      
+    } catch (error) {
+      console.error('     ❌ Error checking sports game result:', error.message);
+      if (error.response) {
+        console.error(`     API Error: ${error.response.status} - ${error.response.statusText}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Check if an esports match is finished via PandaScore API
+   * @param {object} sportsEvent - Esports event data (stored at game creation from PandaScore)
+   * @param {object} game - Full game object with player arrays (for no-competition check)
+   */
+  async checkEsportsGameResult(sportsEvent, game = null) {
+    try {
+      const pandascoreMatchId = sportsEvent.pandascoreMatchId;
+      if (!pandascoreMatchId) {
+        console.error('     ❌ No pandascoreMatchId found in sportsEvent');
+        return null;
+      }
+
+      // Fetch match status from PandaScore via our proxy
+      const matchUrl = `${this.dubsServerUrl}/api/esports/matches/${pandascoreMatchId}`;
+      console.log(`     🎮 Fetching PandaScore match: ${matchUrl}`);
+
+      const response = await axios.get(matchUrl, { timeout: 10000 });
+      const match = response.data?.data;
+
+      if (!match) {
+        console.log('     ❌ Match not found in PandaScore response');
+        return null;
+      }
+
+      console.log(`     🎮 Match status: ${match.status}, winner_id: ${match.winner_id || 'none'}`);
+
+      // PandaScore match statuses: "not_started", "running", "finished", "canceled", "postponed"
+      if (match.status === 'canceled' || match.status === 'postponed') {
+        // Forfeit wins: PandaScore marks as "canceled" with forfeit=true AND a winner_id
+        if (match.forfeit && match.winner_id) {
+          console.log(`     🏳️ Match is a FORFEIT — winner_id: ${match.winner_id}, proceeding to determine winner`);
+          // Fall through to winner determination logic below
+        } else {
+          console.log(`     ⚠️ Match ${match.status} - resolving as REFUND`);
+          return {
+            isFinal: true,
+            status: match.status,
+            winner: null, // Refund all players
+            homeScore: 0,
+            awayScore: 0
+          };
+        }
+      }
+
+      if (match.status !== 'finished' && !(match.forfeit && match.winner_id)) {
+        console.log(`     ⏳ Match not finished yet: ${match.status}`);
+        return { isFinal: false, status: match.status };
+      }
+
+      // Match is finished — determine winner
+      const opponents = sportsEvent.opponents || match.opponents || [];
+      if (opponents.length < 2) {
+        console.error('     ❌ Match has fewer than 2 opponents');
+        return null;
+      }
+
+      // Calculate map scores from match.results
+      let homeScore = 0;
+      let awayScore = 0;
+      if (match.results && Array.isArray(match.results)) {
+        const team0Result = match.results.find(r => r.team_id === opponents[0].opponent?.id);
+        const team1Result = match.results.find(r => r.team_id === opponents[1].opponent?.id);
+        homeScore = team0Result?.score || 0;
+        awayScore = team1Result?.score || 0;
+      }
+
+      // Determine winner: PandaScore gives us winner_id directly
+      const winnerId = match.winner_id;
+      let scoreBasedWinner;
+
+      if (winnerId === opponents[0].opponent?.id) {
+        scoreBasedWinner = 'home'; // opponent[0] = home
+      } else if (winnerId === opponents[1].opponent?.id) {
+        scoreBasedWinner = 'away'; // opponent[1] = away
+      } else {
+        console.error(`     ❌ winner_id ${winnerId} doesn't match either opponent`);
+        if (homeScore > awayScore) scoreBasedWinner = 'home';
+        else if (awayScore > homeScore) scoreBasedWinner = 'away';
+        else {
+          console.error('     ❌ Cannot determine winner - scores tied and winner_id mismatch');
+          return null;
+        }
+      }
+
+      console.log(`     🏆 Winner: ${scoreBasedWinner} (${opponents[scoreBasedWinner === 'home' ? 0 : 1].opponent?.name})`);
+
+      // Check for competition (same logic as sports)
+      const homePlayerCount = game?.homeTeamPlayers?.length || 0;
+      const awayPlayerCount = game?.awayTeamPlayers?.length || 0;
+      const totalPlayerCount = homePlayerCount + awayPlayerCount;
+
+      console.log(`     👥 Player distribution: Home=${homePlayerCount}, Away=${awayPlayerCount}`);
+
+      let winner;
+      const winnerCount = scoreBasedWinner === 'home' ? homePlayerCount : awayPlayerCount;
+      const loserCount = totalPlayerCount - winnerCount;
+
+      if (winnerCount === 0 || loserCount === 0) {
+        winner = null;
+        console.log(`     ⚠️  NO COMPETITION: ${winnerCount === 0 ? 'No bettors on winning side' : 'No bettors on losing side'} - resolving as REFUND`);
+      } else {
+        winner = scoreBasedWinner;
+      }
+
+      return {
+        isFinal: true,
+        status: 'Final',
+        winner,
+        homeScore,
+        awayScore
+      };
+
+    } catch (error) {
+      console.error('     ❌ Error checking esports game result:', error.message);
+      if (error.response) {
+        console.error(`     API Error: ${error.response.status} - ${error.response.statusText}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Normalize team names for matching
+   * Handles both American sports (prefixes) and soccer (suffixes)
+   */
+  normalizeTeamName(name) {
+    return name
+      .toLowerCase()
+      .trim()
+      // American sports - remove city prefixes
+      .replace(/^(los angeles|la)\s+/i, '')
+      .replace(/^(new york|ny)\s+/i, '')
+      .replace(/^(san francisco|sf)\s+/i, '')
+      .replace(/^(golden state)\s+/i, '')
+      // Soccer/EPL - remove common PREFIXES (e.g., "AFC Bournemouth" → "bournemouth")
+      .replace(/^(afc|fc)\s+/i, '')
+      // Soccer/EPL - remove common suffixes
+      .replace(/\s+(fc|afc|sc|cf)$/i, '')
+      .replace(/\s+(united|city|town|athletic|hotspur|wanderers|rovers|albion)$/i, '')
+      // Remove "& Hove" or "and Hove" from "Brighton & Hove Albion" type names
+      .replace(/\s*(and|&)\s*hove\s*/i, ' ')
+      // Remove ampersands and normalize
+      .replace(/\s*&\s*/g, ' ')
+      // Normalize whitespace
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  /**
+   * Resolve game on-chain by calling the smart contract
+   */
+  async resolveGame(game, result) {
+    try {
+      const gameId = game.gameId;
+      console.log(`\n  🔗 Resolving game on-chain: ${gameId}`);
+      console.log(`     - Game ID: ${gameId}`);
+      console.log(`     - Winner: ${result.winner}`);
+      console.log(`     - Score: ${result.homeScore}-${result.awayScore}`);
+      
+      // 🎁 Look up game creator's referrer for on-chain commission payout
+      const referrerWallet = await this.getGameCreatorReferrer(gameId);
+      if (referrerWallet) {
+        console.log(`     🎁 Referrer wallet: ${referrerWallet} (will receive 1% commission on-chain)`);
+      } else {
+        console.log(`     ℹ️  No referrer for game creator - platform keeps full 5%`);
+      }
+      
+      // Build and send resolve_automatic_game transaction
+      const signature = await this.buildAndSendResolveTransaction(gameId, result, referrerWallet);
+      console.log(`     ✅ On-chain resolution signature: ${signature}`);
+      
+      // Update PostgreSQL database after successful on-chain resolution
+      // Pass signature so winners get claim_signature updated for transaction history matching
+      await this.updateGameInPostgreSQL(gameId, result, signature);
+      
+      // 🎁 Record referral commission in database for tracking/display
+      if (referrerWallet) {
+        await this.recordReferralCommission(game, referrerWallet, signature);
+      }
+
+      // 🎟️ Record promo code outcome (if any sponsored players in this game)
+      // Outcome: 'won', 'lost', or 'refunded' (for no competition/cancelled)
+      try {
+        let promoOutcome;
+        if (result.winner === null) {
+          // No competition or cancelled - refund
+          promoOutcome = 'refunded';
+        } else {
+          // Game had a winner (home, away, or draw) - check if sponsored player won
+          // For now, just mark as 'lost' for simplicity - the real check would be complex
+          promoOutcome = 'lost'; // Default, frontend can show actual outcome
+        }
+        await promoService.recordGameOutcome(gameId, promoOutcome);
+      } catch (promoErr) {
+        console.log(`     ⚠️ No promo code for this game (expected if not sponsored)`);
+      }
+
+      // Send web app notifications to participants (game won/lost)
+      if (game.gameMode === 5) {
+        await this.sendEsportsResultNotifications(game, result);
+      } else {
+        await this.sendGameResultNotifications(game, result);
+      }
+
+      // Send Telegram notifications to participants
+      await this.sendTelegramNotifications(game, result);
+      
+      console.log(`  ✅ Game resolved successfully!`);
+      
+    } catch (error) {
+      console.error(`  ❌ Error resolving game:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Look up the referrer wallet of the game creator
+   * Returns null if game creator has no referrer
+   */
+  async getGameCreatorReferrer(gameId) {
+    const logPrefix = `[REFERRAL:${gameId.slice(-8)}]`;
+    try {
+      console.log(`${logPrefix} 🔍 Looking up game creator's referrer...`);
+      console.log(`${logPrefix}    URL: ${this.dubsServerUrl}/api/games/${gameId}/creator-referrer`);
+
+      const response = await axios.get(
+        `${this.dubsServerUrl}/api/games/${gameId}/creator-referrer`,
+        { timeout: 5000 }
+      );
+
+      console.log(`${logPrefix}    Response status: ${response.status}`);
+      console.log(`${logPrefix}    Response data: ${JSON.stringify(response.data)}`);
+
+      if (response.data.success && response.data.referrerWallet) {
+        console.log(`${logPrefix} ✅ Found referrer: ${response.data.referrerWallet}`);
+        console.log(`${logPrefix}    Creator: ${response.data.creatorUsername || 'unknown'}`);
+        console.log(`${logPrefix}    Referrer: ${response.data.referrerUsername || 'unknown'}`);
+        return response.data.referrerWallet;
+      }
+
+      console.log(`${logPrefix} ℹ️ No referrer found - creator has no referral_code or referrer not in DB`);
+      console.log(`${logPrefix}    success: ${response.data.success}, referrerWallet: ${response.data.referrerWallet || 'null'}`);
+      return null;
+    } catch (error) {
+      console.error(`${logPrefix} ❌ ERROR fetching referrer info:`);
+      console.error(`${logPrefix}    Message: ${error.message}`);
+      if (error.response) {
+        console.error(`${logPrefix}    Status: ${error.response.status}`);
+        console.error(`${logPrefix}    Data: ${JSON.stringify(error.response.data)}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Record referral commission in database for tracking
+   * The actual SOL transfer happens on-chain during resolution
+   * @param {Object} game - Game data
+   * @param {string} referrerWallet - Wallet that receives commission
+   * @param {string} txSignature - Transaction signature for the payout
+   */
+  async recordReferralCommission(game, referrerWallet, txSignature) {
+    const logPrefix = `[REFERRAL:${game.gameId?.slice(-8) || 'unknown'}]`;
+    try {
+      console.log(`${logPrefix} 💾 Recording referral commission to database...`);
+      console.log(`${logPrefix}    Referrer wallet: ${referrerWallet}`);
+      console.log(`${logPrefix}    TX signature: ${txSignature}`);
+
+      // Calculate pot size: buyIn * playerCount (including draw players for EPL)
+      const buyInSOL = parseFloat(game.buyIn) || 0;
+      const homePlayers = Array.isArray(game.homeTeamPlayers) ? game.homeTeamPlayers.length : 0;
+      const awayPlayers = Array.isArray(game.awayTeamPlayers) ? game.awayTeamPlayers.length : 0;
+      const drawPlayers = Array.isArray(game.drawTeamPlayers) ? game.drawTeamPlayers.length : 0;
+      const playerCount = homePlayers + awayPlayers + drawPlayers;
+      const potSizeSOL = buyInSOL * playerCount;
+      const potSizeLamports = Math.floor(potSizeSOL * 1_000_000_000);
+      const commissionLamports = Math.floor(potSizeLamports * 0.01); // 1%
+
+      console.log(`${logPrefix}    Game data: buyIn=${buyInSOL}, home=${homePlayers}, away=${awayPlayers}, draw=${drawPlayers}`);
+      console.log(`${logPrefix}    Pot: ${potSizeSOL} SOL (${playerCount} players × ${buyInSOL} SOL)`);
+      console.log(`${logPrefix}    Commission: ${commissionLamports / 1_000_000_000} SOL (${commissionLamports} lamports)`);
+
+      if (commissionLamports <= 0) {
+        console.log(`${logPrefix} ⚠️ SKIPPING - commission is 0 (pot too small or no players)`);
+        return;
+      }
+
+      const requestBody = {
+        gameId: game.gameId,
+        referrerWallet,
+        commissionLamports,
+        paidOnChain: true,
+        txSignature
+      };
+
+      console.log(`${logPrefix}    POST ${this.dubsServerUrl}/api/referral-earnings/record`);
+      console.log(`${logPrefix}    Body: ${JSON.stringify(requestBody)}`);
+
+      const response = await axios.post(
+        `${this.dubsServerUrl}/api/referral-earnings/record`,
+        requestBody,
+        { timeout: 5000 }
+      );
+
+      console.log(`${logPrefix} ✅ Database record created/updated successfully`);
+      console.log(`${logPrefix}    Response: ${JSON.stringify(response.data)}`);
+    } catch (error) {
+      console.error(`${logPrefix} ❌ FAILED to record referral commission:`);
+      console.error(`${logPrefix}    Error: ${error.message}`);
+      if (error.response) {
+        console.error(`${logPrefix}    Status: ${error.response.status}`);
+        console.error(`${logPrefix}    Data: ${JSON.stringify(error.response.data)}`);
+      }
+      // Non-critical - on-chain payout already happened, but DB tracking failed
+    }
+  }
+
+  /**
+   * Update game status in PostgreSQL after resolution
+   * @param {string} gameId - Game ID
+   * @param {object} result - Game result (winner, scores)
+   * @param {string} signature - On-chain transaction signature (for claim_signature tracking)
+   */
+  async updateGameInPostgreSQL(gameId, result, signature = null) {
+    try {
+      // Determine the dubs-server API URL
+      // Priority: DUBS_SERVER_URL > Constructed from PORT > Production default
+      let dubsServerUrl;
+      
+      if (process.env.DUBS_SERVER_URL) {
+        dubsServerUrl = process.env.DUBS_SERVER_URL;
+      } else if (process.env.PORT) {
+        // Running on Heroku or locally - construct URL
+        const port = process.env.PORT;
+        dubsServerUrl = process.env.NODE_ENV === 'production'
+          ? `https://dubs-server-production.herokuapp.com`  // Adjust this to your actual Heroku app name
+          : `http://localhost:${port}`;
+      } else {
+        // Final fallback
+        dubsServerUrl = 'http://localhost:3001';
+      }
+      
+      console.log(`     📡 Updating PostgreSQL at ${dubsServerUrl}...`);
+      
+      // Update via dubs-server (it has PostgreSQL access)
+      // Pass resolveSignature so winners get claim_signature updated for transaction history matching
+      await axios.post(
+        `${dubsServerUrl}/api/games/${gameId}/resolve`,
+        {
+          winner: result.winner,
+          homeScore: result.homeScore,
+          awayScore: result.awayScore,
+          resolvedAt: new Date().toISOString(),
+          resolvedBy: 'oracle',
+          resolveSignature: signature // 🎯 Critical for transaction history matching
+        },
+        {
+          timeout: 10000,
+          headers: { 'Content-Type': 'application/json' }
+        }
+      );
+      console.log(`     ✅ PostgreSQL updated (including claim_signature for winners)`);
+    } catch (error) {
+      console.error('     ⚠️ Error updating PostgreSQL:', error.message);
+      if (error.response) {
+        console.error(`     Status: ${error.response.status}`);
+        console.error(`     Data:`, error.response.data);
+      }
+      // Don't throw - on-chain resolution is what matters
+    }
+  }
+
+  /**
+   * Build and send resolve transaction to Solana
+   * @param {string} gameId - Game ID
+   * @param {object} result - Game result (winner, scores)
+   * @param {string|null} referrerWallet - Optional referrer wallet to receive 1% commission
+   */
+  async buildAndSendResolveTransaction(gameId, result, referrerWallet = null) {
+    const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = require('@solana/web3.js');
+    
+    // Get game PDA (same logic as server.js)
+    const crypto = require('crypto');
+    const programId = new PublicKey(this.programId);
+    
+    let gameIdNum;
+    if (typeof gameId === 'string' && gameId.includes('-')) {
+      const hash = crypto.createHash('sha256').update(gameId).digest();
+      gameIdNum = hash.readBigUInt64LE(0);
+    } else {
+      gameIdNum = BigInt(gameId);
+    }
+    
+    const gameIdBuf = Buffer.alloc(8);
+    gameIdBuf.writeBigUInt64LE(gameIdNum);
+    
+    const [gamePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from("game"), gameIdBuf],
+      programId
+    );
+    
+    // Encode winning team: Some(Home) = [1, 0], Some(Away) = [1, 1], Some(Draw) = [1, 2], None (refund) = [0]
+    let winningTeamBytes;
+    if (result.winner === null) {
+      winningTeamBytes = Buffer.from([0]); // None - refund all (no competition)
+    } else if (result.winner === 'home') {
+      winningTeamBytes = Buffer.from([1, 0]); // Some(Home)
+    } else if (result.winner === 'away') {
+      winningTeamBytes = Buffer.from([1, 1]); // Some(Away)
+    } else if (result.winner === 'draw') {
+      winningTeamBytes = Buffer.from([1, 2]); // Some(Draw) - draw bettors win
+    } else {
+      // Fallback safety - should never reach here
+      console.error(`     ⚠️ Unexpected winner value: ${result.winner}, defaulting to refund`);
+      winningTeamBytes = Buffer.from([0]); // None - refund all
+    }
+    
+    // Discriminator for resolve_automatic_game
+    const RESOLVE_AUTO = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+    
+    // Build instruction data
+    const data = Buffer.concat([
+      RESOLVE_AUTO,
+      gameIdBuf,
+      winningTeamBytes
+    ]);
+    
+    // ═══════════════════════════════════════════════════════════════════════
+    // 💸 FEE DISTRIBUTION ACCOUNTS
+    // ═══════════════════════════════════════════════════════════════════════
+    // remaining_accounts[0] = Operator wallet (receives 4% or 5%)
+    // remaining_accounts[1] = Referrer wallet (optional, receives 1% if present)
+    // Oracle is the signer and receives 1% directly
+    // ═══════════════════════════════════════════════════════════════════════
+    
+    const keys = [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: this.oracleKeypair.publicKey, isSigner: true, isWritable: true }, // Writable! Receives 1% fee
+      // remaining_accounts[0]: Operator wallet
+      { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true },
+    ];
+    
+    // 🎁 If referrer exists, add as remaining_accounts[1] to receive 1% commission
+    if (referrerWallet) {
+      try {
+        const referrerPubkey = new PublicKey(referrerWallet);
+        keys.push({ pubkey: referrerPubkey, isSigner: false, isWritable: true });
+        console.log(`     🎁 Added referrer to transaction: ${referrerWallet}`);
+      } catch (e) {
+        console.log(`     ⚠️ Invalid referrer wallet address: ${referrerWallet}`);
+      }
+    }
+    
+    const ix = new TransactionInstruction({
+      keys,
+      programId: programId,
+      data,
+    });
+    
+    const tx = new Transaction().add(ix);
+    tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    tx.feePayer = this.oracleKeypair.publicKey;
+    
+    // Sign with oracle keypair
+    tx.sign(this.oracleKeypair);
+    
+    // Send transaction
+    const signature = await this.connection.sendRawTransaction(tx.serialize());
+    await this.confirmTransactionPolling(signature);
+
+    return signature;
+  }
+
+  /**
+   * Poll for transaction confirmation (avoids WebSocket subscription which some RPC providers don't support)
+   * @param {string} signature - Transaction signature
+   * @param {number} timeout - Timeout in milliseconds (default 60000)
+   */
+  async confirmTransactionPolling(signature, timeout = 60000) {
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+      const statuses = await this.connection.getSignatureStatuses([signature]);
+      const status = statuses?.value?.[0];
+
+      if (status?.err) {
+        throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+      }
+
+      if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
+        console.log(`     ✅ Transaction confirmed: ${status.confirmationStatus}`);
+        return status;
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    throw new Error('Transaction confirmation timeout');
+  }
+
+  /**
+   * Send Telegram notifications via Telegram bot
+   */
+  async sendTelegramNotifications(game, result) {
+    try {
+      const telegramBotUrl = process.env.TELEGRAM_BOT_URL;
+      
+      if (!telegramBotUrl) {
+        console.log('     ℹ️  TELEGRAM_BOT_URL not set - skipping Telegram notifications');
+        return;
+      }
+      
+      // Send via Telegram bot
+      const response = await axios.post(
+        `${telegramBotUrl}/api/notifications/game-finished`,
+        {
+          gameId: game.gameId,
+          finalScore: {
+            winner: result.winner,
+            homeScore: result.homeScore,
+            awayScore: result.awayScore
+          }
+        },
+        {
+          headers: { 'Content-Type': 'application/json' },
+          timeout: 10000
+        }
+      );
+      
+      if (response.data.success) {
+        console.log(`     📱 Sent Telegram notifications to all participants`);
+      } else {
+        console.log(`     ⚠️  Failed to send Telegram notifications:`, response.data.error);
+      }
+      
+    } catch (error) {
+      console.error('     ⚠️ Failed to send Telegram notifications:', error.message);
+      // Don't throw - notifications are non-critical
+    }
+  }
+
+  /**
+   * Send game result notifications (won/lost) to all participants
+   */
+  async sendGameResultNotifications(game, result) {
+    try {
+      console.log(`     📧 Sending game result notifications for ${game.gameId}`);
+      console.log(`     Game data:`, {
+        hasEvent: !!game.sportsEvent,
+        homeTeam: game.sportsEvent?.strHomeTeam,
+        awayTeam: game.sportsEvent?.strAwayTeam,
+        buyIn: game.buyIn
+      });
+
+      const gameInvite = {
+        gameId: game.gameId,
+        gameAddress: game.gameAddress || '',
+        title: `${game.sportsEvent?.strAwayTeam || 'Away'} @ ${game.sportsEvent?.strHomeTeam || 'Home'}`,
+        imageUrl: game.sportsEvent?.strThumb || game.sportsEvent?.strSquare || '',
+        matchupImageUrl: game.matchupImageUrl, // Pre-generated S3 matchup image
+        buyIn: game.buyIn || 0,
+        league: normalizeLeague(game.sportsEvent?.strLeague),
+        homeTeam: game.sportsEvent?.strHomeTeam,
+        awayTeam: game.sportsEvent?.strAwayTeam,
+        homeTeamBadge: game.sportsEvent?.strHomeTeamBadge,
+        awayTeamBadge: game.sportsEvent?.strAwayTeamBadge,
+      };
+
+      const finalScore = {
+        winner: result.winner,
+        homeScore: result.homeScore,
+        awayScore: result.awayScore,
+      };
+
+      console.log(`     📧 Built gameInvite:`, {
+        title: gameInvite.title,
+        hasImage: !!gameInvite.imageUrl,
+        buyIn: gameInvite.buyIn
+      });
+
+      // Get all unique participant wallet addresses with their team choices
+      const participants = [];
+      if (game.homeTeamPlayers && Array.isArray(game.homeTeamPlayers)) {
+        game.homeTeamPlayers.forEach(wallet => {
+          if (typeof wallet === 'string') {
+            participants.push({ wallet, teamChoice: 'home' });
+          }
+        });
+      }
+      if (game.awayTeamPlayers && Array.isArray(game.awayTeamPlayers)) {
+        game.awayTeamPlayers.forEach(wallet => {
+          if (typeof wallet === 'string') {
+            participants.push({ wallet, teamChoice: 'away' });
+          }
+        });
+      }
+      if (game.drawTeamPlayers && Array.isArray(game.drawTeamPlayers)) {
+        game.drawTeamPlayers.forEach(wallet => {
+          if (typeof wallet === 'string') {
+            participants.push({ wallet, teamChoice: 'draw' });
+          }
+        });
+      }
+
+      if (participants.length === 0) {
+        console.log('     ℹ️  No participants found for result notifications');
+        return;
+      }
+
+      const dubsServerUrl = this.dubsServerUrl;
+
+      for (const participant of participants) {
+        try {
+          const userWon = participant.teamChoice === result.winner;
+          const notificationType = userWon ? 'game_won' : 'game_lost';
+          const message = userWon 
+            ? `${result.homeScore}-${result.awayScore}` 
+            : `${result.homeScore}-${result.awayScore}`;
+
+          await axios.post(
+            `${dubsServerUrl}/api/games/notify-participant`,
+            {
+              walletAddress: participant.wallet,
+              notificationType,
+              message,
+              gameInvite,
+              finalScore,
+            },
+            {
+              headers: { 'Content-Type': 'application/json' },
+              timeout: 5000
+            }
+          );
+        } catch (err) {
+          console.log(`     ⚠️ Failed to notify ${participant.wallet?.slice(0, 8)}:`, err.message);
+        }
+      }
+
+      console.log(`     ✅ Sent game result notifications to ${participants.length} participant(s)`);
+      
+    } catch (error) {
+      console.error('     ⚠️ Failed to send game result notifications:', error.message);
+    }
+  }
+
+  /**
+   * Send web app notifications to game participants
+   * Stores in PostgreSQL chat_notifications table and emits via WebSocket
+   */
+  async sendWebAppNotifications(game, notificationType, message) {
+    try {
+      // Build game invite metadata for notification
+      const gameInvite = {
+        gameId: game.gameId,
+        gameAddress: game.gameAddress || '',
+        title: `${game.sportsEvent?.strAwayTeam || 'Away'} @ ${game.sportsEvent?.strHomeTeam || 'Home'}`,
+        imageUrl: game.sportsEvent?.strThumb || game.sportsEvent?.strSquare || '',
+        matchupImageUrl: game.matchupImageUrl, // Pre-generated S3 matchup image
+        buyIn: game.buyIn || 0,
+        totalPool: game.totalPool || 0, // Total pot for pari-mutuel display
+        league: normalizeLeague(game.sportsEvent?.strLeague),
+        homeTeam: game.sportsEvent?.strHomeTeam,
+        awayTeam: game.sportsEvent?.strAwayTeam,
+        homeTeamBadge: game.sportsEvent?.strHomeTeamBadge,
+        awayTeamBadge: game.sportsEvent?.strAwayTeamBadge,
+        strTimestamp: game.sportsEvent?.strTimestamp,
+      };
+
+      console.log(`     📧 Built gameInvite for ${notificationType}:`, {
+        title: gameInvite.title,
+        hasImage: !!gameInvite.imageUrl,
+        buyIn: gameInvite.buyIn
+      });
+
+      // Get all unique participant wallet addresses
+      const participantWallets = new Set();
+      if (game.homeTeamPlayers && Array.isArray(game.homeTeamPlayers)) {
+        game.homeTeamPlayers.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+      if (game.awayTeamPlayers && Array.isArray(game.awayTeamPlayers)) {
+        game.awayTeamPlayers.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+      if (game.drawTeamPlayers && Array.isArray(game.drawTeamPlayers)) {
+        game.drawTeamPlayers.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+      if (game.participants && Array.isArray(game.participants)) {
+        game.participants.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+
+      if (participantWallets.size === 0) {
+        console.log('     ℹ️  No participants found for notifications');
+        return;
+      }
+
+      // Send notification via dubs-server API (which handles PostgreSQL + WebSocket)
+      const dubsServerUrl = this.dubsServerUrl;
+      
+      for (const walletAddress of participantWallets) {
+        try {
+          // Skip if walletAddress is undefined or null
+          if (!walletAddress) {
+            console.log('     ⚠️ Skipping undefined wallet address');
+            continue;
+          }
+
+          await axios.post(
+            `${dubsServerUrl}/api/games/notify-participant`,
+            {
+              walletAddress,
+              notificationType,
+              message,
+              gameInvite,
+            },
+            {
+              headers: { 'Content-Type': 'application/json' },
+              timeout: 5000
+            }
+          );
+        } catch (err) {
+          console.log(`     ⚠️ Failed to notify ${walletAddress?.slice(0, 8) || 'unknown'}:`, err.message);
+        }
+      }
+
+      console.log(`     ✅ Sent ${notificationType} notifications to ${participantWallets.size} participant(s)`);
+      
+    } catch (error) {
+      console.error('     ⚠️ Failed to send web app notifications:', error.message);
+      // Don't throw - notifications are non-critical
+    }
+  }
+  // ============================================
+  // ESPORTS NOTIFICATIONS
+  // ============================================
+
+  /**
+   * Send esports game result notifications (won/lost) to all participants.
+   * Uses PandaScore opponent data instead of TheSportsDB fields.
+   */
+  async sendEsportsResultNotifications(game, result) {
+    try {
+      const se = game.sportsEvent || {};
+      const opp0 = se.opponents?.[0]?.opponent || {};
+      const opp1 = se.opponents?.[1]?.opponent || {};
+
+      console.log(`     🎮📧 Sending esports result notifications for ${game.gameId}`);
+      console.log(`     Game data:`, {
+        hasEvent: !!se,
+        homeTeam: opp0.name,
+        awayTeam: opp1.name,
+        buyIn: game.buyIn
+      });
+
+      const gameInvite = {
+        gameId: game.gameId,
+        gameAddress: game.gameAddress || '',
+        title: se.matchName || `${opp0.name || 'Team 1'} vs ${opp1.name || 'Team 2'}`,
+        imageUrl: opp0.image_url || '',
+        matchupImageUrl: game.matchupImageUrl || '',
+        buyIn: game.buyIn || 0,
+        league: se.videogame || se.videogameSlug || 'Esports',
+        homeTeam: opp0.name,
+        awayTeam: opp1.name,
+        homeTeamBadge: opp0.image_url,
+        awayTeamBadge: opp1.image_url,
+        isEsports: true,
+        tournament: se.tournament,
+        videogameSlug: se.videogameSlug,
+      };
+
+      const finalScore = {
+        winner: result.winner,
+        homeScore: result.homeScore,
+        awayScore: result.awayScore,
+      };
+
+      console.log(`     🎮📧 Built gameInvite:`, {
+        title: gameInvite.title,
+        buyIn: gameInvite.buyIn
+      });
+
+      // Get all unique participant wallet addresses with their team choices
+      const participants = [];
+      if (game.homeTeamPlayers && Array.isArray(game.homeTeamPlayers)) {
+        game.homeTeamPlayers.forEach(wallet => {
+          if (typeof wallet === 'string') {
+            participants.push({ wallet, teamChoice: 'home' });
+          }
+        });
+      }
+      if (game.awayTeamPlayers && Array.isArray(game.awayTeamPlayers)) {
+        game.awayTeamPlayers.forEach(wallet => {
+          if (typeof wallet === 'string') {
+            participants.push({ wallet, teamChoice: 'away' });
+          }
+        });
+      }
+
+      if (participants.length === 0) {
+        console.log('     ℹ️  No participants found for esports result notifications');
+        return;
+      }
+
+      const dubsServerUrl = this.dubsServerUrl;
+
+      for (const participant of participants) {
+        try {
+          const userWon = participant.teamChoice === result.winner;
+          const notificationType = userWon ? 'game_won' : 'game_lost';
+          const message = `${result.homeScore}-${result.awayScore}`;
+
+          await axios.post(
+            `${dubsServerUrl}/api/games/notify-participant`,
+            {
+              walletAddress: participant.wallet,
+              notificationType,
+              message,
+              gameInvite,
+              finalScore,
+            },
+            {
+              headers: { 'Content-Type': 'application/json' },
+              timeout: 5000
+            }
+          );
+        } catch (err) {
+          console.log(`     ⚠️ Failed to notify ${participant.wallet?.slice(0, 8)}:`, err.message);
+        }
+      }
+
+      console.log(`     ✅ Sent esports result notifications to ${participants.length} participant(s)`);
+
+    } catch (error) {
+      console.error('     ⚠️ Failed to send esports result notifications:', error.message);
+    }
+  }
+
+  /**
+   * Send esports web app notifications (starting soon / starting now).
+   * Uses PandaScore opponent data instead of TheSportsDB fields.
+   */
+  async sendEsportsWebAppNotifications(game, notificationType, message) {
+    try {
+      const se = game.sportsEvent || {};
+      const opp0 = se.opponents?.[0]?.opponent || {};
+      const opp1 = se.opponents?.[1]?.opponent || {};
+
+      const gameInvite = {
+        gameId: game.gameId,
+        gameAddress: game.gameAddress || '',
+        title: se.matchName || `${opp0.name || 'Team 1'} vs ${opp1.name || 'Team 2'}`,
+        imageUrl: opp0.image_url || '',
+        matchupImageUrl: game.matchupImageUrl || '',
+        buyIn: game.buyIn || 0,
+        totalPool: game.totalPool || 0,
+        league: se.videogame || se.videogameSlug || 'Esports',
+        homeTeam: opp0.name,
+        awayTeam: opp1.name,
+        homeTeamBadge: opp0.image_url,
+        awayTeamBadge: opp1.image_url,
+        strTimestamp: se.strTimestamp,
+        isEsports: true,
+        tournament: se.tournament,
+        videogameSlug: se.videogameSlug,
+      };
+
+      console.log(`     🎮📧 Built esports gameInvite for ${notificationType}:`, {
+        title: gameInvite.title,
+        buyIn: gameInvite.buyIn
+      });
+
+      // Get all unique participant wallet addresses
+      const participantWallets = new Set();
+      if (game.homeTeamPlayers && Array.isArray(game.homeTeamPlayers)) {
+        game.homeTeamPlayers.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+      if (game.awayTeamPlayers && Array.isArray(game.awayTeamPlayers)) {
+        game.awayTeamPlayers.forEach(p => {
+          const wallet = typeof p === 'string' ? p : (p.walletAddress || p.wallet);
+          if (wallet) participantWallets.add(wallet);
+        });
+      }
+
+      if (participantWallets.size === 0) {
+        console.log('     ℹ️  No participants found for esports notifications');
+        return;
+      }
+
+      const dubsServerUrl = this.dubsServerUrl;
+
+      for (const walletAddress of participantWallets) {
+        try {
+          if (!walletAddress) continue;
+
+          await axios.post(
+            `${dubsServerUrl}/api/games/notify-participant`,
+            {
+              walletAddress,
+              notificationType,
+              message,
+              gameInvite,
+            },
+            {
+              headers: { 'Content-Type': 'application/json' },
+              timeout: 5000
+            }
+          );
+        } catch (err) {
+          console.log(`     ⚠️ Failed to notify ${walletAddress?.slice(0, 8) || 'unknown'}:`, err.message);
+        }
+      }
+
+      console.log(`     ✅ Sent esports ${notificationType} notifications to ${participantWallets.size} participant(s)`);
+
+    } catch (error) {
+      console.error('     ⚠️ Failed to send esports web app notifications:', error.message);
+    }
+  }
+}
+
+module.exports = AutomaticGameOracle;
+module.exports.normalizeLeague = normalizeLeague;
+