dubs-server 1.0.0

package/scripts/test-connect4-resolve.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+/**
+ * Test Script: Connect4 Game Resolution with Polling Confirmation
+ *
+ * Tests the resolveGame function in connect4GameService.js
+ * to verify the Alchemy-compatible polling confirmation works.
+ *
+ * Usage:
+ *   node test-connect4-resolve.js <gameId>           # Resolve specific game
+ *   node test-connect4-resolve.js --find-pending     # Find and list pending games
+ *   node test-connect4-resolve.js --dry-run <gameId> # Show what would happen
+ */
+
+require('dotenv').config();
+const { Connection, Keypair, PublicKey, Transaction, TransactionInstruction } = require('@solana/web3.js');
+const { pool } = require('../services/db');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const RPC_URL = process.env.SOLANA_RPC_URL || process.env.SOLANA_NETWORK;
+const PROGRAM_ID = new PublicKey(process.env.PROGRAM_ID || '85wJGp9uc8w2FeKX9CEHsudTo1UVCrmuRFy37oCcaoG1');
+const RESOLVE_AUTO_DISCRIMINATOR = Buffer.from([245, 33, 115, 150, 82, 150, 28, 193]);
+
+// Parse args
+const args = process.argv.slice(2);
+const options = {
+  gameId: null,
+  findPending: false,
+  dryRun: false,
+  help: false
+};
+
+args.forEach((arg, i) => {
+  if (arg === '--find-pending') options.findPending = true;
+  else if (arg === '--dry-run') {
+    options.dryRun = true;
+    options.gameId = args[i + 1];
+  }
+  else if (arg === '--help') options.help = true;
+  else if (!arg.startsWith('--')) options.gameId = arg;
+});
+
+console.log('🧪 Connect4 Resolution Test (with Polling Confirmation)');
+console.log('========================================================');
+console.log(`RPC URL: ${RPC_URL || 'NOT SET'}`);
+console.log(`Program ID: ${PROGRAM_ID.toString()}`);
+console.log('');
+
+if (!RPC_URL) {
+  console.error('❌ ERROR: SOLANA_RPC_URL environment variable is not set!');
+  console.log('   Set it to your Alchemy RPC URL');
+  process.exit(1);
+}
+
+const connection = new Connection(RPC_URL, 'confirmed');
+
+/**
+ * Load oracle keypair
+ */
+function loadOracleKeypair() {
+  if (process.env.ORACLE_WALLET_JSON) {
+    const secretKey = JSON.parse(process.env.ORACLE_WALLET_JSON);
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+
+  const walletPath = process.env.ORACLE_WALLET_PATH || path.join(__dirname, '../wallets/oracle.json');
+  if (fs.existsSync(walletPath)) {
+    const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf-8'));
+    return Keypair.fromSecretKey(Uint8Array.from(secretKey));
+  }
+
+  throw new Error('Oracle keypair not found');
+}
+
+/**
+ * Poll for transaction confirmation using getSignatureStatuses
+ * This is the Alchemy-compatible approach (no WebSocket subscriptions)
+ */
+async function pollTransactionConfirmation(signature, lastValidBlockHeight, timeout = 30000) {
+  const start = Date.now();
+  console.log(`🔄 Polling confirmation for ${signature}`);
+  console.log(`   lastValidBlockHeight: ${lastValidBlockHeight}`);
+
+  let pollCount = 0;
+  while (Date.now() - start < timeout) {
+    pollCount++;
+    try {
+      // Check if blockhash has expired
+      const currentBlockHeight = await connection.getBlockHeight('confirmed');
+      if (currentBlockHeight > lastValidBlockHeight) {
+        throw new Error(`Transaction expired: blockhash no longer valid (current: ${currentBlockHeight}, lastValid: ${lastValidBlockHeight})`);
+      }
+
+      // Poll signature status
+      const response = await connection.getSignatureStatuses([signature], {
+        searchTransactionHistory: true
+      });
+
+      const status = response?.value?.[0];
+      if (status) {
+        console.log(`   [Poll ${pollCount}] confirmationStatus: ${status.confirmationStatus}, err: ${status.err ? JSON.stringify(status.err) : 'null'}`);
+
+        if (status.err) {
+          throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        }
+
+        if (status.confirmationStatus === 'confirmed' || status.confirmationStatus === 'finalized') {
+          console.log(`✅ Transaction confirmed: ${status.confirmationStatus}`);
+          return status;
+        }
+      } else {
+        console.log(`   [Poll ${pollCount}] Status: null (not confirmed yet)`);
+      }
+    } catch (pollErr) {
+      if (pollErr.message?.includes('expired') || pollErr.message?.includes('failed')) {
+        throw pollErr;
+      }
+      console.warn(`   [Poll ${pollCount}] Error (will retry): ${pollErr.message}`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+
+/**
+ * Find pending Connect4 games
+ */
+async function findPendingGames() {
+  console.log('🔍 Finding pending Connect4 games...\n');
+
+  const result = await pool.query(`
+    SELECT
+      g.game_id, g.game_status, g.connect4_winner, g.is_resolved, g.created_by,
+      g.buy_in, g.created_at,
+      creator.wallet_address as creator_wallet,
+      opponent.wallet_address as opponent_wallet
+    FROM games g
+    LEFT JOIN user_game_refs creator ON g.game_id = creator.game_id AND creator.role = 'creator'
+    LEFT JOIN user_game_refs opponent ON g.game_id = opponent.game_id AND opponent.role = 'opponent'
+    WHERE g.game_type = 'connect4'
+      AND g.game_status IN ('playing', 'waiting', 'pending')
+      AND g.is_resolved = FALSE
+    ORDER BY g.created_at DESC
+    LIMIT 10
+  `);
+
+  if (result.rows.length === 0) {
+    console.log('   No pending games found');
+    return [];
+  }
+
+  console.log(`Found ${result.rows.length} pending game(s):\n`);
+  result.rows.forEach(g => {
+    console.log(`   Game ID: ${g.game_id}`);
+    console.log(`   Status: ${g.game_status}`);
+    console.log(`   Creator: ${g.creator_wallet?.slice(0, 16) || g.created_by?.slice(0, 16)}...`);
+    console.log(`   Opponent: ${g.opponent_wallet?.slice(0, 16) || 'N/A'}...`);
+    console.log(`   Buy-in: ${g.buy_in} SOL`);
+    console.log(`   Created: ${g.created_at}`);
+    console.log('');
+  });
+
+  return result.rows;
+}
+
+/**
+ * Get game details
+ */
+async function getGameDetails(gameId) {
+  const result = await pool.query(`
+    SELECT
+      g.game_id, g.game_status, g.connect4_winner as winner, g.is_resolved,
+      g.created_by, g.buy_in, g.game_address as game_pda, g.claim_signature,
+      creator.wallet_address as creator_wallet,
+      creator.claimed_at as creator_claimed_at
+    FROM games g
+    LEFT JOIN user_game_refs creator ON g.game_id = creator.game_id AND creator.role = 'creator'
+    WHERE g.game_id = $1
+  `, [gameId]);
+
+  if (result.rows.length === 0) {
+    throw new Error(`Game ${gameId} not found`);
+  }
+
+  return result.rows[0];
+}
+
+/**
+ * Build resolve instruction (for cancel: winner = null)
+ */
+function buildResolveInstruction(gamePDA, gameIdBuf, winner, oracleKeypair) {
+  // Winner: 0 = Team A wins, 1 = Team B wins, 2 = Draw, 255 = No winner (cancel)
+  let winnerByte;
+  if (winner === null || winner === 'cancel') {
+    winnerByte = 255; // No winner - refund both
+  } else if (winner === 'creator' || winner === 'teamA' || winner === 0) {
+    winnerByte = 0;
+  } else if (winner === 'opponent' || winner === 'teamB' || winner === 1) {
+    winnerByte = 1;
+  } else if (winner === 'draw') {
+    winnerByte = 2;
+  } else {
+    throw new Error(`Invalid winner value: ${winner}`);
+  }
+
+  const data = Buffer.concat([
+    RESOLVE_AUTO_DISCRIMINATOR,
+    gameIdBuf,
+    Buffer.from([winnerByte])
+  ]);
+
+  const OPERATOR_WALLET = new PublicKey(process.env.OPERATOR_WALLET || 'BVZXwZpfgyzTBdRFHohkHZppPHnAyqyctRsKy3vWfQib');
+
+  const keys = [
+    { pubkey: gamePDA, isSigner: false, isWritable: true },
+    { pubkey: oracleKeypair.publicKey, isSigner: true, isWritable: true },
+    { pubkey: OPERATOR_WALLET, isSigner: false, isWritable: true },
+    { pubkey: require('@solana/web3.js').SystemProgram.programId, isSigner: false, isWritable: false },
+  ];
+
+  return new TransactionInstruction({
+    keys,
+    programId: PROGRAM_ID,
+    data
+  });
+}
+
+/**
+ * Resolve a Connect4 game (cancel)
+ */
+async function resolveGame(gameId, winner = null) {
+  console.log(`\n📋 Resolving Connect4 Game: ${gameId}`);
+  console.log('------------------------------------------');
+
+  const game = await getGameDetails(gameId);
+  console.log(`   Status: ${game.game_status}`);
+  console.log(`   is_resolved: ${game.is_resolved}`);
+  console.log(`   Winner: ${game.winner || 'null'}`);
+  console.log(`   Game PDA: ${game.game_pda || 'N/A'}`);
+  console.log(`   Creator: ${game.creator_wallet || game.created_by}`);
+
+  if (game.is_resolved) {
+    console.log('\n⚠️  Game is already resolved!');
+    return null;
+  }
+
+  // Load oracle
+  const oracleKeypair = loadOracleKeypair();
+  console.log(`   Oracle: ${oracleKeypair.publicKey.toString()}`);
+
+  // Derive game PDA if not stored
+  let gamePDA;
+  if (game.game_pda) {
+    gamePDA = new PublicKey(game.game_pda);
+  } else {
+    // Derive from game_id
+    const gameIdNum = BigInt(gameId.replace('connect4-', '').split('-')[0]);
+    const gameIdBuf = Buffer.alloc(8);
+    gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+    [gamePDA] = PublicKey.findProgramAddressSync(
+      [Buffer.from('game'), gameIdBuf],
+      PROGRAM_ID
+    );
+  }
+  console.log(`   Derived PDA: ${gamePDA.toString()}`);
+
+  // Check if account exists on-chain
+  const accountInfo = await connection.getAccountInfo(gamePDA);
+  if (!accountInfo) {
+    console.log('\n❌ Game account not found on-chain!');
+    return null;
+  }
+  console.log(`   On-chain account: ${accountInfo.data.length} bytes`);
+
+  // Build game ID buffer
+  const gameIdNum = BigInt(gameId.replace('connect4-', '').split('-')[0]);
+  const gameIdBuf = Buffer.alloc(8);
+  gameIdBuf.writeBigUInt64LE(gameIdNum);
+
+  // Build instruction
+  const ix = buildResolveInstruction(gamePDA, gameIdBuf, winner, oracleKeypair);
+
+  // Build transaction
+  const tx = new Transaction().add(ix);
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = oracleKeypair.publicKey;
+  tx.sign(oracleKeypair);
+
+  console.log(`\n📡 Sending resolve transaction...`);
+  console.log(`   Blockhash: ${blockhash}`);
+  console.log(`   lastValidBlockHeight: ${lastValidBlockHeight}`);
+
+  const signature = await connection.sendRawTransaction(tx.serialize());
+  console.log(`   Signature: ${signature}`);
+  console.log(`   https://solscan.io/tx/${signature}`);
+
+  // Use polling confirmation (Alchemy-compatible)
+  console.log(`\n⏳ Waiting for confirmation (polling)...`);
+  try {
+    await pollTransactionConfirmation(signature, lastValidBlockHeight, 30000);
+    console.log(`\n✅ Game resolved successfully!`);
+
+    // Update database
+    await pool.query(`
+      UPDATE games SET
+        is_resolved = TRUE,
+        game_status = 'cancelled',
+        connect4_winner = NULL,
+        claim_signature = $1,
+        resolved_at = NOW(),
+        updated_at = NOW()
+      WHERE game_id = $2
+    `, [signature, gameId]);
+
+    console.log(`   Database updated`);
+    return signature;
+
+  } catch (confirmErr) {
+    if (confirmErr.message?.includes('AlreadyResolved')) {
+      console.log(`\n⚠️  Game was already resolved on-chain`);
+      return null;
+    }
+    throw confirmErr;
+  }
+}
+
+/**
+ * Main
+ */
+async function main() {
+  if (options.help) {
+    console.log('Usage:');
+    console.log('  node test-connect4-resolve.js <gameId>           # Resolve (cancel) game');
+    console.log('  node test-connect4-resolve.js --find-pending     # List pending games');
+    console.log('  node test-connect4-resolve.js --dry-run <gameId> # Show details only');
+    process.exit(0);
+  }
+
+  try {
+    if (options.findPending) {
+      await findPendingGames();
+    } else if (options.dryRun && options.gameId) {
+      console.log('DRY RUN - showing game details only\n');
+      const game = await getGameDetails(options.gameId);
+      console.log(JSON.stringify(game, null, 2));
+    } else if (options.gameId) {
+      await resolveGame(options.gameId, null); // null = cancel
+    } else {
+      console.log('No game ID provided. Use --find-pending to list games.');
+    }
+
+  } catch (error) {
+    console.error('\n❌ Error:', error.message);
+    if (error.logs) {
+      console.error('Program logs:');
+      error.logs.forEach(log => console.error(`  ${log}`));
+    }
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main();

package/scripts/test-game-state-endpoint.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * Test Game State Endpoint
+ * Tests the /api/games/:gameId/state endpoint for different users
+ */
+
+require('dotenv').config();
+const axios = require('axios');
+const https = require('https');
+
+// Create axios instance that ignores SSL cert issues (for testing only!)
+const axiosInstance = axios.create({
+  httpsAgent: new https.Agent({
+    rejectUnauthorized: false
+  })
+});
+
+const API_URL = process.env.DUBS_SERVER_URL || 'http://localhost:3001';
+
+// Test game ID from database
+const TEST_GAME_ID = 'sport-1764007906160-dnxc6zbps';
+
+// Test wallets - all 3 joined away team and WON
+const TEST_WALLETS = {
+  creator: '3sgQXvLKs4XfBTxG3jY2J2E5NougemfC6i4nZbUVx8xt', // Away team (WINNER)
+  joiner1: 'E2SXYN3GVvQyEo1Pei8PUsyTmFqgkfuK7jTau9CrpfYC', // Away team (WINNER)
+  joiner2: 'CMt4nTCGmTXu7LsH5ujsnUsnBpb6qk7hQJAUPvHoW4aD', // Away team (WINNER)
+  nonParticipant: 'NonParticipantWallet123'
+};
+
+async function testGameState(walletAddress, label) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`Testing: ${label}`);
+  console.log(`Wallet: ${walletAddress}`);
+  console.log('='.repeat(60));
+  
+  try {
+    const response = await axiosInstance.get(
+      `${API_URL}/api/games/${TEST_GAME_ID}/state`,
+      {
+        headers: {
+          'x-wallet-address': walletAddress
+        }
+      }
+    );
+    
+    console.log('\n✅ Response Status:', response.status);
+    console.log('\n📊 Game State:');
+    console.log(JSON.stringify(response.data, null, 2));
+    
+    // Validate expected fields
+    const state = response.data;
+    console.log('\n🔍 Validation:');
+    console.log(`  isLocked: ${state.isLocked} ${state.isLocked !== undefined ? '✅' : '❌'}`);
+    console.log(`  isResolved: ${state.isResolved} ${state.isResolved !== undefined ? '✅' : '❌'}`);
+    console.log(`  totalPlayers: ${state.totalPlayers} ${state.totalPlayers !== undefined ? '✅' : '❌'}`);
+    
+    if (state.isResolved) {
+      console.log(`  winner: ${state.winner} ${state.winner ? '✅' : '❌'}`);
+      console.log(`  homeScore: ${state.homeScore} ${state.homeScore !== undefined ? '✅' : '❌'}`);
+      console.log(`  awayScore: ${state.awayScore} ${state.awayScore !== undefined ? '✅' : '❌'}`);
+    }
+    
+    console.log(`  userParticipated: ${state.userParticipated} ${state.userParticipated !== undefined ? '✅' : '❌'}`);
+    
+    if (state.userParticipated) {
+      console.log(`  userTeamChoice: ${state.userTeamChoice} ${state.userTeamChoice ? '✅' : '❌'}`);
+      console.log(`  userWon: ${state.userWon} ${state.userWon !== undefined ? '✅' : '❌'}`);
+    }
+    
+    // Determine expected button state
+    console.log('\n🎮 Expected Button State:');
+    if (state.isResolved) {
+      if (state.userParticipated) {
+        if (state.userWon) {
+          console.log('  ✅ Should show: "🏆 Claim Prize" (green, pulsing)');
+        } else {
+          console.log('  ❌ Should show: "✖️ You Lost" (red)');
+        }
+      } else {
+        console.log('  👁️  Should show: "View Results" (grey)');
+      }
+    } else if (state.isLocked) {
+      console.log('  🔒 Should show: "Game Started" (grey, disabled)');
+    } else {
+      console.log('  🏆 Should show: "Join Bet" (gradient, clickable)');
+    }
+    
+  } catch (error) {
+    console.error('\n❌ Error:', error.message);
+    if (error.response) {
+      console.error('Status:', error.response.status);
+      console.error('Data:', error.response.data);
+    }
+  }
+}
+
+async function runTests() {
+  console.log('🧪 Testing Game State Endpoint');
+  console.log(`API URL: ${API_URL}`);
+  console.log(`Game ID: ${TEST_GAME_ID}`);
+  
+  // Test 1: Creator (who participated)
+  await testGameState(TEST_WALLETS.creator, 'Creator/Participant');
+  
+  // Test 2: Joiner 1
+  await testGameState(TEST_WALLETS.joiner1, 'Joiner #1');
+  
+  // Test 3: Joiner 2
+  await testGameState(TEST_WALLETS.joiner2, 'Joiner #2');
+  
+  // Test 4: Non-participant
+  await testGameState(TEST_WALLETS.nonParticipant, 'Non-Participant (Spectator)');
+  
+  // Test 5: No wallet header
+  console.log(`\n${'='.repeat(60)}`);
+  console.log('Testing: No Wallet Header (Public Access)');
+  console.log('='.repeat(60));
+  
+  try {
+    const response = await axiosInstance.get(`${API_URL}/api/games/${TEST_GAME_ID}/state`);
+    console.log('\n✅ Response Status:', response.status);
+    console.log('\n📊 Game State:');
+    console.log(JSON.stringify(response.data, null, 2));
+    console.log('\n🔍 Should NOT include: userParticipated, userWon, userTeamChoice');
+  } catch (error) {
+    console.error('\n❌ Error:', error.message);
+  }
+  
+  console.log('\n' + '='.repeat(60));
+  console.log('✅ Tests Complete!');
+  console.log('='.repeat(60));
+}
+
+runTests().catch(console.error);
+

package/scripts/test-invite-notification.js

@@ -0,0 +1,86 @@
+/**
+ * Test script for game invite notifications with CTA button
+ * 
+ * Usage: node test-invite-notification.js <gameId> <telegramUserId> [botToken]
+ * 
+ * Example:
+ *   node test-invite-notification.js sport-1766923697972-8viqv89wv 7874505364
+ */
+
+require('dotenv').config();
+
+const GAME_ID = process.argv[2];
+const TELEGRAM_USER_ID = process.argv[3];
+const BOT_TOKEN = process.argv[4] || process.env.TELEGRAM_BOT_TOKEN;
+
+if (!GAME_ID || !TELEGRAM_USER_ID) {
+  console.error('Usage: node test-invite-notification.js <gameId> <telegramUserId> [botToken]');
+  console.error('Example: node test-invite-notification.js sport-1766923697972-8viqv89wv 7874505364');
+  process.exit(1);
+}
+
+if (!BOT_TOKEN) {
+  console.error('❌ No bot token provided. Either set TELEGRAM_BOT_TOKEN in .env or pass as 3rd argument.');
+  process.exit(1);
+}
+
+const axios = require('axios');
+const urlHelper = require('../utils/urlHelper');
+
+const TELEGRAM_API = `https://api.telegram.org/bot${BOT_TOKEN}`;
+
+async function sendTestInviteNotification() {
+  console.log('\n🧪 Test Game Invite Notification');
+  console.log('='.repeat(40));
+  console.log(`📌 Game ID: ${GAME_ID}`);
+  console.log(`👤 Telegram User ID: ${TELEGRAM_USER_ID}`);
+  console.log(`🌐 Environment: ${process.env.NODE_ENV || 'development'}`);
+  
+  const joinUrl = urlHelper.getGameShareUrl(GAME_ID);
+  console.log(`\n🔗 Join URL: ${joinUrl}`);
+  
+  const inviterUsername = '78naim';
+  const gameTitle = 'Los Angeles Rams @ Atlanta Falcons';
+  const buyIn = '0.1';
+  
+  const notificationText = `🔔 *Notification*\n\n🎮 ${inviterUsername} invited you to join their bet!\n\n${inviterUsername} invited you to join their ${gameTitle} bet! ${buyIn} SOL buy-in`;
+  
+  const payload = {
+    chat_id: TELEGRAM_USER_ID,
+    text: notificationText,
+    parse_mode: 'Markdown',
+    disable_web_page_preview: true,
+    reply_markup: {
+      inline_keyboard: [[
+        { text: '🎮 Join Game', url: joinUrl }
+      ]]
+    }
+  };
+  
+  try {
+    console.log('\n📤 Sending notification...');
+    const response = await axios.post(`${TELEGRAM_API}/sendMessage`, payload);
+    
+    if (response.data.ok) {
+      console.log(`\n✅ Notification sent successfully!`);
+      console.log(`📬 Message ID: ${response.data.result.message_id}`);
+      console.log(`\n📱 Next steps:
+   1. Check your Telegram for the notification
+   2. You should see a "🎮 Join Game" button
+   3. Tap the button to test the deferred deep link
+   4. Verify it takes you to the game join page
+`);
+    } else {
+      console.error('❌ Telegram API returned not OK:', response.data);
+    }
+  } catch (error) {
+    if (error.response) {
+      console.error(`❌ Telegram API error (${error.response.status}):`, error.response.data?.description || error.message);
+    } else {
+      console.error('❌ Failed to send:', error.message);
+    }
+  }
+}
+
+sendTestInviteNotification();
+

package/scripts/test-jackpot-api.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# 🎰 Test script for Jackpot API
+# Tests all endpoints to ensure they're working
+
+BASE_URL="http://localhost:3001/jackpot"
+
+echo "🎰 Testing Dubs Jackpot API"
+echo "============================="
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+# Test health endpoint
+echo -e "${BLUE}1. Testing health endpoint...${NC}"
+curl -s $BASE_URL/health | jq '.'
+echo ""
+
+# Test config endpoint
+echo -e "${BLUE}2. Testing config endpoint...${NC}"
+curl -s $BASE_URL/config | jq '.'
+echo ""
+
+# Test current round
+echo -e "${BLUE}3. Testing current round endpoint...${NC}"
+curl -s $BASE_URL/round/current | jq '.'
+echo ""
+
+# Test stats endpoint
+echo -e "${BLUE}4. Testing stats endpoint...${NC}"
+curl -s $BASE_URL/stats | jq '.'
+echo ""
+
+# Test building an enter transaction
+echo -e "${BLUE}5. Testing build enter transaction...${NC}"
+curl -s -X POST $BASE_URL/build/enter \
+  -H "Content-Type: application/json" \
+  -d '{
+    "playerAddress": "57voP1Y8U4ztX2YAcHveK3JFvVRn1n6T6iUnHdAW6xr9",
+    "amount": 100000000
+  }' | jq '.transaction | length'
+echo " characters in transaction"
+echo ""
+
+# Test building open round transaction
+echo -e "${BLUE}6. Testing build open-round transaction...${NC}"
+curl -s -X POST $BASE_URL/build/open-round \
+  -H "Content-Type: application/json" \
+  -d '{
+    "keeperAddress": "57voP1Y8U4ztX2YAcHveK3JFvVRn1n6T6iUnHdAW6xr9"
+  }' | jq '.roundId, .roundPda'
+echo ""
+
+echo -e "${GREEN}✅ API Test Complete!${NC}"
+echo ""
+echo "📚 Full API docs: JACKPOT_API.md"
+echo "🎰 Program ID: bqoSjTSPLweMuqNG6jy39jmzGyZvZdWjsr4csGfD8F6"
+echo ""
+echo "🚀 Start server: node server.js"
+echo "💻 Access at: http://localhost:3001/jackpot"
+
+
+
+
+
+