dubs-server 1.0.0

package/scripts/test-connect4-e2e.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+/**
+ * End-to-End Test: Connect4 Create -> Cancel -> Claim
+ *
+ * This test validates the full flow with the polling confirmation fix.
+ *
+ * Usage:
+ *   node test-connect4-e2e.js
+ */
+
+require('dotenv').config();
+const { Connection, Keypair, Transaction, PublicKey, LAMPORTS_PER_SOL } = require('@solana/web3.js');
+const { pool } = require('../services/db');
+const axios = require('axios');
+const jwt = require('jsonwebtoken');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const RPC_URL = process.env.SOLANA_RPC_URL || process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+const SERVER_URL = process.env.TEST_SERVER_URL || 'http://localhost:3001';
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret-change-in-production';
+
+console.log('🧪 Connect4 End-to-End Test');
+console.log('===========================');
+console.log(`RPC URL: ${RPC_URL}`);
+console.log(`Server URL: ${SERVER_URL}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Load or create test wallet
+ */
+function getTestWallet() {
+  const testWalletPath = path.join(__dirname, '../wallets/test-wallet.json');
+
+  // Try to load existing test wallet
+  if (fs.existsSync(testWalletPath)) {
+    console.log('📂 Loading existing test wallet...');
+    const secretKey = JSON.parse(fs.readFileSync(testWalletPath, 'utf-8'));
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+
+  // Try oracle wallet for testing
+  if (process.env.ORACLE_WALLET_JSON) {
+    console.log('📂 Using oracle wallet for testing...');
+    const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+
+  // Try operator wallet
+  if (process.env.OPERATOR_WALLET_JSON) {
+    console.log('📂 Using operator wallet for testing...');
+    const secretKey = JSON.parse(process.env.OPERATOR_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+
+  throw new Error('No test wallet found. Create one at wallets/test-wallet.json');
+}
+
+/**
+ * Ensure user exists in database
+ */
+async function ensureUserExists(walletAddress) {
+  const existing = await pool.query(
+    'SELECT wallet_address FROM users WHERE wallet_address = $1',
+    [walletAddress]
+  );
+
+  if (existing.rows.length === 0) {
+    console.log(`   Creating user in database: ${walletAddress.slice(0, 16)}...`);
+    await pool.query(
+      'INSERT INTO users (wallet_address, username) VALUES ($1, $2)',
+      [walletAddress, `test-${walletAddress.slice(0, 8)}`]
+    );
+  }
+}
+
+/**
+ * Generate JWT token for testing
+ */
+function generateTestToken(walletAddress) {
+  return jwt.sign(
+    { walletAddress, type: 'auth' },
+    JWT_SECRET,
+    { expiresIn: '1h' }
+  );
+}
+
+/**
+ * Check wallet balance
+ */
+async function checkBalance(walletAddress) {
+  const balance = await connection.getBalance(new PublicKey(walletAddress));
+  const solBalance = balance / LAMPORTS_PER_SOL;
+  console.log(`   Balance: ${solBalance.toFixed(4)} SOL`);
+  return solBalance;
+}
+
+/**
+ * Step 1: Create Connect4 game
+ */
+async function createGame(wallet, authToken) {
+  console.log('\n📋 Step 1: Create Connect4 Game');
+  console.log('--------------------------------');
+
+  const walletAddress = wallet.publicKey.toString();
+  console.log(`   Creator: ${walletAddress.slice(0, 16)}...`);
+
+  // Build the game transaction
+  const response = await axios.post(
+    `${SERVER_URL}/api/v1/prod/transaction/build/create-connect4-game`,
+    {
+      creatorAddress: walletAddress,
+      buyIn: 0.01, // Small amount for testing
+    },
+    { headers: { 'Content-Type': 'application/json' } }
+  );
+
+  if (!response.data.success) {
+    throw new Error(`Failed to build game: ${response.data.error}`);
+  }
+
+  const { gameId, gameAddress, transaction: txBase64 } = response.data;
+  console.log(`   Game ID: ${gameId}`);
+  console.log(`   Game PDA: ${gameAddress}`);
+
+  // Deserialize and sign the transaction
+  const txBuffer = Buffer.from(txBase64, 'base64');
+  const tx = Transaction.from(txBuffer);
+  tx.sign(wallet);
+
+  // Send the signed transaction
+  console.log(`   Sending transaction...`);
+  const signature = await connection.sendRawTransaction(tx.serialize(), {
+    skipPreflight: false,
+    preflightCommitment: 'confirmed',
+  });
+  console.log(`   Signature: ${signature}`);
+
+  // Wait for confirmation using polling
+  console.log(`   Waiting for confirmation (polling)...`);
+  await pollConfirmation(signature);
+
+  // Record the game in the database
+  await pool.query(`
+    INSERT INTO games (game_id, game_address, game_type, created_by, buy_in, game_status, max_players, game_mode)
+    VALUES ($1, $2, 'connect4', $3, $4, 'waiting', 2, 1)
+    ON CONFLICT (game_id) DO UPDATE SET game_status = 'waiting'
+  `, [gameId, gameAddress, walletAddress, 0.01]);
+
+  // Record user_game_ref
+  await pool.query(`
+    INSERT INTO user_game_refs (wallet_address, game_id, role, team_choice, my_signature)
+    VALUES ($1, $2, 'creator', 'home', $3)
+    ON CONFLICT (wallet_address, game_id) DO NOTHING
+  `, [walletAddress, gameId, signature]);
+
+  console.log(`   ✅ Game created successfully!`);
+  return { gameId, gameAddress, signature };
+}
+
+/**
+ * Step 2: Cancel the game
+ */
+async function cancelGame(gameId, authToken) {
+  console.log('\n📋 Step 2: Cancel Game');
+  console.log('-----------------------');
+  console.log(`   Game ID: ${gameId}`);
+
+  const response = await axios.post(
+    `${SERVER_URL}/api/connect4/cancel`,
+    { gameId },
+    {
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 60000
+    }
+  );
+
+  console.log(`   Response: ${JSON.stringify(response.data)}`);
+
+  if (response.data.success) {
+    console.log(`   ✅ Game cancelled successfully!`);
+    if (response.data.signature) {
+      console.log(`   Signature: ${response.data.signature}`);
+    }
+    return response.data;
+  } else {
+    throw new Error(`Cancel failed: ${response.data.error}`);
+  }
+}
+
+/**
+ * Step 3: Claim the refund
+ */
+async function claimRefund(gameId, authToken) {
+  console.log('\n📋 Step 3: Claim Refund');
+  console.log('------------------------');
+  console.log(`   Game ID: ${gameId}`);
+
+  const response = await axios.post(
+    `${SERVER_URL}/api/connect4/claim`,
+    { gameId },
+    {
+      headers: {
+        'Authorization': `Bearer ${authToken}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 60000
+    }
+  );
+
+  console.log(`   Response status: ${response.status}`);
+
+  if (response.data.transaction) {
+    console.log(`   ✅ Claim transaction built successfully!`);
+    console.log(`   Transaction ready for user to sign`);
+    return { success: true, transaction: response.data.transaction };
+  } else if (response.data.success) {
+    console.log(`   ✅ Claim processed!`);
+    return response.data;
+  } else {
+    console.log(`   Response: ${JSON.stringify(response.data)}`);
+    throw new Error(`Claim failed: ${response.data.error || 'Unknown error'}`);
+  }
+}
+
+/**
+ * Poll for transaction confirmation (Alchemy-compatible)
+ */
+async function pollConfirmation(signature, timeout = 30000) {
+  const start = Date.now();
+
+  while (Date.now() - start < timeout) {
+    const response = await connection.getSignatureStatuses([signature], {
+      searchTransactionHistory: true
+    });
+
+    const status = response?.value?.[0];
+    if (status) {
+      if (status.err) {
+        throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+      }
+      if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
+        return status;
+      }
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  throw new Error('Transaction confirmation timeout');
+}
+
+/**
+ * Verify final game state
+ */
+async function verifyFinalState(gameId) {
+  console.log('\n📋 Verifying Final State');
+  console.log('-------------------------');
+
+  const result = await pool.query(`
+    SELECT g.game_id, g.game_status, g.is_resolved, g.connect4_winner, g.claim_signature,
+           u.wallet_address, u.claimed_at, u.claim_signature as user_claim_sig
+    FROM games g
+    LEFT JOIN user_game_refs u ON g.game_id = u.game_id AND u.role = 'creator'
+    WHERE g.game_id = $1
+  `, [gameId]);
+
+  if (result.rows.length === 0) {
+    console.log(`   ❌ Game not found`);
+    return false;
+  }
+
+  const game = result.rows[0];
+  console.log(`   game_status: ${game.game_status}`);
+  console.log(`   is_resolved: ${game.is_resolved}`);
+  console.log(`   connect4_winner: ${game.connect4_winner || 'null'}`);
+  console.log(`   claim_signature: ${game.claim_signature || 'null'}`);
+
+  const passed = game.game_status === 'cancelled' && game.is_resolved === true;
+  if (passed) {
+    console.log(`   ✅ Game state is correct!`);
+  } else {
+    console.log(`   ❌ Game state is incorrect`);
+  }
+
+  return passed;
+}
+
+/**
+ * Main test execution
+ */
+async function main() {
+  let passed = 0;
+  let failed = 0;
+  let gameId = null;
+
+  try {
+    // Setup
+    const wallet = getTestWallet();
+    const walletAddress = wallet.publicKey.toString();
+    console.log(`🔑 Test wallet: ${walletAddress}`);
+
+    // Check balance
+    const balance = await checkBalance(walletAddress);
+    if (balance < 0.02) {
+      console.log(`\n⚠️  Wallet balance too low for testing.`);
+      console.log(`   Need at least 0.02 SOL, have ${balance.toFixed(4)} SOL`);
+      console.log(`   Airdrop: solana airdrop 1 ${walletAddress} --url devnet`);
+      process.exit(1);
+    }
+
+    // Ensure user exists
+    await ensureUserExists(walletAddress);
+
+    // Generate auth token
+    const authToken = generateTestToken(walletAddress);
+    console.log(`🔐 Auth token generated`);
+
+    // Step 1: Create game
+    const createResult = await createGame(wallet, authToken);
+    gameId = createResult.gameId;
+    passed++;
+
+    // Step 2: Cancel game
+    await cancelGame(gameId, authToken);
+    passed++;
+
+    // Step 3: Claim refund
+    await claimRefund(gameId, authToken);
+    passed++;
+
+    // Verify final state
+    const stateOk = await verifyFinalState(gameId);
+    if (stateOk) passed++; else failed++;
+
+  } catch (error) {
+    console.error(`\n❌ Error: ${error.message}`);
+    if (error.response?.data) {
+      console.error(`   Response: ${JSON.stringify(error.response.data)}`);
+    }
+    failed++;
+  } finally {
+    await pool.end();
+  }
+
+  // Summary
+  console.log('\n===========================');
+  console.log('📊 Test Summary');
+  console.log('===========================');
+  console.log(`   Passed: ${passed}`);
+  console.log(`   Failed: ${failed}`);
+  console.log('');
+
+  if (failed === 0) {
+    console.log('✅ All tests passed! The polling confirmation fix works.');
+  } else {
+    console.log('❌ Some tests failed. Check the output above.');
+  }
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main();