dubs-server 1.0.0

package/routes/pickemAdminRoutes.js

@@ -0,0 +1,199 @@
+/**
+ * Pick'em Admin Routes - Simulation endpoints for testing fight cards
+ * Requires admin wallet in x-wallet-address header
+ * Emits Socket.IO events so connected clients react in real-time
+ */
+
+const express = require('express');
+const router = express.Router();
+const { pool } = require('../services/db');
+const pickemController = require('../controllers/pickemController');
+const expoPushService = require('../services/expoPushService');
+
+const ADMIN_WALLET = 'Hvv1ctqHLR5wonuuRguefS6EpGUe7tFRBX2YWHGr3mes';
+
+let io = null;
+router.setSocketIO = (ioInstance) => {
+  io = ioInstance;
+  console.log('[PickemAdmin] Socket.IO injected');
+};
+
+function emit(event, data) {
+  if (io) io.emit(event, data);
+}
+
+function requireAdmin(req, res, next) {
+  const walletAddress = req.headers['x-wallet-address'] || req.query.wallet;
+  if (!walletAddress || walletAddress !== ADMIN_WALLET) {
+    return res.status(403).json({ success: false, error: 'Admin access required' });
+  }
+  req.adminWallet = walletAddress;
+  next();
+}
+
+router.use(requireAdmin);
+
+/**
+ * POST /api/pickem/admin/fights/:fightId/update
+ * Update a fight's status, winner, and method. Recomputes scores if fight is resolved.
+ */
+router.post('/fights/:fightId/update', async (req, res) => {
+  try {
+    const fightId = parseInt(req.params.fightId);
+    const { status, winner, method } = req.body;
+
+    if (!status) {
+      return res.status(400).json({ success: false, error: 'status is required' });
+    }
+
+    console.log(`[PickemAdmin] Updating fight ${fightId}: status=${status}, winner=${winner || 'none'}, method=${method || 'none'}`);
+
+    const fight = await pickemController.updateFightResult(fightId, {
+      winner: winner || null,
+      method: method || null,
+      status,
+    });
+
+    if (!fight) {
+      return res.status(404).json({ success: false, error: 'Fight not found' });
+    }
+
+    // Emit fight status change
+    if (status === 'live') {
+      emit('pickem:fight_live', { poolId: fight.poolId, fight });
+      expoPushService.sendFightLiveNotifications(fightId, fight)
+        .catch(err => console.error('[PickemAdmin] Push error (fight live):', err.message));
+    }
+
+    let scores = null;
+    if (status === 'final' && winner) {
+      scores = await pickemController.computeScores(fight.poolId);
+      console.log(`[PickemAdmin] Scores recomputed for pool ${fight.poolId}: ${scores.entries.length} entries, max=${scores.maxScore}`);
+      emit('pickem:fight_resolved', { poolId: fight.poolId, fight, scores });
+      expoPushService.sendFightResolvedNotifications(fightId, fight)
+        .catch(err => console.error('[PickemAdmin] Push error (fight resolved):', err.message));
+    }
+
+    // Always emit a generic update so clients know to refetch
+    emit('pickem:pool_updated', { poolId: fight.poolId });
+
+    res.json({ success: true, fight, scores });
+  } catch (error) {
+    console.error('[PickemAdmin] Error updating fight:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+/**
+ * POST /api/pickem/admin/pools/:poolId/reset-fights
+ * Reset all fights to scheduled, clear winners/scores for re-testing
+ */
+router.post('/pools/:poolId/reset-fights', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.poolId);
+    const { resetPoolStatus } = req.body || {};
+
+    console.log(`[PickemAdmin] Resetting fights for pool ${poolId}`);
+
+    const fightsResult = await pool.query(
+      `UPDATE pickem_fights
+       SET status = 'scheduled', winner = NULL, method = NULL, updated_at = NOW()
+       WHERE pool_id = $1`,
+      [poolId]
+    );
+
+    await pool.query(
+      `UPDATE pickem_picks pp
+       SET is_correct = NULL, updated_at = NOW()
+       FROM pickem_entries pe
+       WHERE pp.entry_id = pe.id AND pe.pool_id = $1`,
+      [poolId]
+    );
+
+    await pool.query(
+      `UPDATE pickem_entries
+       SET score = 0, rank = NULL, updated_at = NOW()
+       WHERE pool_id = $1`,
+      [poolId]
+    );
+
+    if (resetPoolStatus) {
+      await pickemController.updatePool(poolId, { status: 'locked' });
+    }
+
+    console.log(`[PickemAdmin] Reset ${fightsResult.rowCount} fights for pool ${poolId}`);
+
+    emit('pickem:pool_reset', { poolId });
+    emit('pickem:pool_updated', { poolId });
+
+    res.json({
+      success: true,
+      fightsReset: fightsResult.rowCount,
+      poolStatusReset: !!resetPoolStatus,
+    });
+  } catch (error) {
+    console.error('[PickemAdmin] Error resetting fights:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+/**
+ * POST /api/pickem/admin/pools/:poolId/status
+ * Change pool status
+ */
+router.post('/pools/:poolId/status', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.poolId);
+    const { status } = req.body;
+
+    if (!status) {
+      return res.status(400).json({ success: false, error: 'status is required' });
+    }
+
+    console.log(`[PickemAdmin] Setting pool ${poolId} status to ${status}`);
+
+    const updatedPool = await pickemController.updatePool(poolId, { status });
+
+    if (status === 'locked') emit('pickem:pool_locked', { poolId });
+    emit('pickem:pool_updated', { poolId });
+
+    res.json({ success: true, pool: updatedPool });
+  } catch (error) {
+    console.error('[PickemAdmin] Error updating pool status:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+/**
+ * POST /api/pickem/admin/pools/:poolId/resolve
+ * Trigger full pool resolution: compute final scores + set complete
+ */
+router.post('/pools/:poolId/resolve', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.poolId);
+
+    console.log(`[PickemAdmin] Resolving pool ${poolId}`);
+
+    await pickemController.updatePool(poolId, { status: 'resolving' });
+    const scores = await pickemController.computeScores(poolId);
+    const updatedPool = await pickemController.updatePool(poolId, { status: 'complete' });
+
+    console.log(`[PickemAdmin] Pool ${poolId} resolved: ${scores.winnerCount} winner(s) with score ${scores.maxScore}`);
+
+    emit('pickem:pool_resolved', { poolId, scores });
+    emit('pickem:pool_updated', { poolId });
+    expoPushService.sendPoolResolvedNotifications(poolId, scores)
+      .catch(err => console.error('[PickemAdmin] Push error (pool resolved):', err.message));
+
+    res.json({
+      success: true,
+      pool: updatedPool,
+      scores,
+    });
+  } catch (error) {
+    console.error('[PickemAdmin] Error resolving pool:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router;

package/routes/pickemRoutes.js

@@ -0,0 +1,231 @@
+/**
+ * Pick'em Routes
+ * UFC Pick'em pool endpoints
+ * Pattern mirrors survivorRoutes.js
+ */
+
+const express = require('express');
+const router = express.Router();
+const pickemController = require('../controllers/pickemController');
+const { authenticate } = require('../middleware/authenticate');
+
+let io = null;
+router.setSocketIO = (ioInstance) => {
+  io = ioInstance;
+  console.log('[Pickem] Socket.IO injected');
+};
+
+// ========== POOL ENDPOINTS ==========
+
+// Create a new pick'em pool (admin)
+router.post('/pools', async (req, res) => {
+  try {
+    const { name, espnEventId, eventDate, lockTime, solanaGameId, solanaGameAddress } = req.body;
+    const createdBy = req.body.createdBy || req.headers['x-wallet-address'] || null;
+
+    if (!name || !eventDate || !lockTime) {
+      return res.status(400).json({ success: false, error: 'name, eventDate, and lockTime are required' });
+    }
+
+    const pool = await pickemController.createPool({
+      name, espnEventId, eventDate, lockTime, solanaGameId, solanaGameAddress, createdBy,
+    });
+
+    res.json({ success: true, pool });
+  } catch (error) {
+    console.error('[Pickem] Error creating pool:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// List pools
+router.get('/pools', async (req, res) => {
+  try {
+    const { status } = req.query;
+    const pools = await pickemController.getPools({ status: status || undefined });
+    res.json({ success: true, pools });
+  } catch (error) {
+    console.error('[Pickem] Error listing pools:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Get pool detail with fights and stats
+router.get('/pools/:id', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const pool = await pickemController.getPoolById(poolId);
+    if (!pool) return res.status(404).json({ success: false, error: 'Pool not found' });
+
+    const fights = await pickemController.getFights(poolId);
+    const stats = await pickemController.getPoolStats(poolId);
+
+    res.json({ success: true, pool, fights, stats });
+  } catch (error) {
+    console.error('[Pickem] Error getting pool:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Update a pool (authenticated — set solana_game_id/address after on-chain creation)
+router.patch('/pools/:id', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const pool = await pickemController.updatePool(poolId, req.body);
+    if (!pool) return res.status(404).json({ success: false, error: 'Pool not found' });
+    res.json({ success: true, pool });
+  } catch (error) {
+    console.error('[Pickem] Error updating pool:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// ========== FIGHT ENDPOINTS ==========
+
+// Get fights for a pool
+router.get('/pools/:id/fights', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const fights = await pickemController.getFights(poolId);
+    res.json({ success: true, count: fights.length, fights });
+  } catch (error) {
+    console.error('[Pickem] Error getting fights:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Import fights for a pool (admin)
+router.post('/pools/:id/fights', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { fights } = req.body;
+
+    if (!fights || !Array.isArray(fights) || fights.length === 0) {
+      return res.status(400).json({ success: false, error: 'fights array is required' });
+    }
+
+    const imported = await pickemController.importFights(poolId, fights);
+    res.json({ success: true, count: imported.length, fights: imported });
+  } catch (error) {
+    console.error('[Pickem] Error importing fights:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// ========== ENTRY ENDPOINTS ==========
+
+// Enter a pool (authenticated — after on-chain join)
+router.post('/pools/:id/enter', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { txSignature } = req.body;
+
+    const entry = await pickemController.joinPool({
+      poolId,
+      userId: req.user.userId,
+      walletAddress: req.user.walletAddress,
+      txSignature,
+    });
+
+    if (io) {
+      io.emit('pickem:entry_joined', { poolId, entry });
+    }
+
+    res.json({ success: true, entry });
+  } catch (error) {
+    console.error('[Pickem] Error joining pool:', error.message);
+    const status = error.message.includes('not found') ? 404
+      : error.message.includes('already') || error.message.includes('duplicate') ? 409
+      : 400;
+    res.status(status).json({ success: false, error: error.message });
+  }
+});
+
+// ========== PICK ENDPOINTS ==========
+
+// Submit all picks at once (authenticated)
+router.post('/pools/:id/picks', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const { picks } = req.body;
+
+    if (!picks || !Array.isArray(picks)) {
+      return res.status(400).json({ success: false, error: 'picks array is required' });
+    }
+
+    const submitted = await pickemController.submitPicks({
+      poolId,
+      userId: req.user.userId,
+      picks,
+    });
+
+    if (io) {
+      io.emit('pickem:picks_submitted', { poolId, userId: req.user.userId });
+    }
+
+    res.json({ success: true, picks: submitted });
+  } catch (error) {
+    console.error('[Pickem] Error submitting picks:', error.message);
+    const status = error.message.includes('not found') ? 404
+      : error.message.includes('Lock time') ? 403
+      : 400;
+    res.status(status).json({ success: false, error: error.message });
+  }
+});
+
+// Get user's picks (authenticated)
+router.get('/pools/:id/my-picks', authenticate, async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const entry = await pickemController.getUserEntry(poolId, req.user.userId);
+
+    if (!entry) {
+      return res.status(404).json({ success: false, error: 'Not entered in this pool' });
+    }
+
+    res.json({ success: true, entry });
+  } catch (error) {
+    console.error('[Pickem] Error getting picks:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// ========== LEADERBOARD / RESULTS ==========
+
+// Leaderboard (public)
+router.get('/pools/:id/leaderboard', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const leaderboard = await pickemController.getLeaderboard(poolId);
+    const stats = await pickemController.getPoolStats(poolId);
+    res.json({ success: true, totalEntries: leaderboard.length, leaderboard, stats });
+  } catch (error) {
+    console.error('[Pickem] Error getting leaderboard:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Final results (public, pool must be complete)
+router.get('/pools/:id/results', async (req, res) => {
+  try {
+    const poolId = parseInt(req.params.id);
+    const pool = await pickemController.getPoolById(poolId);
+    if (!pool) return res.status(404).json({ success: false, error: 'Pool not found' });
+    if (pool.status !== 'complete') {
+      return res.status(400).json({ success: false, error: `Pool is ${pool.status}, results not available yet` });
+    }
+
+    const fights = await pickemController.getFights(poolId);
+    const leaderboard = await pickemController.getLeaderboard(poolId);
+    const winners = await pickemController.getWinners(poolId);
+    const payouts = await pickemController.getPayouts(poolId);
+    const stats = await pickemController.getPoolStats(poolId);
+
+    res.json({ success: true, pool, fights, leaderboard, winners, payouts, stats });
+  } catch (error) {
+    console.error('[Pickem] Error getting results:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router;

package/routes/playerStatsRoutes.js

@@ -0,0 +1,147 @@
+/**
+ * 📊 Player Stats API Routes
+ * 
+ * Endpoints for player PNL, history, and leaderboards
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/authenticate');
+
+module.exports = (playerStatsService) => {
+  
+  /**
+   * GET /stats/player/:walletAddress
+   * Get player statistics (PUBLIC - basic stats for profile cards)
+   */
+  router.get('/player/:walletAddress', async (req, res) => {
+    try {
+      const { walletAddress } = req.params;
+
+      const stats = await playerStatsService.getPlayerStats(walletAddress);
+
+      if (!stats) {
+        return res.status(404).json({
+          success: false,
+          error: 'Player not found'
+        });
+      }
+
+      res.json({
+        success: true,
+        stats
+      });
+    } catch (error) {
+      console.error('Error fetching player stats:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /stats/player/:walletAddress/history
+   * Get player history for chart (SECURED - detailed betting history is sensitive)
+   */
+  router.get('/player/:walletAddress/history', authenticate, async (req, res) => {
+    try {
+      const { walletAddress } = req.params;
+      const limit = parseInt(req.query.limit) || 100;
+
+      const history = await playerStatsService.getPlayerHistory(walletAddress, limit);
+
+      res.json({
+        success: true,
+        history,
+        count: history.length
+      });
+    } catch (error) {
+      console.error('Error fetching player history:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /stats/leaderboard
+   * Get top players by PNL
+   */
+  router.get('/leaderboard', async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 10;
+
+      const leaderboard = await playerStatsService.getLeaderboard(limit);
+
+      res.json({
+        success: true,
+        leaderboard,
+        count: leaderboard.length
+      });
+    } catch (error) {
+      console.error('Error fetching leaderboard:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /stats/lucky
+   * Get the luckiest player (highest current winning streak)
+   */
+  router.get('/lucky', async (req, res) => {
+    try {
+      const luckyPlayer = await playerStatsService.getLuckiestPlayer();
+
+      if (!luckyPlayer) {
+        return res.json({
+          success: true,
+          lucky: null,
+          message: 'No active winning streaks'
+        });
+      }
+
+      res.json({
+        success: true,
+        lucky: luckyPlayer
+      });
+    } catch (error) {
+      console.error('Error fetching luckiest player:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  /**
+   * GET /stats/streaks
+   * Get streak leaderboard (top players by current winning streak)
+   */
+  router.get('/streaks', async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 10;
+
+      const streakLeaderboard = await playerStatsService.getStreakLeaderboard(limit);
+
+      res.json({
+        success: true,
+        streaks: streakLeaderboard,
+        count: streakLeaderboard.length
+      });
+    } catch (error) {
+      console.error('Error fetching streak leaderboard:', error);
+      res.status(500).json({
+        success: false,
+        error: error.message
+      });
+    }
+  });
+
+  return router;
+};
+