dubs-server 1.0.0

package/scripts/test-poll-confirmation.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * Test Script: Poll Transaction Confirmation
+ *
+ * Tests the Alchemy-compatible polling confirmation approach
+ * that uses getSignatureStatuses instead of WebSocket subscriptions.
+ *
+ * Usage:
+ *   node test-poll-confirmation.js                    # Test with a known confirmed tx
+ *   node test-poll-confirmation.js <signature>        # Test with specific signature
+ */
+
+require('dotenv').config();
+const { Connection } = require('@solana/web3.js');
+
+// Configuration
+const RPC_URL = process.env.SOLANA_RPC_URL || process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+
+console.log('🧪 Poll Transaction Confirmation Test');
+console.log('=====================================');
+console.log(`RPC URL: ${RPC_URL}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Poll for transaction confirmation using getSignatureStatuses
+ * This is the Alchemy-compatible approach (no WebSocket subscriptions)
+ */
+async function pollTransactionConfirmation(signature, lastValidBlockHeight = null, timeout = 30000) {
+  const start = Date.now();
+  console.log(`🔄 Polling confirmation for: ${signature}`);
+  if (lastValidBlockHeight) {
+    console.log(`   lastValidBlockHeight: ${lastValidBlockHeight}`);
+  }
+
+  let pollCount = 0;
+  while (Date.now() - start < timeout) {
+    pollCount++;
+    try {
+      // Check if blockhash has expired (if we have lastValidBlockHeight)
+      if (lastValidBlockHeight) {
+        const currentBlockHeight = await connection.getBlockHeight('confirmed');
+        console.log(`   [Poll ${pollCount}] Current block height: ${currentBlockHeight}`);
+        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(`   [Poll ${pollCount}] 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(`✅ Transaction confirmed: ${status.confirmationStatus}`);
+          return status;
+        }
+      } else {
+        console.log(`   [Poll ${pollCount}] Status: null (not found yet)`);
+      }
+    } catch (pollErr) {
+      // If it's a fatal error, rethrow
+      if (pollErr.message?.includes('expired') || pollErr.message?.includes('failed')) {
+        throw pollErr;
+      }
+      console.warn(`   [Poll ${pollCount}] Error (will retry): ${pollErr.message}`);
+    }
+
+    // Wait before next poll
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+
+/**
+ * Test 1: Confirm a known finalized transaction
+ */
+async function testKnownTransaction(signature) {
+  console.log('\n📋 Test 1: Confirm known transaction');
+  console.log('------------------------------------');
+
+  try {
+    const status = await pollTransactionConfirmation(signature, null, 10000);
+    console.log(`\n✅ TEST PASSED: Transaction confirmed`);
+    console.log(`   Slot: ${status.slot}`);
+    console.log(`   Confirmations: ${status.confirmations}`);
+    console.log(`   Status: ${status.confirmationStatus}`);
+    return true;
+  } catch (error) {
+    console.error(`\n❌ TEST FAILED: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Test 2: Verify getSignatureStatuses works with searchTransactionHistory
+ */
+async function testSearchTransactionHistory(signature) {
+  console.log('\n📋 Test 2: searchTransactionHistory parameter');
+  console.log('---------------------------------------------');
+
+  try {
+    // Without searchTransactionHistory (might return null for old txs)
+    console.log('   Testing WITHOUT searchTransactionHistory...');
+    const responseWithout = await connection.getSignatureStatuses([signature]);
+    console.log(`   Result: ${responseWithout?.value?.[0] ? 'Found' : 'Not found (null)'}`);
+
+    // With searchTransactionHistory
+    console.log('   Testing WITH searchTransactionHistory...');
+    const responseWith = await connection.getSignatureStatuses([signature], {
+      searchTransactionHistory: true
+    });
+    console.log(`   Result: ${responseWith?.value?.[0] ? 'Found' : 'Not found (null)'}`);
+
+    if (responseWith?.value?.[0]) {
+      console.log(`\n✅ TEST PASSED: searchTransactionHistory works`);
+      return true;
+    } else {
+      console.log(`\n⚠️  TEST INCONCLUSIVE: Transaction not found (may be too old or invalid)`);
+      return true; // Not a failure, just inconclusive
+    }
+  } catch (error) {
+    console.error(`\n❌ TEST FAILED: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Test 3: Verify getBlockHeight works
+ */
+async function testGetBlockHeight() {
+  console.log('\n📋 Test 3: getBlockHeight functionality');
+  console.log('---------------------------------------');
+
+  try {
+    const blockHeight = await connection.getBlockHeight('confirmed');
+    console.log(`   Current block height: ${blockHeight}`);
+
+    // Get latest blockhash to compare
+    const { lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+    console.log(`   lastValidBlockHeight: ${lastValidBlockHeight}`);
+    console.log(`   Difference: ${lastValidBlockHeight - blockHeight} blocks`);
+
+    if (blockHeight > 0 && lastValidBlockHeight > blockHeight) {
+      console.log(`\n✅ TEST PASSED: getBlockHeight works correctly`);
+      return true;
+    } else {
+      console.log(`\n❌ TEST FAILED: Unexpected block height values`);
+      return false;
+    }
+  } catch (error) {
+    console.error(`\n❌ TEST FAILED: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Test 4: Verify error handling for invalid signature
+ */
+async function testInvalidSignature() {
+  console.log('\n📋 Test 4: Invalid signature handling');
+  console.log('-------------------------------------');
+
+  const invalidSig = 'InvalidSignature123456789012345678901234567890123456789012345678901234567890';
+
+  try {
+    const response = await connection.getSignatureStatuses([invalidSig], {
+      searchTransactionHistory: true
+    });
+
+    if (response?.value?.[0] === null) {
+      console.log(`   Response for invalid sig: null (as expected)`);
+      console.log(`\n✅ TEST PASSED: Invalid signatures return null`);
+      return true;
+    } else {
+      console.log(`   Unexpected response: ${JSON.stringify(response)}`);
+      console.log(`\n⚠️  TEST INCONCLUSIVE`);
+      return true;
+    }
+  } catch (error) {
+    // Some errors are expected for truly malformed signatures
+    console.log(`   Error (expected): ${error.message}`);
+    console.log(`\n✅ TEST PASSED: Invalid signatures handled gracefully`);
+    return true;
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Use provided signature or a known devnet transaction
+  // This is a sample devnet transaction - replace with a real one if needed
+  let testSignature = args[0];
+
+  if (!testSignature) {
+    // Try to get a recent transaction from the connection
+    console.log('No signature provided, fetching a recent confirmed transaction...');
+    try {
+      const signatures = await connection.getSignaturesForAddress(
+        connection._rpcEndpoint.includes('mainnet')
+          ? require('@solana/web3.js').SystemProgram.programId
+          : require('@solana/web3.js').SystemProgram.programId,
+        { limit: 1 }
+      );
+      if (signatures.length > 0) {
+        testSignature = signatures[0].signature;
+        console.log(`Using recent transaction: ${testSignature}\n`);
+      }
+    } catch (e) {
+      console.log('Could not fetch recent transaction, using fallback...');
+    }
+  }
+
+  if (!testSignature) {
+    console.log('\n⚠️  No test signature available.');
+    console.log('   Please provide a signature: node test-poll-confirmation.js <signature>');
+    console.log('   Running remaining tests without transaction confirmation...\n');
+  }
+
+  let passed = 0;
+  let failed = 0;
+
+  // Run tests
+  if (testSignature) {
+    if (await testKnownTransaction(testSignature)) passed++; else failed++;
+    if (await testSearchTransactionHistory(testSignature)) passed++; else failed++;
+  }
+
+  if (await testGetBlockHeight()) passed++; else failed++;
+  if (await testInvalidSignature()) passed++; else failed++;
+
+  // 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 approach works with your RPC.');
+  } else {
+    console.log('❌ Some tests failed. Check the output above for details.');
+  }
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/scripts/test-resolve-game.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+/**
+ * Manual Game Resolution Test Script
+ * Use this to manually resolve games and test the notification system
+ * 
+ * Usage:
+ *   node test-resolve-game.js <gameId>                    # Resolve specific game
+ *   node test-resolve-game.js --all                       # Resolve all pending games
+ *   node test-resolve-game.js <gameId> --winner=home      # Force winner
+ *   node test-resolve-game.js <gameId> --score=3:2        # Force score
+ */
+
+require('dotenv').config();
+const { Keypair } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const AutomaticGameOracle = require('../services/automaticGameOracle');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const gameIdArg = args[0];
+const options = {};
+
+args.forEach(arg => {
+  if (arg.startsWith('--winner=')) {
+    options.forceWinner = arg.split('=')[1]; // 'home' or 'away'
+  }
+  if (arg.startsWith('--score=')) {
+    const [home, away] = arg.split('=')[1].split(':');
+    options.forceScore = { homeScore: parseInt(home), awayScore: parseInt(away) };
+  }
+  if (arg === '--all') {
+    options.resolveAll = true;
+  }
+});
+
+// Load oracle wallet
+function loadOracleWallet() {
+  if (process.env.ORACLE_WALLET_JSON) {
+    console.log('🔑 Loading oracle wallet from environment variable');
+    const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+  
+  const oracleWalletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, 'wallets/oracle.json');
+  
+  if (!fs.existsSync(oracleWalletPath)) {
+    console.error(`❌ Oracle wallet not found at: ${oracleWalletPath}`);
+    console.log('💡 Create one with: solana-keygen new -o wallets/oracle.json');
+    process.exit(1);
+  }
+  
+  console.log('🔑 Loading oracle wallet from file:', oracleWalletPath);
+  const secretKey = JSON.parse(fs.readFileSync(oracleWalletPath, 'utf-8'));
+  return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+}
+
+// Configuration
+const config = {
+  rpcUrl: process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com',
+  programId: process.env.PROGRAM_ID || '8DJTkgk6MDr6tPtw4v2VzYAz9WWvmCg6786vZrEK3o5q',
+  oracleKeypair: loadOracleWallet(),
+  liveScoresApiUrl: process.env.LIVE_SCORES_API_URL || 'http://localhost:3000',
+  dubsGamesApiUrl: process.env.DUBS_GAMES_API_URL || 'http://localhost:3001',
+  checkIntervalMs: 60000,
+};
+
+console.log('🧪 Manual Game Resolution Test');
+console.log('================================');
+console.log(`RPC: ${config.rpcUrl}`);
+console.log(`Program ID: ${config.programId}`);
+console.log(`Oracle: ${config.oracleKeypair.publicKey.toString()}`);
+console.log('');
+
+/**
+ * Fetch a specific game from Firebase
+ */
+async function fetchGame(gameId) {
+  try {
+    const apiUrl = process.env.DUBS_GAMES_API_URL || 'https://dubs-games-api-dev-76c556653fa3.herokuapp.com';
+    const response = await axios.get(`${apiUrl}/api/games/${gameId}`);
+    
+    if (!response.data || !response.data.gameId) {
+      throw new Error('Game not found in Firebase');
+    }
+    
+    return response.data;
+  } catch (error) {
+    throw new Error(`Failed to fetch game: ${error.message}`);
+  }
+}
+
+/**
+ * Fetch all pending games
+ */
+async function fetchPendingGames() {
+  try {
+    const apiUrl = process.env.DUBS_GAMES_API_URL || 'https://dubs-games-api-dev-76c556653fa3.herokuapp.com';
+    const response = await axios.get(`${apiUrl}/api/auth/games/automatic/pending`);
+    
+    if (!response.data.success || !response.data.games) {
+      return [];
+    }
+    
+    return response.data.games;
+  } catch (error) {
+    throw new Error(`Failed to fetch pending games: ${error.message}`);
+  }
+}
+
+/**
+ * Get live score or use forced values
+ */
+async function getGameResult(game, options) {
+  // If forcing winner/score, use that
+  if (options.forceWinner) {
+    const score = options.forceScore || { homeScore: 3, awayScore: 2 };
+    
+    // Make sure winner matches score
+    if (options.forceWinner === 'home' && score.homeScore <= score.awayScore) {
+      score.homeScore = score.awayScore + 1;
+    } else if (options.forceWinner === 'away' && score.awayScore <= score.homeScore) {
+      score.awayScore = score.homeScore + 1;
+    }
+    
+    return {
+      isFinal: true,
+      status: 'Final',
+      winner: options.forceWinner,
+      homeScore: score.homeScore,
+      awayScore: score.awayScore
+    };
+  }
+  
+  // Otherwise, try to fetch real score
+  const oracle = new AutomaticGameOracle(config);
+  const result = await oracle.checkSportsGameResult(game.sportsEvent);
+  
+  if (!result || !result.isFinal) {
+    throw new Error('Game not finished yet. Use --winner=home or --winner=away to force resolution.');
+  }
+  
+  return result;
+}
+
+/**
+ * Resolve a specific game
+ */
+async function resolveGame(gameId, options) {
+  try {
+    console.log(`\n📊 Fetching game: ${gameId}`);
+    const game = await fetchGame(gameId);
+    
+    console.log(`   Title: ${game.title || 'Untitled'}`);
+    console.log(`   Event: ${game.sportsEvent?.strEvent || 'N/A'}`);
+    console.log(`   Participants: ${game.participants?.length || 0}`);
+    console.log(`   Chat ID: ${game.telegramChatId || 'NOT SET'}`);
+    
+    if (!game.telegramChatId) {
+      console.log(`   ⚠️  WARNING: No chat ID - notifications won't be sent!`);
+    }
+    
+    console.log(`\n🔍 Getting game result...`);
+    const result = await getGameResult(game, options);
+    
+    console.log(`   Status: ${result.status}`);
+    console.log(`   Winner: ${result.winner}`);
+    console.log(`   Score: ${result.homeScore}-${result.awayScore}`);
+    
+    console.log(`\n🔗 Resolving on-chain...`);
+    const oracle = new AutomaticGameOracle(config);
+    
+    // This will resolve on-chain, update Firebase, and send Telegram notification
+    await oracle.resolveGame(game, result);
+    
+    console.log(`\n✅ Game resolved successfully!`);
+    
+    if (game.telegramChatId) {
+      console.log(`   📱 Telegram notification sent to chat ${game.telegramChatId}`);
+    }
+    
+  } catch (error) {
+    console.error(`\n❌ Error resolving game:`, error.message);
+    
+    if (error.message?.includes('AlreadyResolved')) {
+      console.log(`   ℹ️  Game was already resolved`);
+    }
+    
+    throw error;
+  }
+}
+
+/**
+ * Resolve all pending games
+ */
+async function resolveAllPendingGames(options) {
+  try {
+    console.log(`\n🔍 Fetching all pending games...`);
+    const games = await fetchPendingGames();
+    
+    if (games.length === 0) {
+      console.log(`   No pending games found`);
+      return;
+    }
+    
+    console.log(`   Found ${games.length} pending game(s)\n`);
+    
+    for (const game of games) {
+      try {
+        console.log(`\n${'='.repeat(60)}`);
+        await resolveGame(game.gameId, options);
+      } catch (error) {
+        console.error(`   Skipping game ${game.gameId}: ${error.message}`);
+        continue;
+      }
+    }
+    
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`\n✅ Finished processing all games`);
+    
+  } catch (error) {
+    console.error(`\n❌ Error:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  try {
+    // Show usage if no arguments
+    if (args.length === 0) {
+      console.log('Usage:');
+      console.log('  node test-resolve-game.js <gameId>                    # Resolve specific game');
+      console.log('  node test-resolve-game.js --all                       # Resolve all pending games');
+      console.log('  node test-resolve-game.js <gameId> --winner=home      # Force home team win');
+      console.log('  node test-resolve-game.js <gameId> --winner=away      # Force away team win');
+      console.log('  node test-resolve-game.js <gameId> --score=3:2        # Force specific score');
+      console.log('');
+      console.log('Examples:');
+      console.log('  node test-resolve-game.js sport-1234567890-abc123');
+      console.log('  node test-resolve-game.js sport-1234567890-abc123 --winner=home');
+      console.log('  node test-resolve-game.js sport-1234567890-abc123 --winner=away --score=5:2');
+      console.log('  node test-resolve-game.js --all');
+      console.log('');
+      process.exit(0);
+    }
+    
+    if (options.resolveAll) {
+      await resolveAllPendingGames(options);
+    } else {
+      if (!gameIdArg || gameIdArg.startsWith('--')) {
+        throw new Error('Please provide a game ID');
+      }
+      await resolveGame(gameIdArg, options);
+    }
+    
+    console.log('\n✨ Done!\n');
+    process.exit(0);
+    
+  } catch (error) {
+    console.error('\n❌ Fatal error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run main function
+main();
+