dubs-server 1.0.0

package/services/jackpotService.js

@@ -0,0 +1,856 @@
+/**
+ * 🎰 Jackpot Service
+ * 
+ * Handles Solpot-style continuous jackpot rounds with provably fair randomness
+ * Features:
+ * - Continuous round cycles
+ * - Weighted entry odds (bigger bets = higher chance)
+ * - Commit-reveal randomness (like Solpot.com)
+ * - Permissionless keeper operations
+ * - Protocol fee collection
+ */
+
+const { Connection, Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+// 🎰 Jackpot Program Configuration (configurable via env vars for multi-environment)
+const JACKPOT_PROGRAM_ID = new PublicKey(
+  process.env.JACKPOT_PROGRAM_ID || 'BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz'
+);
+
+// 🔐 ORACLE WALLET - Submits random seeds (like Solpot's Random.org)
+const ORACLE_WALLET = new PublicKey(
+  process.env.JACKPOT_ORACLE_WALLET || 'FWUJCthDfPcgmTvdQWM5uofxxiYjqJFMMwiLYvS7LBFa'
+);
+
+// Instruction discriminators (SHA256 hash of "global:instruction_name")
+const DISCRIMINATORS = {
+  INITIALIZE: Buffer.from([175, 175, 109, 31, 13, 152, 155, 237]),       // initialize
+  OPEN_ROUND: Buffer.from([66, 235, 123, 240, 8, 35, 185, 159]),         // open_round
+  ENTER_ROUND: Buffer.from([166, 162, 71, 230, 92, 51, 37, 43]),         // enter_round
+  LOCK_ROUND: Buffer.from([68, 124, 43, 230, 30, 44, 248, 227]),         // lock_round
+  CONSUME_RANDOMNESS: Buffer.from([190, 217, 49, 162, 99, 26, 73, 234]), // consume_randomness
+  RESOLVE_ROUND: Buffer.from([165, 114, 237, 158, 1, 36, 70, 254]),      // resolve_round
+  UPDATE_CONFIG: Buffer.from([29, 158, 252, 191, 10, 83, 219, 99]),      // update_config
+  RESET_ROUND: Buffer.from([199, 184, 226, 203, 15, 56, 59, 113]),       // reset_round (account reuse!)
+};
+
+class JackpotService {
+  constructor(config) {
+    this.connection = new Connection(config.rpcUrl || 'http://127.0.0.1:8899', 'confirmed');
+    this.programId = JACKPOT_PROGRAM_ID;
+    this.oracleWallet = ORACLE_WALLET;
+    this.walletsDir = config.walletsDir || path.join(__dirname, '..', 'wallets');
+    
+    // Load oracle keypair - Priority: ENV var > wallet file
+    try {
+      let secretKey;
+      
+      if (process.env.KEEPER_PRIVATE_KEY) {
+        // For Heroku - use environment variable
+        console.log('🔐 Oracle keypair loaded from KEEPER_PRIVATE_KEY env var');
+        secretKey = JSON.parse(process.env.KEEPER_PRIVATE_KEY);
+        this.oracleKeypair = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+      } else {
+        // For local - use wallet file
+        const oracleKeyPath = path.join(this.walletsDir, 'jackpot_oracle.json');
+        if (fs.existsSync(oracleKeyPath)) {
+          secretKey = JSON.parse(fs.readFileSync(oracleKeyPath, 'utf-8'));
+          this.oracleKeypair = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+          console.log('🔐 Oracle keypair loaded from wallet file');
+        }
+      }
+    } catch (e) {
+      console.log('⚠️  Oracle keypair not found - oracle functions will be limited');
+    }
+    
+    console.log('🎰 Jackpot Service initialized');
+
+    // Polling-based tx confirmation (Alchemy doesn't support signatureSubscribe websocket)
+    this.confirmTx = async (signature, timeout = 60000) => {
+      const start = Date.now();
+      while (Date.now() - start < timeout) {
+        const statuses = await this.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;
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+      throw new Error('Transaction confirmation timeout');
+    };
+    console.log('   Program ID:', this.programId.toString());
+    console.log('   Oracle:', this.oracleWallet.toString());
+  }
+
+  /**
+   * Get Config PDA
+   */
+  getConfigPDA() {
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from('config')],
+      this.programId
+    );
+  }
+
+  /**
+   * Get Round PDA from round ID
+   */
+  getRoundPDA(roundId) {
+    const roundIdBuf = Buffer.alloc(8);
+    roundIdBuf.writeBigUInt64LE(BigInt(roundId));
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from('round'), roundIdBuf],
+      this.programId
+    );
+  }
+
+  /**
+   * Get Entries PDA from round ID
+   */
+  getEntriesPDA(roundId) {
+    const roundIdBuf = Buffer.alloc(8);
+    roundIdBuf.writeBigUInt64LE(BigInt(roundId));
+    return PublicKey.findProgramAddressSync(
+      [Buffer.from('entries'), roundIdBuf],
+      this.programId
+    );
+  }
+
+  /**
+   * Get protocol config
+   */
+  async getConfig() {
+    const [configPda] = this.getConfigPDA();
+    
+    try {
+      const accountInfo = await this.connection.getAccountInfo(configPda);
+      if (!accountInfo) {
+        return null;
+      }
+      
+      // Parse config data (simplified - you'd use Borsh in production)
+      const data = accountInfo.data;
+      
+      const roundDurationSlots = data.readBigUInt64LE(74);
+      // ~0.4 seconds per slot on Solana
+      const roundDurationSeconds = Math.floor(Number(roundDurationSlots) * 0.4);
+
+      return {
+        address: configPda.toString(),
+        authority: new PublicKey(data.slice(8, 40)).toString(),
+        treasury: new PublicKey(data.slice(40, 72)).toString(),
+        feeBasisPoints: data.readUInt16LE(72),
+        roundDurationSlots: roundDurationSlots.toString(),
+        roundDurationSeconds,
+        currentRoundId: data.readBigUInt64LE(82).toString(),
+        totalVolume: data.readBigUInt64LE(90).toString(),
+        totalFeesCollected: data.readBigUInt64LE(98).toString(),
+        initialized: true,
+      };
+    } catch (error) {
+      console.error('Error fetching config:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get current round info
+   * NOTE: With account reuse, we always use Round 1 PDAs!
+   * FORCES FRESH READ - NO CACHING
+   */
+  async getCurrentRound() {
+    // Force fresh config read
+    const [configPda] = this.getConfigPDA();
+    const configAccount = await this.connection.getAccountInfo(configPda);
+    if (!configAccount) {
+      return null;
+    }
+
+    const currentRoundId = configAccount.data.readBigUInt64LE(82);
+    if (currentRoundId === 0n) {
+      return null;
+    }
+
+    // Force fresh round + entries read from Round 1 PDAs
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const [roundAccount, entriesAccount] = await Promise.all([
+      this.connection.getAccountInfo(roundPda),
+      this.connection.getAccountInfo(entriesPda),
+    ]);
+    if (!roundAccount) {
+      return null;
+    }
+
+    // Parse round data directly (NO CACHE)
+    const actualRoundId = roundAccount.data.readBigUInt64LE(8);
+    const status = roundAccount.data[16];
+    const statusNames = ['Open', 'Locked', 'Resolved'];
+    const currentSlot = await this.connection.getSlot();
+
+    // Read entryCount from Entries PDA (offset 16, always correct)
+    // The Round PDA entryCount offset is unreliable.
+    const entryCount = entriesAccount ? entriesAccount.data.readUInt32LE(16) : 0;
+
+    return {
+      address: roundPda.toString(),
+      roundId: actualRoundId.toString(),
+      status: statusNames[status] || 'Unknown',
+      startSlot: roundAccount.data.readBigUInt64LE(17).toString(),
+      endSlot: roundAccount.data.readBigUInt64LE(25).toString(),
+      totalPotLamports: roundAccount.data.readBigUInt64LE(33).toString(),
+      totalWeight: roundAccount.data.readBigUInt64LE(41).toString(),
+      entryCount,
+      currentSlot: currentSlot.toString(),
+      timeRemainingSlots: Math.max(0, Number(roundAccount.data.readBigUInt64LE(25)) - currentSlot),
+    };
+  }
+
+  /**
+   * Get specific round info
+   * NOTE: When account reuse is active, always pass roundId=1
+   */
+  async getRoundInfo(roundId) {
+    const [roundPda] = this.getRoundPDA(roundId);
+    const [entriesPda] = this.getEntriesPDA(roundId);
+
+    try {
+      const [accountInfo, entriesInfo] = await Promise.all([
+        this.connection.getAccountInfo(roundPda),
+        this.connection.getAccountInfo(entriesPda),
+      ]);
+      if (!accountInfo) {
+        return null;
+      }
+
+      const data = accountInfo.data;
+
+      // Parse round data (read actual round_id from account)
+      const actualRoundId = data.readBigUInt64LE(8); // First field after discriminator
+      const status = data[16]; // 0=Open, 1=Locked, 2=Resolved
+      const statusNames = ['Open', 'Locked', 'Resolved'];
+
+      const currentSlot = await this.connection.getSlot();
+
+      // Read entryCount from Entries PDA (offset 16, always correct)
+      const entryCount = entriesInfo ? entriesInfo.data.readUInt32LE(16) : 0;
+
+      return {
+        address: roundPda.toString(),
+        roundId: actualRoundId.toString(), // Use actual round_id from account!
+        status: statusNames[status] || 'Unknown',
+        startSlot: data.readBigUInt64LE(17).toString(),
+        endSlot: data.readBigUInt64LE(25).toString(),
+        totalPotLamports: data.readBigUInt64LE(33).toString(),
+        totalWeight: data.readBigUInt64LE(41).toString(),
+        entryCount,
+        currentSlot: currentSlot.toString(),
+        timeRemainingSlots: Math.max(0, Number(data.readBigUInt64LE(25)) - currentSlot),
+      };
+    } catch (error) {
+      console.error('Error fetching round:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get entries for a round
+   * NOTE: Always uses Round 1 PDA due to account reuse!
+   */
+  async getRoundEntries(roundId) {
+    const [entriesPda] = this.getEntriesPDA(1); // Always Round 1!
+    
+    try {
+      const accountInfo = await this.connection.getAccountInfo(entriesPda);
+      if (!accountInfo) {
+        console.log('⚠️  Entries account not found');
+        return [];
+      }
+      
+      // Parse entries - Anchor layout:
+      // 8 bytes: discriminator
+      // 8 bytes: round_id (u64)
+      // 4 bytes: vec length (u32)
+      // entries: player(32) + weight(8) + cumulative_to(16) = 56 bytes each
+      const data = accountInfo.data;
+      
+      if (data.length < 20) {
+        console.log('⚠️  Entries account too small:', data.length);
+        return [];
+      }
+      
+      const entryCount = data.readUInt32LE(16); // After discriminator(8) + round_id(8)
+      console.log(`📊 Entries account: ${data.length} bytes, ${entryCount} entries claimed`);
+      
+      const entries = [];
+      let offset = 20; // Start after: discriminator(8) + round_id(8) + vec_len(4)
+      
+      for (let i = 0; i < entryCount; i++) {
+        if (offset + 56 > data.length) {
+          console.log(`⚠️  Not enough data for entry ${i} at offset ${offset}`);
+          break;
+        }
+        
+        const player = new PublicKey(data.slice(offset, offset + 32));
+        const weight = data.readBigUInt64LE(offset + 32);
+        // Read u128 cumulative_to (16 bytes) - use lower 64 bits
+        const cumulativeToLow = data.readBigUInt64LE(offset + 40);
+        
+        entries.push({
+          player: player.toString(),
+          weight: weight.toString(),
+          cumulativeTo: cumulativeToLow.toString(),
+        });
+        
+        offset += 56; // 32 (pubkey) + 8 (weight) + 16 (cumulative_to u128)
+      }
+      
+      console.log(`✅ Successfully parsed ${entries.length} entries`);
+      return entries;
+    } catch (error) {
+      console.error('❌ Error fetching entries:', error);
+      return [];
+    }
+  }
+
+  /**
+   * BUILD TRANSACTION: Initialize protocol (admin only)
+   */
+  async buildInitializeTransaction({ adminAddress, treasuryAddress, feeBasisPoints, roundDurationSlots }) {
+    const [configPda] = this.getConfigPDA();
+    const admin = new PublicKey(adminAddress);
+    const treasury = new PublicKey(treasuryAddress);
+    
+    const data = Buffer.concat([
+      DISCRIMINATORS.INITIALIZE,
+      this.serializeU16(feeBasisPoints),
+      this.serializeU64(roundDurationSlots),
+    ]);
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: admin, isSigner: true, isWritable: true },
+      { pubkey: treasury, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = admin;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      configPda: configPda.toString(),
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Update protocol config (authority only)
+   * Uses Anchor Option<T> encoding: 0 byte = None, 1 byte + value = Some
+   */
+  async buildUpdateConfigTransaction({ authorityAddress, feeBasisPoints, roundDurationSlots, newAuthority }) {
+    const [configPda] = this.getConfigPDA();
+    const authority = new PublicKey(authorityAddress);
+
+    // Serialize Anchor Option<u16> for fee_basis_points
+    const feeOption = feeBasisPoints != null
+      ? Buffer.concat([Buffer.from([1]), this.serializeU16(feeBasisPoints)])
+      : Buffer.from([0]);
+
+    // Serialize Anchor Option<u64> for round_duration_slots
+    const durationOption = roundDurationSlots != null
+      ? Buffer.concat([Buffer.from([1]), this.serializeU64(roundDurationSlots)])
+      : Buffer.from([0]);
+
+    // Serialize Anchor Option<Pubkey> for new_authority
+    const authorityOption = newAuthority != null
+      ? Buffer.concat([Buffer.from([1]), new PublicKey(newAuthority).toBuffer()])
+      : Buffer.from([0]);
+
+    const data = Buffer.concat([
+      DISCRIMINATORS.UPDATE_CONFIG,
+      feeOption,
+      durationOption,
+      authorityOption,
+    ]);
+
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false },
+    ];
+
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = authority;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      configPda: configPda.toString(),
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Open a new round
+   */
+  async buildOpenRoundTransaction({ keeperAddress }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+    
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+    
+    const nextRoundId = BigInt(config.currentRoundId) + 1n;
+    const [roundPda] = this.getRoundPDA(nextRoundId);
+    const [entriesPda] = this.getEntriesPDA(nextRoundId);
+    const keeper = new PublicKey(keeperAddress);
+    
+    const data = DISCRIMINATORS.OPEN_ROUND;
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: entriesPda, isSigner: false, isWritable: true },
+      { pubkey: keeper, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = keeper;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: nextRoundId.toString(),
+      roundPda: roundPda.toString(),
+      entriesPda: entriesPda.toString(),
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Enter a round
+   * NOTE: Always uses Round 1 PDAs due to account reuse!
+   */
+  async buildEnterRoundTransaction({ playerAddress, amount, roundId }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+    
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+    
+    // Always use Round 1 PDAs (account reuse!)
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const player = new PublicKey(playerAddress);
+    const actualRoundId = config.currentRoundId;
+    
+    const data = Buffer.concat([
+      DISCRIMINATORS.ENTER_ROUND,
+      this.serializeU64(amount),
+    ]);
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: entriesPda, isSigner: false, isWritable: true },
+      { pubkey: player, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = player;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: actualRoundId.toString(),
+      amount: amount.toString(),
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Enter round (sponsored - treasury pays)
+   * Compound tx: SystemProgram.transfer(treasury → player) + enter_round(player, amount)
+   * NOTE: Always uses Round 1 PDAs due to account reuse!
+   */
+  async buildEnterRoundSponsoredTransaction({ playerAddress, amount, treasuryKeypair }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+
+    // Always use Round 1 PDAs (account reuse!)
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const player = new PublicKey(playerAddress);
+    const actualRoundId = config.currentRoundId;
+
+    // IX 1: Treasury transfers SOL to player
+    const transferIx = SystemProgram.transfer({
+      fromPubkey: treasuryKeypair.publicKey,
+      toPubkey: player,
+      lamports: BigInt(amount),
+    });
+
+    // IX 2: Player enters round (identical to normal enter)
+    const enterData = Buffer.concat([
+      DISCRIMINATORS.ENTER_ROUND,
+      this.serializeU64(amount),
+    ]);
+
+    const enterIx = new TransactionInstruction({
+      keys: [
+        { pubkey: configPda, isSigner: false, isWritable: true },
+        { pubkey: roundPda, isSigner: false, isWritable: true },
+        { pubkey: entriesPda, isSigner: false, isWritable: true },
+        { pubkey: player, isSigner: true, isWritable: true },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      ],
+      programId: this.programId,
+      data: enterData,
+    });
+
+    // Build compound transaction
+    const transaction = new Transaction().add(transferIx).add(enterIx);
+
+    // Use 'finalized' commitment for more stable blockhash (lasts longer)
+    const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash('finalized');
+    transaction.recentBlockhash = blockhash;
+    transaction.lastValidBlockHeight = lastValidBlockHeight;
+    transaction.feePayer = treasuryKeypair.publicKey; // Treasury pays tx fee
+
+    // Treasury signs first (server-side)
+    transaction.partialSign(treasuryKeypair);
+
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: actualRoundId.toString(),
+      amount: amount.toString(),
+      sponsored: true,
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Lock round (commit phase)
+   * NOTE: Always uses Round 1 PDA due to account reuse!
+   */
+  async buildLockRoundTransaction({ keeperAddress, roundId }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+    
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+    
+    // Always use Round 1 PDAs (account reuse!)
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const keeper = new PublicKey(keeperAddress);
+    const actualRoundId = config.currentRoundId;
+    
+    // Generate server seed hash (commit phase)
+    const serverSeed = crypto.randomBytes(32);
+    const serverSeedHash = crypto.createHash('sha256').update(serverSeed).digest();
+    
+    const data = Buffer.concat([
+      DISCRIMINATORS.LOCK_ROUND,
+      serverSeedHash, // 32 bytes
+    ]);
+    
+    // LockRound struct has only 3 accounts: config, round, keeper (NO entries!)
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: keeper, isSigner: true, isWritable: true },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = keeper;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: actualRoundId.toString(),
+      serverSeed: serverSeed.toString('hex'),
+      serverSeedHash: serverSeedHash.toString('hex'),
+    };
+  }
+
+  /**
+   * ORACLE: Consume randomness (reveal phase)
+   * This is called by the oracle after lock_round
+   * NOTE: Always uses Round 1 PDA due to account reuse!
+   */
+  async consumeRandomness({ roundId, oracleSeed }) {
+    if (!this.oracleKeypair) {
+      throw new Error('Oracle keypair not loaded');
+    }
+    
+    const [configPda] = this.getConfigPDA();
+    const [roundPda] = this.getRoundPDA(1); // Always Round 1!
+    
+    // Generate oracle seed from Random.org or crypto.randomBytes
+    const seedBuffer = oracleSeed || crypto.randomBytes(32);
+    
+    const data = Buffer.concat([
+      DISCRIMINATORS.CONSUME_RANDOMNESS,
+      seedBuffer, // 32 bytes
+    ]);
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: this.oracleKeypair.publicKey, isSigner: true, isWritable: false },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = this.oracleKeypair.publicKey;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    // Sign and send
+    transaction.sign(this.oracleKeypair);
+    const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
+      skipPreflight: true,
+    });
+    await this.confirmTx(signature);
+
+    return {
+      signature,
+      roundId: roundId.toString(),
+      oracleSeed: seedBuffer.toString('hex'),
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Resolve round and pay winner
+   * NOTE: Always uses Round 1 PDAs due to account reuse!
+   */
+  async buildResolveRoundTransaction({ keeperAddress, roundId }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+    
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+    
+    // Always use Round 1 PDAs (account reuse!)
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const keeper = new PublicKey(keeperAddress);
+    const actualRoundId = config.currentRoundId;
+    
+    // Calculate winner from VRF result (winner is selected DURING resolve, not before!)
+    const roundAccount = await this.connection.getAccountInfo(roundPda);
+    if (!roundAccount) {
+      throw new Error('Round account not found');
+    }
+    
+    // Check for VRF result at offset 51
+    const hasVrf = roundAccount.data[51] === 1;
+    if (!hasVrf) {
+      throw new Error('VRF result not available yet - randomness may not have been consumed');
+    }
+    
+    // Read VRF result (u128 at offset 52-68, little-endian)
+    const vrfBytes = roundAccount.data.slice(52, 68);
+    const vrfHex = Buffer.from(vrfBytes).reverse().toString('hex');
+    const vrfResult = BigInt('0x' + vrfHex);
+    
+    // Get entries
+    const entriesAccount = await this.connection.getAccountInfo(entriesPda);
+    if (!entriesAccount) {
+      throw new Error('Entries account not found');
+    }
+    
+    const entryCount = entriesAccount.data.readUInt32LE(16);
+    if (entryCount === 0) {
+      throw new Error('No entries in round');
+    }
+    
+    // Parse entries: discriminator(8) + round_id(8) + vec_len(4) = 20, then entries
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+      const offset = 20 + (i * 56); // Each entry is 56 bytes
+      const playerBytes = entriesAccount.data.slice(offset, offset + 32);
+      const weight = entriesAccount.data.readBigUInt64LE(offset + 32);
+      // cumulative_to is u128 (16 bytes), not u64!
+      const cumulativeBytes = entriesAccount.data.slice(offset + 40, offset + 56);
+      const cumulativeTo = BigInt('0x' + Buffer.from(cumulativeBytes).reverse().toString('hex'));
+      
+      entries.push({
+        player: new PublicKey(playerBytes),
+        weight,
+        cumulativeTo
+      });
+    }
+    
+    // Calculate winner using same algorithm as on-chain program:
+    //   let winner_point = (entropy % total_weight as u128) as u64;
+    //   if winner_point < entry.cumulative_to as u64 { ... }
+    const totalWeight = roundAccount.data.readBigUInt64LE(41);
+    const winnerPoint = BigInt.asUintN(64, vrfResult % BigInt(totalWeight));
+
+    let winner = null;
+    for (const entry of entries) {
+      if (winnerPoint < BigInt.asUintN(64, entry.cumulativeTo)) {
+        winner = entry.player.toString();
+        break;
+      }
+    }
+    
+    if (!winner) {
+      throw new Error('Could not calculate winner - invalid cumulative weights');
+    }
+    
+    console.log('✅ Calculated winner:', winner.slice(0, 8) + '...');
+    
+    const data = DISCRIMINATORS.RESOLVE_ROUND;
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: entriesPda, isSigner: false, isWritable: false },
+      { pubkey: new PublicKey(winner), isSigner: false, isWritable: true },
+      { pubkey: new PublicKey(config.treasury), isSigner: false, isWritable: true },
+      { pubkey: keeper, isSigner: true, isWritable: true },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = keeper;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: actualRoundId.toString(),
+      winner,
+    };
+  }
+
+  /**
+   * BUILD TRANSACTION: Reset round (account reuse like Solpot!)
+   * Reuses existing Round #1 accounts instead of creating new ones
+   */
+  async buildResetRoundTransaction({ keeperAddress }) {
+    const [configPda] = this.getConfigPDA();
+    const config = await this.getConfig();
+    
+    if (!config) {
+      throw new Error('Protocol not initialized');
+    }
+    
+    // Always use Round 1 PDAs (we reuse them forever!)
+    const [roundPda] = this.getRoundPDA(1);
+    const [entriesPda] = this.getEntriesPDA(1);
+    const keeper = new PublicKey(keeperAddress);
+    
+    const data = DISCRIMINATORS.RESET_ROUND;
+    
+    const keys = [
+      { pubkey: configPda, isSigner: false, isWritable: true },
+      { pubkey: roundPda, isSigner: false, isWritable: true },
+      { pubkey: entriesPda, isSigner: false, isWritable: true },
+      { pubkey: keeper, isSigner: true, isWritable: true },
+    ];
+    
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: this.programId,
+      data,
+    });
+    
+    const transaction = new Transaction().add(instruction);
+    transaction.feePayer = keeper;
+    transaction.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    
+    const nextRoundId = BigInt(config.currentRoundId) + 1n;
+    
+    return {
+      transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
+      roundId: nextRoundId.toString(),
+      roundPda: roundPda.toString(),
+      entriesPda: entriesPda.toString(),
+      reused: true, // Flag that accounts were reused
+    };
+  }
+
+  /**
+   * Get jackpot statistics
+   */
+  async getStats() {
+    const config = await this.getConfig();
+    const currentRound = await this.getCurrentRound();
+    
+    return {
+      initialized: !!config,
+      config: config || {},
+      currentRound: currentRound || {},
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  // ============================================
+  // HELPER FUNCTIONS
+  // ============================================
+
+  serializeU16(value) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16LE(value);
+    return buf;
+  }
+
+  serializeU64(value) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(BigInt(value));
+    return buf;
+  }
+}
+
+module.exports = JackpotService;
+