dubs-server 1.0.0

package/scripts/important/authority-force-lock.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * Authority Force Lock Script
+ * Uses program authority to force-lock games so oracle can resolve them
+ *
+ * Usage:
+ *   SOLANA_RPC_URL=<mainnet-rpc> node scripts/authority-force-lock.js <gameId>
+ *
+ * Examples:
+ *   SOLANA_RPC_URL="https://..." node scripts/authority-force-lock.js sport-1769102132440-xmirk1omx
+ */
+
+require('dotenv').config();
+const {
+  Connection,
+  PublicKey,
+  Keypair,
+  Transaction,
+  TransactionInstruction,
+} = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Program ID (mainnet)
+const PROGRAM_ID = new PublicKey('85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+// authority_force_lock discriminator
+// sha256("global:authority_force_lock")[0..8]
+const AUTHORITY_FORCE_LOCK_DISCRIMINATOR = Buffer.from([
+  186, 206, 107, 11, 185, 154, 217, 166
+]);
+
+// RPC endpoint - use mainnet
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://solana-mainnet.g.alchemy.com/v2/M7pyy3QL4xYOndpcYukNhf-yq2IG6eyl';
+
+console.log('🔐 Authority Force Lock Tool');
+console.log('============================');
+console.log(`RPC: ${RPC_URL.slice(0, 50)}...`);
+console.log(`Program: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Load authority wallet (program upgrade authority)
+ */
+function loadAuthorityWallet() {
+  const walletPath = process.env.AUTHORITY_WALLET_PATH ||
+                     path.join(process.env.HOME, '.config/solana/id.json');
+
+  if (!fs.existsSync(walletPath)) {
+    console.error('❌ Authority wallet not found at:', walletPath);
+    process.exit(1);
+  }
+
+  console.log('🔑 Loading authority wallet from:', walletPath);
+  const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+  return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+}
+
+/**
+ * Get game PDA and u64 ID from string game ID
+ */
+function getGamePDA(gameIdString) {
+  const hash = crypto.createHash('sha256').update(gameIdString).digest();
+  const gameIdNum = hash.readBigUInt64LE(0);
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+  const [gamePDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('game'), gameIdBuf],
+    PROGRAM_ID
+  );
+
+  return { gamePDA, gameIdNum, gameIdBuf };
+}
+
+/**
+ * Build authority_force_lock instruction
+ */
+function buildAuthorityForceLockInstruction(gamePDA, gameIdBuf, authorityWallet) {
+  const data = Buffer.concat([
+    AUTHORITY_FORCE_LOCK_DISCRIMINATOR,
+    gameIdBuf,
+  ]);
+
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: authorityWallet.publicKey, isSigner: true, isWritable: true },
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Poll for transaction confirmation
+ */
+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');
+}
+
+async function forceLockGame(gameIdString) {
+  console.log(`📍 Game ID: ${gameIdString}`);
+  console.log('');
+
+  // Load authority wallet
+  const authorityWallet = loadAuthorityWallet();
+  console.log(`   Authority: ${authorityWallet.publicKey.toString()}`);
+
+  // Get game PDA
+  const { gamePDA, gameIdNum, gameIdBuf } = getGamePDA(gameIdString);
+  console.log(`   Game PDA: ${gamePDA.toString()}`);
+  console.log(`   Game ID (u64): ${gameIdNum}`);
+
+  // Check if game exists
+  const gameAccount = await connection.getAccountInfo(gamePDA);
+  if (!gameAccount) {
+    console.error('❌ Game account not found on-chain!');
+    process.exit(1);
+  }
+  console.log(`   Game balance: ${gameAccount.lamports / 1e9} SOL`);
+  console.log('');
+
+  // Build instruction
+  const instruction = buildAuthorityForceLockInstruction(gamePDA, gameIdBuf, authorityWallet);
+
+  // Build transaction
+  const latestBlockhash = await connection.getLatestBlockhash('confirmed');
+  const transaction = new Transaction();
+  transaction.recentBlockhash = latestBlockhash.blockhash;
+  transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+  transaction.feePayer = authorityWallet.publicKey;
+  transaction.add(instruction);
+
+  // Sign and send
+  transaction.sign(authorityWallet);
+
+  console.log('📡 Sending transaction...');
+  try {
+    const signature = await connection.sendRawTransaction(transaction.serialize(), {
+      skipPreflight: false,
+      preflightCommitment: 'confirmed',
+    });
+
+    console.log(`   Signature: ${signature}`);
+    console.log('   Waiting for confirmation...');
+
+    await confirmTransaction(signature);
+
+    console.log('');
+    console.log('✅ Game force-locked successfully!');
+    console.log(`   Explorer: https://explorer.solana.com/tx/${signature}`);
+    console.log('');
+    console.log('🔄 The oracle should now be able to resolve this game.');
+
+  } catch (error) {
+    console.error('');
+    console.error('❌ Transaction failed:', error.message);
+    if (error.logs) {
+      console.log('📋 Logs:');
+      error.logs.forEach(log => console.log('   ', log));
+    }
+    process.exit(1);
+  }
+}
+
+// Main
+const gameId = process.argv[2];
+if (!gameId) {
+  console.log('Usage: node scripts/authority-force-lock.js <gameId>');
+  console.log('');
+  console.log('Example:');
+  console.log('  SOLANA_RPC_URL="https://..." node scripts/authority-force-lock.js sport-1769102132440-xmirk1omx');
+  process.exit(1);
+}
+
+forceLockGame(gameId);

package/scripts/important/authority-resolve-game.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * Authority Emergency Resolve Script
+ * Uses program authority to resolve postponed/stuck games
+ *
+ * Usage:
+ *   node authority-resolve-game.js <gameId> [winner]
+ *
+ * Examples:
+ *   node authority-resolve-game.js sport-1769366095299-m1h01fvt9           # Refund all (no winner)
+ *   node authority-resolve-game.js sport-1769366095299-m1h01fvt9 home      # Home wins
+ */
+
+require('dotenv').config();
+const {
+  Connection,
+  PublicKey,
+  Keypair,
+  Transaction,
+  TransactionInstruction,
+  LAMPORTS_PER_SOL
+} = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Program ID (mainnet)
+const PROGRAM_ID = new PublicKey('85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+
+// Operator wallet (receives fees)
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+// authority_force_refund discriminator (no lock check!)
+const AUTHORITY_FORCE_REFUND_DISCRIMINATOR = Buffer.from([49, 187, 216, 119, 254, 50, 118, 225]);
+
+// authority_emergency_resolve discriminator (requires lock)
+const AUTHORITY_EMERGENCY_RESOLVE_DISCRIMINATOR = Buffer.from([31, 157, 128, 122, 207, 17, 218, 155]);
+
+// RPC endpoint - use mainnet
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://solana-mainnet.g.alchemy.com/v2/M7pyy3QL4xYOndpcYukNhf-yq2IG6eyl';
+
+console.log('🔧 Authority Emergency Resolve Tool');
+console.log('====================================');
+console.log(`RPC: ${RPC_URL.slice(0, 50)}...`);
+console.log(`Program: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Load authority wallet (program upgrade authority)
+ */
+function loadAuthorityWallet() {
+  const walletPath = process.env.AUTHORITY_WALLET_PATH ||
+                     path.join(process.env.HOME, '.config/solana/id.json');
+
+  if (!fs.existsSync(walletPath)) {
+    console.error('❌ Authority wallet not found at:', walletPath);
+    process.exit(1);
+  }
+
+  console.log('🔑 Loading authority wallet from:', walletPath);
+  const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+  return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+}
+
+/**
+ * Get game PDA and u64 ID from string game ID
+ */
+function getGamePDA(gameIdString) {
+  const hash = crypto.createHash('sha256').update(gameIdString).digest();
+  const gameIdNum = hash.readBigUInt64LE(0);
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+  const [gamePDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from('game'), gameIdBuf],
+    PROGRAM_ID
+  );
+
+  return { gamePDA, gameIdNum, gameIdBuf };
+}
+
+/**
+ * Build authority_force_refund instruction (no lock check!)
+ */
+function buildAuthorityForceRefundInstruction(gamePDA, gameIdBuf, authorityWallet) {
+  const data = Buffer.concat([
+    AUTHORITY_FORCE_REFUND_DISCRIMINATOR,
+    gameIdBuf,
+  ]);
+
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: authorityWallet.publicKey, isSigner: true, isWritable: true },
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Build authority_emergency_resolve instruction (requires lock)
+ */
+function buildAuthorityResolveInstruction(gamePDA, gameIdBuf, authorityWallet, winningTeam) {
+  let winningTeamBuf;
+  if (winningTeam === 'home') {
+    winningTeamBuf = Buffer.from([1, 0]); // Some(Home)
+  } else if (winningTeam === 'away') {
+    winningTeamBuf = Buffer.from([1, 1]); // Some(Away)
+  } else if (winningTeam === 'draw') {
+    winningTeamBuf = Buffer.from([1, 2]); // Some(Draw)
+  } else {
+    winningTeamBuf = Buffer.from([0]); // None - refund all
+  }
+
+  const data = Buffer.concat([
+    AUTHORITY_EMERGENCY_RESOLVE_DISCRIMINATOR,
+    gameIdBuf,
+    winningTeamBuf,
+  ]);
+
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: authorityWallet.publicKey, isSigner: true, isWritable: true },
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Poll for transaction confirmation
+ */
+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');
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length < 1) {
+    console.log('Usage: node authority-resolve-game.js <gameId> [winner]');
+    console.log('');
+    console.log('Arguments:');
+    console.log('  gameId  - The game ID string (e.g., sport-1769366095299-m1h01fvt9)');
+    console.log('  winner  - Optional: home, away, draw (default: refund all)');
+    console.log('');
+    console.log('Examples:');
+    console.log('  node authority-resolve-game.js sport-1769366095299-m1h01fvt9');
+    console.log('  node authority-resolve-game.js sport-1769366095299-m1h01fvt9 home');
+    process.exit(1);
+  }
+
+  const gameIdString = args[0];
+  const winningTeam = args[1] || null;
+
+  console.log(`📍 Game ID: ${gameIdString}`);
+  console.log(`🏆 Winner: ${winningTeam || 'None (refund all)'}`);
+  console.log('');
+
+  // Load authority wallet
+  const authorityWallet = loadAuthorityWallet();
+  console.log(`   Authority: ${authorityWallet.publicKey.toString()}`);
+
+  // Verify it matches program authority
+  const expectedAuthority = '57voP1Y8U4ztX2YAcHveK3JFvVRn1n6T6iUnHdAW6xr9';
+  if (authorityWallet.publicKey.toString() !== expectedAuthority) {
+    console.error(`❌ Wallet doesn't match program authority!`);
+    console.error(`   Expected: ${expectedAuthority}`);
+    console.error(`   Got: ${authorityWallet.publicKey.toString()}`);
+    process.exit(1);
+  }
+  console.log('   ✅ Authority verified');
+
+  // Get game PDA
+  const { gamePDA, gameIdNum, gameIdBuf } = getGamePDA(gameIdString);
+  console.log(`   Game PDA: ${gamePDA.toString()}`);
+  console.log(`   Game ID (u64): ${gameIdNum.toString()}`);
+
+  // Check if game exists on-chain
+  const gameAccount = await connection.getAccountInfo(gamePDA);
+  if (!gameAccount) {
+    console.error('❌ Game account not found on-chain!');
+    process.exit(1);
+  }
+  console.log(`   Game balance: ${gameAccount.lamports / LAMPORTS_PER_SOL} SOL`);
+
+  // Build instruction based on whether we're refunding or declaring winner
+  let ix;
+  if (!winningTeam) {
+    // Use authority_force_refund (no lock check needed!)
+    console.log('');
+    console.log('📋 Using authority_force_refund (bypasses lock check)');
+    ix = buildAuthorityForceRefundInstruction(gamePDA, gameIdBuf, authorityWallet);
+  } else {
+    // Use authority_emergency_resolve (requires lock)
+    console.log('');
+    console.log('📋 Using authority_emergency_resolve (requires game to be locked)');
+    ix = buildAuthorityResolveInstruction(gamePDA, gameIdBuf, authorityWallet, winningTeam);
+    // Add operator wallet to remaining accounts for fee transfer
+    ix.keys.push({ pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true });
+  }
+
+  // Build transaction
+  const tx = new Transaction().add(ix);
+  const { blockhash } = await connection.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = authorityWallet.publicKey;
+  tx.sign(authorityWallet);
+
+  console.log('');
+  console.log('📡 Sending transaction...');
+
+  try {
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+      skipPreflight: false,
+      preflightCommitment: 'confirmed',
+    });
+
+    console.log(`   Signature: ${signature}`);
+    console.log('   ⏳ Confirming...');
+
+    await confirmTransaction(signature);
+
+    console.log('');
+    console.log('✅ Game resolved successfully!');
+    console.log(`   Signature: ${signature}`);
+    console.log('');
+    console.log('💡 Players can now claim their refunds using the Claim button in the app.');
+
+  } catch (error) {
+    console.error('');
+    console.error('❌ Transaction failed:', error.message);
+
+    if (error.logs) {
+      console.error('📋 Logs:');
+      error.logs.forEach(log => console.error('   ', log));
+    }
+
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);