dubs-server 1.0.0

package/routes/keeperMonitoringRoutes.js

@@ -0,0 +1,156 @@
+/**
+ * Keeper Monitoring Routes
+ * 
+ * Endpoints for viewing keeper health, stuck rounds, and logs
+ */
+
+const express = require('express');
+const router = express.Router();
+const KeeperStateService = require('../services/keeperStateService');
+
+const state = new KeeperStateService();
+
+/**
+ * GET /api/keeper/health
+ * Returns overall keeper health summary
+ */
+router.get('/health', async (req, res) => {
+  try {
+    const summary = await state.getHealthSummary();
+    const stuckRounds = await state.getStuckRounds();
+    
+    const health = {
+      healthy: stuckRounds.length === 0 && (summary?.stuck_rounds || 0) === 0,
+      summary,
+      stuckRounds,
+      timestamp: new Date().toISOString()
+    };
+    
+    res.json(health);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/keeper/rounds/stuck
+ * Returns list of stuck rounds
+ */
+router.get('/rounds/stuck', async (req, res) => {
+  try {
+    const stuck = await state.getStuckRounds();
+    res.json({ stuck, count: stuck.length });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/keeper/rounds/:roundId
+ * Returns detailed state for a specific round
+ */
+router.get('/rounds/:roundId', async (req, res) => {
+  try {
+    const roundId = req.params.roundId;
+    const round = await state.getRound(roundId);
+    const actions = await state.getRoundActions(roundId, 50);
+    
+    if (!round) {
+      return res.status(404).json({ error: 'Round not found in database' });
+    }
+    
+    res.json({
+      round,
+      actions,
+      isStuck: state.isRoundStuck(round)
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/keeper/rounds/:roundId/actions
+ * Returns action log for a specific round
+ */
+router.get('/rounds/:roundId/actions', async (req, res) => {
+  try {
+    const roundId = req.params.roundId;
+    const limit = parseInt(req.query.limit) || 100;
+    const actions = await state.getRoundActions(roundId, limit);
+    
+    res.json({ roundId, actions, count: actions.length });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/keeper/dashboard
+ * Returns comprehensive dashboard data
+ */
+router.get('/dashboard', async (req, res) => {
+  try {
+    const summary = await state.getHealthSummary();
+    const stuckRounds = await state.getStuckRounds();
+    
+    // Get recent rounds (last 20)
+    const { rows: recentRounds } = await state.pool.query(`
+      SELECT round_id, status, entry_count, total_pot, winner_pubkey, win_amount,
+             created_at, locked_at, revealed_at, resolved_at, reset_at, retry_count
+      FROM keeper_rounds
+      ORDER BY round_id DESC
+      LIMIT 20
+    `);
+    
+    // Get health metrics (last 24 hours)
+    const { rows: healthMetrics } = await state.pool.query(`
+      SELECT *
+      FROM keeper_health
+      WHERE timestamp > NOW() - INTERVAL '24 hours'
+      ORDER BY timestamp DESC
+      LIMIT 100
+    `);
+    
+    // Calculate success rate
+    const totalRounds = summary?.resolved_rounds || 0;
+    const retriedRounds = summary?.rounds_with_retries || 0;
+    const successRate = totalRounds > 0 ? ((totalRounds - retriedRounds) / totalRounds * 100).toFixed(1) : 100;
+    
+    const dashboard = {
+      summary: {
+        ...summary,
+        successRate: `${successRate}%`,
+        healthy: stuckRounds.length === 0
+      },
+      stuckRounds,
+      recentRounds: recentRounds.map(r => ({
+        ...r,
+        total_pot_sol: r.total_pot ? (Number(r.total_pot) / 1e9).toFixed(4) : '0',
+        win_amount_sol: r.win_amount ? (Number(r.win_amount) / 1e9).toFixed(4) : '0'
+      })),
+      healthMetrics,
+      timestamp: new Date().toISOString()
+    };
+    
+    res.json(dashboard);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/keeper/cleanup
+ * Manually trigger log cleanup
+ */
+router.post('/cleanup', async (req, res) => {
+  try {
+    await state.cleanupOldLogs();
+    res.json({ success: true, message: 'Cleanup completed' });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;
+

package/routes/keeperWebhookRoutes.js

@@ -0,0 +1,466 @@
+/**
+ * Keeper Webhook Routes
+ * 
+ * The keeper (separate dyno) calls these endpoints to trigger WebSocket broadcasts
+ */
+
+const express = require('express');
+const router = express.Router();
+const { instance: history } = require('../services/jackpotHistory');
+const notificationCacheService = require('../services/notificationCacheService');
+
+// Store service references (will be injected)
+let chatServiceInstance = null;
+let playerStatsServiceInstance = null;
+let jackpotServiceInstance = null;
+let userProfileStatsServiceInstance = null;
+
+// Inject dependencies
+router.setChatService = (chatService) => {
+  chatServiceInstance = chatService;
+};
+
+router.setPlayerStatsService = (playerStatsService) => {
+  playerStatsServiceInstance = playerStatsService;
+};
+
+router.setJackpotService = (jackpotService) => {
+  jackpotServiceInstance = jackpotService;
+};
+
+router.setUserProfileStatsService = (service) => {
+  userProfileStatsServiceInstance = service;
+};
+
+/**
+ * POST /api/keeper-webhook/timer-update
+ * Keeper calls this every 5s with current round state
+ */
+router.post('/timer-update', async (req, res) => {
+  try {
+    const { roundId, timeRemaining, entryCount, totalPot, status } = req.body;
+    
+    if (global.io) {
+      global.io.to(`round_${roundId}`).emit('timer_update', {
+        roundId,
+        timeRemaining,
+        entryCount,
+        totalPot,
+        status,
+        timestamp: Date.now()
+      });
+    }
+    
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/keeper-webhook/round-locked
+ * Keeper calls this when round locks
+ */
+router.post('/round-locked', async (req, res) => {
+  try {
+    const { roundId } = req.body;
+    
+    console.log(`📢 Webhook: Round ${roundId} locked`);
+    
+    if (global.io) {
+      global.io.to(`round_${roundId}`).emit('round_locked', {
+        roundId,
+        timestamp: Date.now()
+      });
+      console.log(`⚡ Broadcasted: round_locked`);
+    }
+    
+    res.json({ success: true, broadcasted: true });
+  } catch (error) {
+    console.error('Webhook error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/keeper-webhook/winner-selected
+ * Keeper calls this when winner is selected
+ * 🔥 NOW WITH EPIC CHAT ANNOUNCEMENT! 🔥
+ */
+router.post('/winner-selected', async (req, res) => {
+  try {
+    const { roundId, winner, winAmount, totalPot, entryCount, signature, serverSeed, serverSeedHash, oracleSeed } = req.body;
+
+    console.log('━'.repeat(80));
+    console.log(`📢 WINNER WEBHOOK CALLED!`);
+    console.log(`   Round: ${roundId}`);
+    console.log(`   Winner: ${winner}`);
+    console.log(`   Amount (lamports): ${winAmount}`);
+    console.log(`   Amount (SOL): ${winAmount / 1_000_000_000}`);
+    console.log(`   Total Pot: ${totalPot}`);
+    console.log(`   Entry Count: ${entryCount}`);
+    console.log(`   VRF Data: ${serverSeed ? '✅' : '❌'} seed, ${serverSeedHash ? '✅' : '❌'} hash, ${oracleSeed ? '✅' : '❌'} oracle`);
+    console.log(`   Chat Service: ${chatServiceInstance ? '✅ AVAILABLE' : '❌ NOT AVAILABLE'}`);
+    console.log(`   Socket.IO: ${global.io ? '✅ AVAILABLE' : '❌ NOT AVAILABLE'}`);
+    console.log('━'.repeat(80));
+
+    // 💾 SAVE TO HISTORY with VRF verification data
+    try {
+      await history.addRound({
+        roundId: roundId.toString(),
+        winner,
+        winAmount: winAmount.toString(),
+        totalPot: totalPot.toString(),
+        entryCount,
+        timestamp: new Date().toISOString(),
+        signature: signature || null,
+        serverSeed: serverSeed || null,
+        serverSeedHash: serverSeedHash || null,
+        oracleSeed: oracleSeed || null,
+      });
+      console.log(`💾 Winner saved to history: ${winner.slice(0, 8)}... (VRF: ${serverSeed ? 'YES' : 'NO'})`);
+    } catch (historyError) {
+      console.error('⚠️  Failed to save winner to history:', historyError.message);
+    }
+    
+    // 📊 TRACK WINNER IN PLAYER STATS! 📊
+    let winnerStreak = 1;
+    if (playerStatsServiceInstance) {
+      try {
+        console.log('📊 Recording win in player stats...');
+        const result = await playerStatsServiceInstance.recordWin({
+          walletAddress: winner,
+          roundId,
+          winAmount
+        });
+        winnerStreak = result?.newStreak || 1;
+        console.log(`✅ Win recorded for ${winner.slice(0, 8)}... (streak: ${winnerStreak}🔥)`);
+      } catch (statsError) {
+        console.error('⚠️  Failed to record win in stats:', statsError.message);
+        // Don't fail the whole request if stats tracking fails
+      }
+    }
+
+    // 🏆 POST EPIC WINNER ANNOUNCEMENT TO CHAT! 🏆
+    if (chatServiceInstance) {
+      try {
+        console.log('🔥 Attempting to post winner announcement...');
+        
+        const chatMessage = await chatServiceInstance.postWinnerAnnouncement({
+          winner,
+          winAmount: winAmount / 1_000_000_000, // Convert lamports to SOL
+          roundId
+        });
+        
+        console.log('✅ Chat message created:', chatMessage);
+        
+        // Broadcast the epic message to chat via /chat namespace with correct event name
+        if (global.io) {
+          const chatNamespace = global.io.of('/chat');
+          chatNamespace.emit('new_message', chatMessage);
+          console.log(`🔥 EPIC WINNER ANNOUNCEMENT broadcasted to ALL chat clients!`);
+          console.log(`   Message ID: ${chatMessage.id}`);
+          console.log(`   Winner: ${chatMessage.walletAddress}`);
+          console.log(`   Amount: ◎${chatMessage.winAmount}`);
+        } else {
+          console.warn('⚠️  Socket.IO not available - message saved but not broadcasted');
+        }
+      } catch (chatError) {
+        console.error('❌ Failed to post winner announcement to chat:');
+        console.error('   Error:', chatError.message);
+        console.error('   Stack:', chatError.stack);
+        // Don't fail the whole request if chat fails
+      }
+    } else {
+      console.warn('⚠️  Chat service not available - skipping winner announcement');
+    }
+    
+    // Look up winner's username/avatar/id for animation display + notifications
+    let winnerUsername = winner.slice(0, 4) + '...' + winner.slice(-4);
+    let winnerAvatar = null;
+    let winnerUserId = null;
+    if (chatServiceInstance?.pool) {
+      try {
+        const userResult = await chatServiceInstance.pool.query(
+          'SELECT id, username, avatar FROM users WHERE wallet_address = $1',
+          [winner]
+        );
+        if (userResult.rows.length > 0) {
+          winnerUserId = userResult.rows[0].id;
+          winnerUsername = userResult.rows[0].username || winnerUsername;
+          winnerAvatar = userResult.rows[0].avatar || null;
+        }
+      } catch (lookupErr) {
+        console.warn('⚠️  Failed to look up winner profile:', lookupErr.message);
+      }
+    }
+
+    // 🔔 SEND WIN NOTIFICATION TO WINNER (in-app + Telegram)
+    if (winnerUserId && chatServiceInstance?.pool) {
+      try {
+        const pool = chatServiceInstance.pool;
+        const winAmountSOL = (winAmount / 1_000_000_000).toFixed(4);
+        const totalPotSOL = (totalPot / 1_000_000_000).toFixed(4);
+        const notifMessage = `You won ${winAmountSOL} SOL in Jackpot Round #${roundId}!`;
+
+        const notificationData = {
+          message: notifMessage,
+          gameInvite: {
+            gameId: `jackpot-round-${roundId}`,
+            title: 'Jackpot',
+            buyIn: 0,
+            gameType: 'jackpot',
+          },
+          jackpotWin: {
+            roundId,
+            winAmount: winAmountSOL,
+            totalPot: totalPotSOL,
+            entryCount,
+            winnerUsername,
+          },
+        };
+
+        // Insert into chat_notifications
+        const notifResult = await pool.query(
+          `INSERT INTO chat_notifications (
+            user_id, notification_type, notification_data, read, created_at
+          ) VALUES ($1, $2, $3, false, NOW())
+          RETURNING id`,
+          [winnerUserId, 'game_won', JSON.stringify(notificationData)]
+        );
+        const notificationId = notifResult.rows[0].id;
+
+        const winnerNotifPayload = {
+          id: notificationId,
+          type: 'game_won',
+          senderUsername: 'Jackpot',
+          senderWallet: 'system',
+          message: notifMessage,
+          gameInvite: notificationData.gameInvite,
+          jackpotWin: notificationData.jackpotWin,
+          createdAt: new Date().toISOString(),
+          read: false,
+        };
+
+        // Update Redis notification cache
+        notificationCacheService.cacheNotification(winnerUserId, winnerNotifPayload);
+
+        // Broadcast via WebSocket
+        if (global.io) {
+          const chatNamespace = global.io.of('/chat');
+          chatNamespace.to(`user-${winnerUserId}`).emit('notification', winnerNotifPayload);
+        }
+
+        // Forward to Telegram
+        try {
+          const { forwardChatNotification } = require('../services/telegramNotifications');
+          const telegramMsg = `🏆 You won the Jackpot!\n\nRound #${roundId}\nWinnings: ◎${winAmountSOL}\nTotal Pot: ◎${totalPotSOL}\n${entryCount} entries`;
+          await forwardChatNotification(pool, winnerUserId, 'game_won', 'Jackpot', telegramMsg, { gameId: `jackpot-round-${roundId}` });
+        } catch (tgErr) {
+          console.warn('⚠️  Telegram notification failed:', tgErr.message);
+        }
+
+        console.log(`🔔 Jackpot win notification sent to ${winnerUsername} (user-${winnerUserId})`);
+      } catch (notifError) {
+        console.error('⚠️  Failed to send jackpot win notification:', notifError.message);
+      }
+    }
+
+    // 📢 SEND LOSS NOTIFICATIONS TO ALL NON-WINNERS (in-app + Telegram)
+    if (jackpotServiceInstance && chatServiceInstance?.pool) {
+      try {
+        const entries = await jackpotServiceInstance.getRoundEntries(roundId);
+        // Deduplicate by wallet address (same player can enter multiple times)
+        const uniqueWallets = [...new Set(entries.map(e => e.player))];
+        // Exclude the winner
+        const loserWallets = uniqueWallets.filter(w => w !== winner);
+
+        if (loserWallets.length > 0) {
+          const pool = chatServiceInstance.pool;
+          const winAmountSOL = (winAmount / 1_000_000_000).toFixed(4);
+          const totalPotSOL = (totalPot / 1_000_000_000).toFixed(4);
+
+          // Batch lookup all loser user IDs
+          const userLookup = await pool.query(
+            'SELECT id, username, wallet_address FROM users WHERE wallet_address = ANY($1)',
+            [loserWallets]
+          );
+          const userMap = {};
+          for (const row of userLookup.rows) {
+            userMap[row.wallet_address] = { id: row.id, username: row.username };
+          }
+
+          let lossNotifCount = 0;
+          for (const loserWallet of loserWallets) {
+            const user = userMap[loserWallet];
+            if (!user) continue; // Unregistered wallet, skip
+
+            const lossNotifData = {
+              message: `Jackpot Round #${roundId} won by @${winnerUsername}`,
+              gameInvite: {
+                gameId: `jackpot-round-${roundId}`,
+                title: 'Jackpot',
+                buyIn: 0,
+                gameType: 'jackpot',
+              },
+              jackpotWin: {
+                roundId,
+                winAmount: winAmountSOL,
+                totalPot: totalPotSOL,
+                entryCount,
+                winnerUsername,
+              },
+            };
+
+            try {
+              // Insert into chat_notifications
+              const notifResult = await pool.query(
+                `INSERT INTO chat_notifications (
+                  user_id, notification_type, notification_data, read, created_at
+                ) VALUES ($1, $2, $3, false, NOW())
+                RETURNING id`,
+                [user.id, 'game_lost', JSON.stringify(lossNotifData)]
+              );
+              const notificationId = notifResult.rows[0].id;
+
+              const loserNotifPayload = {
+                id: notificationId,
+                type: 'game_lost',
+                senderUsername: 'Jackpot',
+                senderWallet: 'system',
+                message: lossNotifData.message,
+                gameInvite: lossNotifData.gameInvite,
+                jackpotWin: lossNotifData.jackpotWin,
+                createdAt: new Date().toISOString(),
+                read: false,
+              };
+
+              // Update Redis notification cache
+              notificationCacheService.cacheNotification(user.id, loserNotifPayload);
+
+              // Broadcast via WebSocket
+              if (global.io) {
+                const chatNamespace = global.io.of('/chat');
+                chatNamespace.to(`user-${user.id}`).emit('notification', loserNotifPayload);
+              }
+
+              // Forward to Telegram
+              try {
+                const { forwardChatNotification } = require('../services/telegramNotifications');
+                const telegramMsg = `😔 Jackpot Round #${roundId}\n\nWon by @${winnerUsername}\nPot: ◎${totalPotSOL}\n${entryCount} entries\n\nBetter luck next time!`;
+                await forwardChatNotification(pool, user.id, 'game_lost', 'Jackpot', telegramMsg, { gameId: `jackpot-round-${roundId}` });
+              } catch (tgErr) {
+                // Telegram failures are non-critical
+              }
+
+              lossNotifCount++;
+            } catch (insertErr) {
+              console.warn(`⚠️  Failed to send loss notification to ${user.username}:`, insertErr.message);
+            }
+          }
+          console.log(`📢 Jackpot loss notifications sent to ${lossNotifCount}/${loserWallets.length} losers`);
+        }
+      } catch (entriesErr) {
+        console.error('⚠️  Failed to send jackpot loss notifications:', entriesErr.message);
+      }
+    }
+
+    // Invalidate profile stats cache for all round participants
+    if (userProfileStatsServiceInstance && jackpotServiceInstance) {
+      try {
+        const entries = await jackpotServiceInstance.getRoundEntries(roundId);
+        const wallets = [...new Set(entries.map(e => e.player))];
+        for (const wallet of wallets) {
+          userProfileStatsServiceInstance.invalidateCache(wallet);
+        }
+        console.log(`📊 Profile stats cache invalidated for ${wallets.length} participants`);
+      } catch (cacheErr) {
+        console.warn('⚠️  Failed to invalidate profile stats cache:', cacheErr.message);
+      }
+    }
+
+    // Broadcast winner_selected event to all clients (globally, not just room)
+    if (global.io) {
+      const winnerEvent = {
+        roundId,
+        winner,
+        winAmount,
+        totalPot,
+        entryCount,
+        winStreak: winnerStreak,
+        winnerUsername,
+        winnerAvatar,
+        timestamp: Date.now()
+      };
+      // Emit to specific room (for players in that round)
+      global.io.to(`round_${roundId}`).emit('winner_selected', winnerEvent);
+      // Also emit globally so LastWinner widget updates for everyone
+      global.io.emit('winner_selected', winnerEvent);
+      console.log(`⚡ Broadcasted: winner_selected globally to ALL clients (streak: ${winnerStreak}🔥)`);
+    }
+    
+    res.json({ success: true, broadcasted: true });
+  } catch (error) {
+    console.error('Webhook error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/keeper-webhook/player-entry
+ * Track player entries for PNL stats
+ */
+router.post('/player-entry', async (req, res) => {
+  try {
+    const { walletAddress, roundId, amount } = req.body;
+    
+    console.log(`📢 Webhook: Player entry - ${walletAddress.slice(0, 8)}... wagered ${amount} lamports`);
+    
+    // 📊 TRACK ENTRY IN PLAYER STATS! 📊
+    if (playerStatsServiceInstance) {
+      try {
+        await playerStatsServiceInstance.recordEntry({
+          walletAddress,
+          roundId,
+          amount
+        });
+        console.log(`✅ Entry recorded in stats`);
+      } catch (statsError) {
+        console.error('⚠️  Failed to record entry in stats:', statsError.message);
+      }
+    }
+    
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Webhook error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/keeper-webhook/round-opened
+ * Keeper calls this when new round opens
+ */
+router.post('/round-opened', async (req, res) => {
+  try {
+    const { roundId } = req.body;
+    
+    console.log(`📢 Webhook: New round ${roundId} opened`);
+    
+    if (global.io) {
+      global.io.emit('round_opened', {
+        roundId,
+        timestamp: Date.now()
+      });
+      console.log(`⚡ Broadcasted: round_opened globally`);
+    }
+    
+    res.json({ success: true, broadcasted: true });
+  } catch (error) {
+    console.error('Webhook error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;
+

package/routes/livescoresRoutes.js

@@ -0,0 +1,31 @@
+/**
+ * 🏀 Live Scores Routes
+ * 
+ * Public endpoints for fetching live sports scores
+ * No authentication required - public ESPN data
+ */
+
+const express = require('express');
+const router = express.Router();
+const {
+  getAllLivescores,
+  getLivescoresByLeague
+} = require('../controllers/livescoresController');
+
+/**
+ * GET /api/livescores
+ * Get live scores for all leagues (MLB, NBA, NHL, NFL)
+ * @public No authentication required
+ */
+router.get('/', getAllLivescores);
+
+/**
+ * GET /api/livescores/:league
+ * Get live scores for a specific league
+ * @param {string} league - League name (MLB, NBA, NHL, NFL)
+ * @public No authentication required
+ */
+router.get('/:league', getLivescoresByLeague);
+
+module.exports = router;
+