dubs-server 1.0.0

package/routes/esportsRoutes.js

@@ -0,0 +1,806 @@
+const express = require('express');
+const router = express.Router();
+const axios = require('axios');
+const { pool } = require('../services/db'); // Shared database pool
+
+const PANDASCORE_BASE_URL = 'https://api.pandascore.co';
+const PANDASCORE_API_KEY = process.env.PANDASCORE_API_KEY;
+
+// Socket.IO will be injected by server.js
+let chatNamespace = null;
+
+// Inject Socket.IO instance
+router.setSocketIO = (ioInstance, chatNS) => {
+  chatNamespace = chatNS;
+  console.log('🔌 Socket.IO injected into esports routes');
+};
+
+/**
+ * Helper: build PandaScore request headers
+ */
+function pandaHeaders() {
+  return {
+    accept: 'application/json',
+    authorization: `Bearer ${PANDASCORE_API_KEY}`
+  };
+}
+
+// ============================================
+// LEAGUES
+// ============================================
+
+/**
+ * @route   GET /api/esports/leagues
+ * @desc    List all esports leagues (paginated)
+ * @access  Public
+ * @query   page, per_page, sort, search[name], filter[videogame_id]
+ */
+router.get('/leagues', async (req, res) => {
+  try {
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error('Error fetching esports leagues:', error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch esports leagues' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/videogames/:videogameId/leagues
+ * @desc    List leagues for a specific videogame
+ * @access  Public
+ * @query   page, per_page, sort, search[name]
+ */
+router.get('/videogames/:videogameId/leagues', async (req, res) => {
+  try {
+    const { videogameId } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/videogames/${videogameId}/leagues`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching leagues for videogame ${req.params.videogameId}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch videogame leagues' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/leagues/:leagueId
+ * @desc    Get a single esports league by ID
+ * @access  Public
+ */
+router.get('/leagues/:leagueId', async (req, res) => {
+  try {
+    const { leagueId } = req.params;
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueId}`, {
+      headers: pandaHeaders(),
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching esports league ${req.params.leagueId}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch esports league' });
+  }
+});
+
+// ============================================
+// LEAGUE SUB-RESOURCES (Series, Tournaments, Matches)
+// ============================================
+
+/**
+ * Helper: build common query params from request.
+ * Express parses bracket notation (e.g. filter[status]=running) into nested
+ * objects ({ filter: { status: 'running' } }). We need to reconstruct the
+ * bracket keys for PandaScore's API.
+ */
+function buildParams(query) {
+  const params = {};
+  const { page, per_page, sort } = query;
+  if (page) params.page = page;
+  if (per_page) params.per_page = per_page;
+  if (sort) params.sort = sort;
+
+  // Handle Express-parsed nested objects (filter[x] → { filter: { x: val } })
+  for (const prefix of ['filter', 'search', 'range']) {
+    if (query[prefix] && typeof query[prefix] === 'object') {
+      for (const [key, value] of Object.entries(query[prefix])) {
+        params[`${prefix}[${key}]`] = value;
+      }
+    }
+  }
+
+  // Also handle literal bracket keys (e.g. from curl or non-Express clients)
+  for (const key of Object.keys(query)) {
+    if (key.startsWith('filter[') || key.startsWith('search[') || key.startsWith('range[')) {
+      params[key] = query[key];
+    }
+  }
+
+  return params;
+}
+
+/**
+ * @route   GET /api/esports/leagues/:leagueIdOrSlug/series
+ * @desc    List series for a league
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/leagues/:leagueIdOrSlug/series', async (req, res) => {
+  try {
+    const { leagueIdOrSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueIdOrSlug}/series`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching series for league ${req.params.leagueIdOrSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch league series' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/leagues/:leagueIdOrSlug/tournaments
+ * @desc    List tournaments for a league
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/leagues/:leagueIdOrSlug/tournaments', async (req, res) => {
+  try {
+    const { leagueIdOrSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueIdOrSlug}/tournaments`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching tournaments for league ${req.params.leagueIdOrSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch league tournaments' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/leagues/:leagueIdOrSlug/matches/upcoming
+ * @desc    List upcoming matches for a league
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/leagues/:leagueIdOrSlug/matches/upcoming', async (req, res) => {
+  try {
+    const { leagueIdOrSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueIdOrSlug}/matches/upcoming`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching upcoming matches for league ${req.params.leagueIdOrSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch upcoming matches' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/leagues/:leagueIdOrSlug/matches/running
+ * @desc    List currently running (live) matches for a league
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/leagues/:leagueIdOrSlug/matches/running', async (req, res) => {
+  try {
+    const { leagueIdOrSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueIdOrSlug}/matches/running`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching running matches for league ${req.params.leagueIdOrSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch running matches' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/leagues/:leagueIdOrSlug/matches
+ * @desc    List ALL matches for a league (with rich filtering)
+ * @access  Public
+ * @query   page, per_page, sort, filter[status], filter[opponent_id], filter[future],
+ *          filter[finished], filter[running], filter[not_started], filter[past],
+ *          filter[tournament_id], filter[serie_id], filter[match_type],
+ *          filter[opponents_filled], range[begin_at], search[name]
+ */
+router.get('/leagues/:leagueIdOrSlug/matches', async (req, res) => {
+  try {
+    const { leagueIdOrSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/leagues/${leagueIdOrSlug}/matches`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching matches for league ${req.params.leagueIdOrSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch league matches' });
+  }
+});
+
+// ============================================
+// LIVES (real-time match data with WebSocket URLs)
+// ============================================
+
+/**
+ * @route   GET /api/esports/lives
+ * @desc    Get all currently live matches with WebSocket endpoint URLs
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/lives', async (req, res) => {
+  try {
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/lives`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error('Error fetching live matches:', error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch live matches' });
+  }
+});
+
+// ============================================
+// VIDEOGAME-SPECIFIC ENDPOINTS
+// ============================================
+
+/**
+ * Map PandaScore videogame slugs to their API path segments.
+ * The slug in data responses (e.g. "cs-go") often differs from
+ * the API URL path (e.g. "csgo").
+ */
+function apiSlug(videogameSlug) {
+  const map = {
+    'cs-go': 'csgo',
+    'dota-2': 'dota2',
+    'cod-mw': 'codmw',
+    'league-of-legends': 'lol',
+    'r6-siege': 'r6siege',
+  };
+  return map[videogameSlug] || videogameSlug;
+}
+
+/**
+ * @route   GET /api/esports/:videogameSlug/tournaments
+ * @desc    List tournaments for a specific videogame (e.g. cod-mw, valorant, cs-go)
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/tournaments', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/tournaments`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching tournaments for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch ${req.params.videogameSlug} tournaments` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/tournaments/running
+ * @desc    List currently running tournaments for a videogame
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/tournaments/running', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/tournaments/running`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching running tournaments for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch running ${req.params.videogameSlug} tournaments` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/tournaments/upcoming
+ * @desc    List upcoming tournaments for a videogame
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/tournaments/upcoming', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/tournaments/upcoming`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching upcoming tournaments for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch upcoming ${req.params.videogameSlug} tournaments` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/tournaments/:tournamentId/matches
+ * @desc    Get full matches (with opponents, results, games) for a tournament
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/tournaments/:tournamentId/matches', async (req, res) => {
+  try {
+    const { tournamentId } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/tournaments/${tournamentId}/matches`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching matches for tournament ${req.params.tournamentId}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch tournament matches` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/matches
+ * @desc    List matches for a specific videogame
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/matches', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/matches`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching matches for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch ${req.params.videogameSlug} matches` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/matches/running
+ * @desc    List currently running matches for a videogame
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/matches/running', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/matches/running`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching running matches for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch running ${req.params.videogameSlug} matches` });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/matches/upcoming
+ * @desc    List upcoming matches for a videogame
+ * @access  Public
+ * @query   page, per_page, sort, filter[], search[], range[]
+ */
+router.get('/:videogameSlug/matches/upcoming', async (req, res) => {
+  try {
+    const { videogameSlug } = req.params;
+    const params = buildParams(req.query);
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/matches/upcoming`, {
+      headers: pandaHeaders(),
+      params,
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching upcoming matches for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch upcoming ${req.params.videogameSlug} matches` });
+  }
+});
+
+// ============================================
+// SINGLE MATCH BY ID
+// ============================================
+
+/**
+ * @route   GET /api/esports/matches/:matchId
+ * @desc    Get a single match by PandaScore match ID (game-agnostic)
+ * @access  Public
+ */
+router.get('/matches/:matchId', async (req, res) => {
+  try {
+    const { matchId } = req.params;
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/matches/${matchId}`, {
+      headers: pandaHeaders(),
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching match ${req.params.matchId}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to fetch match' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/:videogameSlug/matches/:matchId
+ * @desc    Get a single match by PandaScore match ID for a specific videogame
+ * @access  Public
+ */
+router.get('/:videogameSlug/matches/:matchId', async (req, res) => {
+  try {
+    const { videogameSlug, matchId } = req.params;
+
+    const response = await axios.get(`${PANDASCORE_BASE_URL}/${apiSlug(videogameSlug)}/matches/${matchId}`, {
+      headers: pandaHeaders(),
+      timeout: 10000
+    });
+
+    res.json({ success: true, data: response.data });
+  } catch (error) {
+    console.error(`Error fetching match ${req.params.matchId} for ${req.params.videogameSlug}:`, error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: `Failed to fetch ${req.params.videogameSlug} match` });
+  }
+});
+
+// ============================================
+// ESPORTS GAME CREATION
+// ============================================
+
+/**
+ * @route   POST /api/esports/games/create
+ * @desc    Validate a PandaScore match and return enriched data for game creation.
+ *          The frontend uses this data to build the on-chain transaction, then
+ *          calls the existing /api/auth/games/save endpoint to persist it.
+ * @access  Public
+ * @body    { pandascoreMatchId: number, videogameSlug: string }
+ */
+router.post('/games/validate', async (req, res) => {
+  try {
+    const { pandascoreMatchId, videogameSlug } = req.body;
+
+    if (!pandascoreMatchId) {
+      return res.status(400).json({
+        success: false,
+        error: 'pandascoreMatchId is required'
+      });
+    }
+
+    // Fetch full match data from PandaScore
+    const matchResponse = await axios.get(`${PANDASCORE_BASE_URL}/matches/${pandascoreMatchId}`, {
+      headers: pandaHeaders(),
+      timeout: 10000
+    });
+
+    const match = matchResponse.data;
+    if (!match) {
+      return res.status(404).json({ success: false, error: 'Match not found on PandaScore' });
+    }
+
+    // Validate: must be not_started or running (live betting allowed)
+    const isLive = match.status === 'running';
+    if (match.status !== 'not_started' && !isLive) {
+      return res.status(400).json({
+        success: false,
+        error: `Match status is "${match.status}" — can only bet on matches that haven't started or are currently live`,
+        matchStatus: match.status
+      });
+    }
+
+    // Validate: must have 2 opponents
+    if (!match.opponents || match.opponents.length < 2) {
+      return res.status(400).json({
+        success: false,
+        error: 'Match does not have 2 confirmed opponents yet'
+      });
+    }
+
+    // For upcoming matches: scheduled_at must be > now + 2 minutes (Solana constraint)
+    // For live matches: skip this check — lock is set to now + 5 minutes instead
+    const scheduledAt = new Date(match.scheduled_at || match.begin_at);
+    if (!isLive) {
+      const minTime = new Date(Date.now() + 2 * 60 * 1000);
+      if (scheduledAt <= minTime) {
+        return res.status(400).json({
+          success: false,
+          error: 'Match starts too soon — must be at least 2 minutes from now'
+        });
+      }
+    }
+
+    // Build the sportsEvent JSONB that will be stored alongside the game
+    const opp0 = match.opponents[0];
+    const opp1 = match.opponents[1];
+    const sportsEvent = {
+      pandascoreMatchId: match.id,
+      videogameSlug: match.videogame?.slug || videogameSlug || 'unknown',
+      videogame: match.videogame?.name || videogameSlug || 'Unknown',
+      matchName: match.name || `${opp0.opponent?.name} vs ${opp1.opponent?.name}`,
+      tournament: match.tournament?.name || '',
+      tournamentId: match.tournament?.id || null,
+      serie: match.serie?.full_name || match.serie?.name || '',
+      tier: match.tournament?.tier || match.serie?.tier || null,
+      matchType: match.match_type || 'best_of',
+      numberOfGames: match.number_of_games || 1,
+      scheduledAt: match.scheduled_at || match.begin_at,
+      // strTimestamp is used by the oracle for lock timing — reuse same convention
+      // For live matches, use the lock time (now + 5 min) so countdown shows correctly
+      strTimestamp: isLive
+        ? new Date(Date.now() + 5 * 60 * 1000).toISOString().replace('Z', '').split('.')[0]
+        : (match.scheduled_at || match.begin_at || '').replace('Z', '').split('.')[0],
+      opponents: match.opponents,
+      streamsList: match.streams_list || [],
+      leagueName: match.league?.name || '',
+      leagueId: match.league?.id || null,
+      // TheSportsDB-compatible fields so existing notification code works
+      strEvent: match.name || `${opp0.opponent?.name} vs ${opp1.opponent?.name}`,
+      strHomeTeam: opp0.opponent?.name,
+      strAwayTeam: opp1.opponent?.name,
+      strHomeTeamBadge: opp0.opponent?.image_url,
+      strAwayTeamBadge: opp1.opponent?.image_url,
+      strLeague: match.videogame?.name || videogameSlug,
+    };
+
+    // Calculate lock_timestamp (Unix seconds)
+    // For live matches: lock 5 minutes from now (gives time for opponent to join)
+    // For upcoming matches: lock at scheduled start time
+    const lockTimestamp = isLive
+      ? Math.floor((Date.now() + 5 * 60 * 1000) / 1000)
+      : Math.floor(scheduledAt.getTime() / 1000);
+
+    res.json({
+      success: true,
+      match: {
+        id: match.id,
+        name: sportsEvent.matchName,
+        status: match.status,
+        scheduledAt: sportsEvent.scheduledAt,
+        lockTimestamp,
+        tournament: sportsEvent.tournament,
+        tier: sportsEvent.tier,
+        matchType: sportsEvent.matchType,
+        numberOfGames: sportsEvent.numberOfGames,
+        opponents: match.opponents.map(o => ({
+          id: o.opponent?.id,
+          name: o.opponent?.name,
+          acronym: o.opponent?.acronym,
+          imageUrl: o.opponent?.image_url,
+        })),
+        streams: sportsEvent.streamsList,
+      },
+      // Pre-built sportsEvent for the frontend to pass to /api/auth/games/save
+      sportsEvent,
+      // gameMode 5 = esports
+      gameMode: 5,
+    });
+
+  } catch (error) {
+    console.error('Error validating esports match:', error.message);
+    const status = error.response?.status || 500;
+    res.status(status).json({ success: false, error: 'Failed to validate esports match' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/games/upcoming
+ * @desc    Get bettable upcoming esports matches (CS + Valorant, S/A tier, not_started)
+ * @access  Public
+ * @query   videogame (cs-go|valorant), page, per_page
+ */
+router.get('/games/upcoming', async (req, res) => {
+  try {
+    const videogames = req.query.videogame
+      ? [req.query.videogame]
+      : ['cs-go', 'valorant'];
+
+    const page = req.query.page || 1;
+    const perPage = req.query.per_page || 20;
+
+    const allMatches = [];
+
+    for (const vg of videogames) {
+      try {
+        const response = await axios.get(
+          `${PANDASCORE_BASE_URL}/${apiSlug(vg)}/matches/upcoming`,
+          {
+            headers: pandaHeaders(),
+            params: {
+              page,
+              per_page: perPage,
+              sort: 'scheduled_at',
+              'filter[opponents_filled]': true,
+            },
+            timeout: 10000
+          }
+        );
+
+        const matches = (response.data || [])
+          .filter(m => {
+            // Allow S, A, B, C, D tier tournaments
+            const tier = m.tournament?.tier || m.serie?.tier;
+            return ['s', 'a', 'b', 'c', 'd'].includes(tier);
+          })
+          .filter(m => {
+            // Must start > 2 min from now
+            const scheduled = new Date(m.scheduled_at || m.begin_at);
+            return scheduled.getTime() > Date.now() + 2 * 60 * 1000;
+          })
+          .map(m => ({
+            id: m.id,
+            name: m.name,
+            videogame: vg,
+            videogameName: m.videogame?.name || vg,
+            scheduledAt: m.scheduled_at || m.begin_at,
+            matchType: m.match_type,
+            numberOfGames: m.number_of_games,
+            tournament: m.tournament?.name,
+            tier: m.tournament?.tier || m.serie?.tier,
+            league: m.league?.name,
+            opponents: (m.opponents || []).map(o => ({
+              id: o.opponent?.id,
+              name: o.opponent?.name,
+              acronym: o.opponent?.acronym,
+              imageUrl: o.opponent?.image_url,
+            })),
+            streams: m.streams_list || [],
+          }));
+
+        allMatches.push(...matches);
+      } catch (err) {
+        console.error(`Error fetching upcoming ${vg} matches:`, err.message);
+      }
+    }
+
+    // Sort by scheduled time
+    allMatches.sort((a, b) => new Date(a.scheduledAt) - new Date(b.scheduledAt));
+
+    res.json({ success: true, data: allMatches });
+  } catch (error) {
+    console.error('Error fetching upcoming esports games:', error.message);
+    res.status(500).json({ success: false, error: 'Failed to fetch upcoming esports games' });
+  }
+});
+
+/**
+ * @route   GET /api/esports/games/pending
+ * @desc    Get esports games that are in our DB (game_mode=5, not resolved)
+ * @access  Public
+ */
+router.get('/games/pending', async (req, res) => {
+  try {
+    const result = await pool.query(`
+      SELECT * FROM games
+      WHERE game_mode = 5
+        AND is_resolved = false
+      ORDER BY created_at DESC
+    `);
+
+    const games = result.rows.map(row => {
+      const se = row.sports_event || {};
+      const opp0 = se.opponents?.[0]?.opponent || {};
+      const opp1 = se.opponents?.[1]?.opponent || {};
+      return {
+        gameId: row.game_id,
+        gameAddress: row.game_address,
+        title: row.title || se.matchName || `${opp0.name || '?'} vs ${opp1.name || '?'}`,
+        gameMode: row.game_mode,
+        buyIn: parseFloat(row.buy_in),
+        createdBy: row.created_by,
+        sportsEvent: se,
+        homeTeam: opp0.name,
+        awayTeam: opp1.name,
+        homeTeamBadge: opp0.image_url,
+        awayTeamBadge: opp1.image_url,
+        videogame: se.videogame || se.videogameSlug,
+        tournament: se.tournament,
+        tier: se.tier,
+        matchType: se.matchType,
+        scheduledAt: se.scheduledAt,
+        homeTeamPlayers: row.home_team_players || [],
+        awayTeamPlayers: row.away_team_players || [],
+        isLocked: row.is_locked,
+        isResolved: row.is_resolved,
+        createdAt: row.created_at,
+      };
+    });
+
+    res.json({ success: true, games });
+  } catch (error) {
+    console.error('Error fetching pending esports games:', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router;