dubs-server 1.0.0

package/scripts/fix-missing-badges.sql

@@ -0,0 +1,91 @@
+-- Retroactively award badges to users who have referrals but no badges
+
+-- Get users who have referrals
+WITH referral_counts AS (
+  SELECT 
+    u.id as user_id,
+    u.my_referral_code,
+    COUNT(referred.id) as referral_count
+  FROM users u
+  LEFT JOIN users referred ON referred.referral_code = u.my_referral_code
+  WHERE u.my_referral_code IS NOT NULL
+  GROUP BY u.id, u.my_referral_code
+)
+-- Award badges based on thresholds
+INSERT INTO user_badges (user_id, badge_type, badge_name, badge_description, badge_icon, referral_count)
+SELECT 
+  rc.user_id,
+  CASE 
+    WHEN rc.referral_count >= 10 THEN 'captain'
+    WHEN rc.referral_count >= 5 THEN 'ambassador'
+    WHEN rc.referral_count >= 1 THEN 'recruiter'
+  END as badge_type,
+  CASE 
+    WHEN rc.referral_count >= 10 THEN 'Captain'
+    WHEN rc.referral_count >= 5 THEN 'Ambassador'
+    WHEN rc.referral_count >= 1 THEN 'Recruiter'
+  END as badge_name,
+  CASE 
+    WHEN rc.referral_count >= 10 THEN 'Referred 10 or more users'
+    WHEN rc.referral_count >= 5 THEN 'Referred 5 users'
+    WHEN rc.referral_count >= 1 THEN 'Referred your first user'
+  END as badge_description,
+  CASE 
+    WHEN rc.referral_count >= 10 THEN '/badges/badge_2-removebg-preview.png'
+    WHEN rc.referral_count >= 5 THEN '/badges/badge_1-removebg-preview.png'
+    WHEN rc.referral_count >= 1 THEN '/badges/badge_0-removebg-preview.png'
+  END as badge_icon,
+  rc.referral_count
+FROM referral_counts rc
+WHERE rc.referral_count >= 1
+ON CONFLICT (user_id, badge_type) DO UPDATE 
+  SET referral_count = EXCLUDED.referral_count;
+
+-- Award lower tier badges if user has higher tier
+INSERT INTO user_badges (user_id, badge_type, badge_name, badge_description, badge_icon, referral_count)
+SELECT DISTINCT
+  ub.user_id,
+  'recruiter',
+  'Recruiter',
+  'Referred your first user',
+  '/badges/badge_0-removebg-preview.png',
+  ub.referral_count
+FROM user_badges ub
+WHERE ub.badge_type IN ('ambassador', 'captain')
+  AND NOT EXISTS (
+    SELECT 1 FROM user_badges ub2 
+    WHERE ub2.user_id = ub.user_id 
+    AND ub2.badge_type = 'recruiter'
+  )
+ON CONFLICT (user_id, badge_type) DO NOTHING;
+
+-- Award ambassador badge if user has captain
+INSERT INTO user_badges (user_id, badge_type, badge_name, badge_description, badge_icon, referral_count)
+SELECT DISTINCT
+  ub.user_id,
+  'ambassador',
+  'Ambassador',
+  'Referred 5 users',
+  '/badges/badge_1-removebg-preview.png',
+  ub.referral_count
+FROM user_badges ub
+WHERE ub.badge_type = 'captain'
+  AND NOT EXISTS (
+    SELECT 1 FROM user_badges ub2 
+    WHERE ub2.user_id = ub.user_id 
+    AND ub2.badge_type = 'ambassador'
+  )
+ON CONFLICT (user_id, badge_type) DO NOTHING;
+
+-- Show results
+SELECT 
+  u.username,
+  u.wallet_address,
+  COUNT(referred.id) as referrals,
+  STRING_AGG(ub.badge_name, ', ') as badges
+FROM users u
+LEFT JOIN users referred ON referred.referral_code = u.my_referral_code
+LEFT JOIN user_badges ub ON ub.user_id = u.id
+WHERE u.my_referral_code IS NOT NULL
+GROUP BY u.id, u.username, u.wallet_address
+ORDER BY referrals DESC;

package/scripts/fix-payment-notifications.sql

@@ -0,0 +1,41 @@
+-- Fix payment notification constraint on Heroku
+-- Run this if payments aren't working after deployment
+
+-- Drop the old constraint
+ALTER TABLE chat_notifications 
+DROP CONSTRAINT IF EXISTS chat_notifications_notification_type_check;
+
+-- Add new constraint with payment types
+ALTER TABLE chat_notifications 
+ADD CONSTRAINT chat_notifications_notification_type_check 
+CHECK (notification_type IN (
+  'reply', 
+  'mention', 
+  'friend_message', 
+  'reaction', 
+  'friend_request', 
+  'friend_request_accepted', 
+  'friend_request_declined', 
+  'referral', 
+  'game_joined', 
+  'game_invite', 
+  'game_starting_soon', 
+  'game_starting_now',
+  'payment_received',
+  'payment_sent'
+));
+
+-- Verify it worked
+SELECT constraint_name, check_clause 
+FROM information_schema.check_constraints 
+WHERE constraint_name = 'chat_notifications_notification_type_check';
+
+
+
+
+
+
+
+
+
+

package/scripts/force-new-round.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// NUCLEAR OPTION: Force increment config round ID to skip stuck round
+
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+const RPC_URL = 'https://api.devnet.solana.com';
+const PROGRAM_ID = new PublicKey('BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+
+async function main() {
+  const oracleKeyPath = path.join(__dirname, '..', 'wallets', 'jackpot_oracle.json');
+  const secretKey = JSON.parse(fs.readFileSync(oracleKeyPath, 'utf-8'));
+  const wallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  
+  console.log('💣 NUCLEAR OPTION: Opening round 98 to skip 97');
+  
+  const connection = new Connection(RPC_URL, 'confirmed');
+  
+  const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], PROGRAM_ID);
+  const [round98Pda] = PublicKey.findProgramAddressSync([Buffer.from('round'), Buffer.from([98,0,0,0,0,0,0,0])], PROGRAM_ID);
+  const [entries98Pda] = PublicKey.findProgramAddressSync([Buffer.from('entries'), Buffer.from([98,0,0,0,0,0,0,0])], PROGRAM_ID);
+  
+  const OPEN_ROUND = Buffer.from([66, 235, 123, 240, 8, 35, 185, 159]);
+  
+  const ix = new TransactionInstruction({
+    keys: [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: round98Pda, isSigner: false, isWritable: true },
+      { pubkey: entries98Pda, isSigner: false, isWritable: true },
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    programId: PROGRAM_ID,
+    data: OPEN_ROUND,
+  });
+  
+  const tx = new Transaction().add(ix);
+  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+  tx.feePayer = wallet.publicKey;
+  tx.sign(wallet);
+  
+  try {
+    const sig = await connection.sendRawTransaction(tx.serialize());
+    console.log('Sig:', sig);
+    await connection.confirmTransaction(sig);
+    console.log('✅ Round 98 opened! System should be unstuck now!');
+  } catch (e) {
+    console.error('❌', e.message);
+  }
+}
+
+const { SystemProgram } = require('@solana/web3.js');
+main();
+

package/scripts/force-resolve-and-claim.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+/**
+ * Force Resolve and Claim Script
+ * Resolves stuck games and claims refunds directly using on-chain data
+ * 
+ * Usage:
+ *   node force-resolve-and-claim.js
+ */
+
+require('dotenv').config();
+const { 
+  Connection, 
+  PublicKey, 
+  Keypair, 
+  Transaction, 
+  TransactionInstruction,
+  sendAndConfirmTransaction,
+  LAMPORTS_PER_SOL 
+} = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CONFIGURATION - Update these values!
+// ═══════════════════════════════════════════════════════════════════════════
+
+// The stuck games to recover (from on-chain analysis)
+const STUCK_GAMES = [
+  {
+    pda: 'FrggqLKgxdiTLybXK3fU8qpFG7YPtyh6fP2Y5onYWGhq',
+    gameId: BigInt('16210635126547177265'),
+    player: 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa',
+  },
+  {
+    pda: 'DQGXTTewkW6QSSWTgaGTS8naepD6yDBumRRezhnpRkLK',
+    gameId: BigInt('13313520635794528485'),
+    player: 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa',
+  },
+  {
+    pda: '6Bhvh1f9H1X3VMigVXLQNKoxCUftcTcnMCPGqzX4aBY',
+    gameId: BigInt('4788170354430293005'),
+    player: 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa',
+  },
+];
+
+// Program ID (mainnet)
+const PROGRAM_ID = new PublicKey('85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+// Hardcoded operator wallet (from program)
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+// Instruction discriminators (calculated from Anchor)
+const RESOLVE_AUTO_DISCRIMINATOR = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+const CLAIM_AUTO_DISCRIMINATOR = Buffer.from([8, 125, 228, 42, 245, 90, 82, 17]);
+
+// RPC endpoint - use Alchemy for reliability
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com';
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('🔧 Force Resolve and Claim Tool');
+console.log('================================');
+console.log(`RPC: ${RPC_URL}`);
+console.log(`Program: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Load oracle wallet from environment or file
+ */
+function loadOracleWallet() {
+  // Try environment variable first
+  if (process.env.ORACLE_WALLET_JSON) {
+    console.log('🔑 Loading oracle wallet from ORACLE_WALLET_JSON env var');
+    const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+  
+  // Try file path
+  const walletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, 'wallets/oracle.json');
+  
+  if (fs.existsSync(walletPath)) {
+    console.log('🔑 Loading oracle wallet from:', walletPath);
+    const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+  
+  console.error('❌ Oracle wallet not found!');
+  console.log('   Set ORACLE_WALLET_JSON env var or create wallets/oracle.json');
+  process.exit(1);
+}
+
+/**
+ * Build resolve_automatic_game instruction
+ * Sets winning_team to None (0 option tag) for refund
+ */
+function buildResolveInstruction(gamePda, gameId, oracleWallet) {
+  // Instruction data: discriminator (8) + game_id (8) + winning_team Option (1 byte = None)
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameId);
+  
+  // Option<TeamChoice>: 0 = None (refund all)
+  const winningTeamBuf = Buffer.from([0]); // None variant
+  
+  const data = Buffer.concat([
+    RESOLVE_AUTO_DISCRIMINATOR,
+    gameIdBuf,
+    winningTeamBuf,
+  ]);
+  
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: new PublicKey(gamePda), isSigner: false, isWritable: true },
+      { pubkey: oracleWallet.publicKey, isSigner: true, isWritable: true },
+      { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true }, // Receives operator fee
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Build claim_automatic_winnings instruction
+ */
+function buildClaimInstruction(gamePda, gameId, playerWallet) {
+  // Instruction data: discriminator (8) + game_id (8)
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameId);
+  
+  const data = Buffer.concat([
+    CLAIM_AUTO_DISCRIMINATOR,
+    gameIdBuf,
+  ]);
+  
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: new PublicKey(gamePda), isSigner: false, isWritable: true },
+      { pubkey: new PublicKey(playerWallet), isSigner: true, isWritable: true },
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Poll for transaction confirmation (Agave 2.0 compatible)
+ */
+async function confirmTransaction(signature, timeout = 60000) {
+  const start = Date.now();
+  
+  while (Date.now() - start < timeout) {
+    const statuses = await 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');
+}
+
+/**
+ * Resolve a single game
+ */
+async function resolveGame(game, oracleWallet) {
+  console.log(`\n📍 Resolving game: ${game.pda}`);
+  console.log(`   Game ID: ${game.gameId.toString()}`);
+  
+  try {
+    const ix = buildResolveInstruction(game.pda, game.gameId, oracleWallet);
+    const tx = new Transaction().add(ix);
+    
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = oracleWallet.publicKey;
+    
+    // Sign FIRST before sending
+    tx.sign(oracleWallet);
+    
+    console.log('   📡 Sending resolve transaction...');
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+      skipPreflight: false,
+      preflightCommitment: 'confirmed',
+    });
+    
+    console.log(`   📝 Signature: ${signature}`);
+    console.log('   ⏳ Confirming...');
+    await confirmTransaction(signature);
+    
+    console.log(`   ✅ Resolved!`);
+    return signature;
+    
+  } catch (error) {
+    // Try to get logs for more details
+    if (error.logs) {
+      console.error('   📋 Logs:', error.logs.join('\n      '));
+    }
+    if (error.message?.includes('AlreadyResolved')) {
+      console.log('   ℹ️  Game already resolved');
+      return 'already_resolved';
+    }
+    if (error.message?.includes('CannotResolveBeforeLockTime')) {
+      console.log('   ⏰ Cannot resolve before lock time (game hasn\'t started yet)');
+      return 'too_early';
+    }
+    console.error(`   ❌ Error: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  
+  console.log('📊 Games to recover:');
+  STUCK_GAMES.forEach((game, i) => {
+    console.log(`   ${i + 1}. PDA: ${game.pda.slice(0, 12)}... | Player: ${game.player.slice(0, 12)}...`);
+  });
+  
+  // Check if --resolve flag is passed
+  if (args.includes('--resolve')) {
+    console.log('\n🔐 Loading oracle wallet...');
+    const oracleWallet = loadOracleWallet();
+    console.log(`   Oracle: ${oracleWallet.publicKey.toString()}`);
+    
+    // Verify oracle matches expected
+    const expectedOracle = 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa';
+    if (oracleWallet.publicKey.toString() !== expectedOracle) {
+      console.error(`   ⚠️  Warning: Oracle doesn't match expected (${expectedOracle})`);
+    }
+    
+    console.log('\n🔧 Resolving games...');
+    
+    for (const game of STUCK_GAMES) {
+      try {
+        await resolveGame(game, oracleWallet);
+      } catch (error) {
+        console.error(`   Failed to resolve ${game.pda}: ${error.message}`);
+      }
+    }
+    
+    console.log('\n✅ Resolution complete!');
+    console.log('💡 Now use the frontend to claim your refunds, or run:');
+    console.log('   node force-resolve-and-claim.js --claim <playerWalletPath>');
+    
+  } else if (args.includes('--claim')) {
+    // For claiming, the player needs to sign
+    console.log('\n💰 Claim mode');
+    console.log('   To claim, use the frontend "Claim" button in My Games');
+    console.log('   Or call the API: POST /api/v1/prod/transaction/build/claim-automatic');
+    console.log('   With body: { "playerAddress": "<wallet>", "gameId": "<gameId>" }');
+    
+  } else {
+    console.log('\nUsage:');
+    console.log('  node force-resolve-and-claim.js --resolve    # Resolve all stuck games (requires oracle wallet)');
+    console.log('  node force-resolve-and-claim.js --claim      # Show claim instructions');
+    console.log('');
+    console.log('Prerequisites:');
+    console.log('  1. Set ORACLE_WALLET_JSON env var with oracle private key array');
+    console.log('     OR create wallets/oracle.json with the keypair');
+    console.log('  2. Oracle must match the one registered in the game accounts');
+    console.log('');
+  }
+}
+
+main().catch(console.error);
+
+

package/scripts/important/README.md

@@ -0,0 +1,115 @@
+# Important Scripts
+
+Scripts for managing games, payouts, and emergency operations.
+
+---
+
+## check-game-status.js
+
+Shows complete game status including all players, their bets, win/loss results, claim status, and expected payouts.
+
+**Usage:**
+```bash
+DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/important/check-game-status.js <gameId>
+```
+
+**Example:**
+```bash
+DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/important/check-game-status.js sport-1769102132440-xmirk1omx
+```
+
+**Output includes:**
+- Game info (teams, score, winner, buy-in, resolved status)
+- Pot breakdown (total pot, platform fee, winner pool)
+- Player table with bets, results, claim status, and payouts
+- Claim transaction signatures and explorer links
+- Summary of pending claims
+
+---
+
+## reconcile-v1-v2-payouts.js
+
+Calculates the difference between V1 (equal split) and V2 (proportional) payouts for any game. Shows what you would owe players to make V1 payouts fair under V2 rules.
+
+**Usage:**
+```bash
+DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/important/reconcile-v1-v2-payouts.js <gameId>
+```
+
+**Output includes:**
+- Pot details and team pools
+- Scenarios for each possible winner (home/away/draw)
+- Per-player breakdown: V1 payout vs V2 payout vs difference owed
+- Total reconciliation amount needed
+- If game is resolved: specific players and wallets to reimburse
+
+---
+
+## list-pending-games-by-version.js
+
+Lists all pending (unresolved) games categorized by version:
+- **V1 (Legacy/Hybrid):** Equal split payouts - `player_amounts.length != total_players`
+- **V2 (Pari-Mutuel):** Proportional payouts - all players in `player_amounts`
+
+**Usage:**
+```bash
+DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/important/list-pending-games-by-version.js
+```
+
+**Output includes:**
+- Games grouped by V1 vs V2
+- Per-game details: matchup, pot size, team pools, odds
+- Player list with bets and expected payouts
+- Summary totals
+
+---
+
+## authority-force-lock.js
+
+Forces a game to locked state using program authority. This allows the oracle to resolve games that were created with future lock times (e.g., timezone issues, events ending early).
+
+**Usage:**
+```bash
+SOLANA_RPC_URL="https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY" node scripts/important/authority-force-lock.js <gameId>
+```
+
+**When to use:**
+- Oracle shows "CannotResolveBeforeLockTime" error
+- Game event has ended but lock time is in the future
+- Need to manually trigger resolution
+
+**Requirements:**
+- Program authority wallet at `~/.config/solana/id.json`
+- Mainnet RPC URL
+
+---
+
+## authority-resolve-game.js
+
+Emergency resolve or refund games using program authority. Can force resolve with a winner or refund all players.
+
+**Usage:**
+```bash
+SOLANA_RPC_URL="https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY" node scripts/important/authority-resolve-game.js <gameId> [winner]
+```
+
+**Examples:**
+```bash
+# Refund all players (no winner)
+node scripts/important/authority-resolve-game.js sport-123
+
+# Resolve with home team winning
+node scripts/important/authority-resolve-game.js sport-123 home
+
+# Resolve with away team winning
+node scripts/important/authority-resolve-game.js sport-123 away
+```
+
+**When to use:**
+- Postponed or cancelled games that need refunding
+- Stuck games where oracle failed
+- Disputed games requiring manual resolution
+
+**Requirements:**
+- Program authority wallet at `~/.config/solana/id.json`
+- Mainnet RPC URL