dubs-server 1.0.0

package/services/pickemOracle.js

@@ -0,0 +1,440 @@
+/**
+ * Pick'em Oracle
+ * Polls UFC fight results via @dubsdotapp/node SDK, resolves pools, distributes winnings on-chain.
+ * Pattern mirrors survivorOracle.js
+ */
+
+const { Dubs } = require('@dubsdotapp/node');
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const { pool } = require('./db');
+const pickemController = require('../controllers/pickemController');
+
+const LAMPORTS_PER_SOL = 1_000_000_000;
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+// distribute_survivor_winnings discriminator (sha256("global:distribute_survivor_winnings")[0..8])
+const DIST_SURVIVOR = Buffer.from(
+  crypto.createHash('sha256').update('global:distribute_survivor_winnings').digest().slice(0, 8)
+);
+
+class PickemOracle {
+  constructor(config = {}) {
+    this.checkIntervalMs = config.checkIntervalMs || 5 * 60 * 1000; // 5 minutes
+    this.isRunning = false;
+    this.intervalId = null;
+
+    // Solana config
+    this.rpcUrl = config.rpcUrl || process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com';
+    this.programId = new PublicKey(config.programId || process.env.PROGRAM_ID || '85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+    this.connection = new Connection(this.rpcUrl, 'confirmed');
+    this.oracleKeypair = config.oracleKeypair || null;
+
+    // Dubs SDK client — dogfooding our own API
+    this.dubs = new Dubs({
+      apiKey: config.apiKey || process.env.DUBS_API_KEY || '',
+      baseUrl: config.baseUrl || process.env.DUBS_SDK_BASE_URL || `http://localhost:${process.env.PORT || 3001}/api/developer/v1`,
+    });
+
+    // Socket.IO ref (injected externally if available)
+    this.io = config.io || null;
+  }
+
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+
+    console.log('🥊 Starting Pick\'em Oracle...');
+    console.log(`   Check interval: ${this.checkIntervalMs / 1000}s`);
+    console.log(`   RPC: ${this.rpcUrl}`);
+    console.log(`   Program: ${this.programId.toString()}`);
+    if (this.oracleKeypair) {
+      console.log(`   Oracle wallet: ${this.oracleKeypair.publicKey.toString()}`);
+    }
+
+    // Run immediately, then on interval
+    this.checkPools().catch(err => console.error('[PickemOracle] Initial check error:', err.message));
+    this.intervalId = setInterval(() => {
+      this.checkPools().catch(err => console.error('[PickemOracle] Check error:', err.message));
+    }, this.checkIntervalMs);
+  }
+
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    console.log('🥊 Pick\'em Oracle stopped.');
+  }
+
+  // ========== MAIN POLLING LOOP ==========
+
+  async checkPools() {
+    console.log('[PickemOracle] Checking pools...');
+
+    // 1. Auto-lock pools past lock_time
+    await this.autoLockPools();
+
+    // 2. Get active pools (locked or resolving)
+    const result = await pool.query(
+      "SELECT * FROM pickem_pools WHERE status IN ('locked', 'resolving')"
+    );
+    const activePools = result.rows;
+
+    if (activePools.length === 0) {
+      console.log('[PickemOracle] No active pools to process.');
+      return;
+    }
+
+    console.log(`[PickemOracle] Processing ${activePools.length} active pool(s)...`);
+
+    // 3. Fetch fight card data via SDK
+    let fightCardData;
+    try {
+      fightCardData = await this.dubs.ufc.fightCard();
+    } catch (err) {
+      console.error('[PickemOracle] Failed to fetch UFC fight card via SDK:', err.message);
+      return;
+    }
+
+    // Build a lookup: competitionId → fight result
+    const fightResultMap = new Map();
+    if (fightCardData && fightCardData.events) {
+      for (const event of fightCardData.events) {
+        for (const fight of event.fights) {
+          if (fight.id) {
+            fightResultMap.set(fight.id, fight);
+          }
+        }
+      }
+    }
+
+    console.log(`[PickemOracle] UFC fight data: ${fightResultMap.size} fights tracked`);
+
+    // 4. Process each pool
+    for (const p of activePools) {
+      try {
+        await this.processPool(p, fightResultMap);
+      } catch (err) {
+        console.error(`[PickemOracle] Error processing pool ${p.id}:`, err.message);
+      }
+    }
+  }
+
+  // ========== AUTO-LOCK ==========
+
+  async autoLockPools() {
+    const result = await pool.query(
+      "UPDATE pickem_pools SET status = 'locked', updated_at = NOW() WHERE status = 'open' AND lock_time <= NOW() RETURNING id, name"
+    );
+    for (const row of result.rows) {
+      console.log(`[PickemOracle] Auto-locked pool ${row.id}: ${row.name}`);
+      if (this.io) {
+        this.io.emit('pickem:pool_locked', { poolId: row.id });
+      }
+    }
+  }
+
+  // ========== PROCESS POOL ==========
+
+  async processPool(pickemPool, fightResultMap) {
+    // Get unresolved fights for this pool
+    const fightsResult = await pool.query(
+      "SELECT * FROM pickem_fights WHERE pool_id = $1 AND status NOT IN ('final', 'cancelled', 'no_contest') ORDER BY fight_order",
+      [pickemPool.id]
+    );
+    const unresolvedFights = fightsResult.rows;
+
+    if (unresolvedFights.length === 0) {
+      // All fights resolved — trigger full pool resolution
+      console.log(`[PickemOracle] Pool ${pickemPool.id}: All fights resolved, triggering pool resolution...`);
+      await this.resolvePool(pickemPool.id);
+      return;
+    }
+
+    // Update each unresolved fight from SDK data
+    let newlyResolved = 0;
+    for (const fight of unresolvedFights) {
+      const sdkFight = fightResultMap.get(fight.espn_competition_id);
+      if (!sdkFight) continue;
+
+      if (sdkFight.status === 'Final') {
+        // Determine winner: 'a' = home/first, 'b' = away/second
+        let winner = null;
+        if (sdkFight.home?.winner === true) {
+          winner = 'a';
+        } else if (sdkFight.away?.winner === true) {
+          winner = 'b';
+        } else if (sdkFight.home?.score > sdkFight.away?.score) {
+          winner = 'a';
+        } else if (sdkFight.away?.score > sdkFight.home?.score) {
+          winner = 'b';
+        }
+
+        const method = sdkFight.ufcData?.statusDetail || sdkFight.statusDetail || null;
+
+        if (!winner) {
+          console.log(`[PickemOracle] Pool ${pickemPool.id} Fight #${fight.fight_order}: ${fight.fighter_a_name} vs ${fight.fighter_b_name} → FINAL but no winner detected! SDK data: home.winner=${sdkFight.home?.winner}, away.winner=${sdkFight.away?.winner}, home.score=${sdkFight.home?.score}, away.score=${sdkFight.away?.score}`);
+        }
+
+        await pickemController.updateFightResult(fight.id, {
+          winner,
+          method,
+          status: 'final',
+        });
+
+        const winnerName = winner === 'a' ? fight.fighter_a_name : winner === 'b' ? fight.fighter_b_name : 'UNKNOWN';
+        console.log(`[PickemOracle] Pool ${pickemPool.id} Fight #${fight.fight_order}: ${fight.fighter_a_name} vs ${fight.fighter_b_name} → Winner: ${winnerName} (${method || 'unknown'})`);
+
+        if (this.io) {
+          this.io.emit('pickem:fight_resolved', {
+            poolId: pickemPool.id,
+            fightId: fight.id,
+            winner,
+            method,
+          });
+        }
+        newlyResolved++;
+      } else if (['Canceled', 'Postponed', 'Cancelled'].includes(sdkFight.status)) {
+        await pickemController.updateFightResult(fight.id, {
+          winner: null,
+          method: null,
+          status: 'cancelled',
+        });
+        console.log(`[PickemOracle] Pool ${pickemPool.id} Fight #${fight.fight_order}: ${fight.fighter_a_name} vs ${fight.fighter_b_name} → Cancelled`);
+        newlyResolved++;
+      } else if (sdkFight.status === 'In Progress') {
+        await pool.query(
+          "UPDATE pickem_fights SET status = 'live', updated_at = NOW() WHERE id = $1",
+          [fight.id]
+        );
+      }
+    }
+
+    if (newlyResolved > 0) {
+      console.log(`[PickemOracle] Pool ${pickemPool.id}: ${newlyResolved} fight(s) newly resolved`);
+
+      // Incrementally mark picks correct/incorrect and recompute scores
+      try {
+        // Mark is_correct for all resolved fights in this pool
+        await pool.query(`
+          UPDATE pickem_picks pp
+          SET is_correct = (pp.pick = f.winner), updated_at = NOW()
+          FROM pickem_fights f
+          WHERE pp.fight_id = f.id
+            AND f.pool_id = $1
+            AND f.status = 'final'
+            AND f.winner IS NOT NULL
+            AND pp.is_correct IS NULL
+        `, [pickemPool.id]);
+
+        // Recompute scores for all entries in this pool
+        await pool.query(`
+          UPDATE pickem_entries e
+          SET score = (SELECT COUNT(*) FROM pickem_picks p WHERE p.entry_id = e.id AND p.is_correct = true),
+              updated_at = NOW()
+          WHERE e.pool_id = $1
+        `, [pickemPool.id]);
+
+        console.log(`[PickemOracle] Pool ${pickemPool.id}: Scores updated incrementally`);
+      } catch (scoreErr) {
+        console.error(`[PickemOracle] Pool ${pickemPool.id}: Error updating incremental scores:`, scoreErr.message);
+      }
+
+      // Check if all fights are now terminal
+      const stats = await pickemController.getPoolStats(pickemPool.id);
+      if (stats.allFightsResolved) {
+        console.log(`[PickemOracle] Pool ${pickemPool.id}: All fights now resolved, triggering pool resolution...`);
+        await this.resolvePool(pickemPool.id);
+      }
+    }
+  }
+
+  // ========== RESOLVE POOL ==========
+
+  async resolvePool(poolId) {
+    const client = await pool.connect();
+    try {
+      await client.query('BEGIN');
+
+      // Lock pool row
+      const poolResult = await client.query(
+        "SELECT * FROM pickem_pools WHERE id = $1 FOR UPDATE",
+        [poolId]
+      );
+      const pickemPool = poolResult.rows[0];
+      if (!pickemPool) throw new Error(`Pool ${poolId} not found`);
+      if (pickemPool.status === 'complete') {
+        console.log(`[PickemOracle] Pool ${poolId} already complete, skipping.`);
+        await client.query('COMMIT');
+        return;
+      }
+
+      // Set status to resolving
+      await client.query(
+        "UPDATE pickem_pools SET status = 'resolving', updated_at = NOW() WHERE id = $1",
+        [poolId]
+      );
+
+      await client.query('COMMIT');
+    } catch (err) {
+      await client.query('ROLLBACK');
+      throw err;
+    } finally {
+      client.release();
+    }
+
+    // Compute scores (uses its own transaction)
+    console.log(`[PickemOracle] Pool ${poolId}: Computing scores...`);
+    const scoreResult = await pickemController.computeScores(poolId);
+    console.log(`[PickemOracle] Pool ${poolId}: Max score = ${scoreResult.maxScore}, Winners = ${scoreResult.winnerCount}`);
+
+    // Distribute on-chain if we have a Solana game
+    const poolResult = await pool.query('SELECT * FROM pickem_pools WHERE id = $1', [poolId]);
+    const pickemPool = poolResult.rows[0];
+
+    if (pickemPool.solana_game_id && this.oracleKeypair && scoreResult.winners.length > 0) {
+      try {
+        console.log(`[PickemOracle] Pool ${poolId}: Distributing winnings on-chain...`);
+        const signatures = await this.distributeWinnings(pickemPool, scoreResult.winners);
+
+        // Record payouts
+        const totalEntries = Number(pickemPool.total_entries);
+        const totalPotLamports = totalEntries * Number(pickemPool.buy_in_lamports);
+        const netPotLamports = Math.floor(totalPotLamports * 0.94); // 6% fee
+        const perWinner = Math.floor(netPotLamports / scoreResult.winnerCount);
+
+        for (const winner of scoreResult.winners) {
+          await pickemController.recordPayout({
+            poolId,
+            entryId: winner.id,
+            walletAddress: winner.walletAddress,
+            amountLamports: perWinner,
+            txSignature: signatures[0], // First batch signature
+            status: 'completed',
+          });
+        }
+
+        console.log(`[PickemOracle] Pool ${poolId}: Payouts recorded. ${scoreResult.winnerCount} winner(s), ${perWinner / LAMPORTS_PER_SOL} SOL each.`);
+      } catch (err) {
+        console.error(`[PickemOracle] Pool ${poolId}: On-chain distribution failed:`, err.message);
+        // Mark payouts as failed but still complete the pool
+        for (const winner of scoreResult.winners) {
+          await pickemController.recordPayout({
+            poolId,
+            entryId: winner.id,
+            walletAddress: winner.walletAddress,
+            amountLamports: 0,
+            txSignature: null,
+            status: 'failed',
+          });
+        }
+      }
+    } else {
+      if (!pickemPool.solana_game_id) console.log(`[PickemOracle] Pool ${poolId}: No solana_game_id, skipping on-chain distribution.`);
+      if (!this.oracleKeypair) console.log(`[PickemOracle] Pool ${poolId}: No oracle keypair, skipping on-chain distribution.`);
+      if (scoreResult.winners.length === 0) console.log(`[PickemOracle] Pool ${poolId}: No entries, skipping distribution.`);
+    }
+
+    // Mark pool complete
+    await pool.query(
+      "UPDATE pickem_pools SET status = 'complete', updated_at = NOW() WHERE id = $1",
+      [poolId]
+    );
+
+    console.log(`[PickemOracle] Pool ${poolId}: COMPLETE ✅`);
+
+    if (this.io) {
+      this.io.emit('pickem:pool_resolved', {
+        poolId,
+        maxScore: scoreResult.maxScore,
+        winnerCount: scoreResult.winnerCount,
+        winners: scoreResult.winners.map(w => ({
+          walletAddress: w.walletAddress,
+          username: w.username,
+          score: w.score,
+        })),
+      });
+    }
+  }
+
+  // ========== SOLANA DISTRIBUTION ==========
+
+  async distributeWinnings(pickemPool, winners) {
+    const gameIdNum = BigInt(pickemPool.solana_game_id);
+    const gameIdBuf = Buffer.alloc(8);
+    gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+    const [gamePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('game'), gameIdBuf],
+      this.programId
+    );
+
+    // Batch winners (max 50 per tx due to contract limit)
+    const batches = [];
+    for (let i = 0; i < winners.length; i += 50) {
+      batches.push(winners.slice(i, i + 50));
+    }
+
+    const signatures = [];
+    for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+      const batch = batches[batchIdx];
+
+      const data = Buffer.concat([DIST_SURVIVOR, gameIdBuf]);
+
+      const keys = [
+        { pubkey: gamePDA, isSigner: false, isWritable: true },
+        { pubkey: this.oracleKeypair.publicKey, isSigner: true, isWritable: true },
+        // remaining_accounts[0] = operator wallet
+        { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true },
+      ];
+
+      // remaining_accounts[1..n] = winner wallets
+      for (const w of batch) {
+        keys.push({ pubkey: new PublicKey(w.walletAddress), isSigner: false, isWritable: true });
+      }
+
+      const ix = new TransactionInstruction({
+        keys,
+        programId: this.programId,
+        data,
+      });
+
+      const tx = new Transaction().add(ix);
+      const { blockhash } = await this.connection.getLatestBlockhash();
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = this.oracleKeypair.publicKey;
+      tx.sign(this.oracleKeypair);
+
+      console.log(`[PickemOracle] Sending distribute_survivor_winnings batch ${batchIdx + 1}/${batches.length} (${batch.length} winners)...`);
+      const sig = await this.connection.sendRawTransaction(tx.serialize());
+      await this.confirmTransactionPolling(sig);
+      signatures.push(sig);
+      console.log(`[PickemOracle] Batch ${batchIdx + 1} confirmed: ${sig}`);
+    }
+
+    return signatures;
+  }
+
+  // ========== HELPERS ==========
+
+  async confirmTransactionPolling(signature, timeout = 60000) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const statuses = await this.connection.getSignatureStatuses([signature]);
+      const status = statuses?.value?.[0];
+      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');
+  }
+}
+
+module.exports = PickemOracle;