dubs-server 1.0.0

package/services/connect4GameService.js

@@ -0,0 +1,1049 @@
+/**
+ * Connect 4 Game Service
+ *
+ * Handles all game logic for Connect 4:
+ * - Board state management
+ * - Move validation
+ * - Win detection
+ * - Game state persistence
+ * - On-chain payout resolution
+ */
+
+const { pool } = require('./db');
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const referralEarningsService = require('./referralEarningsService');
+
+// Solana configuration
+const PROGRAM_ID = new PublicKey(process.env.PROGRAM_ID || 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+const OPERATOR_WALLET = new PublicKey(process.env.OPERATOR_WALLET || 'BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+const RPC_URL = process.env.SOLANA_RPC_URL; // Must be set to Alchemy URL
+
+// Discriminator for resolve_automatic_game instruction
+const RESOLVE_AUTO_DISCRIMINATOR = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+
+/**
+ * Poll for transaction confirmation using getSignatureStatuses
+ * This is the Alchemy-compatible approach (no WebSocket subscriptions)
+ *
+ * @param {Connection} connection - Solana connection
+ * @param {string} signature - Transaction signature to confirm
+ * @param {number} lastValidBlockHeight - Block height after which tx expires
+ * @param {number} timeout - Maximum time to wait in ms (default 30s)
+ * @returns {object} - Confirmation status
+ */
+async function pollTransactionConfirmation(connection, signature, lastValidBlockHeight, timeout = 30000) {
+  const start = Date.now();
+  console.log(`🔴🟡 [Connect4] Polling confirmation for ${signature}, lastValidBlockHeight: ${lastValidBlockHeight}`);
+
+  while (Date.now() - start < timeout) {
+    try {
+      // Check if blockhash has expired (transaction dropped)
+      const currentBlockHeight = await connection.getBlockHeight('confirmed');
+      if (currentBlockHeight > lastValidBlockHeight) {
+        throw new Error(`Transaction expired: blockhash no longer valid (current: ${currentBlockHeight}, lastValid: ${lastValidBlockHeight})`);
+      }
+
+      // Poll signature status
+      const response = await connection.getSignatureStatuses([signature], {
+        searchTransactionHistory: true
+      });
+
+      const status = response?.value?.[0];
+      if (status) {
+        console.log(`🔴🟡 [Connect4] Signature status: ${JSON.stringify(status)}`);
+
+        // Check for error
+        if (status.err) {
+          throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        }
+
+        // Check confirmation level
+        if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
+          console.log(`✅ [Connect4] Transaction confirmed: ${status.confirmationStatus}`);
+          return status;
+        }
+      }
+    } catch (pollErr) {
+      // If it's a fatal error (not just "not found yet"), rethrow
+      if (pollErr.message?.includes('expired') || pollErr.message?.includes('failed')) {
+        throw pollErr;
+      }
+      console.warn(`⚠️ [Connect4] Poll error (will retry): ${pollErr.message}`);
+    }
+
+    // Wait before next poll (1 second as recommended by Solana docs)
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+
+/**
+ * Load oracle keypair for Connect4 resolution
+ * Connect4 games use automatic mode, which means the smart contract sets
+ * game.oracle = hardcoded ORACLE_WALLET (FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa)
+ * We MUST use the oracle wallet to resolve, not the operator wallet.
+ */
+function loadOracleKeypair() {
+  try {
+    // First try environment variable (JSON array of secret key bytes)
+    if (process.env.ORACLE_WALLET_JSON) {
+      const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+      return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    }
+
+    // Fallback to file - use oracle.json (matches smart contract hardcoded ORACLE_WALLET)
+    const walletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, '../wallets/oracle.json');
+    if (fs.existsSync(walletPath)) {
+      const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+      return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    }
+
+    console.warn('⚠️ [Connect4] No oracle keypair found - payouts will be disabled');
+    return null;
+  } catch (error) {
+    console.error('❌ [Connect4] Failed to load oracle keypair:', error.message);
+    return null;
+  }
+}
+
+// Initialize oracle keypair and connection
+let oracleKeypair = null;
+let connection = null;
+
+function initializeSolana() {
+  console.log(`🔴🟡 [Connect4] initializeSolana called, oracleKeypair exists: ${!!oracleKeypair}`);
+  if (!oracleKeypair) {
+    console.log(`🔴🟡 [Connect4] Loading oracle keypair...`);
+    console.log(`🔴🟡 [Connect4] ORACLE_WALLET_JSON env exists: ${!!process.env.ORACLE_WALLET_JSON}`);
+    oracleKeypair = loadOracleKeypair();
+    if (oracleKeypair) {
+      console.log(`🔴🟡 [Connect4] Oracle wallet loaded: ${oracleKeypair.publicKey.toString()}`);
+    } else {
+      console.log(`🔴🟡 [Connect4] Failed to load oracle keypair!`);
+    }
+  }
+  if (!connection) {
+    connection = new Connection(RPC_URL, 'confirmed');
+    console.log(`🔴🟡 [Connect4] Solana connection initialized: ${RPC_URL}`);
+  }
+}
+
+/**
+ * Verify a transaction was successful on-chain
+ * Uses polling to check signature status (Alchemy-compatible, no WebSocket)
+ *
+ * @param {string} signature - Transaction signature to verify
+ * @param {number} timeout - Maximum time to wait in ms (default 15s)
+ * @returns {object} - { success: boolean, error?: string, status?: object }
+ */
+async function verifyTransactionSuccess(signature, timeout = 15000) {
+  // Ensure connection is initialized
+  if (!connection) {
+    initializeSolana();
+  }
+
+  if (!signature || typeof signature !== 'string' || signature.length < 80) {
+    console.log(`❌ [TxVerify] Invalid signature format: ${signature}`);
+    return { success: false, error: 'Invalid signature format' };
+  }
+
+  const start = Date.now();
+  console.log(`🔍 [TxVerify] Verifying transaction: ${signature}`);
+  console.log(`🔍 [TxVerify] Using RPC: ${connection.rpcEndpoint}`);
+
+  while (Date.now() - start < timeout) {
+    try {
+      const response = await connection.getSignatureStatuses([signature], {
+        searchTransactionHistory: true
+      });
+
+      const status = response?.value?.[0];
+      console.log(`🔍 [TxVerify] Poll result:`, status ? JSON.stringify(status) : 'null');
+
+      if (status) {
+        // Check for error
+        if (status.err) {
+          console.log(`❌ [TxVerify] Transaction FAILED on-chain: ${JSON.stringify(status.err)}`);
+          return { success: false, error: `Transaction failed: ${JSON.stringify(status.err)}`, status };
+        }
+
+        // Check confirmation level
+        if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
+          console.log(`✅ [TxVerify] Transaction VERIFIED: ${status.confirmationStatus}`);
+          return { success: true, status };
+        }
+
+        // Transaction found but not yet confirmed, keep polling
+        console.log(`⏳ [TxVerify] Transaction pending: ${status.confirmationStatus || 'processing'}`);
+      } else {
+        console.log(`⏳ [TxVerify] Transaction not found yet, polling...`);
+      }
+    } catch (pollErr) {
+      console.warn(`⚠️ [TxVerify] Poll error (will retry): ${pollErr.message}`);
+    }
+
+    // Wait before next poll
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  // Timeout - transaction not found or not confirmed
+  console.log(`⚠️ [TxVerify] Transaction not confirmed within ${timeout}ms - REJECTING`);
+  return { success: false, error: `Transaction not confirmed within ${timeout}ms` };
+}
+
+// Board dimensions
+const ROWS = 6;
+const COLS = 7;
+const WINNING_LENGTH = 4;
+
+/**
+ * Create an empty 6x7 board
+ * Board is represented as a 2D array where:
+ * - null = empty cell
+ * - 'home' = player 1's piece
+ * - 'away' = player 2's piece
+ *
+ * Row 0 is the TOP of the board, Row 5 is the BOTTOM
+ */
+function createEmptyBoard() {
+  return Array(ROWS).fill(null).map(() => Array(COLS).fill(null));
+}
+
+/**
+ * Find the lowest empty row in a column (where a piece would land)
+ * @param {Array} board - 2D board array
+ * @param {number} col - Column index (0-6)
+ * @returns {number} Row index where piece lands, or -1 if column is full
+ */
+function getLowestEmptyRow(board, col) {
+  // Start from bottom (row 5) and work up
+  for (let row = ROWS - 1; row >= 0; row--) {
+    if (board[row][col] === null) {
+      return row;
+    }
+  }
+  return -1; // Column is full
+}
+
+/**
+ * Check if a move results in a win
+ * @param {Array} board - 2D board array (after the move)
+ * @param {number} row - Row of the last placed piece
+ * @param {number} col - Column of the last placed piece
+ * @param {string} color - 'home' or 'away'
+ * @returns {Array|null} Array of winning cells [{row, col}] or null if no win
+ */
+function checkWin(board, row, col, color) {
+  // Check all 4 directions: horizontal, vertical, diagonal-down, diagonal-up
+  const directions = [
+    { dr: 0, dc: 1 },   // horizontal
+    { dr: 1, dc: 0 },   // vertical
+    { dr: 1, dc: 1 },   // diagonal down-right
+    { dr: 1, dc: -1 },  // diagonal down-left
+  ];
+
+  for (const { dr, dc } of directions) {
+    const cells = getConnectedCells(board, row, col, dr, dc, color);
+    if (cells.length >= WINNING_LENGTH) {
+      // Return only the first 4 connected cells
+      return cells.slice(0, WINNING_LENGTH);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get all connected cells in a direction (both ways)
+ */
+function getConnectedCells(board, row, col, dr, dc, color) {
+  const cells = [{ row, col }];
+
+  // Check positive direction
+  let r = row + dr;
+  let c = col + dc;
+  while (isValidCell(r, c) && board[r][c] === color) {
+    cells.push({ row: r, col: c });
+    r += dr;
+    c += dc;
+  }
+
+  // Check negative direction
+  r = row - dr;
+  c = col - dc;
+  while (isValidCell(r, c) && board[r][c] === color) {
+    cells.unshift({ row: r, col: c });
+    r -= dr;
+    c -= dc;
+  }
+
+  return cells;
+}
+
+/**
+ * Check if cell coordinates are valid
+ */
+function isValidCell(row, col) {
+  return row >= 0 && row < ROWS && col >= 0 && col < COLS;
+}
+
+/**
+ * Check if the board is full (draw condition)
+ */
+function isBoardFull(board) {
+  // Check if top row has any empty cells
+  return board[0].every(cell => cell !== null);
+}
+
+/**
+ * Get game state from database and transform to Connect4Game format
+ * @param {string} gameId - Game ID
+ * @returns {Object} Connect4Game object
+ */
+async function getGameState(gameId) {
+  const result = await pool.query(`
+    SELECT
+      g.game_id,
+      g.game_address,
+      g.buy_in,
+      g.created_by,
+      g.game_status,
+      g.connect4_board,
+      g.connect4_current_turn,
+      g.connect4_winner,
+      g.connect4_winning_cells,
+      g.lock_timestamp,
+      g.created_at,
+      g.started_at,
+      g.completed_at,
+      g.invited_player,
+      g.image_url,
+      g.matchup_image_url,
+      -- Player 1 (creator - red)
+      u1.id as player1_user_id,
+      u1.username as player1_username,
+      u1.avatar as player1_avatar,
+      u1.wallet_address as player1_wallet,
+      -- Player 2 (joiner - yellow)
+      g.away_team_players[1] as player2_wallet,
+      u2.id as player2_user_id,
+      u2.username as player2_username,
+      u2.avatar as player2_avatar
+    FROM games g
+    LEFT JOIN users u1 ON g.created_by = u1.wallet_address
+    LEFT JOIN users u2 ON g.away_team_players[1] = u2.wallet_address
+    WHERE g.game_id = $1 AND g.game_type = 'connect4'
+  `, [gameId]);
+
+  if (result.rows.length === 0) {
+    return null;
+  }
+
+  const row = result.rows[0];
+
+  // Get board - JSONB is already parsed by node-postgres, no need for JSON.parse
+  let board;
+  if (row.connect4_board) {
+    // If it's a string (shouldn't happen with JSONB but just in case), parse it
+    board = typeof row.connect4_board === 'string'
+      ? JSON.parse(row.connect4_board)
+      : row.connect4_board;
+  } else {
+    board = createEmptyBoard();
+  }
+
+  // Get winning cells - same as above, JSONB is already parsed
+  let winningCells = null;
+  if (row.connect4_winning_cells) {
+    winningCells = typeof row.connect4_winning_cells === 'string'
+      ? JSON.parse(row.connect4_winning_cells)
+      : row.connect4_winning_cells;
+  }
+
+  // Map database status to frontend status
+  let status = 'waiting';
+  if (row.game_status === 'playing' || row.game_status === 'in_progress') {
+    status = 'playing';
+  } else if (row.game_status === 'completed' || row.game_status === 'resolved') {
+    status = 'completed';
+  } else if (row.game_status === 'cancelled') {
+    status = 'cancelled';
+  }
+
+  // Build Connect4Game object
+  // Use homePlayer/awayPlayer naming to match frontend expectations
+  const game = {
+    gameId: row.game_id,
+    gameAddress: row.game_address,
+    buyIn: parseFloat(row.buy_in),
+
+    homePlayer: {
+      walletAddress: row.player1_wallet || row.created_by,
+      username: row.player1_username || formatWallet(row.created_by),
+      avatar: row.player1_avatar || null,
+    },
+
+    awayPlayer: row.player2_wallet ? {
+      walletAddress: row.player2_wallet,
+      username: row.player2_username || formatWallet(row.player2_wallet),
+      avatar: row.player2_avatar || null,
+    } : null,
+
+    invitedPlayer: row.invited_player || null, // For visibility filtering (private games)
+    imageUrl: row.image_url || null,
+    matchupImageUrl: row.matchup_image_url || null,
+
+    status,
+    board,
+    currentTurn: row.connect4_current_turn || 'home',
+
+    winner: row.connect4_winner || null,
+    winningCells,
+    winnerWallet: null, // Will be set below if there's a winner
+    winnerUsername: null,
+    winnerPrize: row.connect4_winner ? parseFloat(row.buy_in) * 2 * 0.99 : null, // 1% fee
+
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+    // Lock timestamp: stored value or computed as created_at + 130 seconds (2 min 10 sec)
+    lockTimestamp: row.lock_timestamp
+      ? parseInt(row.lock_timestamp)
+      : (row.created_at ? Math.floor(new Date(row.created_at).getTime() / 1000) + 130 : null),
+  };
+
+  // Set winner info
+  if (row.connect4_winner === 'home' && game.homePlayer) {
+    game.winnerWallet = game.homePlayer.walletAddress;
+    game.winnerUsername = game.homePlayer.username;
+  } else if (row.connect4_winner === 'away' && game.awayPlayer) {
+    game.winnerWallet = game.awayPlayer.walletAddress;
+    game.winnerUsername = game.awayPlayer.username;
+  } else if (row.connect4_winner === 'draw') {
+    game.winnerWallet = 'draw';
+    game.winnerUsername = 'Draw';
+  }
+
+  return game;
+}
+
+/**
+ * Process a move
+ * @param {string} gameId - Game ID
+ * @param {string} walletAddress - Wallet of player making the move
+ * @param {number} column - Column to drop piece (0-6)
+ * @returns {Object} Result with board, move details, win info
+ */
+async function processMove(gameId, walletAddress, column) {
+  // Get current game state
+  const game = await getGameState(gameId);
+
+  if (!game) {
+    throw new Error('Game not found');
+  }
+
+  // Allow moves when playing OR waiting (creator can make opening moves while waiting for opponent)
+  if (game.status !== 'playing' && game.status !== 'waiting') {
+    throw new Error(`Game is not in progress (status: ${game.status})`);
+  }
+
+  // Determine player's color
+  let playerColor;
+  if (game.homePlayer?.walletAddress === walletAddress) {
+    playerColor = 'home';
+  } else if (game.awayPlayer?.walletAddress === walletAddress) {
+    playerColor = 'away';
+  } else {
+    throw new Error('You are not a player in this game');
+  }
+
+  // Check if it's their turn
+  if (game.currentTurn !== playerColor) {
+    throw new Error(`Not your turn. Current turn: ${game.currentTurn}`);
+  }
+
+  // Validate column
+  if (column < 0 || column >= COLS) {
+    throw new Error(`Invalid column: ${column}. Must be 0-6`);
+  }
+
+  // Find where piece lands
+  const row = getLowestEmptyRow(game.board, column);
+  if (row === -1) {
+    throw new Error('Column is full');
+  }
+
+  // Make the move
+  const board = game.board.map(r => [...r]); // Deep copy
+  board[row][column] = playerColor;
+
+  // Check for win
+  const winningCells = checkWin(board, row, column, playerColor);
+  const isWin = winningCells !== null;
+
+  // Check for draw
+  const isDraw = !isWin && isBoardFull(board);
+
+  // Determine next turn
+  const nextTurn = playerColor === 'home' ? 'away' : 'home';
+
+  // Determine game result
+  let winner = null;
+  let newStatus = 'playing';
+
+  if (isWin) {
+    winner = playerColor;
+    newStatus = 'completed';
+  } else if (isDraw) {
+    winner = 'draw';
+    newStatus = 'completed';
+  }
+
+  // Update database
+  await pool.query(`
+    UPDATE games SET
+      connect4_board = $1,
+      connect4_current_turn = $2,
+      connect4_winner = $3,
+      connect4_winning_cells = $4,
+      game_status = $5,
+      completed_at = $6,
+      updated_at = NOW()
+    WHERE game_id = $7
+  `, [
+    JSON.stringify(board),
+    isWin || isDraw ? null : nextTurn,
+    winner,
+    winningCells ? JSON.stringify(winningCells) : null,
+    newStatus,
+    (isWin || isDraw) ? new Date() : null,
+    gameId,
+  ]);
+
+  // Get winner info if game ended
+  let winnerWallet = null;
+  let winnerUsername = null;
+  let winnerPrize = null;
+
+  if (isWin) {
+    if (playerColor === 'home') {
+      winnerWallet = game.homePlayer.walletAddress;
+      winnerUsername = game.homePlayer.username;
+    } else {
+      winnerWallet = game.awayPlayer.walletAddress;
+      winnerUsername = game.awayPlayer.username;
+    }
+    winnerPrize = game.buyIn * 2 * 0.95; // 5% total fee (1% oracle, 4% operator)
+    console.log(`🔴🟡 [Connect4] Game ended with win! Winner: ${winnerUsername} (${winnerWallet})`);
+    // NOTE: Payout is NOT automatic - winner must claim via /api/connect4/claim
+  } else if (isDraw) {
+    console.log(`🔴🟡 [Connect4] Game ended in draw! Players can claim refund via /api/connect4/claim`);
+    // NOTE: Refund is NOT automatic - players must claim via /api/connect4/claim
+  }
+
+  return {
+    gameId,
+    column,
+    row,
+    color: playerColor,
+    board,
+    currentTurn: isWin || isDraw ? null : nextTurn,
+    winner,
+    winningCells,
+    winnerWallet,
+    winnerUsername,
+    winnerPrize,
+    isDraw,
+    isGameOver: isWin || isDraw,
+  };
+}
+
+/**
+ * Format wallet address for display
+ */
+function formatWallet(wallet) {
+  if (!wallet) return 'Unknown';
+  return `${wallet.slice(0, 4)}...${wallet.slice(-4)}`;
+}
+
+/**
+ * Resolve a Connect4 game on-chain and distribute winnings
+ * @param {string} gameId - Game ID (c4-xxxxx format)
+ * @param {string} winner - 'home', 'away', or 'draw'
+ * @param {string} winnerWallet - Wallet address of the winner (null for draw)
+ * @returns {Object} Result with signature or error
+ */
+async function resolveGame(gameId, winner, winnerWallet) {
+  console.log(`🔴🟡 [Connect4] Resolving game ${gameId} - Winner: ${winner}`);
+
+  // Ensure Solana is initialized
+  initializeSolana();
+
+  if (!oracleKeypair) {
+    console.error('❌ [Connect4] Cannot resolve: No oracle keypair available');
+    return { success: false, error: 'Oracle keypair not available' };
+  }
+
+  try {
+    // Get game address and buy-in from database
+    const gameResult = await pool.query(
+      'SELECT game_address, created_by, buy_in FROM games WHERE game_id = $1',
+      [gameId]
+    );
+
+    if (gameResult.rows.length === 0) {
+      throw new Error('Game not found in database');
+    }
+
+    const { game_address, created_by, buy_in } = gameResult.rows[0];
+
+    // Look up referrer for the game creator (for 1% commission)
+    let referrerWallet = null;
+    try {
+      // Find referrer by matching creator's referral_code to referrer's my_referral_code
+      const referrerResult = await pool.query(`
+        SELECT referrer.wallet_address as referrer_wallet
+        FROM users creator
+        JOIN users referrer ON creator.referral_code = referrer.my_referral_code
+        WHERE creator.wallet_address = $1
+          AND creator.referral_code IS NOT NULL`,
+        [created_by]
+      );
+      if (referrerResult.rows.length > 0 && referrerResult.rows[0].referrer_wallet) {
+        referrerWallet = referrerResult.rows[0].referrer_wallet;
+        console.log(`🔴🟡 [Connect4] Found referrer for creator: ${referrerWallet}`);
+      }
+    } catch (refErr) {
+      console.warn('⚠️ [Connect4] Could not look up referrer:', refErr.message);
+    }
+
+    // Convert gameId to u64 for on-chain
+    const hash = crypto.createHash('sha256').update(gameId).digest();
+    const gameIdNum = hash.readBigUInt64LE(0);
+    const gameIdBuf = Buffer.alloc(8);
+    gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+    // Get game PDA
+    const [gamePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from("game"), gameIdBuf],
+      PROGRAM_ID
+    );
+
+    console.log(`🔴🟡 [Connect4] Game PDA: ${gamePDA.toString()}`);
+
+    // Encode winning team
+    // Connect4: red = player1 = home, yellow = player2 = away
+    let winningTeamBytes;
+    if (winner === 'draw' || winner === null) {
+      winningTeamBytes = Buffer.from([0]); // None - refund all
+      console.log(`🔴🟡 [Connect4] Encoding winner: DRAW (refund)`);
+    } else if (winner === 'home') {
+      winningTeamBytes = Buffer.from([1, 0]); // Some(Home)
+      console.log(`🔴🟡 [Connect4] Encoding winner: HOME`);
+    } else if (winner === 'away') {
+      winningTeamBytes = Buffer.from([1, 1]); // Some(Away)
+      console.log(`🔴🟡 [Connect4] Encoding winner: AWAY`);
+    } else {
+      console.error(`⚠️ [Connect4] Unexpected winner value: ${winner}, defaulting to refund`);
+      winningTeamBytes = Buffer.from([0]); // None - refund all
+    }
+
+    // Build instruction data
+    const data = Buffer.concat([
+      RESOLVE_AUTO_DISCRIMINATOR,
+      gameIdBuf,
+      winningTeamBytes
+    ]);
+
+    // Build accounts
+    const keys = [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: oracleKeypair.publicKey, isSigner: true, isWritable: true }, // Oracle receives 1% fee
+      { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true }, // Operator receives 4% (or 5% if no referrer)
+    ];
+
+    // Add referrer if exists (receives 1% commission)
+    if (referrerWallet) {
+      try {
+        const referrerPubkey = new PublicKey(referrerWallet);
+        keys.push({ pubkey: referrerPubkey, isSigner: false, isWritable: true });
+        console.log(`🔴🟡 [Connect4] Added referrer to transaction: ${referrerWallet}`);
+      } catch (e) {
+        console.warn(`⚠️ [Connect4] Invalid referrer wallet: ${referrerWallet}`);
+      }
+    }
+
+    // Create instruction
+    const ix = new TransactionInstruction({
+      keys,
+      programId: PROGRAM_ID,
+      data,
+    });
+
+    // Build and send transaction
+    const tx = new Transaction().add(ix);
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = oracleKeypair.publicKey;
+    tx.sign(oracleKeypair);
+
+    const signature = await connection.sendRawTransaction(tx.serialize());
+    console.log(`🔴🟡 [Connect4] Resolve tx sent: ${signature}, waiting for confirmation...`);
+
+    // Wait for confirmation using polling (Alchemy-compatible, no WebSocket)
+    try {
+      await pollTransactionConfirmation(connection, signature, lastValidBlockHeight, 30000);
+      console.log(`✅ [Connect4] Game ${gameId} resolved on-chain! Signature: ${signature}`);
+    } catch (confirmErr) {
+      // Check if it's already resolved (common case)
+      if (confirmErr.message?.includes('AlreadyResolved')) {
+        console.log(`🔴🟡 [Connect4] Game already resolved, continuing...`);
+      } else {
+        console.error(`❌ [Connect4] Resolve confirmation failed:`, confirmErr.message);
+        throw confirmErr;
+      }
+    }
+
+    // Update database to mark as resolved
+    await pool.query(`
+      UPDATE games SET
+        is_resolved = TRUE,
+        claim_signature = $1,
+        resolved_at = NOW(),
+        updated_at = NOW()
+      WHERE game_id = $2
+    `, [signature, gameId]);
+
+    console.log(`✅ [Connect4] Database updated: is_resolved=true, claim_signature=${signature}`);
+
+    // Update winner's user_game_refs with claim_signature for transaction history linking
+    if (winnerWallet) {
+      await pool.query(`
+        UPDATE user_game_refs SET
+          claim_signature = $1,
+          claimed_at = NOW(),
+          updated_at = NOW()
+        WHERE game_id = $2 AND wallet_address = $3
+      `, [signature, gameId, winnerWallet]);
+      console.log(`✅ [Connect4] Winner's user_game_refs updated with claim_signature`);
+    }
+
+    // Record referral earning with payout signature (if referrer was paid)
+    if (referrerWallet) {
+      try {
+        // Calculate commission: 1% of total pot (buy_in * 2 for 2-player Connect4)
+        const potSizeLamports = Math.floor(parseFloat(buy_in) * 2 * 1e9);
+        const commissionLamports = Math.floor(potSizeLamports * 0.01);
+
+        // Record the on-chain commission (creates record if doesn't exist)
+        await referralEarningsService.recordOnChainCommission(
+          gameId,
+          referrerWallet,
+          commissionLamports,
+          true, // paidOnChain
+          signature, // txSignature
+          'connect4' // gameType
+        );
+        console.log(`✅ [Connect4] Referral earning recorded: ${commissionLamports / 1e9} SOL to ${referrerWallet.slice(0, 8)}...`);
+      } catch (refErr) {
+        console.warn('⚠️ [Connect4] Failed to record referral earning:', refErr.message);
+      }
+    }
+
+    return { success: true, signature };
+
+  } catch (error) {
+    console.error(`❌ [Connect4] Failed to resolve game ${gameId}:`, error.message);
+
+    // Check if game was already resolved on-chain (error 6033)
+    if (error.message && error.message.includes('AlreadyResolved')) {
+      console.log(`🔴🟡 [Connect4] Game ${gameId} was already resolved on-chain, updating database`);
+      try {
+        await pool.query(`
+          UPDATE games SET
+            is_resolved = TRUE,
+            game_status = 'completed',
+            completed_at = COALESCE(completed_at, NOW()),
+            updated_at = NOW()
+          WHERE game_id = $1
+        `, [gameId]);
+        return { success: true, alreadyResolved: true, message: 'Game was already resolved on-chain' };
+      } catch (dbErr) {
+        console.error('❌ [Connect4] Failed to update database after AlreadyResolved:', dbErr.message);
+      }
+    }
+
+    // Even if on-chain fails, mark the game as completed in database
+    try {
+      await pool.query(`
+        UPDATE games SET
+          game_status = 'completed',
+          completed_at = NOW(),
+          updated_at = NOW()
+        WHERE game_id = $1
+      `, [gameId]);
+    } catch (dbErr) {
+      console.error('❌ [Connect4] Failed to update database:', dbErr.message);
+    }
+
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Initialize database columns for Connect4 if not present
+ */
+async function initializeConnect4Columns() {
+  try {
+    // Add Connect4 specific columns if they don't exist
+    await pool.query(`
+      DO $$
+      BEGIN
+        -- Add connect4_board column
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'connect4_board') THEN
+          ALTER TABLE games ADD COLUMN connect4_board JSONB;
+        END IF;
+
+        -- Add connect4_current_turn column
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'connect4_current_turn') THEN
+          ALTER TABLE games ADD COLUMN connect4_current_turn VARCHAR(10) DEFAULT 'home';
+        END IF;
+
+        -- Add connect4_winner column
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'connect4_winner') THEN
+          ALTER TABLE games ADD COLUMN connect4_winner VARCHAR(10);
+        END IF;
+
+        -- Add connect4_winning_cells column
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'connect4_winning_cells') THEN
+          ALTER TABLE games ADD COLUMN connect4_winning_cells JSONB;
+        END IF;
+
+        -- Add started_at column if missing
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'started_at') THEN
+          ALTER TABLE games ADD COLUMN started_at TIMESTAMP;
+        END IF;
+
+        -- Add completed_at column if missing
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'completed_at') THEN
+          ALTER TABLE games ADD COLUMN completed_at TIMESTAMP;
+        END IF;
+
+        -- Add game_status column if missing
+        IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+                       WHERE table_name = 'games' AND column_name = 'game_status') THEN
+          ALTER TABLE games ADD COLUMN game_status VARCHAR(20) DEFAULT 'waiting';
+        END IF;
+      END $$;
+    `);
+    console.log('🔴🟡 Connect4 database columns initialized');
+  } catch (error) {
+    console.error('Failed to initialize Connect4 columns:', error);
+    throw error;
+  }
+}
+
+/**
+ * Start a game (called when player 2 joins)
+ * Sets status to 'playing' but preserves existing board and turn
+ * (creator may have made opening moves while waiting)
+ */
+async function startGame(gameId) {
+  console.log(`[startGame] 🔴🟡 Starting game ${gameId}...`);
+
+  // Get current game state to preserve any existing moves
+  const currentGame = await getGameState(gameId);
+
+  console.log(`[startGame] Current game state BEFORE update:`);
+  console.log(`[startGame]   - status: ${currentGame?.status}`);
+  console.log(`[startGame]   - currentTurn: ${currentGame?.currentTurn}`);
+  console.log(`[startGame]   - board has moves: ${JSON.stringify(currentGame?.board) !== JSON.stringify(createEmptyBoard())}`);
+
+  // Check raw DB values
+  const rawResult = await pool.query(
+    'SELECT connect4_board, connect4_current_turn, game_status FROM games WHERE game_id = $1',
+    [gameId]
+  );
+  const rawRow = rawResult.rows[0];
+  console.log(`[startGame] Raw DB values:`);
+  console.log(`[startGame]   - connect4_board: ${rawRow?.connect4_board ? 'HAS VALUE' : 'NULL'}`);
+  console.log(`[startGame]   - connect4_current_turn: ${rawRow?.connect4_current_turn}`);
+  console.log(`[startGame]   - game_status: ${rawRow?.game_status}`);
+
+  // Use existing board if moves were made, otherwise create empty
+  const board = currentGame?.board || createEmptyBoard();
+  // Preserve current turn (don't reset to red if moves were made)
+  const currentTurn = currentGame?.currentTurn || 'home';
+
+  console.log(`[startGame] Values to use in COALESCE fallback:`);
+  console.log(`[startGame]   - board: ${JSON.stringify(board) === JSON.stringify(createEmptyBoard()) ? 'EMPTY' : 'HAS MOVES'}`);
+  console.log(`[startGame]   - currentTurn: ${currentTurn}`);
+
+  await pool.query(`
+    UPDATE games SET
+      game_status = 'playing',
+      connect4_board = COALESCE(connect4_board, $1),
+      connect4_current_turn = COALESCE(connect4_current_turn, $2),
+      started_at = NOW(),
+      updated_at = NOW()
+    WHERE game_id = $3
+  `, [JSON.stringify(board), currentTurn, gameId]);
+
+  const finalGame = await getGameState(gameId);
+
+  console.log(`[startGame] Game state AFTER update:`);
+  console.log(`[startGame]   - status: ${finalGame?.status}`);
+  console.log(`[startGame]   - currentTurn: ${finalGame?.currentTurn}`);
+  console.log(`[startGame]   - board has moves: ${JSON.stringify(finalGame?.board) !== JSON.stringify(createEmptyBoard())}`);
+
+  return finalGame;
+}
+
+/**
+ * Claim prize for a completed Connect4 game
+ * Called by the winner (or any player for a draw)
+ * @param {string} gameId - Game ID
+ * @param {string} walletAddress - Wallet address of the claimer
+ * @returns {Object} Result with signature or error
+ */
+async function claimPrize(gameId, walletAddress) {
+  const logPrefix = `[Connect4 ClaimPrize ${gameId}]`;
+  console.log(`${logPrefix} ====== SERVICE STARTED ======`);
+  console.log(`${logPrefix} Claimer wallet: ${walletAddress}`);
+
+  // Get game state
+  console.log(`${logPrefix} Fetching game state...`);
+  const game = await getGameState(gameId);
+
+  if (!game) {
+    console.log(`${logPrefix} ❌ Game not found`);
+    return { success: false, error: 'Game not found' };
+  }
+
+  console.log(`${logPrefix} Game state:`, JSON.stringify({
+    status: game.status,
+    winner: game.winner,
+    homePlayer: game.homePlayer?.walletAddress,
+    awayPlayer: game.awayPlayer?.walletAddress,
+    buyIn: game.buyIn,
+    winnerWallet: game.winnerWallet,
+  }));
+
+  if (game.status !== 'completed' && game.status !== 'cancelled') {
+    console.log(`${logPrefix} ❌ Invalid game status: ${game.status}`);
+    return { success: false, error: 'Game is not completed yet' };
+  }
+
+  // Check if already resolved on-chain
+  console.log(`${logPrefix} Checking if already resolved...`);
+  const claimCheck = await pool.query(
+    'SELECT is_resolved, claim_signature FROM games WHERE game_id = $1',
+    [gameId]
+  );
+
+  const isResolved = claimCheck.rows[0]?.is_resolved;
+  const existingSignature = claimCheck.rows[0]?.claim_signature;
+  console.log(`${logPrefix} Resolution status: is_resolved=${isResolved}, has_signature=${!!existingSignature}`);
+
+  // If game is already resolved on-chain, skip resolution and return success
+  // The endpoint will build a claim transaction for the user to sign
+  if (isResolved) {
+    console.log(`${logPrefix} ✅ Already resolved, returning existing signature`);
+    console.log(`${logPrefix} ====== SERVICE SUCCESS (already resolved) ======`);
+    return {
+      success: true,
+      alreadyResolved: true,
+      signature: existingSignature,
+      message: 'Game resolved, sign transaction to claim prize',
+    };
+  }
+
+  // Verify the claimer is authorized
+  const isHomePlayer = game.homePlayer?.walletAddress === walletAddress;
+  const isAwayPlayer = game.awayPlayer?.walletAddress === walletAddress;
+  console.log(`${logPrefix} Authorization check: isHomePlayer=${isHomePlayer}, isAwayPlayer=${isAwayPlayer}`);
+
+  if (!isHomePlayer && !isAwayPlayer) {
+    console.log(`${logPrefix} ❌ Claimer not a player in this game`);
+    console.log(`${logPrefix} Claimer: ${walletAddress}`);
+    console.log(`${logPrefix} Home: ${game.homePlayer?.walletAddress}`);
+    console.log(`${logPrefix} Away: ${game.awayPlayer?.walletAddress}`);
+    return { success: false, error: 'You are not a player in this game' };
+  }
+
+  // For wins, only the winner can claim
+  // For cancelled games (winner=null) or draws, anyone can claim their refund
+  console.log(`${logPrefix} Winner check: game.winner=${game.winner}`);
+  if (game.winner !== 'draw' && game.winner !== null) {
+    const winnerWalletCheck = game.winner === 'home'
+      ? game.homePlayer?.walletAddress
+      : game.awayPlayer?.walletAddress;
+
+    console.log(`${logPrefix} Winner wallet: ${winnerWalletCheck}`);
+    if (walletAddress !== winnerWalletCheck) {
+      console.log(`${logPrefix} ❌ Claimer is not the winner`);
+      return { success: false, error: 'Only the winner can claim the prize' };
+    }
+  } else {
+    console.log(`${logPrefix} Game is draw/cancelled - any player can claim refund`);
+  }
+
+  // Attempt to resolve the game on-chain
+  const winnerWallet = game.winner === 'draw' || game.winner === null
+    ? null
+    : (game.winner === 'home' ? game.homePlayer?.walletAddress : game.awayPlayer?.walletAddress);
+
+  console.log(`${logPrefix} Calling resolveGame with winner=${game.winner}, winnerWallet=${winnerWallet}...`);
+  const resolveStartTime = Date.now();
+  const result = await resolveGame(gameId, game.winner, winnerWallet);
+  console.log(`${logPrefix} resolveGame completed in ${Date.now() - resolveStartTime}ms`);
+  console.log(`${logPrefix} resolveGame result:`, JSON.stringify({
+    success: result.success,
+    alreadyResolved: result.alreadyResolved,
+    signature: result.signature,
+    error: result.error,
+  }));
+
+  if (result.success) {
+    console.log(`${logPrefix} ====== SERVICE SUCCESS ======`);
+    return {
+      success: true,
+      alreadyResolved: result.alreadyResolved || false,
+      signature: result.signature,
+      message: result.alreadyResolved
+        ? 'Game already resolved - prize ready to claim!'
+        : (game.winner === 'draw' || game.winner === null ? 'Refund processed!' : 'Prize claimed successfully!'),
+    };
+  } else {
+    console.log(`${logPrefix} ❌ resolveGame failed: ${result.error}`);
+    console.log(`${logPrefix} ====== SERVICE FAILED ======`);
+    return { success: false, error: result.error || 'Failed to claim prize' };
+  }
+}
+
+module.exports = {
+  createEmptyBoard,
+  getLowestEmptyRow,
+  checkWin,
+  isBoardFull,
+  getGameState,
+  processMove,
+  resolveGame,
+  claimPrize,
+  initializeConnect4Columns,
+  initializeSolana,
+  startGame,
+  verifyTransactionSuccess,
+  ROWS,
+  COLS,
+};