dubs-server 1.0.0

package/scripts/test-connect4-cancel-claim.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+/**
+ * Test Script: Connect4 Cancel and Claim Flow
+ *
+ * Tests the full flow of:
+ * 1. Creating a Connect4 game
+ * 2. Cancelling the game
+ * 3. Claiming the refund
+ *
+ * This validates the fix for the Alchemy WebSocket issue.
+ *
+ * Usage:
+ *   node test-connect4-cancel-claim.js                    # Run full test with new game
+ *   node test-connect4-cancel-claim.js --game-id=<id>     # Test claim on existing cancelled game
+ *   node test-connect4-cancel-claim.js --cancel-only=<id> # Just cancel an existing game
+ *   node test-connect4-cancel-claim.js --claim-only=<id>  # Just claim an existing cancelled game
+ */
+
+require('dotenv').config();
+const { Connection, Keypair, PublicKey } = require('@solana/web3.js');
+const { pool } = require('../services/db');
+const axios = require('axios');
+
+// 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 PROGRAM_ID = new PublicKey(process.env.PROGRAM_ID || '85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+// Parse args
+const args = process.argv.slice(2);
+const options = {};
+args.forEach(arg => {
+  if (arg.startsWith('--game-id=')) options.gameId = arg.split('=')[1];
+  if (arg.startsWith('--cancel-only=')) options.cancelOnly = arg.split('=')[1];
+  if (arg.startsWith('--claim-only=')) options.claimOnly = arg.split('=')[1];
+  if (arg === '--help') options.help = true;
+});
+
+console.log('🧪 Connect4 Cancel & Claim Flow Test');
+console.log('=====================================');
+console.log(`RPC URL: ${RPC_URL}`);
+console.log(`Server URL: ${SERVER_URL}`);
+console.log(`Program ID: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Get a test auth token for API calls
+ */
+async function getTestAuthToken(walletAddress) {
+  // In a real test, you'd authenticate properly
+  // For now, we'll query the database directly for an existing user
+  const result = await pool.query(
+    'SELECT dubs_auth_token FROM users WHERE wallet_address = $1 LIMIT 1',
+    [walletAddress]
+  );
+
+  if (result.rows.length > 0 && result.rows[0].dubs_auth_token) {
+    return result.rows[0].dubs_auth_token;
+  }
+
+  throw new Error(`No auth token found for wallet ${walletAddress}. User must be registered first.`);
+}
+
+/**
+ * Find a cancelled Connect4 game that hasn't been claimed
+ */
+async function findCancelledUnclaimedGame() {
+  console.log('🔍 Looking for cancelled unclaimed Connect4 games...');
+
+  const result = await pool.query(`
+    SELECT g.game_id, g.buy_in, g.is_resolved, g.connect4_winner as winner, g.game_status,
+           creator.wallet_address as creator_wallet, creator.claimed_at
+    FROM games g
+    LEFT JOIN user_game_refs creator ON g.game_id = creator.game_id AND creator.role = 'creator'
+    WHERE g.game_type = 'connect4'
+      AND g.game_status = 'cancelled'
+      AND g.is_resolved = TRUE
+      AND creator.claimed_at IS NULL
+    ORDER BY g.created_at DESC
+    LIMIT 5
+  `);
+
+  if (result.rows.length === 0) {
+    console.log('   No cancelled unclaimed games found');
+    return null;
+  }
+
+  console.log(`   Found ${result.rows.length} cancelled unclaimed game(s):`);
+  result.rows.forEach(g => {
+    console.log(`   - ${g.game_id} (creator: ${g.creator_wallet?.slice(0, 8)}..., buy_in: ${g.buy_in})`);
+  });
+
+  return result.rows[0];
+}
+
+/**
+ * Find an active Connect4 game that can be cancelled
+ */
+async function findActiveCancellableGame() {
+  console.log('🔍 Looking for active Connect4 games that can be cancelled...');
+
+  const result = await pool.query(`
+    SELECT g.game_id, g.buy_in, g.game_status,
+           creator.wallet_address as creator_wallet
+    FROM games g
+    LEFT JOIN user_game_refs creator ON g.game_id = creator.game_id AND creator.role = 'creator'
+    WHERE g.game_type = 'connect4'
+      AND g.game_status IN ('waiting', 'pending')
+      AND g.is_resolved = FALSE
+    ORDER BY g.created_at DESC
+    LIMIT 5
+  `);
+
+  if (result.rows.length === 0) {
+    console.log('   No cancellable games found');
+    return null;
+  }
+
+  console.log(`   Found ${result.rows.length} cancellable game(s):`);
+  result.rows.forEach(g => {
+    console.log(`   - ${g.game_id} (status: ${g.game_status}, creator: ${g.creator_wallet?.slice(0, 8)}...)`);
+  });
+
+  return result.rows[0];
+}
+
+/**
+ * Test cancelling a Connect4 game via API
+ */
+async function testCancelGame(gameId, creatorWallet) {
+  console.log(`\n📋 Test: Cancel Connect4 Game`);
+  console.log('------------------------------');
+  console.log(`   Game ID: ${gameId}`);
+  console.log(`   Creator: ${creatorWallet}`);
+
+  try {
+    const authToken = await getTestAuthToken(creatorWallet);
+    console.log(`   Auth token: ${authToken.slice(0, 20)}...`);
+
+    console.log(`   Calling POST ${SERVER_URL}/api/connect4/cancel...`);
+
+    const response = await axios.post(
+      `${SERVER_URL}/api/connect4/cancel`,
+      { gameId },
+      {
+        headers: {
+          'Authorization': `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        },
+        timeout: 60000 // 60 second timeout for on-chain confirmation
+      }
+    );
+
+    console.log(`   Response status: ${response.status}`);
+    console.log(`   Response data: ${JSON.stringify(response.data, null, 2)}`);
+
+    if (response.data.success) {
+      console.log(`\n✅ CANCEL TEST PASSED`);
+      console.log(`   Signature: ${response.data.signature || 'N/A'}`);
+      return { success: true, signature: response.data.signature };
+    } else {
+      console.log(`\n❌ CANCEL TEST FAILED: ${response.data.error || 'Unknown error'}`);
+      return { success: false, error: response.data.error };
+    }
+  } catch (error) {
+    const errorMsg = error.response?.data?.error || error.message;
+    console.error(`\n❌ CANCEL TEST FAILED: ${errorMsg}`);
+
+    if (error.response?.data) {
+      console.log(`   Full response: ${JSON.stringify(error.response.data, null, 2)}`);
+    }
+
+    return { success: false, error: errorMsg };
+  }
+}
+
+/**
+ * Test claiming a Connect4 refund via API
+ */
+async function testClaimRefund(gameId, playerWallet) {
+  console.log(`\n📋 Test: Claim Connect4 Refund`);
+  console.log('-------------------------------');
+  console.log(`   Game ID: ${gameId}`);
+  console.log(`   Player: ${playerWallet}`);
+
+  try {
+    const authToken = await getTestAuthToken(playerWallet);
+    console.log(`   Auth token: ${authToken.slice(0, 20)}...`);
+
+    console.log(`   Calling POST ${SERVER_URL}/api/connect4/claim...`);
+
+    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}`);
+    console.log(`   Response data: ${JSON.stringify(response.data, null, 2)}`);
+
+    if (response.data.success || response.data.transaction) {
+      console.log(`\n✅ CLAIM API TEST PASSED`);
+      console.log(`   Transaction returned for user to sign`);
+
+      // The claim endpoint returns a transaction for the user to sign
+      // In a real test, we'd sign and send it
+      return { success: true, transaction: response.data.transaction };
+    } else {
+      console.log(`\n❌ CLAIM TEST FAILED: ${response.data.error || 'Unknown error'}`);
+      return { success: false, error: response.data.error };
+    }
+  } catch (error) {
+    const errorMsg = error.response?.data?.error || error.message;
+    console.error(`\n❌ CLAIM TEST FAILED: ${errorMsg}`);
+
+    if (error.response?.data) {
+      console.log(`   Full response: ${JSON.stringify(error.response.data, null, 2)}`);
+    }
+
+    return { success: false, error: errorMsg };
+  }
+}
+
+/**
+ * Verify game state in database
+ */
+async function verifyGameState(gameId) {
+  console.log(`\n📋 Verifying game state in database...`);
+
+  const result = await pool.query(`
+    SELECT
+      g.game_id, g.game_status, g.connect4_winner as winner, g.is_resolved,
+      g.claim_signature, g.buy_in,
+      creator.wallet_address as creator_wallet, creator.claimed_at
+    FROM games g
+    LEFT JOIN user_game_refs creator ON g.game_id = creator.game_id AND creator.role = 'creator'
+    WHERE g.game_id = $1
+  `, [gameId]);
+
+  if (result.rows.length === 0) {
+    console.log(`   ❌ Game not found in database`);
+    return null;
+  }
+
+  const game = result.rows[0];
+  console.log(`   Game ID: ${game.game_id}`);
+  console.log(`   Status: ${game.game_status}`);
+  console.log(`   Winner: ${game.winner || 'null'}`);
+  console.log(`   is_resolved: ${game.is_resolved}`);
+  console.log(`   claimed_at: ${game.claimed_at || 'null'}`);
+  console.log(`   claim_signature: ${game.claim_signature || 'null'}`);
+  console.log(`   Creator: ${game.creator_wallet}`);
+  console.log(`   Buy-in: ${game.buy_in}`);
+
+  return game;
+}
+
+/**
+ * Main test execution
+ */
+async function main() {
+  if (options.help) {
+    console.log('Usage:');
+    console.log('  node test-connect4-cancel-claim.js                    # Auto-find and test');
+    console.log('  node test-connect4-cancel-claim.js --cancel-only=<id> # Just cancel');
+    console.log('  node test-connect4-cancel-claim.js --claim-only=<id>  # Just claim');
+    console.log('  node test-connect4-cancel-claim.js --game-id=<id>     # Full flow on specific game');
+    process.exit(0);
+  }
+
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    // Test 1: Cancel only
+    if (options.cancelOnly) {
+      const game = await verifyGameState(options.cancelOnly);
+      if (game) {
+        const result = await testCancelGame(options.cancelOnly, game.creator_wallet);
+        if (result.success) passed++; else failed++;
+        await verifyGameState(options.cancelOnly);
+      } else {
+        failed++;
+      }
+    }
+    // Test 2: Claim only
+    else if (options.claimOnly) {
+      const game = await verifyGameState(options.claimOnly);
+      if (game) {
+        const result = await testClaimRefund(options.claimOnly, game.creator_wallet);
+        if (result.success) passed++; else failed++;
+        await verifyGameState(options.claimOnly);
+      } else {
+        failed++;
+      }
+    }
+    // Test 3: Full flow - find or use provided game
+    else {
+      // First, try to find a cancelled unclaimed game to test claim
+      let game = await findCancelledUnclaimedGame();
+
+      if (game) {
+        console.log(`\n🎯 Testing claim on cancelled game: ${game.game_id}`);
+        const claimResult = await testClaimRefund(game.game_id, game.creator_wallet);
+        if (claimResult.success) passed++; else failed++;
+        await verifyGameState(game.game_id);
+      } else {
+        console.log('\n⚠️  No cancelled unclaimed games found to test claim.');
+
+        // Try to find an active game to cancel first
+        const activeGame = await findActiveCancellableGame();
+        if (activeGame) {
+          console.log(`\n🎯 Testing cancel + claim flow on: ${activeGame.game_id}`);
+
+          // Cancel it
+          const cancelResult = await testCancelGame(activeGame.game_id, activeGame.creator_wallet);
+          if (cancelResult.success) {
+            passed++;
+
+            // Now test claim
+            const claimResult = await testClaimRefund(activeGame.game_id, activeGame.creator_wallet);
+            if (claimResult.success) passed++; else failed++;
+          } else {
+            failed++;
+          }
+
+          await verifyGameState(activeGame.game_id);
+        } else {
+          console.log('\n⚠️  No games available for testing.');
+          console.log('   Create a Connect4 game first, then run this script.');
+        }
+      }
+    }
+
+    // Summary
+    console.log('\n=====================================');
+    console.log('📊 Test Summary');
+    console.log('=====================================');
+    console.log(`   Passed: ${passed}`);
+    console.log(`   Failed: ${failed}`);
+    console.log('');
+
+    if (failed === 0 && passed > 0) {
+      console.log('✅ All tests passed!');
+    } else if (passed === 0 && failed === 0) {
+      console.log('⚠️  No tests were run. Create a Connect4 game first.');
+    } else {
+      console.log('❌ Some tests failed. Check the output above.');
+    }
+
+  } catch (error) {
+    console.error('\n❌ Fatal error:', error.message);
+    console.error(error.stack);
+    failed++;
+  } finally {
+    await pool.end();
+  }
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main();