dubs-server 1.0.0

package/scripts/important/reconcile-v1-v2-payouts.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+/**
+ * V1 vs V2 Payout Reconciliation Script
+ *
+ * Shows what each player would receive in V1 (equal split) vs V2 (proportional),
+ * and calculates the difference you would owe them to make it fair.
+ *
+ * Usage:
+ *   DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/reconcile-v1-v2-payouts.js <gameId>
+ */
+
+const { Pool } = require('pg');
+
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  console.error('❌ DATABASE_URL not set. Run with:');
+  console.error('   DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/reconcile-v1-v2-payouts.js <gameId>');
+  process.exit(1);
+}
+
+const pool = new Pool({
+  connectionString: DATABASE_URL,
+  ssl: { rejectUnauthorized: false }
+});
+
+async function reconcilePayouts(gameId) {
+  try {
+    // Get game data
+    const gameResult = await pool.query(`
+      SELECT
+        g.game_id,
+        g.buy_in,
+        g.is_resolved,
+        g.home_team_players,
+        g.away_team_players,
+        g.draw_team_players,
+        g.player_amounts,
+        g.sports_event->>'strHomeTeam' as home_team,
+        g.sports_event->>'strAwayTeam' as away_team,
+        g.sports_event->'finalScore'->>'winner' as winner,
+        g.game_type
+      FROM games g
+      WHERE g.game_id = $1
+    `, [gameId]);
+
+    if (gameResult.rows.length === 0) {
+      console.error('❌ Game not found');
+      process.exit(1);
+    }
+
+    const game = gameResult.rows[0];
+    const homeTeam = game.home_team || 'Home';
+    const awayTeam = game.away_team || 'Away';
+
+    // Get participants
+    const participantsResult = await pool.query(`
+      SELECT
+        ugr.wallet_address,
+        u.username,
+        ugr.team_choice
+      FROM user_game_refs ugr
+      LEFT JOIN users u ON ugr.wallet_address = u.wallet_address
+      WHERE ugr.game_id = $1
+      ORDER BY ugr.team_choice, ugr.joined_at
+    `, [gameId]);
+
+    const playerAmounts = game.player_amounts || {};
+    const buyIn = parseFloat(game.buy_in);
+
+    const getPlayerAmount = (wallet) => {
+      if (playerAmounts[wallet] !== undefined) {
+        return parseFloat(playerAmounts[wallet]);
+      }
+      return buyIn;
+    };
+
+    // Calculate pools
+    const homePlayers = game.home_team_players || [];
+    const awayPlayers = game.away_team_players || [];
+    const drawPlayers = game.draw_team_players || [];
+
+    const homeTeamPool = homePlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+    const awayTeamPool = awayPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+    const drawTeamPool = drawPlayers.reduce((sum, wallet) => sum + getPlayerAmount(wallet), 0);
+    const totalPot = homeTeamPool + awayTeamPool + drawTeamPool;
+    const platformFee = totalPot * 0.06;
+    const winnerPool = totalPot - platformFee;
+
+    // Check if V1 or V2
+    const totalPlayerCount = homePlayers.length + awayPlayers.length + drawPlayers.length;
+    const playerAmountsCount = Object.keys(playerAmounts).length;
+    const isPureV2 = totalPlayerCount > 0 && playerAmountsCount === totalPlayerCount;
+
+    // Build player list with details
+    const players = participantsResult.rows.map(p => ({
+      username: p.username || p.wallet_address.slice(0, 8) + '...',
+      wallet: p.wallet_address,
+      team: p.team_choice,
+      teamName: p.team_choice === 'home' ? homeTeam : p.team_choice === 'away' ? awayTeam : 'Draw',
+      bet: getPlayerAmount(p.wallet_address)
+    }));
+
+    const homePlayersList = players.filter(p => p.team === 'home');
+    const awayPlayersList = players.filter(p => p.team === 'away');
+    const drawPlayersList = players.filter(p => p.team === 'draw');
+
+    // Print header
+    console.log('');
+    console.log('╔═══════════════════════════════════════════════════════════════════════════════╗');
+    console.log('║              V1 vs V2 PAYOUT RECONCILIATION                                   ║');
+    console.log('╚═══════════════════════════════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log(`Game ID: ${gameId}`);
+    console.log(`Matchup: ${homeTeam} vs ${awayTeam}`);
+    console.log(`Type: ${game.game_type || 'sports'}`);
+    console.log(`Status: ${game.is_resolved ? 'Resolved' : 'Pending'}`);
+    if (game.winner) {
+      console.log(`Winner: ${game.winner === 'home' ? homeTeam : game.winner === 'away' ? awayTeam : 'Draw'}`);
+    }
+    console.log('');
+    console.log(`Mode: ${isPureV2 ? 'V2 (Pure Pari-Mutuel) ✅' : 'V1/Hybrid (Legacy) ⚠️'}`);
+    console.log('');
+    console.log('┌─────────────────────────────────────────────────────────────────────────────────┐');
+    console.log('│  POT DETAILS                                                                    │');
+    console.log('├─────────────────────────────────────────────────────────────────────────────────┤');
+    console.log(`│  Total Pot:        ${totalPot.toFixed(4).padStart(10)} SOL                                          │`);
+    console.log(`│  Platform Fee (6%): ${platformFee.toFixed(4).padStart(9)} SOL                                          │`);
+    console.log(`│  Winner Pool:      ${winnerPool.toFixed(4).padStart(10)} SOL                                          │`);
+    console.log('├─────────────────────────────────────────────────────────────────────────────────┤');
+    console.log(`│  ${homeTeam.padEnd(20)}: ${homeTeamPool.toFixed(4).padStart(8)} SOL (${homePlayers.length} players)                            │`);
+    console.log(`│  ${awayTeam.padEnd(20)}: ${awayTeamPool.toFixed(4).padStart(8)} SOL (${awayPlayers.length} players)                            │`);
+    if (drawPlayers.length > 0) {
+      console.log(`│  Draw                 : ${drawTeamPool.toFixed(4).padStart(8)} SOL (${drawPlayers.length} players)                            │`);
+    }
+    console.log('└─────────────────────────────────────────────────────────────────────────────────┘');
+    console.log('');
+
+    // Function to calculate and display scenario
+    function displayScenario(winningTeam, winningTeamName, winnersList, winnersPool, losersList) {
+      const v1PayoutPerWinner = winnersList.length > 0 ? winnerPool / winnersList.length : 0;
+
+      console.log('┌─────────────────────────────────────────────────────────────────────────────────┐');
+      console.log(`│  SCENARIO: ${winningTeamName.toUpperCase()} WINS`.padEnd(82) + '│');
+      console.log('├─────────────────────────────────────────────────────────────────────────────────┤');
+      console.log('│  WINNERS:                                                                       │');
+      console.log('│  ┌────────────────┬──────────┬─────────────┬─────────────┬─────────────────────┐│');
+      console.log('│  │ Player         │ Bet      │ V1 (Equal)  │ V2 (Prop)   │ You Owe             ││');
+      console.log('│  ├────────────────┼──────────┼─────────────┼─────────────┼─────────────────────┤│');
+
+      let totalOwed = 0;
+      const reconciliation = [];
+
+      for (const p of winnersList) {
+        const v2Payout = winnersPool > 0 ? (p.bet / winnersPool) * winnerPool : 0;
+        const difference = v2Payout - v1PayoutPerWinner;
+        const owed = difference > 0 ? difference : 0;
+        totalOwed += owed;
+
+        reconciliation.push({
+          username: p.username,
+          wallet: p.wallet,
+          bet: p.bet,
+          v1Payout: v1PayoutPerWinner,
+          v2Payout: v2Payout,
+          difference: difference,
+          owed: owed
+        });
+
+        const username = p.username.slice(0, 14).padEnd(14);
+        const bet = p.bet.toFixed(4).padStart(8);
+        const v1 = v1PayoutPerWinner.toFixed(4).padStart(9) + ' SOL';
+        const v2 = v2Payout.toFixed(4).padStart(9) + ' SOL';
+        const owedStr = owed > 0 ? `+${owed.toFixed(4)} SOL`.padStart(17) : '0 (overpaid)'.padStart(17);
+
+        console.log(`│  │ ${username} │ ${bet} │ ${v1} │ ${v2} │ ${owedStr} ││`);
+      }
+
+      console.log('│  └────────────────┴──────────┴─────────────┴─────────────┴─────────────────────┘│');
+      console.log('│                                                                                 │');
+      console.log(`│  TOTAL YOU OWE IF ${winningTeamName.toUpperCase()} WINS: ${totalOwed.toFixed(4)} SOL`.padEnd(82) + '│');
+      console.log('│                                                                                 │');
+      console.log('│  LOSERS: (get nothing in both V1 and V2)                                        │');
+
+      if (losersList.length === 0) {
+        console.log('│    (none)                                                                       │');
+      } else {
+        const loserNames = losersList.map(p => p.username).join(', ');
+        const truncatedLosers = loserNames.length > 70 ? loserNames.slice(0, 67) + '...' : loserNames;
+        console.log(`│    ${truncatedLosers.padEnd(75)}│`);
+      }
+
+      console.log('└─────────────────────────────────────────────────────────────────────────────────┘');
+      console.log('');
+
+      return { totalOwed, reconciliation };
+    }
+
+    // Scenario 1: Home wins
+    const homeWinsResult = displayScenario('home', homeTeam, homePlayersList, homeTeamPool, [...awayPlayersList, ...drawPlayersList]);
+
+    // Scenario 2: Away wins
+    const awayWinsResult = displayScenario('away', awayTeam, awayPlayersList, awayTeamPool, [...homePlayersList, ...drawPlayersList]);
+
+    // Scenario 3: Draw wins (if applicable)
+    let drawWinsResult = null;
+    if (drawPlayers.length > 0) {
+      drawWinsResult = displayScenario('draw', 'Draw', drawPlayersList, drawTeamPool, [...homePlayersList, ...awayPlayersList]);
+    }
+
+    // Summary
+    console.log('╔═══════════════════════════════════════════════════════════════════════════════╗');
+    console.log('║  SUMMARY                                                                      ║');
+    console.log('╠═══════════════════════════════════════════════════════════════════════════════╣');
+    console.log(`║  If ${homeTeam.padEnd(20)} wins: Owe ${homeWinsResult.totalOwed.toFixed(4).padStart(8)} SOL                          ║`);
+    console.log(`║  If ${awayTeam.padEnd(20)} wins: Owe ${awayWinsResult.totalOwed.toFixed(4).padStart(8)} SOL                          ║`);
+    if (drawWinsResult) {
+      console.log(`║  If Draw                  wins: Owe ${drawWinsResult.totalOwed.toFixed(4).padStart(8)} SOL                          ║`);
+    }
+    console.log('╚═══════════════════════════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    // If game is already resolved, show what actually needs to happen
+    if (game.winner) {
+      console.log('┌─────────────────────────────────────────────────────────────────────────────────┐');
+      console.log('│  ⚠️  GAME IS RESOLVED - ACTION NEEDED                                           │');
+      console.log('├─────────────────────────────────────────────────────────────────────────────────┤');
+
+      const actualResult = game.winner === 'home' ? homeWinsResult :
+                          game.winner === 'away' ? awayWinsResult : drawWinsResult;
+
+      if (actualResult) {
+        console.log(`│  Winner: ${game.winner === 'home' ? homeTeam : game.winner === 'away' ? awayTeam : 'Draw'}`.padEnd(82) + '│');
+        console.log('│                                                                                 │');
+        console.log('│  Players to reimburse:                                                          │');
+
+        for (const p of actualResult.reconciliation) {
+          if (p.owed > 0) {
+            console.log(`│    ${p.username.padEnd(20)} → Send ${p.owed.toFixed(4)} SOL`.padEnd(82) + '│');
+            console.log(`│      Wallet: ${p.wallet}`.padEnd(82) + '│');
+          }
+        }
+
+        console.log('│                                                                                 │');
+        console.log(`│  TOTAL TO SEND: ${actualResult.totalOwed.toFixed(4)} SOL`.padEnd(82) + '│');
+      }
+
+      console.log('└─────────────────────────────────────────────────────────────────────────────────┘');
+      console.log('');
+    }
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+// Main
+const gameId = process.argv[2];
+if (!gameId) {
+  console.log('Usage: node scripts/reconcile-v1-v2-payouts.js <gameId>');
+  console.log('');
+  console.log('Example:');
+  console.log('  DATABASE_URL=$(heroku config:get DATABASE_URL -a dubs-server-prod) node scripts/reconcile-v1-v2-payouts.js sport-1769102132440-xmirk1omx');
+  process.exit(1);
+}
+
+reconcilePayouts(gameId);

package/scripts/initialize-jackpot.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+/**
+ * 🎰 Initialize Dubs Jackpot Protocol
+ * 
+ * One-time setup to configure the jackpot protocol
+ * Uses oracle wallet as admin
+ */
+
+const { Connection, Keypair, PublicKey, Transaction } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+const PROGRAM_ID = new PublicKey('BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+const RPC_URL = process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+
+async function main() {
+  console.log('🎰 Initializing Dubs Jackpot Protocol\n');
+  
+  // Load oracle wallet (will be the admin)
+  const oracleKeyPath = path.join(__dirname, '..', 'wallets', 'jackpot_oracle.json');
+  
+  let oracleWallet;
+  if (fs.existsSync(oracleKeyPath)) {
+    const secretKey = JSON.parse(fs.readFileSync(oracleKeyPath, 'utf-8'));
+    oracleWallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    console.log('✅ Loaded oracle wallet from', oracleKeyPath);
+  } else {
+    // Use the main operator wallet as fallback
+    const mainWalletPath = path.join(require('os').homedir(), '.config/solana/id.json');
+    if (!fs.existsSync(mainWalletPath)) {
+      console.error('❌ No wallet found!');
+      console.log('Create one with: solana-keygen new');
+      process.exit(1);
+    }
+    const secretKey = JSON.parse(fs.readFileSync(mainWalletPath, 'utf-8'));
+    oracleWallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    console.log('✅ Using main wallet:', oracleWallet.publicKey.toString());
+  }
+  
+  const connection = new Connection(RPC_URL, 'confirmed');
+  
+  // Check balance
+  const balance = await connection.getBalance(oracleWallet.publicKey);
+  console.log('💰 Balance:', (balance / 1e9).toFixed(4), 'SOL');
+  
+  if (balance < 0.1 * 1e9) {
+    console.log('⚠️  Low balance! You may need to airdrop:');
+    console.log(`   solana airdrop 1 ${oracleWallet.publicKey.toString()} --url devnet`);
+  }
+  
+  // Configuration
+  const adminAddress = oracleWallet.publicKey;
+  const treasuryAddress = oracleWallet.publicKey; // Use same wallet for treasury
+  const feeBasisPoints = 500; // 5% fee
+  const roundDurationSlots = 150; // 1 MINUTE rounds! (~60 seconds)
+  
+  console.log('\n📝 Configuration:');
+  console.log('   Admin:', adminAddress.toString());
+  console.log('   Treasury:', treasuryAddress.toString());
+  console.log('   Fee:', feeBasisPoints, 'bps (5%)');
+  console.log('   Round Duration:', roundDurationSlots, 'slots (~1 minute)');
+  console.log('   Network:', RPC_URL);
+  
+  // Build transaction using API
+  console.log('\n🔨 Building initialize transaction...');
+  
+  const API_BASE = 'http://localhost:3001';
+  const axios = require('axios');
+  
+  try {
+    const { data } = await axios.post(`${API_BASE}/jackpot/build/initialize`, {
+      adminAddress: adminAddress.toString(),
+      treasuryAddress: treasuryAddress.toString(),
+      feeBasisPoints,
+      roundDurationSlots,
+    });
+    
+    console.log('✅ Transaction built');
+    console.log('   Config PDA:', data.configPda);
+    
+    // Deserialize and get fresh blockhash
+    const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+    tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+    tx.feePayer = oracleWallet.publicKey;
+    tx.sign(oracleWallet);
+    
+    console.log('\n📤 Sending transaction...');
+    const signature = await connection.sendRawTransaction(tx.serialize());
+    console.log('   Signature:', signature);
+    
+    console.log('\n⏳ Confirming...');
+    await connection.confirmTransaction(signature);
+    
+    console.log('\n🎉 PROTOCOL INITIALIZED!');
+    console.log('\n✅ Next steps:');
+    console.log('   1. Open first round: node scripts/open-jackpot-round.js');
+    console.log('   2. Refresh frontend: http://localhost:3000');
+    console.log('   3. Start betting! 🎰');
+    
+  } catch (error) {
+    console.error('\n❌ Error:', error.message);
+    if (error.response) {
+      console.error('   API Error:', error.response.data);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);
+

package/scripts/jackpot/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(heroku pg:psql:*)",
+      "Bash(heroku run:*)",
+      "Bash(lsof:*)",
+      "Bash(xargs kill:*)"
+    ]
+  }
+}

package/scripts/jackpot/force-reset.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Force reset a stuck jackpot round
+ *
+ * Usage:
+ *   node scripts/jackpot/force-reset.js
+ *
+ * Environment:
+ *   SOLANA_RPC_URL  - RPC endpoint (default: devnet)
+ *   API_BASE        - Server URL (default: http://localhost:3001)
+ *   KEEPER_PRIVATE_KEY - Keeper wallet (optional, falls back to wallet files)
+ */
+
+const { Connection, Keypair, Transaction } = require('@solana/web3.js');
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com';
+const API_BASE = process.env.API_BASE || 'http://localhost:3001';
+
+function loadWallet() {
+  if (process.env.KEEPER_PRIVATE_KEY) {
+    console.log('Loading wallet from KEEPER_PRIVATE_KEY env var');
+    return Keypair.fromSecretKey(Uint8Array.from(JSON.parse(process.env.KEEPER_PRIVATE_KEY)));
+  }
+
+  const oracleKeyPath = path.join(__dirname, '..', '..', 'wallets', 'jackpot_oracle.json');
+  if (fs.existsSync(oracleKeyPath)) {
+    console.log('Loading wallet from wallets/jackpot_oracle.json');
+    return Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync(oracleKeyPath, 'utf-8'))));
+  }
+
+  const defaultPath = path.join(require('os').homedir(), '.config/solana/id.json');
+  if (fs.existsSync(defaultPath)) {
+    console.log('Loading wallet from ~/.config/solana/id.json');
+    return Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync(defaultPath, 'utf-8'))));
+  }
+
+  console.error('No wallet found. Set KEEPER_PRIVATE_KEY or add a wallet file.');
+  process.exit(1);
+}
+
+async function main() {
+  const wallet = loadWallet();
+  const connection = new Connection(RPC_URL, 'confirmed');
+
+  console.log('\n♻️  Force resetting round...');
+  console.log('   Wallet:', wallet.publicKey.toString());
+  console.log('   API:', API_BASE);
+  console.log('   RPC:', RPC_URL.includes('devnet') ? 'Devnet' : RPC_URL.slice(0, 50) + '...');
+  console.log();
+
+  try {
+    const { data } = await axios.post(`${API_BASE}/jackpot/build/reset-round`, {
+      keeperAddress: wallet.publicKey.toString(),
+    });
+
+    const tx = Transaction.from(Buffer.from(data.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('Signature:', signature);
+
+    // Poll for confirmation (Alchemy doesn't support signatureSubscribe)
+    const start = Date.now();
+    while (Date.now() - start < 60000) {
+      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') break;
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+
+    console.log(`\n✅ Round reset! New round: ${data.roundId}`);
+  } catch (error) {
+    console.error('❌ Error:', error.response?.data || error.message);
+  }
+}
+
+main();

package/scripts/jackpot/initialize-mainnet.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * Initialize Jackpot Protocol on Mainnet
+ *
+ * Standalone script — does NOT require the server to be running.
+ * Builds, signs, and sends the initialize transaction directly.
+ */
+
+const { Connection, Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+// ── Configuration ──────────────────────────────────────────────
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.mainnet-beta.solana.com';
+const PROGRAM_ID = new PublicKey('BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+const TREASURY = new PublicKey('BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+const FEE_BPS = 500;                  // 5%
+const ROUND_DURATION_SLOTS = 1512000;  // ~7 days at 400ms/slot
+
+// Anchor discriminator for "global:initialize"
+const INITIALIZE_DISC = Buffer.from([175, 175, 109, 31, 13, 152, 155, 237]);
+
+// ── Helpers ────────────────────────────────────────────────────
+function serializeU16(v) { const b = Buffer.alloc(2); b.writeUInt16LE(v); return b; }
+function serializeU64(v) { const b = Buffer.alloc(8); b.writeBigUInt64LE(BigInt(v)); return b; }
+
+// ── Main ───────────────────────────────────────────────────────
+async function main() {
+  console.log('🎰 Initialize Jackpot Protocol — MAINNET\n');
+
+  // Load admin wallet (default Solana CLI wallet = upgrade authority)
+  const walletPath = path.join(require('os').homedir(), '.config/solana/id.json');
+  if (!fs.existsSync(walletPath)) {
+    console.error('❌ No wallet at', walletPath);
+    process.exit(1);
+  }
+  const admin = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(fs.readFileSync(walletPath, 'utf-8'))));
+
+  const connection = new Connection(RPC_URL, 'confirmed');
+  const balance = await connection.getBalance(admin.publicKey);
+
+  // Derive config PDA
+  const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], PROGRAM_ID);
+
+  console.log('   RPC:       ', RPC_URL.slice(0, 50) + '...');
+  console.log('   Program:   ', PROGRAM_ID.toString());
+  console.log('   Admin:     ', admin.publicKey.toString());
+  console.log('   Treasury:  ', TREASURY.toString());
+  console.log('   Config PDA:', configPda.toString());
+  console.log('   Fee:       ', FEE_BPS, 'bps (5%)');
+  console.log('   Duration:  ', ROUND_DURATION_SLOTS.toLocaleString(), 'slots (~7 days)');
+  console.log('   Balance:   ', (balance / 1e9).toFixed(4), 'SOL\n');
+
+  // Check if already initialized
+  const existing = await connection.getAccountInfo(configPda);
+  if (existing) {
+    console.log('⚠️  Config PDA already exists! Protocol may already be initialized.');
+    console.log('   Account size:', existing.data.length, 'bytes');
+    process.exit(1);
+  }
+
+  // Build instruction
+  const data = Buffer.concat([
+    INITIALIZE_DISC,
+    serializeU16(FEE_BPS),
+    serializeU64(ROUND_DURATION_SLOTS),
+  ]);
+
+  const keys = [
+    { pubkey: configPda, isSigner: false, isWritable: true },
+    { pubkey: admin.publicKey, isSigner: true, isWritable: true },
+    { pubkey: TREASURY, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+  ];
+
+  const ix = new TransactionInstruction({ keys, programId: PROGRAM_ID, data });
+  const tx = new Transaction().add(ix);
+  tx.feePayer = admin.publicKey;
+  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+  tx.sign(admin);
+
+  console.log('📤 Sending initialize transaction...');
+  const signature = await connection.sendRawTransaction(tx.serialize(), { skipPreflight: false });
+  console.log('   Signature:', signature);
+
+  console.log('⏳ Confirming...');
+  await connection.confirmTransaction(signature, 'confirmed');
+
+  console.log('\n🎉 PROTOCOL INITIALIZED ON MAINNET!');
+  console.log('   Config PDA:', configPda.toString());
+  console.log('   TX:', signature);
+  console.log('\n   Next: deploy backend with keeper to start rounds.');
+}
+
+main().catch(err => {
+  console.error('❌ Error:', err.message);
+  if (err.logs) console.error('Logs:', err.logs);
+  process.exit(1);
+});