dubs-server 1.0.0

package/scripts/rebuild-heroku-database.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+# ============================================
+# 🎮 REBUILD HEROKU DATABASE FROM SCRATCH
+# ============================================
+# This script completely nukes and rebuilds the Heroku database
+# with the complete new schema
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Get DATABASE_URL from Heroku
+echo "📡 Getting Heroku database URL..."
+DB_URL=$(heroku config:get DATABASE_URL 2>&1 | grep -v "Warning" | grep -v "Error ID" | grep "postgres://")
+
+if [ -z "$DB_URL" ]; then
+    echo -e "${RED}❌ Could not get DATABASE_URL from Heroku${NC}"
+    echo "Make sure you're in the right directory with Heroku app configured"
+    exit 1
+fi
+
+echo -e "${GREEN}✅ Found Heroku database${NC}"
+echo ""
+
+echo "╔════════════════════════════════════════════════╗"
+echo "║   ⚠️  NUKE HEROKU PRODUCTION DATABASE ⚠️       ║"
+echo "╚════════════════════════════════════════════════╝"
+echo ""
+echo -e "${RED}This will DELETE EVERYTHING and rebuild from scratch!${NC}"
+echo ""
+echo "Database: $(echo $DB_URL | sed 's/postgres:\/\/.*@/postgres:\/\/*****@/')"
+echo ""
+
+read -p "Type 'NUKE' to confirm: " -r
+echo ""
+
+if [[ ! $REPLY == "NUKE" ]]; then
+    echo -e "${GREEN}✅ Cancelled${NC}"
+    exit 0
+fi
+
+echo ""
+echo "🗑️  Step 1: Dropping all tables..."
+echo ""
+
+psql "$DB_URL" << 'DROPSQL'
+-- Drop all views first
+DROP VIEW IF EXISTS keeper_health_summary CASCADE;
+DROP VIEW IF EXISTS stuck_rounds CASCADE;
+
+-- Drop all tables
+DROP TABLE IF EXISTS chat_notifications CASCADE;
+DROP TABLE IF EXISTS chat_reactions CASCADE;
+DROP TABLE IF EXISTS chat_messages CASCADE;
+DROP TABLE IF EXISTS user_relationships CASCADE;
+DROP TABLE IF EXISTS friend_requests CASCADE;
+DROP TABLE IF EXISTS friends CASCADE;
+DROP TABLE IF EXISTS group_members CASCADE;
+DROP TABLE IF EXISTS groups CASCADE;
+DROP TABLE IF EXISTS player_history CASCADE;
+DROP TABLE IF EXISTS player_stats CASCADE;
+DROP TABLE IF EXISTS user_badges CASCADE;
+DROP TABLE IF EXISTS auth_nonces CASCADE;
+DROP TABLE IF EXISTS user_sessions CASCADE;
+DROP TABLE IF EXISTS keeper_actions CASCADE;
+DROP TABLE IF EXISTS keeper_health CASCADE;
+DROP TABLE IF EXISTS keeper_rounds CASCADE;
+DROP TABLE IF EXISTS jackpot_rounds CASCADE;
+DROP TABLE IF EXISTS users CASCADE;
+
+SELECT 'All tables dropped' as status;
+DROPSQL
+
+echo -e "${GREEN}✅ All tables dropped${NC}"
+echo ""
+echo "🏗️  Step 2: Creating complete schema..."
+echo ""
+
+# Run the complete schema setup
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+psql "$DB_URL" < "$SCRIPT_DIR/setup-complete-database.sql"
+
+echo ""
+echo -e "${GREEN}✅ Schema created${NC}"
+echo ""
+echo "📊 Step 3: Verifying setup..."
+echo ""
+
+# Count tables
+TABLE_COUNT=$(psql "$DB_URL" -t -c "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE';" | xargs)
+
+echo "Tables created: $TABLE_COUNT"
+echo ""
+
+# List tables
+psql "$DB_URL" -c "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE' ORDER BY table_name;"
+
+echo ""
+echo "╔════════════════════════════════════════════════╗"
+echo "║       ✅ HEROKU DATABASE REBUILT! ✅            ║"
+echo "╚════════════════════════════════════════════════╝"
+echo ""
+echo -e "${GREEN}✅ Complete schema with $TABLE_COUNT tables${NC}"
+echo -e "${GREEN}✅ All indexes and views created${NC}"
+echo -e "${GREEN}✅ Ready for production use${NC}"
+echo ""
+echo "🚀 Your Heroku database is now fresh and ready!"
+echo ""

package/scripts/recover-funds.js

@@ -0,0 +1,357 @@
+#!/usr/bin/env node
+/**
+ * Fund Recovery Script
+ * Check game PDAs and help recover stuck funds
+ * 
+ * Usage:
+ *   node recover-funds.js <pda1> <pda2> ...
+ *   node recover-funds.js --claim <gameId> <playerAddress>
+ */
+
+require('dotenv').config();
+const { Connection, PublicKey, Keypair, Transaction, TransactionInstruction, LAMPORTS_PER_SOL } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+// Program ID (mainnet)
+const PROGRAM_ID = new PublicKey('85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+// Instruction discriminators
+const CLAIM_AUTO = Buffer.from([8, 125, 228, 42, 245, 90, 82, 17]); // claim_automatic_winnings
+const EMERGENCY_REFUND = Buffer.from([/* need to calculate */]); // emergency_refund_automatic
+
+// RPC endpoint
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com';
+
+console.log('💰 Fund Recovery Tool');
+console.log('=====================');
+console.log(`RPC: ${RPC_URL}`);
+console.log(`Program: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Decode game account data
+ */
+function decodeGameAccount(data) {
+  try {
+    // Skip 8 byte discriminator
+    let offset = 8;
+    
+    // game_id: u64
+    const gameId = data.readBigUInt64LE(offset);
+    offset += 8;
+    
+    // authority: Pubkey (32 bytes)
+    const authority = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    
+    // buy_in: u64
+    const buyIn = data.readBigUInt64LE(offset);
+    offset += 8;
+    
+    // max_players: u8
+    const maxPlayers = data.readUInt8(offset);
+    offset += 1;
+    
+    // operator_wallet: Pubkey (32 bytes)
+    const operatorWallet = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    
+    // operator_fee_percentage: u8
+    const operatorFee = data.readUInt8(offset);
+    offset += 1;
+    
+    // players vec: 4 bytes length + 32 bytes * length
+    const playersLen = data.readUInt32LE(offset);
+    offset += 4;
+    const players = [];
+    for (let i = 0; i < playersLen; i++) {
+      players.push(new PublicKey(data.slice(offset, offset + 32)));
+      offset += 32;
+    }
+    
+    // total_pot: u64
+    const totalPot = data.readBigUInt64LE(offset);
+    offset += 8;
+    
+    // is_active: bool
+    const isActive = data.readUInt8(offset) === 1;
+    offset += 1;
+    
+    // votes vec: skip for now (4 bytes length + entries)
+    const votesLen = data.readUInt32LE(offset);
+    offset += 4;
+    offset += votesLen * (32 + 32); // voter + voted_for
+    
+    // voting_enabled: bool
+    const votingEnabled = data.readUInt8(offset) === 1;
+    offset += 1;
+    
+    // game_mode: u8
+    const gameMode = data.readUInt8(offset);
+    offset += 1;
+    
+    // referee: Option<Pubkey> - 1 byte tag + 32 bytes if Some
+    const hasReferee = data.readUInt8(offset) === 1;
+    offset += 1;
+    if (hasReferee) {
+      offset += 32;
+    }
+    
+    // referee_commission: u8
+    const refereeCommission = data.readUInt8(offset);
+    offset += 1;
+    
+    // player_picks vec: 4 bytes length + (32 + 1) bytes * length
+    const picksLen = data.readUInt32LE(offset);
+    offset += 4;
+    const playerPicks = [];
+    for (let i = 0; i < picksLen; i++) {
+      const player = new PublicKey(data.slice(offset, offset + 32));
+      offset += 32;
+      const teamChoice = data.readUInt8(offset); // 0 = Home, 1 = Away
+      offset += 1;
+      playerPicks.push({ player: player.toString(), teamChoice: teamChoice === 0 ? 'Home' : 'Away' });
+    }
+    
+    // lock_timestamp: i64
+    const lockTimestamp = Number(data.readBigInt64LE(offset));
+    offset += 8;
+    
+    // is_locked: bool
+    const isLocked = data.readUInt8(offset) === 1;
+    offset += 1;
+    
+    // is_resolved: bool
+    const isResolved = data.readUInt8(offset) === 1;
+    offset += 1;
+    
+    // winning_team: Option<TeamChoice>
+    const hasWinner = data.readUInt8(offset) === 1;
+    offset += 1;
+    let winningTeam = null;
+    if (hasWinner) {
+      winningTeam = data.readUInt8(offset) === 0 ? 'Home' : 'Away';
+      offset += 1;
+    }
+    
+    // sports_event_id: String (4 bytes length + chars)
+    const eventIdLen = data.readUInt32LE(offset);
+    offset += 4;
+    const sportsEventId = data.slice(offset, offset + eventIdLen).toString('utf8');
+    offset += eventIdLen;
+    
+    // oracle: Pubkey
+    const oracle = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    
+    // claimed_players vec
+    const claimedLen = data.readUInt32LE(offset);
+    offset += 4;
+    const claimedPlayers = [];
+    for (let i = 0; i < claimedLen; i++) {
+      claimedPlayers.push(new PublicKey(data.slice(offset, offset + 32)).toString());
+      offset += 32;
+    }
+    
+    // operator_fee_claimed: bool
+    const operatorFeeClaimed = data.readUInt8(offset) === 1;
+    
+    return {
+      gameId: gameId.toString(),
+      authority: authority.toString(),
+      buyIn: Number(buyIn) / LAMPORTS_PER_SOL,
+      maxPlayers,
+      operatorWallet: operatorWallet.toString(),
+      operatorFee,
+      players: players.map(p => p.toString()),
+      totalPot: Number(totalPot) / LAMPORTS_PER_SOL,
+      isActive,
+      votingEnabled,
+      gameMode: ['Manual', 'Democratic', 'Referee', 'Automatic'][gameMode],
+      playerPicks,
+      lockTimestamp: new Date(lockTimestamp * 1000).toISOString(),
+      isLocked,
+      isResolved,
+      winningTeam,
+      sportsEventId,
+      oracle: oracle.toString(),
+      claimedPlayers,
+      operatorFeeClaimed,
+    };
+  } catch (error) {
+    console.error('Decode error:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Check a single game PDA
+ */
+async function checkGamePDA(pdaAddress) {
+  console.log(`\n📍 Checking PDA: ${pdaAddress}`);
+  console.log('─'.repeat(60));
+  
+  try {
+    const pda = new PublicKey(pdaAddress);
+    const accountInfo = await connection.getAccountInfo(pda);
+    
+    if (!accountInfo) {
+      console.log('   ❌ Account does not exist (funds may have been withdrawn)');
+      return null;
+    }
+    
+    console.log(`   💰 Balance: ${accountInfo.lamports / LAMPORTS_PER_SOL} SOL`);
+    console.log(`   📦 Data size: ${accountInfo.data.length} bytes`);
+    console.log(`   👤 Owner: ${accountInfo.owner.toString()}`);
+    
+    if (!accountInfo.owner.equals(PROGRAM_ID)) {
+      console.log('   ⚠️  Not owned by Dubs program!');
+      return null;
+    }
+    
+    const game = decodeGameAccount(accountInfo.data);
+    
+    if (!game) {
+      console.log('   ⚠️  Could not decode game data');
+      return null;
+    }
+    
+    console.log(`\n   📊 Game State:`);
+    console.log(`      Game ID: ${game.gameId}`);
+    console.log(`      Mode: ${game.gameMode}`);
+    console.log(`      Buy-in: ${game.buyIn} SOL`);
+    console.log(`      Prize Pool: ${game.totalPot} SOL`);
+    console.log(`      Active: ${game.isActive}`);
+    console.log(`      Locked: ${game.isLocked}`);
+    console.log(`      Resolved: ${game.isResolved}`);
+    console.log(`      Winner: ${game.winningTeam || 'None (refund all)'}`);
+    console.log(`      Lock Time: ${game.lockTimestamp}`);
+    console.log(`      Sports Event: ${game.sportsEventId || 'N/A'}`);
+    
+    console.log(`\n   👥 Player Picks (${game.playerPicks.length}):`);
+    game.playerPicks.forEach((pick, i) => {
+      const claimed = game.claimedPlayers.includes(pick.player) ? '✅ CLAIMED' : '⏳ Unclaimed';
+      console.log(`      ${i + 1}. ${pick.player.slice(0, 8)}... → ${pick.teamChoice} ${claimed}`);
+    });
+    
+    if (game.claimedPlayers.length > 0) {
+      console.log(`\n   ✅ Claimed Players (${game.claimedPlayers.length}):`);
+      game.claimedPlayers.forEach((p, i) => {
+        console.log(`      ${i + 1}. ${p.slice(0, 8)}...`);
+      });
+    }
+    
+    // Determine recovery action
+    console.log(`\n   🔧 Recovery Status:`);
+    
+    if (game.isResolved) {
+      if (game.winningTeam === null) {
+        console.log(`      ✅ Game resolved as TIE/REFUND - all players can claim!`);
+      } else {
+        console.log(`      ✅ Game resolved - ${game.winningTeam} team won`);
+      }
+      
+      const unclaimedPlayers = game.playerPicks
+        .filter(p => !game.claimedPlayers.includes(p.player))
+        .map(p => p.player);
+      
+      if (unclaimedPlayers.length > 0) {
+        console.log(`      📢 ${unclaimedPlayers.length} player(s) can still claim!`);
+        console.log(`      💡 Use: node recover-funds.js --claim ${game.gameId} <yourWalletAddress>`);
+      } else {
+        console.log(`      ✅ All players have claimed`);
+      }
+    } else {
+      const now = Date.now();
+      const lockTime = new Date(game.lockTimestamp).getTime();
+      const sevenDays = 7 * 24 * 60 * 60 * 1000;
+      
+      if (now > lockTime + sevenDays) {
+        console.log(`      ⚠️  NOT resolved but 7 days have passed!`);
+        console.log(`      💡 Emergency refund is available!`);
+        console.log(`      💡 Oracle or anyone can trigger emergency_refund_automatic`);
+      } else {
+        const daysUntil = Math.ceil((lockTime + sevenDays - now) / (24 * 60 * 60 * 1000));
+        console.log(`      ⏳ NOT resolved yet`);
+        console.log(`      ⏳ Emergency refund available in ${daysUntil} days`);
+        console.log(`      💡 Oracle needs to resolve this game first`);
+        console.log(`      💡 Or wait for emergency refund window`);
+      }
+    }
+    
+    return game;
+    
+  } catch (error) {
+    console.log(`   ❌ Error: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Build claim transaction
+ */
+async function buildClaimTransaction(gameId, playerAddress) {
+  console.log(`\n🔨 Building claim transaction...`);
+  console.log(`   Game ID: ${gameId}`);
+  console.log(`   Player: ${playerAddress}`);
+  
+  try {
+    // Convert gameId to buffer
+    // The gameId in the account is a u64, but we store it as a hash of the string gameId
+    // We need to figure out the PDA derivation
+    
+    // For now, output instructions for manual claim via API
+    console.log(`\n   💡 To claim, use the API endpoint:`);
+    console.log(`   POST /api/v1/prod/transaction/build/claim-automatic`);
+    console.log(`   Body: { "playerAddress": "${playerAddress}", "gameId": "${gameId}" }`);
+    console.log(`\n   Or use the frontend claim button in My Games`);
+    
+  } catch (error) {
+    console.error(`   ❌ Error: ${error.message}`);
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log('Usage:');
+    console.log('  node recover-funds.js <pda1> [pda2] [pda3] ...   # Check game PDAs');
+    console.log('  node recover-funds.js --claim <gameId> <wallet>  # Build claim tx');
+    console.log('');
+    console.log('Examples:');
+    console.log('  node recover-funds.js FrggqLKgxdiTLybXK3fU8qpFG7YPtyh6fP2Y5onYWGhq');
+    console.log('  node recover-funds.js --claim sport-123456-abc 7D47yF4qKdQGkT9xNWon...');
+    process.exit(0);
+  }
+  
+  if (args[0] === '--claim') {
+    if (args.length < 3) {
+      console.error('❌ Usage: node recover-funds.js --claim <gameId> <playerAddress>');
+      process.exit(1);
+    }
+    await buildClaimTransaction(args[1], args[2]);
+  } else {
+    // Check each PDA
+    const pdas = args.filter(a => !a.startsWith('--'));
+    
+    console.log(`\n🔍 Checking ${pdas.length} game PDA(s)...\n`);
+    
+    for (const pda of pdas) {
+      await checkGamePDA(pda);
+    }
+    
+    console.log('\n' + '═'.repeat(60));
+    console.log('✨ Done!\n');
+  }
+}
+
+main().catch(console.error);
+
+