dubs-server 1.0.0

package/scripts/backfill-matchup-images.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+/**
+ * Backfill Matchup Images Script
+ * 
+ * Generates matchup images for existing sports games that don't have one.
+ * Uploads to S3 and updates the database.
+ * 
+ * Usage:
+ *   node scripts/backfill-matchup-images.js          # Process all games without matchup images
+ *   node scripts/backfill-matchup-images.js --limit 10  # Process only 10 games
+ *   node scripts/backfill-matchup-images.js --game-id sport-xxx  # Process specific game
+ */
+
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Lazy load services (will fail if canvas not installed)
+let matchupImageService = null;
+let s3Service = null;
+
+function getMatchupImageService() {
+  if (!matchupImageService) {
+    try {
+      matchupImageService = require('../services/matchupImageService');
+      console.log('✅ Matchup image service loaded');
+    } catch (err) {
+      console.error('❌ Failed to load matchup image service:', err.message);
+      console.error('   Install canvas: npm install canvas');
+      process.exit(1);
+    }
+  }
+  return matchupImageService;
+}
+
+function getS3Service() {
+  if (!s3Service) {
+    try {
+      const S3Service = require('../services/s3Service');
+      s3Service = new S3Service();
+      if (!s3Service.isConfigured()) {
+        console.error('❌ S3 credentials not configured');
+        console.error('   Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in .env');
+        process.exit(1);
+      }
+      console.log('✅ S3 service loaded');
+    } catch (err) {
+      console.error('❌ Failed to load S3 service:', err.message);
+      process.exit(1);
+    }
+  }
+  return s3Service;
+}
+
+// Database connection
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.DATABASE_URL?.includes('amazonaws') || process.env.DATABASE_URL?.includes('heroku')
+    ? { rejectUnauthorized: false }
+    : false
+});
+
+// League name normalization
+const leagueMap = {
+  'NATIONAL HOCKEY LEAGUE': 'NHL',
+  'NATIONAL BASKETBALL ASSOCIATION': 'NBA',
+  'NATIONAL FOOTBALL LEAGUE': 'NFL',
+  'MAJOR LEAGUE BASEBALL': 'MLB',
+  'ENGLISH PREMIER LEAGUE': 'EPL',
+  'PREMIER LEAGUE': 'EPL',
+  'NHL': 'NHL',
+  'NBA': 'NBA',
+  'NFL': 'NFL',
+  'MLB': 'MLB',
+  'EPL': 'EPL'
+};
+
+function normalizeLeague(league) {
+  return leagueMap[league?.toUpperCase()] || 'NHL';
+}
+
+async function processGame(game) {
+  const service = getMatchupImageService();
+  const s3 = getS3Service();
+  
+  const sportsEvent = game.sports_event;
+  const homeTeam = sportsEvent?.strHomeTeam;
+  const awayTeam = sportsEvent?.strAwayTeam;
+  const league = normalizeLeague(sportsEvent?.strLeague);
+  
+  if (!homeTeam || !awayTeam) {
+    console.log(`  ⚠️ Skipping ${game.game_id} - missing team names`);
+    return { skipped: true };
+  }
+  
+  console.log(`  📝 Processing: ${awayTeam} @ ${homeTeam} (${league})`);
+  
+  try {
+    // Check if image already exists (team-based key allows reuse)
+    const matchupKey = s3.getMatchupImageKey(awayTeam, homeTeam, league);
+    const exists = await s3.matchupImageExists(matchupKey);
+    
+    let publicUrl;
+    if (exists) {
+      // Image already exists, reuse it
+      publicUrl = `https://${s3.bucketName}.s3.${s3.region}.amazonaws.com/${matchupKey}`;
+      console.log(`  ♻️  Reusing existing image for ${awayTeam} @ ${homeTeam}`);
+    } else {
+      // Generate image at full quality (600x315), will be resized to 300x158 on upload
+      const result = await service.generateMatchupImage({
+        homeTeam,
+        awayTeam,
+        league,
+        width: 600,
+        height: 315
+      });
+      
+      // Upload to S3 (will check again and upload if needed)
+      const uploadResult = await s3.uploadMatchupImage(awayTeam, homeTeam, league, result.buffer);
+      publicUrl = uploadResult.publicUrl;
+      
+      if (uploadResult.wasReused) {
+        console.log(`  ♻️  Image was created by another process, reusing it`);
+      }
+    }
+    
+    // Update database
+    await pool.query(`
+      UPDATE games 
+      SET matchup_image_url = $1, updated_at = NOW()
+      WHERE game_id = $2
+    `, [publicUrl, game.game_id]);
+    
+    console.log(`  ✅ Saved: ${publicUrl}`);
+    return { success: true, url: publicUrl };
+    
+  } catch (err) {
+    console.error(`  ❌ Failed: ${err.message}`);
+    return { error: err.message };
+  }
+}
+
+async function main() {
+  console.log('');
+  console.log('🎨 Matchup Image Backfill Script');
+  console.log('================================');
+  console.log('');
+  
+  // Parse arguments
+  const args = process.argv.slice(2);
+  let limit = null;
+  let gameId = null;
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--limit' && args[i + 1]) {
+      limit = parseInt(args[i + 1], 10);
+    }
+    if (args[i] === '--game-id' && args[i + 1]) {
+      gameId = args[i + 1];
+    }
+  }
+  
+  // Initialize services
+  getMatchupImageService();
+  getS3Service();
+  
+  try {
+    // Query for games needing matchup images
+    let query;
+    let params;
+    
+    if (gameId) {
+      query = `
+        SELECT game_id, sports_event 
+        FROM games 
+        WHERE game_id = $1 AND game_mode = 4
+      `;
+      params = [gameId];
+    } else {
+      query = `
+        SELECT game_id, sports_event 
+        FROM games 
+        WHERE game_mode = 4 
+          AND matchup_image_url IS NULL 
+          AND sports_event IS NOT NULL
+        ORDER BY created_at DESC
+        ${limit ? `LIMIT ${limit}` : ''}
+      `;
+      params = [];
+    }
+    
+    const result = await pool.query(query, params);
+    const games = result.rows;
+    
+    console.log(`📊 Found ${games.length} games to process`);
+    console.log('');
+    
+    if (games.length === 0) {
+      console.log('✅ No games need processing!');
+      process.exit(0);
+    }
+    
+    // Process games
+    let processed = 0;
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    
+    for (const game of games) {
+      console.log(`[${processed + 1}/${games.length}] ${game.game_id}`);
+      
+      const result = await processGame(game);
+      processed++;
+      
+      if (result.success) succeeded++;
+      else if (result.skipped) skipped++;
+      else failed++;
+      
+      // Small delay to avoid rate limiting
+      await new Promise(r => setTimeout(r, 100));
+    }
+    
+    console.log('');
+    console.log('📊 Summary');
+    console.log('==========');
+    console.log(`  Total processed: ${processed}`);
+    console.log(`  ✅ Succeeded:    ${succeeded}`);
+    console.log(`  ⚠️  Skipped:      ${skipped}`);
+    console.log(`  ❌ Failed:       ${failed}`);
+    console.log('');
+    
+    process.exit(failed > 0 ? 1 : 0);
+    
+  } catch (err) {
+    console.error('❌ Fatal error:', err);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main().catch(err => {
+  console.error('❌ Unhandled error:', err);
+  process.exit(1);
+});
+

package/scripts/backfill-missing-signatures.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * Backfill missing my_signature values by querying Solana blockchain
+ *
+ * This script:
+ * 1. Finds user_game_refs records with NULL my_signature
+ * 2. Queries Solana for transactions from that wallet
+ * 3. Finds transactions that interact with the game PDA
+ * 4. Updates the database with the recovered signature
+ *
+ * Run with: node scripts/backfill-missing-signatures.js [--dry-run]
+ */
+
+const { Pool } = require('pg');
+const { Connection, PublicKey } = require('@solana/web3.js');
+require('dotenv').config();
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+// Use Alchemy or other RPC
+const ALCHEMY_KEY = process.env.ALCHEMY_API_KEY || process.env.SOLANA_RPC_API_KEY;
+const RPC_URL = ALCHEMY_KEY
+  ? `https://solana-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`
+  : 'https://api.devnet.solana.com';
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+const isDryRun = process.argv.includes('--dry-run');
+
+async function findJoinTransactionForGame(walletAddress, gameAddress) {
+  try {
+    const wallet = new PublicKey(walletAddress);
+    const gamePda = new PublicKey(gameAddress);
+
+    console.log(`   🔍 Searching for JOIN transaction...`);
+    console.log(`      Wallet: ${walletAddress.slice(0, 8)}...`);
+    console.log(`      Game PDA: ${gameAddress.slice(0, 8)}...`);
+
+    // Get signatures for the wallet (last 100 transactions)
+    const signatures = await connection.getSignaturesForAddress(wallet, {
+      limit: 100,
+    });
+
+    console.log(`      Found ${signatures.length} wallet transactions to check`);
+
+    // Check each transaction to see if it involves the game PDA
+    for (const sigInfo of signatures) {
+      try {
+        const tx = await connection.getTransaction(sigInfo.signature, {
+          maxSupportedTransactionVersion: 0,
+        });
+
+        if (!tx || !tx.transaction) continue;
+
+        // Get the account keys from the transaction
+        const accountKeys = tx.transaction.message.staticAccountKeys ||
+                            tx.transaction.message.accountKeys || [];
+
+        // Check if the game PDA is in the transaction accounts
+        const hasGamePda = accountKeys.some(key =>
+          key.toString() === gameAddress
+        );
+
+        if (hasGamePda) {
+          console.log(`      ✅ Found matching transaction: ${sigInfo.signature.slice(0, 16)}...`);
+          return sigInfo.signature;
+        }
+      } catch (txError) {
+        // Skip transactions we can't parse
+        continue;
+      }
+    }
+
+    console.log(`      ❌ No matching transaction found`);
+    return null;
+
+  } catch (error) {
+    console.error(`   Error searching for transaction:`, error.message);
+    return null;
+  }
+}
+
+async function backfillMissingSignatures() {
+  console.log('🔧 Backfill Missing Signatures Script');
+  console.log('=====================================');
+  console.log(`Mode: ${isDryRun ? '🏃 DRY RUN (no changes will be made)' : '💾 LIVE (will update database)'}`);
+  console.log(`RPC: ${RPC_URL.includes('alchemy') ? 'Alchemy' : 'Public RPC'}`);
+  console.log('');
+
+  try {
+    // Find records with missing signatures
+    const result = await pool.query(`
+      SELECT
+        ugr.wallet_address,
+        ugr.game_id,
+        ugr.role,
+        g.game_address,
+        g.buy_in,
+        ugr.joined_at
+      FROM user_game_refs ugr
+      LEFT JOIN games g ON ugr.game_id = g.game_id
+      WHERE (ugr.my_signature IS NULL OR ugr.my_signature = '')
+        AND g.game_address IS NOT NULL
+      ORDER BY ugr.joined_at DESC
+    `);
+
+    if (result.rows.length === 0) {
+      console.log('✅ No records with missing signatures found!');
+      return;
+    }
+
+    console.log(`📋 Found ${result.rows.length} records with missing signatures:\n`);
+
+    let recovered = 0;
+    let failed = 0;
+
+    for (const row of result.rows) {
+      console.log(`\n📍 Processing: ${row.game_id}`);
+      console.log(`   Wallet: ${row.wallet_address.slice(0, 8)}...`);
+      console.log(`   Role: ${row.role}`);
+      console.log(`   Joined: ${row.joined_at}`);
+
+      const signature = await findJoinTransactionForGame(
+        row.wallet_address,
+        row.game_address
+      );
+
+      if (signature) {
+        const explorerUrl = `https://explorer.solana.com/tx/${signature}?cluster=${
+          process.env.SOLANA_NETWORK || 'devnet'
+        }`;
+
+        if (isDryRun) {
+          console.log(`   🏃 DRY RUN: Would update with signature: ${signature.slice(0, 20)}...`);
+          recovered++;
+        } else {
+          // Update the database
+          await pool.query(`
+            UPDATE user_game_refs
+            SET my_signature = $1, my_explorer_url = $2
+            WHERE wallet_address = $3 AND game_id = $4
+          `, [signature, explorerUrl, row.wallet_address, row.game_id]);
+
+          console.log(`   💾 Updated database with recovered signature`);
+          recovered++;
+        }
+      } else {
+        console.log(`   ⚠️ Could not recover signature (transaction may be too old or not found)`);
+        failed++;
+      }
+
+      // Rate limit to avoid RPC throttling (2 seconds between records)
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+
+    console.log('\n=====================================');
+    console.log('📊 Summary:');
+    console.log(`   ✅ Recovered: ${recovered}`);
+    console.log(`   ❌ Failed: ${failed}`);
+    console.log(`   📋 Total: ${result.rows.length}`);
+
+    if (isDryRun && recovered > 0) {
+      console.log('\n💡 Run without --dry-run to apply changes');
+    }
+
+  } catch (error) {
+    console.error('❌ Error:', error);
+  } finally {
+    await pool.end();
+  }
+}
+
+backfillMissingSignatures();

package/scripts/backfill-referral-earnings.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * Backfill Missing Referral Earnings
+ *
+ * This script finds all resolved games where:
+ * - The game creator has a referrer
+ * - No referral_earnings record exists
+ *
+ * And creates the missing referral_earnings records.
+ *
+ * Usage:
+ *   node scripts/backfill-referral-earnings.js --dry-run   # Preview changes
+ *   node scripts/backfill-referral-earnings.js             # Execute backfill
+ *
+ * On Heroku:
+ *   heroku run node scripts/backfill-referral-earnings.js --app dubs-server-prod --dry-run
+ *   heroku run node scripts/backfill-referral-earnings.js --app dubs-server-prod
+ */
+
+require('dotenv').config();
+const { Pool } = require('pg');
+
+// Parse command line arguments
+const isDryRun = process.argv.includes('--dry-run');
+
+// Configuration
+const REFERRAL_COMMISSION_RATE = 0.01; // 1%
+const LAMPORTS_PER_SOL = 1_000_000_000;
+
+// Database connection
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+});
+
+async function findMissingReferralEarnings() {
+  console.log('🔍 Finding resolved games with missing referral earnings...\n');
+
+  const result = await pool.query(`
+    SELECT
+      g.game_id,
+      g.game_type,
+      g.buy_in,
+      g.title,
+      g.created_at as game_created_at,
+      g.updated_at as game_resolved_at,
+      COALESCE(array_length(g.home_team_players, 1), 0) as home_count,
+      COALESCE(array_length(g.away_team_players, 1), 0) as away_count,
+      COALESCE(array_length(g.draw_team_players, 1), 0) as draw_count,
+      g.created_by as creator_wallet,
+      creator.id as creator_user_id,
+      creator.username as creator_username,
+      referrer.id as referrer_user_id,
+      referrer.wallet_address as referrer_wallet,
+      referrer.username as referrer_username
+    FROM games g
+    JOIN users creator ON g.created_by = creator.wallet_address
+    JOIN users referrer ON creator.referral_code = referrer.my_referral_code
+    WHERE g.is_resolved = true
+      AND NOT EXISTS (
+        SELECT 1 FROM referral_earnings
+        WHERE game_id = g.game_id
+      )
+    ORDER BY g.created_at ASC
+  `);
+
+  return result.rows;
+}
+
+async function backfillReferralEarning(game) {
+  const playerCount = game.home_count + game.away_count + game.draw_count;
+  const buyInSOL = parseFloat(game.buy_in) || 0;
+  const potSizeSOL = buyInSOL * playerCount;
+  const potSizeLamports = Math.floor(potSizeSOL * LAMPORTS_PER_SOL);
+  const commissionLamports = Math.floor(potSizeLamports * REFERRAL_COMMISSION_RATE);
+
+  if (commissionLamports <= 0) {
+    console.log(`  ⏭️  Skipping ${game.game_id} - pot too small (${potSizeSOL} SOL)`);
+    return { skipped: true, reason: 'pot_too_small' };
+  }
+
+  console.log(`  📝 ${game.game_id}`);
+  console.log(`     Creator: ${game.creator_username} (${game.creator_wallet.slice(0, 8)}...)`);
+  console.log(`     Referrer: ${game.referrer_username} (${game.referrer_wallet.slice(0, 8)}...)`);
+  console.log(`     Pot: ${potSizeSOL} SOL (${playerCount} players × ${buyInSOL} SOL)`);
+  console.log(`     Commission: ${commissionLamports / LAMPORTS_PER_SOL} SOL (1%)`);
+
+  if (isDryRun) {
+    console.log(`     🔸 DRY RUN - would insert referral_earnings record\n`);
+    return { skipped: false, dryRun: true };
+  }
+
+  try {
+    const insertResult = await pool.query(`
+      INSERT INTO referral_earnings (
+        referrer_user_id,
+        referrer_wallet,
+        referee_user_id,
+        referee_wallet,
+        game_id,
+        game_type,
+        pot_size,
+        referee_buy_in,
+        referee_won,
+        referee_payout,
+        commission_rate,
+        commission_amount,
+        status,
+        paid_at,
+        payout_tx_signature,
+        notes
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
+      ON CONFLICT (referee_wallet, game_id) DO NOTHING
+      RETURNING id
+    `, [
+      game.referrer_user_id,
+      game.referrer_wallet,
+      game.creator_user_id,
+      game.creator_wallet,
+      game.game_id,
+      game.game_type || 'sports',
+      potSizeLamports,
+      potSizeLamports, // Using pot size as "buy-in" since commission is based on whole pot
+      true, // Game was resolved
+      0,
+      REFERRAL_COMMISSION_RATE,
+      commissionLamports,
+      'paid', // Already paid on-chain
+      game.game_resolved_at || new Date(),
+      null, // No tx signature available for backfilled records
+      'Backfilled - on-chain payment occurred at game resolution'
+    ]);
+
+    if (insertResult.rows.length > 0) {
+      console.log(`     ✅ Created referral_earnings record (ID: ${insertResult.rows[0].id})\n`);
+      return { skipped: false, inserted: true, id: insertResult.rows[0].id };
+    } else {
+      console.log(`     ⚠️ Record already exists (conflict)\n`);
+      return { skipped: true, reason: 'conflict' };
+    }
+  } catch (error) {
+    console.error(`     ❌ Error: ${error.message}\n`);
+    return { skipped: true, reason: 'error', error: error.message };
+  }
+}
+
+async function main() {
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('   Referral Earnings Backfill Script');
+  console.log(`   Mode: ${isDryRun ? '🔸 DRY RUN (no changes will be made)' : '🔹 LIVE (will insert records)'}`);
+  console.log('═══════════════════════════════════════════════════════════════\n');
+
+  try {
+    const missingGames = await findMissingReferralEarnings();
+
+    if (missingGames.length === 0) {
+      console.log('✅ No missing referral earnings found. All resolved games with referrers have records.\n');
+      return;
+    }
+
+    console.log(`Found ${missingGames.length} resolved game(s) with referrers but missing referral_earnings\n`);
+    console.log('───────────────────────────────────────────────────────────────\n');
+
+    let inserted = 0;
+    let skipped = 0;
+    let totalCommissionLamports = 0;
+
+    for (const game of missingGames) {
+      const result = await backfillReferralEarning(game);
+
+      if (result.skipped) {
+        skipped++;
+      } else {
+        inserted++;
+        const playerCount = game.home_count + game.away_count + game.draw_count;
+        const potSizeLamports = Math.floor(parseFloat(game.buy_in) * playerCount * LAMPORTS_PER_SOL);
+        totalCommissionLamports += Math.floor(potSizeLamports * REFERRAL_COMMISSION_RATE);
+      }
+    }
+
+    console.log('───────────────────────────────────────────────────────────────\n');
+    console.log('📊 Summary:');
+    console.log(`   Total games processed: ${missingGames.length}`);
+    console.log(`   Records ${isDryRun ? 'to be inserted' : 'inserted'}: ${inserted}`);
+    console.log(`   Skipped: ${skipped}`);
+    console.log(`   Total commission: ${totalCommissionLamports / LAMPORTS_PER_SOL} SOL`);
+
+    if (isDryRun) {
+      console.log('\n🔸 DRY RUN complete. Run without --dry-run to execute backfill.');
+    } else {
+      console.log('\n✅ Backfill complete!');
+    }
+
+  } catch (error) {
+    console.error('❌ Fatal error:', error);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main();