dubs-server 1.0.0

package/routes/actionsRoutes.js

@@ -0,0 +1,699 @@
+/**
+ * Solana Actions Routes - Blink integration for X/Twitter sharing
+ *
+ * ISOLATED MODULE - Can be safely deleted if not needed
+ *
+ * This module implements Solana Actions specification to allow users
+ * to join bets directly from X/Twitter without visiting the site.
+ *
+ * Endpoints:
+ *   GET  /api/actions/join-bet/:gameId - Returns action metadata (icon, buttons)
+ *   POST /api/actions/join-bet/:gameId - Returns signable join transaction
+ *
+ * Feature flag: ENABLE_SOLANA_ACTIONS=true in .env to enable
+ *
+ * @see https://solana.com/docs/advanced/actions
+ */
+
+const express = require('express');
+const router = express.Router();
+const { Connection, PublicKey, SystemProgram, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+
+// ============ CONFIGURATION ============
+
+const PROGRAM_ID = new PublicKey(process.env.PROGRAM_ID || "85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1");
+const LAMPORTS_PER_SOL = 1_000_000_000;
+
+// Join automatic game discriminator (must match server.js)
+const JOIN_AUTO = Buffer.from([87, 51, 29, 81, 147, 216, 222, 119]);
+
+// Default bet amounts for action buttons (in SOL)
+const DEFAULT_BET_AMOUNTS = [0.05, 0.1, 0.25];
+
+// ============ SOCKET.IO INJECTION ============
+
+let chatNamespace = null;
+
+// Inject Socket.IO instance (called from server.js)
+router.setSocketIO = (ioInstance, chatNS) => {
+  chatNamespace = chatNS;
+  console.log('🔌 Socket.IO injected into actions routes');
+};
+
+// ============ HELPER FUNCTIONS (copied to keep isolated) ============
+
+function uuidToU64(uuid) {
+  const hash = crypto.createHash('sha256').update(uuid).digest();
+  return hash.readBigUInt64LE(0);
+}
+
+function getGamePDA(gameId) {
+  let gameIdNum;
+  if (typeof gameId === 'string' && gameId.includes('-')) {
+    gameIdNum = uuidToU64(gameId);
+  } else {
+    gameIdNum = BigInt(gameId);
+  }
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+  return PublicKey.findProgramAddressSync([Buffer.from("game"), gameIdBuf], PROGRAM_ID);
+}
+
+function getGameIdBuffer(gameId) {
+  let gameIdNum;
+  if (typeof gameId === 'string' && gameId.includes('-')) {
+    gameIdNum = uuidToU64(gameId);
+  } else {
+    gameIdNum = BigInt(gameId);
+  }
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(gameIdNum);
+  return buf;
+}
+
+// ============ CORS MIDDLEWARE FOR ACTIONS ============
+
+/**
+ * Solana Actions require specific CORS headers
+ * This middleware adds them to all routes in this file
+ */
+router.use((req, res, next) => {
+  // CORS headers required by Solana Actions spec
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Encoding, Accept-Encoding, Accept, X-Requested-With');
+  res.setHeader('Access-Control-Expose-Headers', 'X-Action-Version, X-Blockchain-Ids');
+  res.setHeader('X-Action-Version', '2.2');
+  // Set blockchain ID based on environment (devnet vs mainnet)
+  const isDevnet = (process.env.SOLANA_NETWORK || '').includes('devnet');
+  const blockchainId = isDevnet
+    ? 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1' // devnet
+    : 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'; // mainnet
+  res.setHeader('X-Blockchain-Ids', blockchainId);
+
+  if (req.method === 'OPTIONS') {
+    return res.status(200).end();
+  }
+  next();
+});
+
+// ============ FACTORY FUNCTION ============
+
+/**
+ * Create actions routes with database pool injection
+ * @param {Pool} pool - PostgreSQL connection pool
+ * @param {Connection} connection - Solana RPC connection
+ */
+function createActionsRoutes(pool, connection) {
+
+  // ============ AUTO-CREATE USER FOR BLINK JOINS ============
+
+  /**
+   * Find or create a minimal user record for Blink joins
+   * Users created this way are marked as needing onboarding
+   */
+  async function findOrCreateBlinkUser(walletAddress) {
+    try {
+      // Check if user exists
+      const existingUser = await pool.query(
+        'SELECT id, username FROM users WHERE wallet_address = $1',
+        [walletAddress]
+      );
+
+      if (existingUser.rows.length > 0) {
+        return { exists: true, user: existingUser.rows[0] };
+      }
+
+      // Create minimal user for Blink join
+      // Uses existing columns only - no schema changes needed
+      const shortWallet = walletAddress.slice(0, 6);
+      const autoUsername = `blink_${shortWallet}`;
+
+      const result = await pool.query(
+        `INSERT INTO users
+         (wallet_address, username, created_at, onboarding_complete)
+         VALUES ($1, $2, NOW(), false)
+         ON CONFLICT (wallet_address) DO NOTHING
+         RETURNING id, username`,
+        [walletAddress, autoUsername]
+      );
+
+      if (result.rows.length > 0) {
+        console.log(`[Actions] Created Blink user: ${autoUsername} (${walletAddress.slice(0, 8)}...)`);
+        return { exists: false, created: true, user: result.rows[0] };
+      }
+
+      // Race condition: user was created between check and insert
+      const raceUser = await pool.query(
+        'SELECT id, username FROM users WHERE wallet_address = $1',
+        [walletAddress]
+      );
+      return { exists: true, user: raceUser.rows[0] };
+
+    } catch (error) {
+      console.error('[Actions] Error in findOrCreateBlinkUser:', error.message);
+      // Don't fail the transaction - just log and continue
+      return { exists: false, created: false, error: error.message };
+    }
+  }
+
+  // ============ GET ENDPOINT - ACTION METADATA ============
+
+  /**
+   * GET /api/actions/join-bet/:gameId
+   * Returns action metadata for rendering the Blink UI
+   */
+  router.get('/join-bet/:gameId', async (req, res) => {
+    try {
+      const { gameId } = req.params;
+
+      // Fetch game from database
+      const gameResult = await pool.query(
+        `SELECT
+          game_id, title, buy_in, is_locked, is_resolved,
+          matchup_image_url, sports_event, lock_timestamp,
+          home_team_players, away_team_players, draw_team_players,
+          total_pool, home_pool, away_pool, draw_pool
+        FROM games WHERE game_id = $1`,
+        [gameId]
+      );
+
+      if (gameResult.rows.length === 0) {
+        return res.status(404).json({
+          icon: 'https://dubs.app/logo.png',
+          title: 'Game Not Found',
+          description: 'This bet no longer exists',
+          label: 'Not Found',
+          disabled: true,
+          error: { message: 'Game not found' }
+        });
+      }
+
+      const game = gameResult.rows[0];
+      const sportsEvent = game.sports_event || {};
+
+      // Check if game is joinable
+      if (game.is_locked) {
+        return res.json({
+          icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+          title: game.title || 'Betting Closed',
+          description: 'Betting has closed for this game',
+          label: 'Closed',
+          disabled: true,
+          error: { message: 'Betting is closed' }
+        });
+      }
+
+      if (game.is_resolved) {
+        return res.json({
+          icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+          title: game.title || 'Game Finished',
+          description: 'This game has already been resolved',
+          label: 'Finished',
+          disabled: true,
+          error: { message: 'Game is finished' }
+        });
+      }
+
+      // Extract team names
+      const homeTeam = sportsEvent.strHomeTeam || 'Home';
+      const awayTeam = sportsEvent.strAwayTeam || 'Away';
+      const hasDrawOption = sportsEvent.strSport === 'Soccer' ||
+                            sportsEvent.strLeague?.includes('MLS') ||
+                            sportsEvent.strLeague?.includes('Premier League');
+
+      // Build base URL from request (required for absolute hrefs)
+      const protocol = req.headers['x-forwarded-proto'] || req.protocol || 'https';
+      const host = req.headers['x-forwarded-host'] || req.headers.host;
+      const baseUrl = `${protocol}://${host}`;
+
+      // Build action links for each team
+      const actions = [];
+
+      // Home team action with amount parameter
+      actions.push({
+        type: 'transaction',
+        label: `${homeTeam}`,
+        href: `${baseUrl}/api/actions/join-bet/${gameId}?team=home&amount={amount}`,
+        parameters: [
+          {
+            name: 'amount',
+            label: 'Bet Amount (SOL)',
+            required: true,
+            type: 'number',
+            min: 0.01,
+            max: 10,
+          }
+        ]
+      });
+
+      // Away team action with amount parameter
+      actions.push({
+        type: 'transaction',
+        label: `${awayTeam}`,
+        href: `${baseUrl}/api/actions/join-bet/${gameId}?team=away&amount={amount}`,
+        parameters: [
+          {
+            name: 'amount',
+            label: 'Bet Amount (SOL)',
+            required: true,
+            type: 'number',
+            min: 0.01,
+            max: 10,
+          }
+        ]
+      });
+
+      // Draw option for soccer
+      if (hasDrawOption) {
+        actions.push({
+          type: 'transaction',
+          label: 'Draw',
+          href: `${baseUrl}/api/actions/join-bet/${gameId}?team=draw&amount={amount}`,
+          parameters: [
+            {
+              name: 'amount',
+              label: 'Bet Amount (SOL)',
+              required: true,
+              type: 'number',
+              min: 0.01,
+              max: 10,
+            }
+          ]
+        });
+      }
+
+      // Format pool info for description
+      const totalPool = parseFloat(game.total_pool) || 0;
+      const playerCount = (game.home_team_players?.length || 0) +
+                          (game.away_team_players?.length || 0) +
+                          (game.draw_team_players?.length || 0);
+
+      const description = totalPool > 0
+        ? `${playerCount} player${playerCount !== 1 ? 's' : ''} | ${totalPool.toFixed(2)} SOL pot`
+        : 'Be the first to bet!';
+
+      // Return action metadata
+      res.json({
+        type: 'action',
+        icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+        title: game.title || `${homeTeam} vs ${awayTeam}`,
+        description: description,
+        label: 'Place Bet',
+        links: {
+          actions: actions
+        }
+      });
+
+    } catch (error) {
+      console.error('[Actions] GET error:', error);
+      res.status(500).json({
+        icon: 'https://dubs.app/logo.png',
+        title: 'Error',
+        description: 'Failed to load game',
+        label: 'Error',
+        disabled: true,
+        error: { message: error.message }
+      });
+    }
+  });
+
+  // ============ POST ENDPOINT - BUILD TRANSACTION ============
+
+  /**
+   * POST /api/actions/join-bet/:gameId
+   * Returns a signable transaction to join the bet
+   */
+  router.post('/join-bet/:gameId', async (req, res) => {
+    try {
+      const { gameId } = req.params;
+      const { team, amount } = req.query;
+      const { account } = req.body; // User's wallet address (base58)
+
+      // Build base URL for callback
+      const protocol = req.headers['x-forwarded-proto'] || req.protocol || 'https';
+      const host = req.headers['x-forwarded-host'] || req.headers.host;
+      const baseUrl = `${protocol}://${host}`;
+
+      // Validate inputs
+      if (!account) {
+        return res.status(400).json({
+          error: { message: 'Wallet account is required' }
+        });
+      }
+
+      if (!team || !['home', 'away', 'draw'].includes(team)) {
+        return res.status(400).json({
+          error: { message: 'Team must be home, away, or draw' }
+        });
+      }
+
+      const betAmount = parseFloat(amount);
+      if (!betAmount || betAmount <= 0 || betAmount > 10) {
+        return res.status(400).json({
+          error: { message: 'Amount must be between 0.01 and 10 SOL' }
+        });
+      }
+
+      // Validate wallet address format
+      let playerPubkey;
+      try {
+        playerPubkey = new PublicKey(account);
+      } catch (e) {
+        return res.status(400).json({
+          error: { message: 'Invalid wallet address' }
+        });
+      }
+
+      // Verify game exists and is joinable
+      const gameResult = await pool.query(
+        `SELECT game_id, is_locked, is_resolved, title, sports_event,
+                home_team_players, away_team_players, draw_team_players
+         FROM games WHERE game_id = $1`,
+        [gameId]
+      );
+
+      if (gameResult.rows.length === 0) {
+        return res.status(404).json({
+          type: 'action',
+          icon: 'https://dubs.app/logo.png',
+          title: 'Game Not Found',
+          description: 'This bet no longer exists',
+          label: 'Not Found',
+          disabled: true,
+          error: { message: 'Game not found' }
+        });
+      }
+
+      const game = gameResult.rows[0];
+
+      if (game.is_locked) {
+        return res.status(400).json({
+          type: 'action',
+          icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+          title: 'Betting Closed',
+          description: 'Betting has closed for this game',
+          label: 'Closed',
+          disabled: true,
+          error: { message: 'Betting has closed for this game' }
+        });
+      }
+
+      if (game.is_resolved) {
+        return res.status(400).json({
+          type: 'action',
+          icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+          title: 'Game Finished',
+          description: 'This game has already been resolved',
+          label: 'Finished',
+          disabled: true,
+          error: { message: 'This game has already been resolved' }
+        });
+      }
+
+      // Check if player already joined
+      const allPlayers = [
+        ...(game.home_team_players || []),
+        ...(game.away_team_players || []),
+        ...(game.draw_team_players || [])
+      ];
+
+      if (allPlayers.includes(account)) {
+        return res.status(400).json({
+          type: 'action',
+          icon: game.matchup_image_url || 'https://dubs.app/logo.png',
+          title: 'Already Joined',
+          description: 'You have already joined this bet',
+          label: 'Already Joined',
+          disabled: true,
+          error: { message: 'You have already joined this bet' }
+        });
+      }
+
+      // Auto-create user if needed (for tracking/notifications)
+      await findOrCreateBlinkUser(account);
+
+      // Build the join transaction
+      const [gamePDA] = getGamePDA(gameId);
+      const gameIdBuf = getGameIdBuffer(gameId);
+
+      // Convert amount to lamports
+      const amountBuf = Buffer.alloc(8);
+      amountBuf.writeBigUInt64LE(BigInt(Math.round(betAmount * LAMPORTS_PER_SOL)));
+
+      // Encode team choice: 0 = Home, 1 = Away, 2 = Draw
+      const teamChoiceByte = team === 'home' ? 0 : team === 'away' ? 1 : 2;
+
+      // Build instruction data for join_automatic_game
+      const data = Buffer.concat([
+        JOIN_AUTO,
+        gameIdBuf,
+        Buffer.from([teamChoiceByte]),
+        amountBuf
+      ]);
+
+      const instruction = new TransactionInstruction({
+        keys: [
+          { pubkey: gamePDA, isSigner: false, isWritable: true },
+          { pubkey: playerPubkey, isSigner: true, isWritable: true },
+          { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        programId: PROGRAM_ID,
+        data,
+      });
+
+      const transaction = new Transaction().add(instruction);
+      transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+      transaction.feePayer = playerPubkey;
+
+      const serialized = transaction.serialize({ requireAllSignatures: false }).toString('base64');
+
+      // Get team name for message
+      const sportsEvent = game.sports_event || {};
+      const teamName = team === 'home' ? (sportsEvent.strHomeTeam || 'Home') :
+                       team === 'away' ? (sportsEvent.strAwayTeam || 'Away') : 'Draw';
+
+      console.log(`[Actions] Built join tx for ${account.slice(0, 8)}... | ${betAmount} SOL on ${teamName} | Game: ${gameId.slice(-8)}`);
+
+      res.json({
+        type: 'transaction',
+        transaction: serialized,
+        message: `Bet ${betAmount} SOL on ${teamName}`,
+        links: {
+          next: {
+            type: 'post',
+            href: `${baseUrl}/api/actions/confirm-join/${gameId}?team=${team}&amount=${betAmount}`
+          }
+        }
+      });
+
+    } catch (error) {
+      console.error('[Actions] POST error:', error);
+      res.status(500).json({
+        error: { message: error.message || 'Failed to build transaction' }
+      });
+    }
+  });
+
+  // ============ CONFIRM ENDPOINT - POST-TRANSACTION DATABASE UPDATE ============
+
+  /**
+   * POST /api/actions/confirm-join/:gameId
+   * Called by Blink client after transaction confirms - updates the database
+   */
+  router.post('/confirm-join/:gameId', async (req, res) => {
+    try {
+      const { gameId } = req.params;
+      const { team, amount } = req.query;
+      const { account, signature } = req.body; // account + signature from Blink client
+
+      console.log(`[Actions] Confirm join: ${account?.slice(0, 8)}... | Game: ${gameId.slice(-8)} | Sig: ${signature?.slice(0, 16)}...`);
+
+      if (!account || !signature) {
+        return res.status(400).json({
+          error: { message: 'Account and signature are required' }
+        });
+      }
+
+      const wallet = account;
+
+      const betAmount = parseFloat(amount) || 0;
+
+      // Verify team choice from on-chain transaction (source of truth)
+      // The query param `team` can diverge from what was actually signed on-chain
+      let verifiedTeam = team;
+      try {
+        const txInfo = await connection.getTransaction(signature, {
+          commitment: 'confirmed',
+          maxSupportedTransactionVersion: 0
+        });
+        if (txInfo?.transaction?.message) {
+          const msg = txInfo.transaction.message;
+          const programIdStr = PROGRAM_ID.toString();
+          const accountKeys = msg.staticAccountKeys || msg.accountKeys || [];
+          const instructions = msg.compiledInstructions || msg.instructions || [];
+          for (const ix of instructions) {
+            const progIdx = ix.programIdIndex;
+            const progKey = accountKeys[progIdx]?.toString();
+            if (progKey === programIdStr) {
+              const data = Buffer.from(ix.data);
+              // join_automatic_game: 8-byte discriminator + 8-byte gameId + 1-byte teamChoice
+              if (data.length >= 17 && data.slice(0, 8).equals(JOIN_AUTO)) {
+                const teamByte = data[16];
+                const onChainTeam = teamByte === 0 ? 'home' : teamByte === 1 ? 'away' : 'draw';
+                if (onChainTeam !== team) {
+                  console.warn(`[Actions] ⚠️ TEAM MISMATCH: query=${team}, on-chain=${onChainTeam} | Wallet: ${wallet.slice(0, 8)}... | Game: ${gameId}`);
+                }
+                verifiedTeam = onChainTeam;
+                break;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        console.warn(`[Actions] Could not verify on-chain team choice, using query param: ${err.message}`);
+      }
+
+      const teamChoice = verifiedTeam || 'home';
+
+      // Determine which fields to update
+      const teamField = teamChoice === 'home' ? 'home_team_players'
+        : teamChoice === 'away' ? 'away_team_players'
+        : 'draw_team_players';
+
+      const poolField = teamChoice === 'home' ? 'home_pool'
+        : teamChoice === 'away' ? 'away_pool'
+        : 'draw_pool';
+
+      // Update game with new player (same logic as gamesRoutes join endpoint)
+      await pool.query(`
+        UPDATE games
+        SET ${teamField} = array_append(${teamField}, $1),
+            ${poolField} = COALESCE(${poolField}, 0) + $3,
+            total_pool = COALESCE(total_pool, 0) + $3,
+            player_amounts = COALESCE(player_amounts, '{}'::jsonb) || jsonb_build_object($1, $3),
+            updated_at = NOW()
+        WHERE game_id = $2
+          AND NOT ($1 = ANY(COALESCE(home_team_players, ARRAY[]::text[]))
+               OR $1 = ANY(COALESCE(away_team_players, ARRAY[]::text[]))
+               OR $1 = ANY(COALESCE(draw_team_players, ARRAY[]::text[])))
+      `, [wallet, gameId, betAmount]);
+
+      // Save user's game reference
+      await pool.query(`
+        INSERT INTO user_game_refs (
+          wallet_address, game_id, role, joined_at, team_choice,
+          my_signature, my_explorer_url, status, wallet_type
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        ON CONFLICT (wallet_address, game_id)
+        DO UPDATE SET
+          team_choice = EXCLUDED.team_choice,
+          my_signature = COALESCE(EXCLUDED.my_signature, user_game_refs.my_signature),
+          status = EXCLUDED.status
+      `, [
+        wallet,
+        gameId,
+        'player',
+        new Date().toISOString(),
+        teamChoice,
+        signature,
+        `https://explorer.solana.com/tx/${signature}${(process.env.SOLANA_NETWORK || '').includes('devnet') ? '?cluster=devnet' : ''}`,
+        'active',
+        'blink'
+      ]);
+
+      console.log(`[Actions] ✅ Database updated for Blink join: ${wallet.slice(0, 8)}... -> ${teamChoice} team`);
+
+      // Get updated game data for WebSocket broadcast
+      const gameResult = await pool.query('SELECT * FROM games WHERE game_id = $1', [gameId]);
+      const updatedGame = gameResult.rows[0];
+
+      // Get user info for notifications
+      const userResult = await pool.query('SELECT id, username FROM users WHERE wallet_address = $1', [wallet]);
+      const user = userResult.rows[0];
+      const joinerUsername = user?.username || `blink_${wallet.slice(0, 6)}`;
+
+      // Emit WebSocket event to all connected clients
+      if (chatNamespace && updatedGame) {
+        chatNamespace.emit('game:player_joined', {
+          gameId: gameId,
+          walletAddress: wallet,
+          teamChoice: teamChoice,
+          homeTeamCount: updatedGame.home_team_players?.length || 0,
+          awayTeamCount: updatedGame.away_team_players?.length || 0,
+          drawTeamCount: updatedGame.draw_team_players?.length || 0,
+          totalPlayers: (updatedGame.home_team_players?.length || 0) + (updatedGame.away_team_players?.length || 0) + (updatedGame.draw_team_players?.length || 0),
+          timestamp: Date.now(),
+          source: 'blink'
+        });
+        console.log(`[Actions] 📡 Broadcasted game:player_joined event`);
+      }
+
+      // Send notifications to other participants
+      try {
+        const { forwardChatNotification } = require('../services/telegramNotifications');
+
+        // Get all participants except the joiner
+        const allParticipants = [
+          ...(updatedGame.home_team_players || []),
+          ...(updatedGame.away_team_players || []),
+          ...(updatedGame.draw_team_players || []),
+          updatedGame.created_by
+        ].filter(w => w && w !== wallet);
+
+        const uniqueParticipants = [...new Set(allParticipants)];
+
+        // Get participant user IDs
+        if (uniqueParticipants.length > 0) {
+          const participantsResult = await pool.query(
+            'SELECT id, wallet_address FROM users WHERE wallet_address = ANY($1)',
+            [uniqueParticipants]
+          );
+
+          for (const participant of participantsResult.rows) {
+            const notification = {
+              type: 'player_joined',
+              title: '🎮 New Player Joined!',
+              body: `${joinerUsername} joined your bet with ${betAmount} SOL`,
+              gameId: gameId,
+              data: { gameId, joinerUsername, teamChoice, betAmount }
+            };
+
+            await forwardChatNotification(participant.id, notification).catch(err => {
+              console.log(`[Actions] Notification to ${participant.wallet_address.slice(0, 8)} failed:`, err.message);
+            });
+          }
+          console.log(`[Actions] 📬 Sent notifications to ${participantsResult.rows.length} participant(s)`);
+        }
+      } catch (notifError) {
+        console.error('[Actions] Notification error (non-fatal):', notifError.message);
+      }
+
+      // Return a completed action response with all required fields
+      res.json({
+        type: 'completed',
+        icon: 'https://dubs.app/logo.png',
+        title: 'Bet Placed!',
+        description: `Successfully bet ${betAmount} SOL on ${teamChoice}`,
+        label: 'Complete'
+      });
+
+    } catch (error) {
+      console.error('[Actions] Confirm error:', error);
+      res.status(500).json({
+        type: 'action',
+        icon: 'https://dubs.app/logo.png',
+        title: 'Error',
+        description: error.message || 'Failed to confirm join',
+        label: 'Error',
+        disabled: true,
+        error: { message: error.message || 'Failed to confirm join' }
+      });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createActionsRoutes;