dubs-server 1.0.0

package/services/jackpotHistory.js

@@ -0,0 +1,331 @@
+/**
+ * 🎰 Jackpot History Service (Postgres)
+ * 
+ * Tracks round results in Heroku Postgres database
+ * NOTE: Gracefully degrades when DATABASE_URL is not set (local dev)
+ */
+
+const { pool } = require('./db'); // Shared database pool
+
+class JackpotHistory {
+  constructor() {
+    // Check if database is configured
+    this.enabled = !!process.env.DATABASE_URL;
+    
+    // In-memory storage for local dev (fallback when no DATABASE_URL)
+    this.memoryRounds = [];
+    this.lastWinnerMemory = null;
+    
+    if (this.enabled) {
+      // Use shared pool from services/db.js
+      this.pool = pool;
+      
+      // Initialize table on startup
+      this.initializeTable();
+    } else {
+      console.log('⚠️  Jackpot history: No DATABASE_URL set - using in-memory storage (local dev mode)');
+      this.pool = null;
+    }
+  }
+  
+  // Helper to check if DB operations should run
+  _shouldRun() {
+    return this.enabled && this.pool;
+  }
+
+  async initializeTable() {
+    if (!this._shouldRun()) return;
+
+    try {
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS jackpot_rounds (
+          id SERIAL PRIMARY KEY,
+          round_id VARCHAR(50) UNIQUE NOT NULL,
+          winner VARCHAR(100) NOT NULL,
+          win_amount VARCHAR(50) NOT NULL,
+          total_pot VARCHAR(50) NOT NULL,
+          entry_count INTEGER NOT NULL,
+          timestamp TIMESTAMP DEFAULT NOW(),
+          signature VARCHAR(200),
+          server_seed TEXT,
+          server_seed_hash TEXT,
+          oracle_seed TEXT,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_round_id ON jackpot_rounds(round_id);
+        CREATE INDEX IF NOT EXISTS idx_timestamp ON jackpot_rounds(timestamp DESC);
+
+        CREATE TABLE IF NOT EXISTS jackpot_entries (
+          id SERIAL PRIMARY KEY,
+          wallet_address VARCHAR(64) NOT NULL,
+          round_id VARCHAR(32) NOT NULL,
+          amount BIGINT NOT NULL,
+          transaction_signature VARCHAR(128) NOT NULL,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_jackpot_entries_wallet ON jackpot_entries(wallet_address);
+        CREATE INDEX IF NOT EXISTS idx_jackpot_entries_sig ON jackpot_entries(transaction_signature);
+      `);
+
+      // Migrate: add VRF columns if table existed before they were added
+      const cols = ['timestamp', 'signature', 'server_seed', 'server_seed_hash', 'oracle_seed'];
+      for (const col of cols) {
+        try {
+          const type = col === 'timestamp' ? 'TIMESTAMP DEFAULT NOW()'
+            : col === 'signature' ? 'VARCHAR(200)'
+            : 'TEXT';
+          await this.pool.query(`ALTER TABLE jackpot_rounds ADD COLUMN IF NOT EXISTS ${col} ${type}`);
+        } catch (e) {
+          // Column already exists — safe to ignore
+        }
+      }
+
+      console.log('✅ Jackpot history table initialized');
+    } catch (error) {
+      console.error('❌ Failed to initialize table:', error.message);
+    }
+  }
+
+  async getHistory() {
+    // Fallback to in-memory storage for local dev
+    if (!this._shouldRun()) {
+      return { rounds: this.memoryRounds.slice().reverse().slice(0, 100) };
+    }
+    
+    try {
+      const result = await this.pool.query(
+        'SELECT * FROM jackpot_rounds ORDER BY timestamp DESC LIMIT 100'
+      );
+      
+      return {
+        rounds: result.rows.map(row => ({
+          roundId: row.round_id,
+          winner: row.winner,
+          winAmount: row.win_amount,
+          totalPot: row.total_pot,
+          entryCount: row.entry_count,
+          timestamp: row.timestamp,
+          signature: row.signature,
+          serverSeed: row.server_seed,
+          serverSeedHash: row.server_seed_hash,
+          oracleSeed: row.oracle_seed,
+        }))
+      };
+    } catch (error) {
+      console.error('Error getting history:', error);
+      return { rounds: [] };
+    }
+  }
+
+  async addRound(roundData) {
+    const normalizedData = {
+      roundId: roundData.roundId,
+      winner: roundData.winner,
+      winAmount: roundData.winAmount,
+      totalPot: roundData.totalPot,
+      entryCount: roundData.entryCount,
+      timestamp: roundData.timestamp || new Date().toISOString(),
+      signature: roundData.signature || null,
+      serverSeed: roundData.serverSeed || null,
+      serverSeedHash: roundData.serverSeedHash || null,
+      oracleSeed: roundData.oracleSeed || null,
+    };
+    
+    // Always update in-memory storage (for local dev fallback)
+    this.memoryRounds.push(normalizedData);
+    this.lastWinnerMemory = normalizedData;
+    console.log(`📝 [Memory] Saved round ${roundData.roundId} - Winner: ${roundData.winner.slice(0,8)}...`);
+    
+    if (!this._shouldRun()) return;
+    
+    try {
+      await this.pool.query(
+        `INSERT INTO jackpot_rounds 
+        (round_id, winner, win_amount, total_pot, entry_count, timestamp, signature, server_seed, server_seed_hash, oracle_seed)
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+        ON CONFLICT (round_id) DO UPDATE SET
+          winner = EXCLUDED.winner,
+          win_amount = EXCLUDED.win_amount,
+          total_pot = EXCLUDED.total_pot,
+          entry_count = EXCLUDED.entry_count,
+          timestamp = EXCLUDED.timestamp,
+          signature = EXCLUDED.signature,
+          server_seed = EXCLUDED.server_seed,
+          server_seed_hash = EXCLUDED.server_seed_hash,
+          oracle_seed = EXCLUDED.oracle_seed`,
+        [
+          normalizedData.roundId,
+          normalizedData.winner,
+          normalizedData.winAmount,
+          normalizedData.totalPot,
+          normalizedData.entryCount,
+          normalizedData.timestamp,
+          normalizedData.signature,
+          normalizedData.serverSeed,
+          normalizedData.serverSeedHash,
+          normalizedData.oracleSeed,
+        ]
+      );
+      console.log(`📝 [DB] Saved round ${roundData.roundId} to history`);
+    } catch (error) {
+      console.error('Error adding round to DB:', error);
+  }
+  }
+
+  async getLastWinner() {
+    // Fallback to in-memory storage for local dev
+    if (!this._shouldRun()) {
+      return this.lastWinnerMemory;
+    }
+    
+    try {
+      const result = await this.pool.query(
+        'SELECT * FROM jackpot_rounds ORDER BY timestamp DESC LIMIT 1'
+      );
+      
+      if (result.rows.length === 0) return null;
+      
+      const row = result.rows[0];
+      return {
+        roundId: row.round_id,
+        winner: row.winner,
+        winAmount: row.win_amount,
+        totalPot: row.total_pot,
+        entryCount: row.entry_count,
+        timestamp: row.timestamp,
+        signature: row.signature,
+        serverSeed: row.server_seed,
+        serverSeedHash: row.server_seed_hash,
+        oracleSeed: row.oracle_seed,
+      };
+    } catch (error) {
+      console.error('Error getting last winner:', error);
+      return null;
+    }
+  }
+
+  async getRound(roundId) {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query(
+        'SELECT * FROM jackpot_rounds WHERE round_id = $1',
+        [roundId.toString()]
+      );
+      
+      if (result.rows.length === 0) return null;
+      
+      const row = result.rows[0];
+      return {
+        roundId: row.round_id,
+        winner: row.winner,
+        winAmount: row.win_amount,
+        totalPot: row.total_pot,
+        entryCount: row.entry_count,
+        timestamp: row.timestamp,
+        signature: row.signature,
+        serverSeed: row.server_seed,
+        serverSeedHash: row.server_seed_hash,
+        oracleSeed: row.oracle_seed,
+      };
+    } catch (error) {
+      console.error('Error getting round:', error);
+      return null;
+    }
+  }
+
+  async addEntry({ walletAddress, roundId, amount, signature }) {
+    if (!this._shouldRun()) return;
+
+    try {
+      await this.pool.query(
+        `INSERT INTO jackpot_entries (wallet_address, round_id, amount, transaction_signature)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT DO NOTHING`,
+        [walletAddress, roundId.toString(), amount, signature]
+      );
+      console.log(`📝 [DB] Saved jackpot entry for ${walletAddress.slice(0, 8)}... in round ${roundId}`);
+    } catch (error) {
+      console.error('Error saving jackpot entry:', error);
+    }
+  }
+
+  async getEntriesByWallet(walletAddress) {
+    if (!this._shouldRun()) return [];
+
+    try {
+      const result = await this.pool.query(
+        `SELECT round_id, amount, transaction_signature, created_at
+         FROM jackpot_entries
+         WHERE wallet_address = $1
+         ORDER BY created_at DESC
+         LIMIT 200`,
+        [walletAddress]
+      );
+
+      return result.rows.map(row => ({
+        roundId: row.round_id,
+        amount: row.amount.toString(),
+        signature: row.transaction_signature,
+        createdAt: row.created_at,
+      }));
+    } catch (error) {
+      console.error('Error getting jackpot entries by wallet:', error);
+      return [];
+    }
+  }
+
+  async getWinsByWallet(walletAddress) {
+    if (!this._shouldRun()) return [];
+
+    try {
+      const result = await this.pool.query(
+        `SELECT round_id, win_amount, total_pot, entry_count, signature, timestamp
+         FROM jackpot_rounds
+         WHERE winner = $1
+         ORDER BY timestamp DESC
+         LIMIT 200`,
+        [walletAddress]
+      );
+
+      return result.rows.map(row => ({
+        roundId: row.round_id,
+        winAmount: row.win_amount,
+        totalPot: row.total_pot,
+        entryCount: row.entry_count,
+        signature: row.signature,
+        timestamp: row.timestamp,
+      }));
+    } catch (error) {
+      console.error('Error getting jackpot wins by wallet:', error);
+      return [];
+    }
+  }
+
+  async getStats() {
+    if (!this._shouldRun()) return null;
+    
+    try {
+      const result = await this.pool.query(`
+        SELECT 
+          COUNT(*) as total_rounds,
+          SUM(CAST(total_pot AS BIGINT)) as total_volume,
+          SUM(CAST(win_amount AS BIGINT)) as total_winnings,
+          SUM(CAST(total_pot AS BIGINT) - CAST(win_amount AS BIGINT)) as total_fees
+        FROM jackpot_rounds
+      `);
+      
+      return result.rows[0];
+    } catch (error) {
+      console.error('Error getting stats:', error);
+      return null;
+    }
+  }
+}
+
+// Export both class and singleton instance for shared state
+const jackpotHistoryInstance = new JackpotHistory();
+module.exports = JackpotHistory;
+module.exports.instance = jackpotHistoryInstance;