dubs-server 1.0.0

package/routes/arcadeRoutes.js

@@ -0,0 +1,557 @@
+/**
+ * 🎮 Arcade Match API Routes
+ * 
+ * RESTful API for managing arcade matches
+ * Isolated from the main sports betting system
+ */
+
+const express = require('express');
+const router = express.Router();
+const { v4: uuidv4 } = require('uuid');
+
+module.exports = (arcadeService) => {
+  
+  // ============================================
+  // 🎮 BUILD TRANSACTION ENDPOINTS (MUST BE FIRST!)
+  // These must come before parameterized routes to avoid matching issues
+  // ============================================
+
+  /**
+   * POST /arcade/build/match/create
+   * Build UNSIGNED transaction for creating arcade match
+   * Returns base64 transaction for user to sign with their wallet
+   * 
+   * Body:
+   * {
+   *   creatorAddress: string (Solana pubkey),
+   *   stake: number (in lamports),
+   *   gameType?: 'asteroids' | 'snake',
+   *   matchType?: 'bestOf1' | 'bestOf3',
+   *   deadlineMinutes?: number
+   * }
+   */
+  router.post('/build/match/create', async (req, res) => {
+    try {
+      const {
+        creatorAddress,
+        stake,
+        gameType = 'asteroids',
+        matchType = 'bestOf1',
+        deadlineMinutes = 60,
+      } = req.body;
+
+      // Validate inputs
+      if (!creatorAddress || !stake) {
+        return res.status(400).json({
+          error: 'Missing required fields: creatorAddress, stake'
+        });
+      }
+
+      if (stake <= 0) {
+        return res.status(400).json({
+          error: 'Stake must be greater than 0'
+        });
+      }
+
+      // Build UNSIGNED transaction
+      const result = await arcadeService.buildCreateMatchTransaction({
+        creatorAddress,
+        stake,
+        gameType,
+        matchType,
+        deadlineMinutes,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build create match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/build/match/join
+   * Build UNSIGNED transaction for joining arcade match
+   * 
+   * Body:
+   * {
+   *   matchId: string (u64 as string),
+   *   opponentAddress: string (Solana pubkey)
+   * }
+   */
+  router.post('/build/match/join', async (req, res) => {
+    console.log('🎮 [BUILD JOIN] Route hit!');
+    console.log('🎮 [BUILD JOIN] Body:', req.body);
+    
+    try {
+      const { matchId, opponentAddress } = req.body;
+
+      if (!matchId || !opponentAddress) {
+        return res.status(400).json({
+          error: 'Missing required fields: matchId, opponentAddress'
+        });
+      }
+
+      // Build UNSIGNED transaction
+      const result = await arcadeService.buildJoinMatchTransaction({
+        matchId,
+        opponentAddress,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build join match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/build/match/score
+   * Build UNSIGNED transaction for submitting a score
+   * 
+   * Body:
+   * {
+   *   matchId: string (u64 as string),
+   *   playerAddress: string (Solana pubkey),
+   *   score: number,
+   *   gameRound?: number (defaults to 1)
+   * }
+   */
+  router.post('/build/match/score', async (req, res) => {
+    console.log('🎮 [BUILD SUBMIT SCORE] ✅ CORRECT ROUTE HIT!');
+    console.log('🎮 [BUILD SUBMIT SCORE] Body:', req.body);
+    
+    try {
+      const { matchId, playerAddress, score, gameRound = 1 } = req.body;
+
+      if (!matchId || !playerAddress || score === undefined) {
+        return res.status(400).json({
+          error: 'Missing required fields: matchId, playerAddress, score'
+        });
+      }
+
+      if (score < 0) {
+        return res.status(400).json({
+          error: 'Score must be non-negative'
+        });
+      }
+
+      // Build UNSIGNED transaction
+      const result = await arcadeService.buildSubmitScoreTransaction({
+        matchId,
+        playerAddress,
+        score,
+        gameRound,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build submit score error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/build/match/resolve
+   * Build UNSIGNED transaction for resolving a match
+   * 
+   * Body:
+   * {
+   *   matchId: string (u64 as string),
+   *   callerAddress: string (who's calling - pays gas),
+   *   creatorAddress: string,
+   *   opponentAddress: string
+   * }
+   */
+  router.post('/build/match/resolve', async (req, res) => {
+    console.log('🎮 [BUILD RESOLVE] Route hit!');
+    console.log('🎮 [BUILD RESOLVE] Body:', req.body);
+    
+    try {
+      const { matchId, callerAddress, creatorAddress, opponentAddress } = req.body;
+
+      if (!matchId || !callerAddress || !creatorAddress || !opponentAddress) {
+        return res.status(400).json({
+          error: 'Missing required fields: matchId, callerAddress, creatorAddress, opponentAddress'
+        });
+      }
+
+      // Build UNSIGNED transaction
+      const result = await arcadeService.buildResolveMatchTransaction({
+        matchId,
+        callerAddress,
+        creatorAddress,
+        opponentAddress,
+      });
+
+      res.json(result);
+    } catch (error) {
+      console.error('Build resolve match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to build transaction',
+      });
+    }
+  });
+
+  // ============================================
+  // 🏥 HEALTH & INFO ENDPOINTS
+  // ============================================
+
+  /**
+   * GET /arcade/health
+   * Health check for arcade service
+   */
+  router.get('/health', (req, res) => {
+    res.json({
+      status: 'healthy',
+      service: 'arcade-matches',
+      programId: arcadeService.programId.toString(),
+      operatorWallet: arcadeService.operatorWallet.toString(),
+      timestamp: new Date().toISOString(),
+    });
+  });
+
+  // ============================================
+  // 🎮 LEGACY ENDPOINTS (For testing with test wallets)
+  // ============================================
+
+  /**
+   * POST /arcade/matches/create
+   * Create a new arcade match (LEGACY - for testing with test wallets)
+   * 
+   * Body:
+   * {
+   *   creatorName: string,
+   *   stake: number (in lamports),
+   *   gameType?: 'asteroids' | 'snake',
+   *   matchType?: 'bestOf1' | 'bestOf3',
+   *   deadlineMinutes?: number
+   * }
+   */
+  router.post('/matches/create', async (req, res) => {
+    try {
+      const {
+        creatorName,
+        stake,
+        gameType = 'asteroids',
+        matchType = 'bestOf1',
+        deadlineMinutes = 60,
+      } = req.body;
+
+      // Validate inputs
+      if (!creatorName || !stake) {
+        return res.status(400).json({
+          error: 'Missing required fields: creatorName, stake'
+        });
+      }
+
+      if (stake <= 0) {
+        return res.status(400).json({
+          error: 'Stake must be greater than 0'
+        });
+      }
+
+      if (!['asteroids', 'snake'].includes(gameType)) {
+        return res.status(400).json({
+          error: 'gameType must be "asteroids" or "snake"'
+        });
+      }
+
+      if (!['bestOf1', 'bestOf3'].includes(matchType)) {
+        return res.status(400).json({
+          error: 'matchType must be "bestOf1" or "bestOf3"'
+        });
+      }
+
+      // Generate unique match ID
+      const matchId = uuidv4();
+
+      // Create match
+      const result = await arcadeService.createMatch({
+        matchId,
+        creatorName,
+        stake,
+        gameType,
+        matchType,
+        deadlineMinutes,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Create match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to create match',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/matches/:matchId/join
+   * Join an existing match
+   * 
+   * Body:
+   * {
+   *   opponentName: string
+   * }
+   */
+  router.post('/matches/:matchId/join', async (req, res) => {
+    console.log('🎮 [LEGACY JOIN] Route hit! matchId:', req.params.matchId);
+    console.log('🎮 [LEGACY JOIN] Body:', req.body);
+    
+    try {
+      const { matchId } = req.params;
+      const { opponentName } = req.body;
+
+      if (!opponentName) {
+        return res.status(400).json({
+          error: 'Missing required field: opponentName'
+        });
+      }
+
+      const result = await arcadeService.joinMatch({
+        matchId,
+        opponentName,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Join match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to join match',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/matches/:matchId/score
+   * Submit a score for a match
+   * 
+   * Body:
+   * {
+   *   playerName: string,
+   *   score: number,
+   *   gameRound?: number (1-3, defaults to 1)
+   * }
+   */
+  router.post('/matches/:matchId/score', async (req, res) => {
+    console.log('🎮 [LEGACY SUBMIT SCORE] ❌ WRONG ROUTE! matchId:', req.params.matchId);
+    console.log('🎮 [LEGACY SUBMIT SCORE] Body:', req.body);
+    
+    try {
+      const { matchId } = req.params;
+      const { playerName, score, gameRound = 1 } = req.body;
+
+      if (!playerName || score === undefined) {
+        return res.status(400).json({
+          error: 'Missing required fields: playerName, score'
+        });
+      }
+
+      if (score < 0) {
+        return res.status(400).json({
+          error: 'Score must be non-negative'
+        });
+      }
+
+      if (gameRound < 1 || gameRound > 3) {
+        return res.status(400).json({
+          error: 'gameRound must be between 1 and 3'
+        });
+      }
+
+      const result = await arcadeService.submitScore({
+        matchId,
+        playerName,
+        score,
+        gameRound,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Submit score error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to submit score',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/matches/:matchId/resolve
+   * Resolve a match and distribute winnings
+   * 
+   * Body:
+   * {
+   *   callerName: string (usually the creator)
+   * }
+   */
+  router.post('/matches/:matchId/resolve', async (req, res) => {
+    try {
+      const { matchId } = req.params;
+      const { callerName } = req.body;
+
+      if (!callerName) {
+        return res.status(400).json({
+          error: 'Missing required field: callerName'
+        });
+      }
+
+      const result = await arcadeService.resolveMatch({
+        matchId,
+        callerName,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Resolve match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to resolve match',
+      });
+    }
+  });
+
+  /**
+   * POST /arcade/matches/:matchId/cancel
+   * Cancel a match (if no opponent joined)
+   * 
+   * Body:
+   * {
+   *   creatorName: string
+   * }
+   */
+  router.post('/matches/:matchId/cancel', async (req, res) => {
+    try {
+      const { matchId } = req.params;
+      const { creatorName } = req.body;
+
+      if (!creatorName) {
+        return res.status(400).json({
+          error: 'Missing required field: creatorName'
+        });
+      }
+
+      const result = await arcadeService.cancelMatch({
+        matchId,
+        creatorName,
+      });
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Cancel match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to cancel match',
+      });
+    }
+  });
+
+  /**
+   * GET /arcade/matches/:matchId
+   * Get match information
+   */
+  router.get('/matches/:matchId', async (req, res) => {
+    try {
+      const { matchId } = req.params;
+
+      const matchData = await arcadeService.getMatchData(matchId);
+
+      if (!matchData) {
+        return res.status(404).json({
+          error: 'Match not found'
+        });
+      }
+
+      res.json({
+        success: true,
+        match: matchData,
+      });
+    } catch (error) {
+      console.error('Get match error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get match data',
+      });
+    }
+  });
+
+  // ============================================
+  // 💰 WALLET & TESTING ENDPOINTS
+  // ============================================
+
+  /**
+   * POST /arcade/wallet/airdrop
+   * Airdrop SOL to a wallet (for testing on localnet/devnet)
+   * 
+   * Body:
+   * {
+   *   playerName: string,
+   *   amount?: number (in SOL, defaults to 1)
+   * }
+   */
+  router.post('/wallet/airdrop', async (req, res) => {
+    try {
+      const { playerName, amount = 1 } = req.body;
+
+      if (!playerName) {
+        return res.status(400).json({
+          error: 'Missing required field: playerName'
+        });
+      }
+
+      const result = await arcadeService.airdrop(playerName, amount);
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Airdrop error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to airdrop'
+      });
+    }
+  });
+
+  /**
+   * GET /arcade/wallet/:playerName/balance
+   * Get wallet balance
+   */
+  router.get('/wallet/:playerName/balance', async (req, res) => {
+    try {
+      const { playerName } = req.params;
+
+      const result = await arcadeService.getBalance(playerName);
+
+      res.json({
+        success: true,
+        ...result,
+      });
+    } catch (error) {
+      console.error('Get balance error:', error);
+      res.status(500).json({
+        error: error.message || 'Failed to get balance'
+      });
+    }
+  });
+
+  return router;
+};
+