dubs-server 1.0.0

package/scripts/resolve-direct.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * 🔧 Direct resolve using the fixed JackpotService (bypasses API server)
+ */
+
+const { Connection, Keypair, Transaction } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+const JackpotService = require('../services/jackpotService');
+
+const RPC_URL = 'https://api.devnet.solana.com';
+
+async function resolveRound() {
+  console.log('🔧 Direct Round Resolution (using fixed code)\n');
+  
+  // Load keeper wallet
+  const mainWalletPath = path.join(require('os').homedir(), '.config/solana/id.json');
+  const secretKey = JSON.parse(fs.readFileSync(mainWalletPath, 'utf-8'));
+  const wallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  
+  console.log('Keeper wallet:', wallet.publicKey.toString());
+  console.log();
+  
+  // Initialize service
+  const jackpotService = new JackpotService({
+    rpcUrl: RPC_URL,
+    programId: 'BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz',
+  });
+  
+  // Get round info
+  const round = await jackpotService.getCurrentRound();
+  console.log(`Round ${round.roundId} - Status: ${round.status}`);
+  console.log(`Pot: ${Number(round.totalPotLamports) / 1e9} SOL`);
+  console.log();
+  
+  if (round.status !== 'Locked') {
+    console.log(`⚠️  Round is not locked (status: ${round.status})`);
+    return;
+  }
+  
+  try {
+    // Build resolve transaction using FIXED code
+    console.log('📝 Building resolve transaction with FIXED winner calculation...');
+    const result = await jackpotService.buildResolveRoundTransaction({
+      keeperAddress: wallet.publicKey.toString(),
+      roundId: round.roundId,
+    });
+    
+    console.log(`✅ Winner: ${result.winner}`);
+    console.log();
+    
+    // Sign and send
+    console.log('✍️  Signing and sending transaction...');
+    const connection = new Connection(RPC_URL, 'confirmed');
+    const tx = Transaction.from(Buffer.from(result.transaction, 'base64'));
+    tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+    tx.feePayer = wallet.publicKey;
+    tx.sign(wallet);
+    
+    const signature = await connection.sendRawTransaction(tx.serialize(), {
+      skipPreflight: false,
+    });
+    
+    console.log(`📡 Transaction sent: ${signature}`);
+    console.log('⏳ Confirming...');
+    
+    await connection.confirmTransaction(signature);
+    
+    console.log();
+    console.log('🎉🎉🎉 SUCCESS! Round resolved!');
+    console.log(`   Winner: ${result.winner}`);
+    console.log(`   Prize: ${(Number(round.totalPotLamports) * 0.95 / 1e9).toFixed(4)} SOL`);
+    console.log(`   Transaction: https://explorer.solana.com/tx/${signature}?cluster=devnet`);
+    console.log();
+    console.log('✅ YOUR ROUND IS NOW UNLOCKED!');
+    console.log('   The keeper bot will reset it and start Round 51.');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    if (error.logs) {
+      console.error('Logs:', error.logs);
+    }
+  }
+}
+
+resolveRound().catch(console.error);
+

package/scripts/resolve-mock-game.js

@@ -0,0 +1,124 @@
+// Manually resolve a mock game for testing
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const fs = require('fs');
+const crypto = require('crypto');
+
+const PROGRAM_ID = new PublicKey('8DJTkgk6MDr6tPtw4v2VzYAz9WWvmCg6786vZrEK3o5q');
+const OPERATOR_WALLET = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+const RPC_URL = 'https://api.devnet.solana.com';
+
+// Load oracle keypair
+const oracleKeypairData = JSON.parse(fs.readFileSync('./wallets/oracle.json', 'utf-8'));
+const oracleKeypair = Keypair.fromSecretKey(Uint8Array.from(oracleKeypairData));
+
+console.log('🤖 Manual Game Resolution Script');
+console.log('=================================\n');
+console.log('Oracle wallet:', oracleKeypair.publicKey.toString());
+console.log('Operator wallet:', OPERATOR_WALLET.toString());
+console.log('');
+
+const gameId = process.argv[2]; // Get from command line
+const winner = process.argv[3]; // 'home', 'away', or 'tie'
+
+if (!gameId || !winner) {
+  console.log('Usage: node resolve-mock-game.js <gameId> <winner>');
+  console.log('');
+  console.log('Example:');
+  console.log('  node resolve-mock-game.js sport-1761927514471-308lnavgp home');
+  console.log('  node resolve-mock-game.js sport-1761927514471-308lnavgp away');
+  console.log('  node resolve-mock-game.js sport-1761927514471-308lnavgp tie');
+  console.log('');
+  process.exit(1);
+}
+
+async function resolveGame() {
+  const connection = new Connection(RPC_URL, 'confirmed');
+  
+  console.log(`Resolving game: ${gameId}`);
+  console.log(`Winner: ${winner}\n`);
+  
+  // Get game PDA
+  const hash = crypto.createHash('sha256').update(gameId).digest();
+  const gameIdNum = hash.readBigUInt64LE(0);
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+  
+  const [gamePDA] = PublicKey.findProgramAddressSync(
+    [Buffer.from("game"), gameIdBuf],
+    PROGRAM_ID
+  );
+  
+  console.log('Game PDA:', gamePDA.toString());
+  
+  // Encode winning team
+  let winningTeamBytes;
+  if (winner === 'tie') {
+    winningTeamBytes = Buffer.from([0]); // None
+    console.log('Encoding: None (tie - refund all)');
+  } else if (winner === 'home') {
+    winningTeamBytes = Buffer.from([1, 0]); // Some(Home)
+    console.log('Encoding: Some(Home)');
+  } else if (winner === 'away') {
+    winningTeamBytes = Buffer.from([1, 1]); // Some(Away)
+    console.log('Encoding: Some(Away)');
+  } else {
+    console.log('❌ Invalid winner! Use: home, away, or tie');
+    process.exit(1);
+  }
+  
+  // Build resolve transaction
+  const RESOLVE_AUTO = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+  
+  const data = Buffer.concat([
+    RESOLVE_AUTO,
+    gameIdBuf,
+    winningTeamBytes
+  ]);
+  
+  const ix = new TransactionInstruction({
+    keys: [
+      { pubkey: gamePDA, isSigner: false, isWritable: true },
+      { pubkey: oracleKeypair.publicKey, isSigner: true, isWritable: false },
+      // 🔐 Operator wallet receives fee
+      { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true },
+    ],
+    programId: PROGRAM_ID,
+    data,
+  });
+  
+  console.log('\n📤 Submitting resolution transaction...');
+  
+  const tx = new Transaction().add(ix);
+  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+  tx.feePayer = oracleKeypair.publicKey;
+  
+  tx.sign(oracleKeypair);
+  
+  try {
+    const signature = await connection.sendRawTransaction(tx.serialize());
+    console.log('✅ Transaction sent:', signature);
+    
+    console.log('\n⏳ Waiting for confirmation...');
+    await connection.confirmTransaction(signature);
+    
+    console.log('✅ Transaction confirmed!');
+    console.log('\n🎉 Game resolved successfully!');
+    console.log(`\nView on explorer:`);
+    console.log(`https://explorer.solana.com/tx/${signature}?cluster=devnet`);
+    console.log('');
+    console.log('💰 Check operator wallet balance:');
+    console.log(`solana balance ${OPERATOR_WALLET.toString()} --url devnet`);
+    console.log('');
+    console.log('Players can now use /claim to get their prizes!');
+    
+  } catch (error) {
+    console.log('❌ Error resolving game:', error.message);
+    if (error.logs) {
+      console.log('\nProgram logs:');
+      error.logs.forEach(log => console.log('  ', log));
+    }
+  }
+}
+
+resolveGame().catch(console.error);
+

package/scripts/resolve-pickem-game.js

@@ -0,0 +1,55 @@
+/**
+ * One-off script to resolve a pickem game via the Dubs SDK.
+ * Usage: node scripts/resolve-pickem-game.js <gameId> <winnerTeam>
+ * Example: node scripts/resolve-pickem-game.js df2f0746-b3f8-46ad-9187-e5b7d9fbca8f home
+ */
+
+require('dotenv').config();
+const { Dubs } = require('@dubsdotapp/node');
+
+const gameId = process.argv[2];
+const winnerTeam = process.argv[3] || 'home';
+
+if (!gameId) {
+  console.error('Usage: node scripts/resolve-pickem-game.js <gameId> <winnerTeam>');
+  process.exit(1);
+}
+
+const apiKey = process.env.DUBS_API_KEY;
+const resolutionSecret = process.env.DUBS_RESOLUTION_SECRET;
+const baseUrl = process.env.DUBS_SDK_BASE_URL;
+
+if (!apiKey || !resolutionSecret) {
+  console.error('Missing DUBS_API_KEY or DUBS_RESOLUTION_SECRET');
+  process.exit(1);
+}
+
+async function main() {
+  const dubs = new Dubs({ apiKey, resolutionSecret, baseUrl });
+
+  console.log(`Fetching game ${gameId}...`);
+  const { game } = await dubs.games.get(gameId);
+  console.log(`Game: ${game.title}`);
+  console.log(`Status: ${game.status}, isResolved: ${game.isResolved}`);
+  console.log(`Bettors: ${game.bettors?.length ?? 0}`);
+  for (const b of game.bettors || []) {
+    console.log(`  ${b.wallet} — team: ${b.team}, amount: ${b.amount}`);
+  }
+
+  if (game.isResolved) {
+    console.log('Game already resolved. Nothing to do.');
+    return;
+  }
+
+  console.log(`\nResolving with winner: '${winnerTeam}'...`);
+  const result = await dubs.resolveGame(gameId, {
+    winner: winnerTeam,
+    metadata: { source: 'manual_pickem_resolve' },
+  });
+  console.log('Resolved!', JSON.stringify(result, null, 2));
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/scripts/resolve-round-manual.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const PROGRAM_ID = new PublicKey('BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+const RPC_URL = 'https://api.devnet.solana.com';
+
+async function main() {
+  const connection = new Connection(RPC_URL, 'confirmed');
+  
+  // Load oracle wallet
+  const oracleKeyPath = path.join(__dirname, '..', 'wallets', 'jackpot_oracle.json');
+  const secretKey = JSON.parse(fs.readFileSync(oracleKeyPath, 'utf-8'));
+  const oracle = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  
+  console.log('🎲 Manual Round Resolution');
+  console.log('Oracle:', oracle.publicKey.toString());
+  
+  // Get config
+  const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], PROGRAM_ID);
+  const configData = await connection.getAccountInfo(configPda);
+  const currentRoundId = configData.data.readBigUInt64LE(82);
+  
+  console.log('Current Round ID:', currentRoundId.toString());
+  
+  // Get round PDA
+  const roundIdBuf = Buffer.alloc(8);
+  roundIdBuf.writeBigUInt64LE(currentRoundId);
+  const [roundPda] = PublicKey.findProgramAddressSync([Buffer.from('round'), roundIdBuf], PROGRAM_ID);
+  
+  console.log('Round PDA:', roundPda.toString());
+  
+  // Check round status
+  const roundData = await connection.getAccountInfo(roundPda);
+  if (!roundData) {
+    console.log('❌ Round account not found');
+    return;
+  }
+  
+  const status = roundData.data[16]; // 0=Open, 1=Locked, 2=Resolved
+  console.log('Status:', ['Open', 'Locked', 'Resolved'][status]);
+  
+  if (status !== 1) {
+    console.log('❌ Round is not locked');
+    return;
+  }
+  
+  // Submit oracle randomness
+  console.log('\n🎲 Submitting oracle randomness...');
+  const oracleSeed = crypto.randomBytes(32);
+  
+  const CONSUME_RANDOMNESS_DISC = Buffer.from([190, 217, 49, 162, 99, 26, 73, 234]);
+  const data = Buffer.concat([CONSUME_RANDOMNESS_DISC, oracleSeed]);
+  
+  const keys = [
+    { pubkey: configPda, isSigner: false, isWritable: true },
+    { pubkey: roundPda, isSigner: false, isWritable: true },
+    { pubkey: oracle.publicKey, isSigner: true, isWritable: false },
+  ];
+  
+  const instruction = new TransactionInstruction({ keys, programId: PROGRAM_ID, data });
+  const tx = new Transaction().add(instruction);
+  tx.feePayer = oracle.publicKey;
+  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+  tx.sign(oracle);
+  
+  const sig = await connection.sendRawTransaction(tx.serialize(), { skipPreflight: true });
+  await connection.confirmTransaction(sig);
+  
+  console.log('✅ Randomness submitted! Sig:', sig.slice(0, 8) + '...');
+  console.log('\n💡 Now run: node scripts/open-jackpot-round.js to resolve and open next round');
+}
+
+main().catch(console.error);
+
+
+
+
+
+