dubs-server 1.0.0

package/services/customGameResolver.js

@@ -0,0 +1,260 @@
+/**
+ * Custom Game Resolver Service
+ *
+ * Handles on-chain resolution of developer custom games (game_mode=6).
+ * Extracted from AutomaticGameOracle to avoid circular dependencies
+ * with the polling loop / ESPN / PandaScore integration.
+ *
+ * Shares the same oracle keypair, program ID, and transaction format.
+ */
+
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+// Must match the contract's hardcoded address
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+// resolve_automatic_game discriminator
+const RESOLVE_AUTO = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+
+// authority_force_lock discriminator — sha256("global:authority_force_lock")[0..8]
+// Sets lock_timestamp = now so resolve_automatic_game passes the lock check
+const AUTHORITY_FORCE_LOCK = Buffer.from([186, 206, 107, 11, 185, 154, 217, 166]);
+
+class CustomGameResolver {
+  constructor() {
+    const rpcUrl = process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+    const programId = process.env.PROGRAM_ID || '85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1';
+
+    this.connection = new Connection(rpcUrl, 'confirmed');
+    this.programId = new PublicKey(programId);
+    this.oracleKeypair = this._loadOracleKeypair();
+    this.dubsServerUrl = process.env.DUBS_SERVER_URL || `http://localhost:${process.env.PORT || 3001}`;
+  }
+
+  /**
+   * Load oracle keypair from env var or wallet file.
+   * Returns null if unavailable (resolve calls will fail gracefully).
+   */
+  _loadOracleKeypair() {
+    try {
+      if (process.env.ORACLE_WALLET_JSON) {
+        const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+        return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+      }
+
+      const walletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, '../wallets/oracle.json');
+      if (fs.existsSync(walletPath)) {
+        const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+        return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+      }
+
+      console.warn('[CustomGameResolver] No oracle keypair found — resolve will be disabled');
+      return null;
+    } catch (err) {
+      console.error('[CustomGameResolver] Failed to load oracle keypair:', err.message);
+      return null;
+    }
+  }
+
+  /**
+   * Resolve a custom game on-chain and update the database.
+   *
+   * @param {string} gameId - The game ID
+   * @param {string|null} winner - 'home', 'away', 'draw', or null (refund)
+   * @param {object} [metadata] - Optional proof/metadata from developer
+   * @returns {{ signature: string }} - On-chain transaction signature
+   */
+  async resolveGame(gameId, winner, metadata = null) {
+    if (!this.oracleKeypair) {
+      throw new Error('Oracle keypair not loaded — cannot resolve games');
+    }
+
+    console.log(`\n[CustomGameResolver] Resolving game: ${gameId}`);
+    console.log(`  Winner: ${winner === null ? 'null (REFUND)' : winner}`);
+
+    // Look up referrer for commission payout
+    const referrerWallet = await this.getGameCreatorReferrer(gameId);
+    if (referrerWallet) {
+      console.log(`  Referrer: ${referrerWallet}`);
+    }
+
+    // Build + send on-chain resolve transaction
+    const signature = await this.buildAndSendResolveTransaction(gameId, winner, referrerWallet);
+    console.log(`  On-chain signature: ${signature}`);
+
+    // Update PostgreSQL
+    await this.updateGameInPostgreSQL(gameId, winner, signature);
+
+    console.log(`[CustomGameResolver] Game ${gameId} resolved successfully`);
+    return { signature };
+  }
+
+  /**
+   * Build and send authority_force_lock + resolve_automatic_game in a single transaction.
+   *
+   * The force-lock instruction sets lock_timestamp = now so the resolve instruction's
+   * `current_time >= lock_timestamp` check passes immediately. This lets developers
+   * resolve custom games at any time without waiting for an artificial lock timer.
+   */
+  async buildAndSendResolveTransaction(gameId, winner, referrerWallet = null) {
+    // Derive game PDA
+    let gameIdNum;
+    if (typeof gameId === 'string' && gameId.includes('-')) {
+      const hash = crypto.createHash('sha256').update(gameId).digest();
+      gameIdNum = hash.readBigUInt64LE(0);
+    } else {
+      gameIdNum = BigInt(gameId);
+    }
+
+    const gameIdBuf = Buffer.alloc(8);
+    gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+    const [gamePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('game'), gameIdBuf],
+      this.programId
+    );
+
+    // Instruction 1: authority_force_lock — sets lock_timestamp = now
+    const forceLockData = Buffer.concat([AUTHORITY_FORCE_LOCK, gameIdBuf]);
+    const forceLockIx = new TransactionInstruction({
+      keys: [
+        { pubkey: gamePDA, isSigner: false, isWritable: true },
+        { pubkey: this.oracleKeypair.publicKey, isSigner: true, isWritable: true },
+      ],
+      programId: this.programId,
+      data: forceLockData,
+    });
+
+    // Instruction 2: resolve_automatic_game
+    // Encode winning team: Some(Home)=[1,0], Some(Away)=[1,1], Some(Draw)=[1,2], None(refund)=[0]
+    let winningTeamBytes;
+    if (winner === null) {
+      winningTeamBytes = Buffer.from([0]);
+    } else if (winner === 'home') {
+      winningTeamBytes = Buffer.from([1, 0]);
+    } else if (winner === 'away') {
+      winningTeamBytes = Buffer.from([1, 1]);
+    } else if (winner === 'draw') {
+      winningTeamBytes = Buffer.from([1, 2]);
+    } else {
+      console.error(`[CustomGameResolver] Unexpected winner value: ${winner}, defaulting to refund`);
+      winningTeamBytes = Buffer.from([0]);
+    }
+
+    const resolveData = Buffer.concat([RESOLVE_AUTO, gameIdBuf, winningTeamBytes]);
+
+    const resolveKeys = [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: this.oracleKeypair.publicKey, isSigner: true, isWritable: true },
+      { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true },
+    ];
+
+    if (referrerWallet) {
+      try {
+        const referrerPubkey = new PublicKey(referrerWallet);
+        resolveKeys.push({ pubkey: referrerPubkey, isSigner: false, isWritable: true });
+      } catch (e) {
+        console.warn(`[CustomGameResolver] Invalid referrer wallet: ${referrerWallet}`);
+      }
+    }
+
+    const resolveIx = new TransactionInstruction({
+      keys: resolveKeys,
+      programId: this.programId,
+      data: resolveData,
+    });
+
+    // Combine both instructions: force-lock first, then resolve
+    const tx = new Transaction().add(forceLockIx).add(resolveIx);
+    tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    tx.feePayer = this.oracleKeypair.publicKey;
+    tx.sign(this.oracleKeypair);
+
+    const signature = await this.connection.sendRawTransaction(tx.serialize());
+    await this.confirmTransactionPolling(signature);
+
+    return signature;
+  }
+
+  /**
+   * Update game status in PostgreSQL via the internal resolve endpoint.
+   */
+  async updateGameInPostgreSQL(gameId, winner, signature) {
+    try {
+      await axios.post(
+        `${this.dubsServerUrl}/api/games/${gameId}/resolve`,
+        {
+          winner,
+          homeScore: null,
+          awayScore: null,
+          resolvedAt: new Date().toISOString(),
+          resolvedBy: 'developer',
+          resolveSignature: signature,
+        },
+        { timeout: 10000, headers: { 'Content-Type': 'application/json' } }
+      );
+      console.log(`  PostgreSQL updated`);
+    } catch (error) {
+      console.error(`[CustomGameResolver] Error updating PostgreSQL:`, error.message);
+      // Don't throw — on-chain resolution is what matters
+    }
+  }
+
+  /**
+   * Look up the game creator's referrer wallet for commission payout.
+   */
+  async getGameCreatorReferrer(gameId) {
+    try {
+      const response = await axios.get(
+        `${this.dubsServerUrl}/api/games/${gameId}/creator-referrer`,
+        { timeout: 5000 }
+      );
+      if (response.data.success && response.data.referrerWallet) {
+        return response.data.referrerWallet;
+      }
+      return null;
+    } catch (error) {
+      console.warn(`[CustomGameResolver] Could not fetch referrer for ${gameId}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Poll for transaction confirmation.
+   */
+  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') {
+        console.log(`  Transaction confirmed: ${status.confirmationStatus}`);
+        return status;
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    throw new Error('Transaction confirmation timeout');
+  }
+}
+
+// Singleton
+let instance = null;
+
+function getCustomGameResolver() {
+  if (!instance) {
+    instance = new CustomGameResolver();
+  }
+  return instance;
+}
+
+module.exports = { CustomGameResolver, getCustomGameResolver };

package/services/db.js

@@ -0,0 +1,79 @@
+/**
+ * 🗄️ Shared Database Pool
+ * 
+ * Centralized PostgreSQL connection pool for the entire application.
+ * IMPORTANT: All services should import from here instead of creating their own pools.
+ * 
+ * Heroku PostgreSQL connection limits:
+ * - Hobby/Basic: 20 connections
+ * - Standard-0: 120 connections
+ * - Standard-2: 400 connections
+ * 
+ * We set max to 8 to leave room for:
+ * - Heroku's own management connections
+ * - Multiple dynos (if scaled)
+ * - External tools (pgAdmin, migrations, etc.)
+ */
+
+const { Pool } = require('pg');
+
+// Determine if we're on Heroku/AWS (need SSL)
+const isProduction = process.env.DATABASE_URL && 
+  (process.env.DATABASE_URL.includes('amazonaws') || process.env.DATABASE_URL.includes('heroku'));
+
+// Create the shared pool with explicit connection limits
+const pool = process.env.DATABASE_URL ? new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: isProduction ? { rejectUnauthorized: false } : false,
+  
+  // Connection pool settings - CRITICAL for Heroku
+  max: parseInt(process.env.DB_POOL_MAX, 10) || 5,        // Maximum connections in pool (reduced from 8)
+  min: 0,                                                  // Don't hold idle connections unnecessarily
+  idleTimeoutMillis: 10000,                                // Close idle connections after 10s (was 30s)
+  connectionTimeoutMillis: 10000,                          // Timeout acquiring connection after 10s
+  allowExitOnIdle: true,                                   // Allow process to exit when pool is idle
+}) : null;
+
+// Log pool configuration on startup
+if (pool) {
+  console.log('[DB] Shared pool created:', {
+    max: pool.options.max,
+    min: pool.options.min,
+    idleTimeoutMillis: pool.options.idleTimeoutMillis,
+    ssl: !!pool.options.ssl
+  });
+  
+  // Monitor pool events for debugging connection issues
+  pool.on('error', (err) => {
+    console.error('[DB] Unexpected pool error:', err.message);
+  });
+  
+  pool.on('connect', () => {
+    console.log('[DB] New client connected. Total:', pool.totalCount, 'Idle:', pool.idleCount);
+  });
+  
+  pool.on('remove', () => {
+    console.log('[DB] Client removed. Total:', pool.totalCount, 'Idle:', pool.idleCount);
+  });
+}
+
+// Graceful shutdown
+async function closePool() {
+  if (pool) {
+    console.log('[DB] Closing pool...');
+    await pool.end();
+    console.log('[DB] Pool closed.');
+  }
+}
+
+// Export the shared pool
+module.exports = {
+  pool,
+  closePool,
+  // Convenience method to get a client for transactions
+  getClient: async () => pool ? pool.connect() : null,
+  // Convenience method to run a query
+  query: (...args) => pool ? pool.query(...args) : Promise.reject(new Error('Database not configured')),
+};
+
+