dubs-server 1.0.0

package/scripts/check-chat-schema.js

@@ -0,0 +1,130 @@
+/**
+ * 🔍 Check Current Chat Database Schema
+ * 
+ * Inspects the actual Heroku Postgres database to see what we have
+ */
+
+const { Pool } = require('pg');
+
+async function checkSchema() {
+  const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+    ssl: process.env.DATABASE_URL ? { rejectUnauthorized: false } : false,
+  });
+
+  try {
+    console.log('🔍 Checking Heroku Postgres database...\n');
+
+    // Check if table exists
+    const tableCheck = await pool.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'chat_messages'
+      );
+    `);
+
+    if (!tableCheck.rows[0].exists) {
+      console.log('❌ Table chat_messages does NOT exist!');
+      await pool.end();
+      return;
+    }
+
+    console.log('✅ Table chat_messages EXISTS\n');
+
+    // Get all columns
+    const columns = await pool.query(`
+      SELECT 
+        column_name, 
+        data_type,
+        is_nullable,
+        column_default
+      FROM information_schema.columns 
+      WHERE table_name = 'chat_messages'
+      ORDER BY ordinal_position;
+    `);
+
+    console.log('📊 CURRENT TABLE STRUCTURE:');
+    console.log('─'.repeat(80));
+    columns.rows.forEach(row => {
+      console.log(`   ${row.column_name.padEnd(30)} ${row.data_type.padEnd(20)} ${row.is_nullable === 'YES' ? 'NULL' : 'NOT NULL'}`);
+      if (row.column_default) {
+        console.log(`      Default: ${row.column_default}`);
+      }
+    });
+    console.log('─'.repeat(80));
+
+    // Get indexes
+    const indexes = await pool.query(`
+      SELECT indexname, indexdef
+      FROM pg_indexes
+      WHERE tablename = 'chat_messages';
+    `);
+
+    if (indexes.rows.length > 0) {
+      console.log('\n🔑 INDEXES:');
+      indexes.rows.forEach(row => {
+        console.log(`   ${row.indexname}`);
+        console.log(`      ${row.indexdef}`);
+      });
+    }
+
+    // Get row count
+    const count = await pool.query(`SELECT COUNT(*) FROM chat_messages;`);
+    console.log(`\n💬 Total messages in database: ${count.rows[0].count}`);
+
+    // Get sample messages
+    const sample = await pool.query(`
+      SELECT * FROM chat_messages 
+      ORDER BY timestamp DESC 
+      LIMIT 3;
+    `);
+
+    if (sample.rows.length > 0) {
+      console.log('\n📝 SAMPLE MESSAGES (most recent):');
+      sample.rows.forEach((msg, i) => {
+        console.log(`\n   Message ${i + 1}:`);
+        console.log(`      ID: ${msg.id}`);
+        console.log(`      Wallet: ${msg.wallet_address?.slice(0, 8)}...`);
+        console.log(`      Message: ${msg.message?.slice(0, 50)}...`);
+        console.log(`      Time: ${msg.timestamp}`);
+        // Check for new columns
+        if ('is_winner_announcement' in msg) {
+          console.log(`      🏆 Winner: ${msg.is_winner_announcement}`);
+        }
+        if ('win_amount' in msg) {
+          console.log(`      💰 Amount: ${msg.win_amount}`);
+        }
+        if ('round_id' in msg) {
+          console.log(`      🎰 Round: ${msg.round_id}`);
+        }
+      });
+    }
+
+    // Check what columns are MISSING for winner announcements
+    console.log('\n🔥 WINNER ANNOUNCEMENT FEATURE CHECK:');
+    const hasWinnerCol = columns.rows.some(c => c.column_name === 'is_winner_announcement');
+    const hasAmountCol = columns.rows.some(c => c.column_name === 'win_amount');
+    const hasRoundCol = columns.rows.some(c => c.column_name === 'round_id');
+
+    console.log(`   is_winner_announcement: ${hasWinnerCol ? '✅ EXISTS' : '❌ MISSING'}`);
+    console.log(`   win_amount: ${hasAmountCol ? '✅ EXISTS' : '❌ MISSING'}`);
+    console.log(`   round_id: ${hasRoundCol ? '✅ EXISTS' : '❌ MISSING'}`);
+
+    if (!hasWinnerCol || !hasAmountCol || !hasRoundCol) {
+      console.log('\n⚠️  MIGRATION NEEDED! Run: node scripts/migrate-chat-winners.js');
+    } else {
+      console.log('\n✅ All columns exist! Winner announcements should work!');
+    }
+
+    await pool.end();
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error);
+    await pool.end();
+    process.exit(1);
+  }
+}
+
+// Run it
+checkSchema();
+

package/scripts/check-db.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# 🔍 Check Chat Database Schema on Heroku
+# This runs the check script on Heroku directly
+
+echo "🚀 Checking database schema on Heroku..."
+echo ""
+
+# Run the check script on Heroku
+heroku run node scripts/check-chat-schema.js --app dubs-server
+
+echo ""
+echo "✅ Check complete!"
+

package/scripts/check_oracle_in_game.js

@@ -0,0 +1,54 @@
+const { Connection, PublicKey } = require('@solana/web3.js');
+const crypto = require('crypto');
+
+const conn = new Connection('https://api.mainnet-beta.solana.com');
+const PROGRAM_ID = new PublicKey('85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+function gameIdToU64(gameId) {
+  const hash = crypto.createHash('sha256').update(gameId).digest();
+  return hash.readBigUInt64LE(0);
+}
+
+function getGamePDA(gameId) {
+  const gameIdNum = gameIdToU64(gameId);
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+  const [pda] = PublicKey.findProgramAddressSync([Buffer.from('game'), gameIdBuf], PROGRAM_ID);
+  return pda;
+}
+
+async function checkOracleInGame(gameId) {
+  const pda = getGamePDA(gameId);
+  console.log(`Game: ${gameId}`);
+  console.log(`PDA: ${pda.toString()}`);
+  
+  const account = await conn.getAccountInfo(pda);
+  if (!account) {
+    console.log('❌ Game account not found (might not be created yet)');
+    return;
+  }
+  
+  const data = account.data;
+  // Oracle field is at a specific offset in the Game struct
+  // After many fields, the oracle Pubkey is 32 bytes
+  
+  // Rough parsing - oracle is near the end before claimed_players
+  // Let's look for both possible oracle addresses
+  const dataHex = data.toString('hex');
+  
+  const OLD_ORACLE = 'b93a8976ea13d935dcaf96f0cb26ab727f51191d63c016724230c2c1c8bd215e'; // DU4CHEH...
+  const NEW_ORACLE = 'd790532829777790e1e36b4bcbd2516f45c480c6787a24562023caae1e0ee268bd23'; // FWUJCth...
+  
+  if (dataHex.includes(OLD_ORACLE)) {
+    console.log('❌ OLD ORACLE DETECTED: DU4CHEHUJ2EeezAXyfyi8vLB7dmXKq41myKnA5DZ9Mru');
+    console.log('   This game will have resolution issues!');
+  } else if (dataHex.includes(NEW_ORACLE.slice(0, 64))) {
+    console.log('✅ NEW ORACLE DETECTED: FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa');
+    console.log('   This game will resolve automatically! ✅');
+  } else {
+    console.log('🔍 Oracle address not clearly identified in data');
+    console.log('   Data length:', data.length, 'bytes');
+  }
+}
+
+checkOracleInGame('sport-1767213423275-k0s504tfl').catch(console.error);

package/scripts/cleanup-database.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/**
+ * Database Cleanup Script
+ * 
+ * Manages data retention to prevent unbounded growth:
+ * - Keeps essential audit data
+ * - Archives old logs
+ * - Maintains performance
+ * 
+ * Run via Heroku Scheduler: Daily at 3am
+ */
+
+const { Pool } = require('pg');
+
+const RETENTION_POLICIES = {
+  // Keep completed round records forever (users need to verify)
+  keeper_rounds_resolved: null, // Never delete
+  
+  // Archive old incomplete/stuck rounds after 30 days
+  keeper_rounds_incomplete: 30, // days
+  
+  // Keep detailed action logs for 30 days
+  keeper_actions: 30, // days
+  
+  // Keep health snapshots for 90 days
+  keeper_health: 90, // days
+  
+  // Keep jackpot history forever (verification data)
+  jackpot_rounds: null, // Never delete
+};
+
+class DatabaseCleaner {
+  constructor() {
+    this.pool = new Pool({
+      connectionString: process.env.DATABASE_URL,
+      ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+    });
+  }
+
+  async getTableStats() {
+    const stats = {};
+    
+    const tables = ['keeper_rounds', 'keeper_actions', 'keeper_health', 'jackpot_rounds'];
+    
+    for (const table of tables) {
+      const result = await this.pool.query(`SELECT COUNT(*) as count FROM ${table}`);
+      const sizeResult = await this.pool.query(`
+        SELECT pg_size_pretty(pg_total_relation_size('${table}')) as size
+      `);
+      stats[table] = {
+        rows: parseInt(result.rows[0].count),
+        size: sizeResult.rows[0].size
+      };
+    }
+    
+    return stats;
+  }
+
+  async cleanupKeeperActions() {
+    console.log('\n🧹 Cleaning keeper_actions...');
+    
+    const days = RETENTION_POLICIES.keeper_actions;
+    
+    const result = await this.pool.query(`
+      DELETE FROM keeper_actions
+      WHERE timestamp < NOW() - INTERVAL '${days} days'
+      RETURNING id
+    `);
+    
+    console.log(`   Deleted ${result.rowCount} old action logs (older than ${days} days)`);
+    return result.rowCount;
+  }
+
+  async cleanupKeeperHealth() {
+    console.log('\n🧹 Cleaning keeper_health...');
+    
+    const days = RETENTION_POLICIES.keeper_health;
+    
+    const result = await this.pool.query(`
+      DELETE FROM keeper_health
+      WHERE timestamp < NOW() - INTERVAL '${days} days'
+      RETURNING id
+    `);
+    
+    console.log(`   Deleted ${result.rowCount} old health snapshots (older than ${days} days)`);
+    return result.rowCount;
+  }
+
+  async archiveOldIncompleteRounds() {
+    console.log('\n🧹 Archiving incomplete keeper_rounds...');
+    
+    const days = RETENTION_POLICIES.keeper_rounds_incomplete;
+    
+    // Only delete rounds that are stuck/incomplete and old
+    const result = await this.pool.query(`
+      DELETE FROM keeper_rounds
+      WHERE status NOT IN ('resolved', 'open')
+        AND updated_at < NOW() - INTERVAL '${days} days'
+      RETURNING round_id, status
+    `);
+    
+    console.log(`   Archived ${result.rowCount} old incomplete rounds (older than ${days} days)`);
+    
+    if (result.rowCount > 0) {
+      console.log('   Rounds archived:', result.rows.map(r => `${r.round_id} (${r.status})`).join(', '));
+    }
+    
+    return result.rowCount;
+  }
+
+  async vacuum() {
+    console.log('\n🗜️  Running VACUUM to reclaim space...');
+    
+    await this.pool.query('VACUUM ANALYZE keeper_actions');
+    await this.pool.query('VACUUM ANALYZE keeper_health');
+    await this.pool.query('VACUUM ANALYZE keeper_rounds');
+    
+    console.log('   ✅ VACUUM complete');
+  }
+
+  async run() {
+    console.log('🧹 DATABASE CLEANUP STARTING');
+    console.log('='.repeat(80));
+    console.log(`Time: ${new Date().toISOString()}`);
+    console.log();
+    
+    try {
+      // Show stats before cleanup
+      console.log('📊 Before Cleanup:');
+      const statsBefore = await this.getTableStats();
+      for (const [table, stats] of Object.entries(statsBefore)) {
+        console.log(`   ${table}: ${stats.rows.toLocaleString()} rows (${stats.size})`);
+      }
+      
+      // Cleanup
+      const actionsDeleted = await this.cleanupKeeperActions();
+      const healthDeleted = await this.cleanupKeeperHealth();
+      const roundsArchived = await this.archiveOldIncompleteRounds();
+      
+      // Vacuum
+      await this.vacuum();
+      
+      // Show stats after cleanup
+      console.log('\n📊 After Cleanup:');
+      const statsAfter = await this.getTableStats();
+      for (const [table, stats] of Object.entries(statsAfter)) {
+        const before = statsBefore[table].rows;
+        const after = stats.rows;
+        const diff = before - after;
+        const diffStr = diff > 0 ? ` (-${diff})` : '';
+        console.log(`   ${table}: ${stats.rows.toLocaleString()} rows${diffStr} (${stats.size})`);
+      }
+      
+      // Summary
+      console.log('\n' + '='.repeat(80));
+      console.log('✅ CLEANUP COMPLETE');
+      console.log('='.repeat(80));
+      console.log(`
+Summary:
+  - ${actionsDeleted} action logs deleted
+  - ${healthDeleted} health snapshots deleted
+  - ${roundsArchived} incomplete rounds archived
+  - keeper_rounds (resolved): Kept forever ✅
+  - jackpot_rounds: Kept forever ✅
+  
+Retention Policies:
+  - keeper_actions: ${RETENTION_POLICIES.keeper_actions} days
+  - keeper_health: ${RETENTION_POLICIES.keeper_health} days
+  - keeper_rounds (incomplete): ${RETENTION_POLICIES.keeper_rounds_incomplete} days
+  - keeper_rounds (resolved): Forever (audit trail)
+  - jackpot_rounds: Forever (user verification)
+      `);
+      console.log('='.repeat(80));
+      
+    } catch (error) {
+      console.error('\n❌ CLEANUP FAILED:', error.message);
+      console.error(error);
+      process.exit(1);
+    } finally {
+      await this.pool.end();
+    }
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  const cleaner = new DatabaseCleaner();
+  cleaner.run();
+}
+
+module.exports = DatabaseCleaner;
+

package/scripts/clear-notification-cache.js

@@ -0,0 +1,85 @@
+/**
+ * Clear all notification caches from Redis
+ * 
+ * Usage:
+ *   REDIS_URL=<your-redis-url> node scripts/clear-notification-cache.js
+ * 
+ * Or via Heroku:
+ *   heroku run node scripts/clear-notification-cache.js -a <app-name>
+ */
+
+const Redis = require('ioredis');
+
+async function clearNotificationCache() {
+  const redisUrl = process.env.REDIS_URL;
+
+  if (!redisUrl) {
+    console.error('❌ REDIS_URL environment variable is required');
+    console.log('Usage: REDIS_URL=<your-redis-url> node scripts/clear-notification-cache.js');
+    process.exit(1);
+  }
+
+  console.log('🔗 Connecting to Redis...');
+  
+  const client = new Redis(redisUrl, {
+    tls: redisUrl.startsWith('rediss://') ? { rejectUnauthorized: false } : undefined,
+  });
+
+  try {
+    await client.ping();
+    console.log('✅ Connected to Redis\n');
+
+    // Find and delete all notification-related keys
+    const patterns = [
+      'notifications:*',   // User notification sorted sets
+      'notification:*',    // Individual notification hashes
+      'unread:*',          // Unread counts
+    ];
+
+    let totalDeleted = 0;
+
+    for (const pattern of patterns) {
+      console.log(`🔍 Scanning for keys matching: ${pattern}`);
+      
+      let cursor = '0';
+      let keysToDelete = [];
+
+      // Use SCAN to find keys (safe for production)
+      do {
+        const [newCursor, keys] = await client.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+        cursor = newCursor;
+        keysToDelete = keysToDelete.concat(keys);
+      } while (cursor !== '0');
+
+      if (keysToDelete.length > 0) {
+        console.log(`   Found ${keysToDelete.length} keys`);
+        
+        // Delete in batches
+        const batchSize = 100;
+        for (let i = 0; i < keysToDelete.length; i += batchSize) {
+          const batch = keysToDelete.slice(i, i + batchSize);
+          await client.del(...batch);
+        }
+        
+        totalDeleted += keysToDelete.length;
+        console.log(`   ✅ Deleted ${keysToDelete.length} keys`);
+      } else {
+        console.log(`   No keys found`);
+      }
+    }
+
+    console.log(`\n🎉 Done! Cleared ${totalDeleted} notification cache keys.`);
+    console.log('📝 Users will have their caches rebuilt from PostgreSQL on next request.');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  } finally {
+    await client.quit();
+    console.log('\n🔌 Disconnected from Redis');
+  }
+}
+
+clearNotificationCache();
+
+

package/scripts/convert-mnemonic.js

@@ -0,0 +1,50 @@
+// Convert mnemonic to Solana keypair
+const fs = require('fs');
+
+// Your mnemonic
+const mnemonic = process.argv[2] || 'abuse comfort amazing live royal auto target quick damage flavor rug dress';
+
+console.log('🔑 Converting mnemonic to Solana keypair...\n');
+console.log('Mnemonic:', mnemonic);
+console.log('');
+
+// Using solana-keygen programmatically
+const { execSync } = require('child_process');
+
+try {
+  // Create a temp file with the mnemonic
+  const tempFile = '/tmp/temp-mnemonic.txt';
+  fs.writeFileSync(tempFile, mnemonic);
+  
+  // Use solana-keygen to recover
+  const output = execSync(`solana-keygen recover -o wallets/oracle-new.json --force 'prompt://key=0/0' < ${tempFile}`, {
+    stdio: ['pipe', 'pipe', 'pipe']
+  }).toString();
+  
+  // Get public key
+  const pubkey = execSync('solana-keygen pubkey wallets/oracle-new.json').toString().trim();
+  
+  console.log('✅ Keypair recovered!');
+  console.log('Public Key:', pubkey);
+  console.log('');
+  console.log('Expected: FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa');
+  console.log('Match:', pubkey === 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa' ? '✅ YES' : '❌ NO');
+  console.log('');
+  console.log('Saved to: wallets/oracle-new.json');
+  console.log('');
+  console.log('To use:');
+  console.log('  mv wallets/oracle-new.json wallets/oracle.json');
+  
+  // Clean up
+  fs.unlinkSync(tempFile);
+  
+} catch (error) {
+  console.error('Error:', error.message);
+  console.log('\n📝 MANUAL STEPS:\n');
+  console.log('1. Run this command:');
+  console.log('   solana-keygen recover -o wallets/oracle.json --force\n');
+  console.log('2. When prompted, enter your mnemonic phrase\n');
+  console.log('3. Press Enter for default derivation path\n');
+  console.log('4. Verify public key matches: FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa\n');
+}
+

package/scripts/create-users-table.sql

@@ -0,0 +1,44 @@
+-- Users table for wallet-based authentication
+-- Run this to create the users table in your Postgres database
+
+CREATE TABLE IF NOT EXISTS users (
+  id SERIAL PRIMARY KEY,
+  wallet_address VARCHAR(44) UNIQUE NOT NULL,
+  email VARCHAR(255),
+  username VARCHAR(50) NOT NULL,
+  avatar TEXT,
+  referral_code VARCHAR(50),
+  signature TEXT,
+  onboarding_complete BOOLEAN DEFAULT false,
+  created_at TIMESTAMP DEFAULT NOW(),
+  updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Nonces table for secure signature verification (prevents replay attacks)
+CREATE TABLE IF NOT EXISTS auth_nonces (
+  wallet_address VARCHAR(44) PRIMARY KEY,
+  nonce VARCHAR(64) NOT NULL,
+  expires_at TIMESTAMP NOT NULL,
+  used BOOLEAN DEFAULT false,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Index for faster wallet lookups
+CREATE INDEX IF NOT EXISTS idx_users_wallet ON users(wallet_address);
+
+-- Index for username lookups
+CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
+
+-- Index for nonce cleanup
+CREATE INDEX IF NOT EXISTS idx_nonces_expires ON auth_nonces(expires_at);
+
+COMMENT ON TABLE users IS 'User profiles with wallet-based authentication';
+COMMENT ON COLUMN users.wallet_address IS 'Solana wallet public key (base58)';
+COMMENT ON COLUMN users.signature IS 'Signature proving wallet ownership';
+COMMENT ON COLUMN users.onboarding_complete IS 'Whether user has completed onboarding flow';
+
+COMMENT ON TABLE auth_nonces IS 'One-time nonces for signature verification (prevents replay attacks)';
+COMMENT ON COLUMN auth_nonces.nonce IS 'Cryptographically secure random nonce';
+COMMENT ON COLUMN auth_nonces.used IS 'Whether this nonce has been used';
+COMMENT ON COLUMN auth_nonces.expires_at IS 'Nonce expiration time (5 minutes)';
+