dubs-server 1.0.0

package/routes/jackpotRoutes.js

@@ -0,0 +1,754 @@
+/**
+ * 🎰 Jackpot API Routes
+ * 
+ * RESTful API for Solpot-style continuous jackpot
+ * Isolated from sports betting and arcade systems
+ */
+
+const express = require('express');
+const router = express.Router();
+const crypto = require('crypto');
+const { instance: history } = require('../services/jackpotHistory');
+const promoService = require('../services/promoService');
+const promoTreasuryService = require('../services/promoTreasuryService');
+
+module.exports = (jackpotService) => {
+  
+  // ============================================
+  // 🏗️ BUILD TRANSACTION ENDPOINTS
+  // Returns unsigned transactions for frontend to sign
+  // ============================================
+
+  /**
+   * POST /jackpot/build/initialize
+   * Build UNSIGNED transaction for initializing the protocol
+   * 
+   * Body:
+   * {
+   *   adminAddress: string (Solana pubkey),
+   *   treasuryAddress: string (Solana pubkey),
+   *   feeBasisPoints: number (e.g., 500 = 5%),
+   *   roundDurationSlots: number (e.g., 1800 = ~12 min)
+   * }
+   */
+  router.post('/build/initialize', async (req, res) => {
+    try {
+      const {
+        adminAddress,
+        treasuryAddress,
+        feeBasisPoints = 500,
+        roundDurationSlots = 1800,
+      } = req.body;
+
+      if (!adminAddress || !treasuryAddress) {
+        return res.status(400).json({
+          error: 'Missing required fields: adminAddress, treasuryAddress'
+        });
+      }
+
+      if (feeBasisPoints > 1000) {
+        return res.status(400).json({
+          error: 'Fee cannot exceed 10% (1000 basis points)'
+        });
+      }
+
+      const result = await jackpotService.buildInitializeTransaction({
+        adminAddress,
+        treasuryAddress,
+        feeBasisPoints,
+        roundDurationSlots,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build initialize error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/update-config
+   * Build UNSIGNED transaction for updating protocol config (authority only)
+   *
+   * Body:
+   * {
+   *   authorityAddress: string (Solana pubkey),
+   *   feeBasisPoints?: number (e.g., 500 = 5%),
+   *   roundDurationSlots?: number (e.g., 1512000 = ~1 week),
+   *   newAuthority?: string (Solana pubkey)
+   * }
+   */
+  router.post('/build/update-config', async (req, res) => {
+    try {
+      const { authorityAddress, feeBasisPoints, roundDurationSlots, newAuthority } = req.body;
+
+      if (!authorityAddress) {
+        return res.status(400).json({
+          error: 'Missing required field: authorityAddress'
+        });
+      }
+
+      if (feeBasisPoints != null && feeBasisPoints > 1000) {
+        return res.status(400).json({
+          error: 'Fee cannot exceed 10% (1000 basis points)'
+        });
+      }
+
+      const result = await jackpotService.buildUpdateConfigTransaction({
+        authorityAddress,
+        feeBasisPoints,
+        roundDurationSlots,
+        newAuthority,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build update-config error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/open-round
+   * Build UNSIGNED transaction for opening a new round
+   * 
+   * Body:
+   * {
+   *   keeperAddress: string (Solana pubkey)
+   * }
+   */
+  router.post('/build/open-round', async (req, res) => {
+    try {
+      const { keeperAddress } = req.body;
+
+      if (!keeperAddress) {
+        return res.status(400).json({
+          error: 'Missing required field: keeperAddress'
+        });
+      }
+
+      const result = await jackpotService.buildOpenRoundTransaction({
+        keeperAddress,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build open round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/enter
+   * Build UNSIGNED transaction for entering the current round
+   * 
+   * Body:
+   * {
+   *   playerAddress: string (Solana pubkey),
+   *   amount: number (lamports),
+   *   roundId?: string (optional, uses current round if not provided)
+   * }
+   */
+  router.post('/build/enter', async (req, res) => {
+    try {
+      const { playerAddress, amount, roundId } = req.body;
+
+      if (!playerAddress || !amount) {
+        return res.status(400).json({
+          error: 'Missing required fields: playerAddress, amount'
+        });
+      }
+
+      if (amount < 10000) {
+        return res.status(400).json({
+          error: 'Minimum entry amount is 10,000 lamports (0.00001 SOL)'
+        });
+      }
+
+      const result = await jackpotService.buildEnterRoundTransaction({
+        playerAddress,
+        amount,
+        roundId,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build enter round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+  
+  /**
+   * POST /jackpot/build/enter-sponsored
+   * Build UNSIGNED transaction for entering via promo code (treasury pays)
+   * Compound tx: SystemProgram.transfer(treasury → player) + enter_round(player, amount)
+   *
+   * Body:
+   * {
+   *   playerAddress: string (Solana pubkey),
+   *   promoCode: string (e.g. "DUBS-XXXX-XXXX")
+   * }
+   */
+  router.post('/build/enter-sponsored', async (req, res) => {
+    try {
+      const { playerAddress, promoCode } = req.body;
+
+      if (!playerAddress || !promoCode) {
+        return res.status(400).json({
+          error: 'Missing required fields: playerAddress, promoCode'
+        });
+      }
+
+      // Verify treasury is ready
+      if (!promoTreasuryService.isReady()) {
+        return res.status(503).json({ error: 'Promo system is currently unavailable' });
+      }
+
+      // Get user's active promo (must be reserved first)
+      const activePromo = await promoService.getActivePromoForUser(playerAddress);
+      if (!activePromo) {
+        return res.status(400).json({ error: 'No active promo code found. Please reserve a code first.' });
+      }
+
+      // Verify the promo code matches
+      if (activePromo.code !== promoCode.trim().toUpperCase()) {
+        return res.status(400).json({ error: 'Promo code does not match your reserved code' });
+      }
+
+      // Check treasury balance
+      const balanceCheck = await promoTreasuryService.hasEnoughBalance(activePromo.amountLamports);
+      if (!balanceCheck.enough) {
+        return res.status(503).json({ error: 'Promo system temporarily unavailable' });
+      }
+
+      const treasuryKeypair = promoTreasuryService.getKeypair();
+
+      const result = await jackpotService.buildEnterRoundSponsoredTransaction({
+        playerAddress,
+        amount: activePromo.amountLamports,
+        treasuryKeypair,
+      });
+
+      // NOTE: Do NOT mark promo as used here!
+      // Frontend calls /api/promo/confirm-usage AFTER transaction is confirmed on-chain
+
+      res.json({
+        ...result,
+        promoCode: activePromo.code,
+        sponsorWallet: treasuryKeypair.publicKey.toString(),
+      });
+    } catch (error) {
+      console.error('Build enter-sponsored error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build sponsored transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/player-joined
+   * Notify server that a player's transaction confirmed (triggers WebSocket broadcast)
+   * 
+   * Body:
+   * {
+   *   playerAddress: string,
+   *   roundId: string,
+   *   amount: number (lamports),
+   *   signature: string
+   * }
+   */
+  router.post('/player-joined', async (req, res) => {
+    try {
+      const { playerAddress, roundId, amount, signature } = req.body;
+      
+      console.log(`👤 Player joined notification: ${playerAddress.slice(0,8)}... for round ${roundId}`);
+      
+      // Broadcast to all clients (globally + room) so every viewer gets the update
+      if (global.io) {
+        const event = {
+          roundId,
+          player: playerAddress,
+          weight: amount,
+          timestamp: Date.now(),
+          signature
+        };
+        global.io.to(`round_${roundId}`).emit('player_joined', event);
+        global.io.emit('player_joined', event);
+        console.log(`⚡ Broadcasted: player_joined globally to ALL clients`);
+      }
+
+      // Persist entry for transaction history linking
+      if (signature && playerAddress && roundId) {
+        history.addEntry({
+          walletAddress: playerAddress,
+          roundId: roundId.toString(),
+          amount: amount || 0,
+          signature,
+        }).catch(err => console.error('Failed to persist jackpot entry:', err));
+      }
+
+      res.json({ success: true, broadcasted: true });
+    } catch (error) {
+      console.error('Player joined notification error:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/lock-round
+   * Build UNSIGNED transaction for locking a round (commit phase)
+   * 
+   * Body:
+   * {
+   *   keeperAddress: string (Solana pubkey),
+   *   serverSeed?: string (optional, auto-generated if not provided),
+   *   roundId?: string (optional, uses current round if not provided)
+   * }
+   */
+  router.post('/build/lock-round', async (req, res) => {
+    try {
+      const { keeperAddress, roundId } = req.body;
+
+      if (!keeperAddress) {
+        return res.status(400).json({
+          error: 'Missing required field: keeperAddress'
+        });
+      }
+
+      const result = await jackpotService.buildLockRoundTransaction({
+        keeperAddress,
+        roundId,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build lock round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/resolve
+   * Build UNSIGNED transaction for resolving a round
+   * 
+   * Body:
+   * {
+   *   keeperAddress: string (Solana pubkey),
+   *   roundId?: string (optional, uses current round if not provided)
+   * }
+   */
+  router.post('/build/resolve', async (req, res) => {
+    try {
+      const { keeperAddress, roundId } = req.body;
+
+      if (!keeperAddress) {
+        return res.status(400).json({
+          error: 'Missing required field: keeperAddress'
+        });
+      }
+
+      const result = await jackpotService.buildResolveRoundTransaction({
+        keeperAddress,
+        roundId,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build resolve error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /jackpot/build/reset-round
+   * Build UNSIGNED transaction for resetting round (account reuse - Solpot style!)
+   * Reuses Round #1 accounts forever instead of creating new ones
+   * 
+   * Body:
+   * {
+   *   keeperAddress: string (Solana pubkey)
+   * }
+   */
+  router.post('/build/reset-round', async (req, res) => {
+    try {
+      const { keeperAddress } = req.body;
+
+      if (!keeperAddress) {
+        return res.status(400).json({
+          error: 'Missing required field: keeperAddress'
+        });
+      }
+
+      const result = await jackpotService.buildResetRoundTransaction({
+        keeperAddress,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build reset round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  // ============================================
+  // 🤖 ORACLE ENDPOINTS (Server-side only)
+  // ============================================
+
+  /**
+   * POST /jackpot/oracle/reveal
+   * Oracle submits random seed (reveal phase)
+   * 
+   * Body:
+   * {
+   *   roundId: string,
+   *   oracleSeed?: string (hex, optional - auto-generated from Random.org style if not provided)
+   * }
+   */
+  router.post('/oracle/reveal', async (req, res) => {
+    try {
+      const { roundId } = req.body;
+      let { oracleSeed } = req.body;
+
+      if (!roundId) {
+        return res.status(400).json({
+          error: 'Missing required field: roundId'
+        });
+      }
+
+      // Generate oracle seed if not provided (from Random.org in production)
+      if (!oracleSeed) {
+        // In production, fetch from Random.org API
+        oracleSeed = crypto.randomBytes(32);
+      } else {
+        oracleSeed = Buffer.from(oracleSeed, 'hex');
+      }
+
+      const result = await jackpotService.consumeRandomness({
+        roundId,
+        oracleSeed,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Oracle reveal error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to reveal randomness',
+      });
+    }
+  });
+
+  // ============================================
+  // 📊 QUERY ENDPOINTS
+  // ============================================
+
+  /**
+   * GET /jackpot/config
+   * Get protocol configuration
+   */
+  router.get('/config', async (req, res) => {
+    try {
+      const config = await jackpotService.getConfig();
+
+      if (!config) {
+        return res.status(404).json({
+          error: 'Protocol not initialized'
+        });
+      }
+
+      res.json({
+        success: true,
+        config,
+      });
+    } catch (error) {
+      console.error('Get config error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get config',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/round/current
+   * Get current round information
+   */
+  router.get('/round/current', async (req, res) => {
+    try {
+      const round = await jackpotService.getCurrentRound();
+
+      if (!round) {
+        return res.status(404).json({
+          error: 'No active round'
+        });
+      }
+
+      res.json({
+        success: true,
+        round,
+      });
+    } catch (error) {
+      console.error('Get current round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get current round',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/round/:roundId
+   * Get specific round information
+   */
+  router.get('/round/:roundId', async (req, res) => {
+    try {
+      const { roundId } = req.params;
+
+      const round = await jackpotService.getRoundInfo(roundId);
+
+      if (!round) {
+        return res.status(404).json({
+          error: 'Round not found'
+        });
+      }
+
+      res.json({
+        success: true,
+        round,
+      });
+    } catch (error) {
+      console.error('Get round error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get round',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/round/:roundId/verify
+   * Get verification data for a round (for provably fair verification)
+   * Returns: round data, entries, server seed, oracle seed, signatures
+   */
+  router.get('/round/:roundId/verify', async (req, res) => {
+    try {
+      const { roundId } = req.params;
+
+      // Get round from history database (has verification seeds)
+      const historyData = await history.getHistory();
+      const historicalRound = historyData.rounds.find(r => r.roundId === roundId);
+      
+      if (!historicalRound) {
+        return res.status(404).json({
+          error: 'Round not found in history. Only completed rounds can be verified.'
+        });
+      }
+
+      // Get entries for weight verification (current round entries)
+      let entries = [];
+      try {
+        const entriesRes = await jackpotService.getRoundEntries(1); // Always round 1 PDA
+        entries = entriesRes?.entries || [];
+      } catch (e) {
+        console.log('Could not fetch entries (expected for old rounds)');
+      }
+      
+      res.json({
+        success: true,
+        verification: {
+          roundId: historicalRound.roundId,
+          winner: historicalRound.winner,
+          winAmount: historicalRound.winAmount,
+          totalPot: historicalRound.totalPot,
+          entryCount: historicalRound.entryCount,
+          timestamp: historicalRound.timestamp,
+          signature: historicalRound.signature,
+          
+          // Provably fair verification data
+          serverSeed: historicalRound.serverSeed,
+          serverSeedHash: historicalRound.serverSeedHash,
+          oracleSeed: historicalRound.oracleSeed,
+          
+          // Entries for weight verification
+          entries,
+        }
+      });
+    } catch (error) {
+      console.error('Get verification data error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get verification data',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/round/:roundId/entries
+   * Get all entries for a round
+   * NOTE: With account reuse, we always query Round 1 PDAs!
+   */
+  router.get('/round/:roundId/entries', async (req, res) => {
+    try {
+      const { roundId } = req.params;
+
+      // Always use Round 1 PDA for entries (account reuse!)
+      const entries = await jackpotService.getRoundEntries(1);
+      const round = await jackpotService.getRoundInfo(1);
+
+      // Calculate odds for each entry
+      const totalWeight = round ? BigInt(round.totalWeight) : 0n;
+      
+      const entriesWithOdds = entries.map(entry => ({
+        ...entry,
+        oddsPercent: totalWeight > 0n 
+          ? (Number(BigInt(entry.weight) * 10000n / totalWeight) / 100).toFixed(2)
+          : '0.00',
+      }));
+
+      res.json({
+        success: true,
+        roundId: round ? round.roundId : roundId.toString(), // Return actual round ID from account
+        entries: entriesWithOdds,
+        totalEntries: entries.length,
+      });
+    } catch (error) {
+      console.error('Get entries error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get entries',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/stats
+   * Get overall jackpot statistics
+   */
+  router.get('/stats', async (req, res) => {
+    try {
+      const stats = await jackpotService.getStats();
+
+      res.json({
+        success: true,
+        ...stats,
+      });
+    } catch (error) {
+      console.error('Get stats error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get stats',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/winner/last
+   * Get last winner information
+   */
+  router.get('/winner/last', async (req, res) => {
+    try {
+      const lastWinner = await history.getLastWinner();
+      
+      if (!lastWinner) {
+        return res.json({
+          success: true,
+          winner: null,
+          message: 'No winners yet'
+        });
+      }
+
+      res.json({
+        success: true,
+        winner: lastWinner,
+      });
+    } catch (error) {
+      console.error('Get last winner error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get last winner',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/history
+   * Get round history
+   */
+  router.get('/history', async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 10;
+      const historyData = await history.getHistory();
+      
+      res.json({
+        success: true,
+        rounds: historyData.rounds.slice(0, limit),
+        total: historyData.rounds.length,
+      });
+    } catch (error) {
+      console.error('Get history error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get history',
+      });
+    }
+  });
+
+  /**
+   * GET /jackpot/history/wallet/:walletAddress
+   * Get jackpot entries and wins for a specific wallet (for transaction history linking)
+   */
+  router.get('/history/wallet/:walletAddress', async (req, res) => {
+    try {
+      const { walletAddress } = req.params;
+
+      if (!walletAddress || walletAddress.length < 32) {
+        return res.status(400).json({ error: 'Invalid wallet address' });
+      }
+
+      const [entries, wins] = await Promise.all([
+        history.getEntriesByWallet(walletAddress),
+        history.getWinsByWallet(walletAddress),
+      ]);
+
+      res.json({
+        success: true,
+        entries,
+        wins,
+      });
+    } catch (error) {
+      console.error('Get wallet jackpot history error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get wallet jackpot history',
+      });
+    }
+  });
+
+  // ============================================
+  // 🏥 HEALTH ENDPOINT
+  // ============================================
+
+  /**
+   * GET /jackpot/health
+   * Health check for jackpot service
+   */
+  router.get('/health', (req, res) => {
+    res.json({
+      status: 'healthy',
+      service: 'jackpot',
+      programId: jackpotService.programId.toString(),
+      oracleWallet: jackpotService.oracleWallet.toString(),
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  return router;
+};
+