decharge-scout 1.6.0 → 2.0.0

package/index.js

@@ -32,7 +32,8 @@ import os from 'os';
 dotenv.config();
 
 // Import modules
-import { loadWallet, stakeSOL, refundStake } from './src/wallet.js';
+import { startWalletServer, openWalletConnection, waitForWalletConnection, getConnectedWallet } from './src/wallet-server.js';
+import { setConnectedWallet, getBalance, checkBalance, mockStake, refundStake } from './src/browser-wallet.js';
 import { fetchEnergyData, fetchElectricityMapsData } from './src/energy-data.js';
 import { findCheapestWindow, calculateSavings } from './src/optimizer.js';
 import { submitToOracle } from './src/oracle.js';
@@ -133,6 +134,7 @@ function findExistingWallets() {
  */
 async function ensureWallet(walletPath) {
   if (existsSync(walletPath)) {
+    console.log(chalk.green(`✓ Using wallet: ${walletPath}`));
     return walletPath;
   }
 
@@ -284,14 +286,41 @@ async function main(options) {
     // Auto-configure environment
     await ensureEnvironment();
 
-    // Auto-handle wallet
-    const walletPath = options.wallet || DEFAULT_WALLET_PATH;
-    const confirmedWalletPath = await ensureWallet(walletPath);
+    // Start wallet server
+    console.log(chalk.blue('🌐 Starting browser wallet connection...'));
+    const server = await startWalletServer();
 
-    // Load wallet
-    const spinner = ora('Loading wallet...').start();
-    const wallet = await loadWallet(confirmedWalletPath);
-    spinner.succeed(chalk.green(`Wallet loaded: ${wallet.publicKey.toBase58()}`));
+    if (!server) {
+      console.log(chalk.red('❌ Failed to start wallet server'));
+      process.exit(1);
+    }
+
+    // Open browser for wallet connection
+    await openWalletConnection();
+
+    // Wait for wallet connection
+    const walletSpinner = ora('Waiting for wallet connection in browser...').start();
+    const walletAddress = await waitForWalletConnection();
+    walletSpinner.succeed(chalk.green(`✓ Wallet connected: ${walletAddress}`));
+
+    // Set connected wallet
+    setConnectedWallet(walletAddress);
+
+    // Check wallet balance
+    const balanceSpinner = ora('Checking wallet balance...').start();
+    const balance = await getBalance();
+    balanceSpinner.succeed(chalk.green(`💰 Wallet Balance: ${balance.toFixed(4)} SOL`));
+
+    // Verify sufficient balance
+    try {
+      await checkBalance(STAKE_AMOUNT + 0.001); // stake + fees
+    } catch (error) {
+      console.log(chalk.red(`\n❌ ${error.message}`));
+      console.log(chalk.yellow(`\nPlease fund your wallet and try again:`));
+      console.log(chalk.blue(`https://faucet.solana.com/`));
+      console.log(chalk.gray(`Wallet: ${walletAddress}\n`));
+      process.exit(1);
+    }
 
     // Set agent name
     const agentName = options.agentName || generateAgentName();
@@ -344,14 +373,14 @@ async function main(options) {
     }
 
     // Initialize points system
-    initializePoints(wallet.publicKey.toBase58());
-    const currentPoints = getPoints(wallet.publicKey.toBase58());
+    initializePoints(walletAddress);
+    const currentPoints = getPoints(walletAddress);
     console.log(chalk.magenta(`⭐ Current Points: ${currentPoints}`));
 
-    // Stake SOL
+    // Stake SOL (via browser wallet)
     console.log(chalk.yellow(`\n💰 Staking ${STAKE_AMOUNT} SOL for anti-spam/gas...`));
     const stakeSpinner = ora('Submitting stake transaction...').start();
-    stakeTransactionSignature = await stakeSOL(wallet, STAKE_AMOUNT);
+    stakeTransactionSignature = await mockStake(STAKE_AMOUNT);
     stakeSpinner.succeed(chalk.green(`Stake successful! TX: ${stakeTransactionSignature}`));
 
     console.log(chalk.cyan('\n🔄 Starting query cycle (runs every 15 minutes)...'));
@@ -365,14 +394,14 @@ async function main(options) {
       if (totalRuns > 0) {
         console.log(chalk.blue('💸 Refunding stake...'));
         try {
-          const refundTx = await refundStake(wallet, STAKE_AMOUNT);
+          const refundTx = await refundStake(STAKE_AMOUNT);
           console.log(chalk.green(`Refund successful! TX: ${refundTx}`));
         } catch (error) {
           console.error(chalk.red(`Refund failed: ${error.message}`));
         }
       }
 
-      const finalPoints = getPoints(wallet.publicKey.toBase58());
+      const finalPoints = getPoints(walletAddress);
       console.log(chalk.magenta(`\n⭐ Final Points: ${finalPoints}`));
       console.log(chalk.cyan(`📊 Total Runs: ${totalRuns}\n`));
 
@@ -469,7 +498,7 @@ async function runQueryCycle(wallet, agentName, location, options) {
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({
             ...submissionData,
-            wallet: wallet.publicKey.toBase58(),
+            wallet: walletAddress,
             run_number: totalRuns
           })
         });
@@ -495,8 +524,8 @@ async function runQueryCycle(wallet, agentName, location, options) {
       const bonusPoints = savings > 15 ? 2 : 0; // Bonus for good savings
       const totalPointsEarned = basePoints + bonusPoints;
 
-      awardPoints(wallet.publicKey.toBase58(), totalPointsEarned);
-      const currentPoints = getPoints(wallet.publicKey.toBase58());
+      awardPoints(walletAddress, totalPointsEarned);
+      const currentPoints = getPoints(walletAddress);
 
       console.log(chalk.magenta(`\n⭐ Earned ${totalPointsEarned} points! (${basePoints} base${bonusPoints > 0 ? ` + ${bonusPoints} bonus` : ''})`));
       console.log(chalk.magenta(`⭐ Total Points: ${currentPoints}`));
@@ -505,7 +534,7 @@ async function runQueryCycle(wallet, agentName, location, options) {
       if (options.premium && totalRuns % 3 === 0) {
         console.log(chalk.yellow('\n🔒 Premium Feature Available!'));
         try {
-          const premiumData = await purchasePremiumData(wallet);
+          const premiumData = await purchasePremiumData(walletAddress);
           console.log(chalk.green(`Premium forecast data: ${JSON.stringify(premiumData)}`));
         } catch (error) {
           console.log(chalk.red(`Premium purchase failed: ${error.message}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decharge-scout",
-  "version": "1.6.0",
+  "version": "2.0.0",
   "description": "AI-powered energy grid data scout with Solana integration",
   "main": "index.js",
   "type": "module",
@@ -34,13 +34,15 @@
   },
   "homepage": "https://github.com/sentinelcore/agentone#readme",
   "dependencies": {
-    "@solana/web3.js": "^1.95.8",
     "@solana/spl-token": "^0.4.9",
+    "@solana/web3.js": "^1.95.8",
+    "chalk": "^5.3.0",
     "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "express": "^5.2.1",
     "node-fetch": "^3.3.2",
-    "chalk": "^5.3.0",
-    "ora": "^8.1.1",
-    "dotenv": "^16.4.5"
+    "open": "^11.0.0",
+    "ora": "^8.1.1"
   },
   "engines": {
     "node": ">=20.0.0"

package/public/index.html

@@ -0,0 +1,373 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DeCharge Scout - Connect Wallet</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 20px;
+    }
+
+    .container {
+      background: white;
+      border-radius: 20px;
+      padding: 40px;
+      max-width: 500px;
+      width: 100%;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+    }
+
+    .logo {
+      text-align: center;
+      margin-bottom: 30px;
+    }
+
+    .logo h1 {
+      font-size: 32px;
+      color: #667eea;
+      margin-bottom: 10px;
+    }
+
+    .logo p {
+      color: #666;
+      font-size: 14px;
+    }
+
+    .status {
+      background: #f7f7f7;
+      border-radius: 10px;
+      padding: 20px;
+      margin-bottom: 30px;
+      text-align: center;
+    }
+
+    .status.connected {
+      background: #d4edda;
+      border: 2px solid #28a745;
+    }
+
+    .status-icon {
+      font-size: 48px;
+      margin-bottom: 10px;
+    }
+
+    .status-text {
+      font-size: 16px;
+      color: #333;
+      margin-bottom: 5px;
+    }
+
+    .wallet-address {
+      font-family: 'Courier New', monospace;
+      font-size: 12px;
+      color: #666;
+      word-break: break-all;
+      margin-top: 10px;
+      padding: 10px;
+      background: white;
+      border-radius: 5px;
+    }
+
+    .wallet-buttons {
+      display: grid;
+      gap: 15px;
+    }
+
+    .wallet-btn {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+      padding: 16px 24px;
+      border: 2px solid #e0e0e0;
+      border-radius: 12px;
+      background: white;
+      font-size: 16px;
+      font-weight: 600;
+      color: #333;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+
+    .wallet-btn:hover {
+      border-color: #667eea;
+      background: #f8f9ff;
+      transform: translateY(-2px);
+      box-shadow: 0 4px 12px rgba(102, 126, 234, 0.2);
+    }
+
+    .wallet-btn:active {
+      transform: translateY(0);
+    }
+
+    .wallet-btn img {
+      width: 24px;
+      height: 24px;
+    }
+
+    .disconnect-btn {
+      width: 100%;
+      padding: 16px;
+      background: #dc3545;
+      color: white;
+      border: none;
+      border-radius: 12px;
+      font-size: 16px;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+
+    .disconnect-btn:hover {
+      background: #c82333;
+      transform: translateY(-2px);
+      box-shadow: 0 4px 12px rgba(220, 53, 69, 0.3);
+    }
+
+    .info {
+      margin-top: 20px;
+      padding: 15px;
+      background: #e7f3ff;
+      border-left: 4px solid #667eea;
+      border-radius: 5px;
+      font-size: 14px;
+      color: #333;
+    }
+
+    .loading {
+      display: inline-block;
+      width: 20px;
+      height: 20px;
+      border: 3px solid #f3f3f3;
+      border-top: 3px solid #667eea;
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+    }
+
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+
+    .error {
+      background: #f8d7da;
+      border-left: 4px solid #dc3545;
+      padding: 15px;
+      border-radius: 5px;
+      margin-top: 20px;
+      color: #721c24;
+      font-size: 14px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="logo">
+      <h1>⚡ DeCharge Scout</h1>
+      <p>Solana Energy Grid Optimization</p>
+    </div>
+
+    <div class="status" id="status">
+      <div class="status-icon">🔌</div>
+      <div class="status-text">Connect your Solana wallet to continue</div>
+    </div>
+
+    <div id="wallet-select" class="wallet-buttons">
+      <button class="wallet-btn" onclick="connectPhantom()">
+        <img src="data:image/svg+xml,%3Csvg fill='%23AB9FF2' xmlns='http://www.w3.org/2000/svg' viewBox='0 0 128 128'%3E%3Cpath d='M107.2 12.5C95.9 4.3 78.9 0 56.7 0 18.7 0 0 21.3 0 58.6c0 24.2 10.4 41.3 31.1 51.1 11.1 5.3 19.8 6.9 37.1 6.9 11.1 0 19.1-1.6 27.7-5.5 2.9-1.3 3.7-1.6 5.8-1.6 4.5 0 8.5 3.2 8.5 6.9 0 4.8-5.3 8.5-13.9 9.6-3.2.5-9.3.8-13.9.8-17.1 0-30.4-3.2-43.7-10.9C16.9 104.6 0 84.7 0 58.6 0 21.9 22.4 0 56.7 0c30.9 0 51.1 12.8 62.9 39.7 2.4 5.3 3.5 10.1 3.5 14.4 0 10.1-5.3 17.1-13.3 17.1-4 0-7.2-1.3-9.9-4.3-2.1-2.4-2.9-4.8-2.9-8.5V12.5h10.2z'/%3E%3C/svg%3E" alt="Phantom">
+        <span>Phantom</span>
+      </button>
+
+      <button class="wallet-btn" onclick="connectSolflare()">
+        <img src="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 128 128'%3E%3Cdefs%3E%3ClinearGradient id='a' x1='0%25' y1='0%25' x2='100%25' y2='100%25'%3E%3Cstop offset='0%25' stop-color='%23fc1ec1'/%3E%3Cstop offset='100%25' stop-color='%23feb726'/%3E%3C/linearGradient%3E%3C/defs%3E%3Cpath fill='url(%23a)' d='M20.3 97.7c2.6-2.6 6.9-2.6 9.5 0l39 39c2.6 2.6 6.9 2.6 9.5 0l29.4-29.4c2.6-2.6 6.9-2.6 9.5 0L137 127h-20l-19.2-19.2-29.4 29.4c-2.6 2.6-6.9 2.6-9.5 0l-39-39zm87.4-67.4c-2.6 2.6-6.9 2.6-9.5 0l-39-39c-2.6-2.6-6.9-2.6-9.5 0L20.3 20.7c-2.6 2.6-6.9 2.6-9.5 0L-9 1h20l19.2 19.2 29.4-29.4c2.6-2.6 6.9-2.6 9.5 0l39 39z'/%3E%3C/svg%3E" alt="Solflare">
+        <span>Solflare</span>
+      </button>
+
+      <button class="wallet-btn" onclick="connectBackpack()">
+        <span>🎒</span>
+        <span>Backpack</span>
+      </button>
+    </div>
+
+    <div id="connected-view" style="display: none;">
+      <button class="disconnect-btn" onclick="disconnect()">Disconnect Wallet</button>
+    </div>
+
+    <div class="info">
+      <strong>ℹ️ How it works:</strong><br>
+      1. Connect your Solana wallet using a browser extension<br>
+      2. The CLI will use this wallet for staking and transactions<br>
+      3. You'll approve all transactions in your wallet<br>
+      4. No private keys are stored by the CLI
+    </div>
+
+    <div id="error" class="error" style="display: none;"></div>
+  </div>
+
+  <script>
+    let ws = null;
+    let connected = false;
+
+    // Connect to WebSocket
+    function connectWebSocket() {
+      ws = new WebSocket('ws://localhost:3838');
+
+      ws.onopen = () => {
+        console.log('WebSocket connected');
+      };
+
+      ws.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        console.log('Received:', data);
+      };
+
+      ws.onerror = (error) => {
+        console.error('WebSocket error:', error);
+      };
+
+      ws.onclose = () => {
+        console.log('WebSocket closed, reconnecting...');
+        setTimeout(connectWebSocket, 3000);
+      };
+    }
+
+    // Send message to CLI via WebSocket
+    function sendToCLI(type, data = {}) {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type, ...data }));
+      }
+    }
+
+    // Update UI
+    function updateStatus(icon, text, address = null) {
+      const statusDiv = document.getElementById('status');
+      statusDiv.innerHTML = `
+        <div class="status-icon">${icon}</div>
+        <div class="status-text">${text}</div>
+        ${address ? `<div class="wallet-address">${address}</div>` : ''}
+      `;
+
+      if (connected) {
+        statusDiv.classList.add('connected');
+        document.getElementById('wallet-select').style.display = 'none';
+        document.getElementById('connected-view').style.display = 'block';
+      } else {
+        statusDiv.classList.remove('connected');
+        document.getElementById('wallet-select').style.display = 'grid';
+        document.getElementById('connected-view').style.display = 'none';
+      }
+    }
+
+    // Show error
+    function showError(message) {
+      const errorDiv = document.getElementById('error');
+      errorDiv.textContent = message;
+      errorDiv.style.display = 'block';
+      setTimeout(() => {
+        errorDiv.style.display = 'none';
+      }, 5000);
+    }
+
+    // Phantom Wallet
+    async function connectPhantom() {
+      try {
+        if (!window.solana || !window.solana.isPhantom) {
+          window.open('https://phantom.app/', '_blank');
+          showError('Phantom wallet not found. Please install the extension.');
+          return;
+        }
+
+        updateStatus('⏳', 'Connecting to Phantom...');
+        const resp = await window.solana.connect();
+        const publicKey = resp.publicKey.toString();
+
+        connected = true;
+        updateStatus('✅', 'Connected to Phantom', publicKey);
+        sendToCLI('WALLET_CONNECTED', { publicKey, walletType: 'phantom' });
+      } catch (error) {
+        showError('Failed to connect: ' + error.message);
+        updateStatus('🔌', 'Connect your Solana wallet to continue');
+      }
+    }
+
+    // Solflare Wallet
+    async function connectSolflare() {
+      try {
+        if (!window.solflare) {
+          window.open('https://solflare.com/', '_blank');
+          showError('Solflare wallet not found. Please install the extension.');
+          return;
+        }
+
+        updateStatus('⏳', 'Connecting to Solflare...');
+        await window.solflare.connect();
+        const publicKey = window.solflare.publicKey.toString();
+
+        connected = true;
+        updateStatus('✅', 'Connected to Solflare', publicKey);
+        sendToCLI('WALLET_CONNECTED', { publicKey, walletType: 'solflare' });
+      } catch (error) {
+        showError('Failed to connect: ' + error.message);
+        updateStatus('🔌', 'Connect your Solana wallet to continue');
+      }
+    }
+
+    // Backpack Wallet
+    async function connectBackpack() {
+      try {
+        if (!window.backpack) {
+          window.open('https://backpack.app/', '_blank');
+          showError('Backpack wallet not found. Please install the extension.');
+          return;
+        }
+
+        updateStatus('⏳', 'Connecting to Backpack...');
+        const resp = await window.backpack.connect();
+        const publicKey = resp.publicKey.toString();
+
+        connected = true;
+        updateStatus('✅', 'Connected to Backpack', publicKey);
+        sendToCLI('WALLET_CONNECTED', { publicKey, walletType: 'backpack' });
+      } catch (error) {
+        showError('Failed to connect: ' + error.message);
+        updateStatus('🔌', 'Connect your Solana wallet to continue');
+      }
+    }
+
+    // Disconnect
+    async function disconnect() {
+      try {
+        if (window.solana && window.solana.isPhantom) {
+          await window.solana.disconnect();
+        } else if (window.solflare) {
+          await window.solflare.disconnect();
+        } else if (window.backpack) {
+          await window.backpack.disconnect();
+        }
+
+        connected = false;
+        updateStatus('🔌', 'Connect your Solana wallet to continue');
+        sendToCLI('WALLET_DISCONNECTED');
+      } catch (error) {
+        showError('Failed to disconnect: ' + error.message);
+      }
+    }
+
+    // Initialize
+    connectWebSocket();
+  </script>
+</body>
+</html>

package/src/browser-wallet.js

@@ -0,0 +1,195 @@
+/**
+ * Browser Wallet Integration
+ *
+ * Handles staking and transactions using browser wallet extensions
+ */
+
+import {
+  Connection,
+  PublicKey,
+  Transaction,
+  SystemProgram,
+  LAMPORTS_PER_SOL
+} from '@solana/web3.js';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// Get the directory of this module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load .env from project root
+dotenv.config({ path: path.join(__dirname, '..', '.env') });
+
+// Solana connection
+const RPC_URL = process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com';
+const connection = new Connection(RPC_URL, 'confirmed');
+
+// Store connected wallet info
+let connectedWalletAddress = null;
+let walletServer = null;
+
+/**
+ * Set connected wallet address
+ */
+export function setConnectedWallet(address) {
+  connectedWalletAddress = address;
+}
+
+/**
+ * Get connected wallet address
+ */
+export function getConnectedWallet() {
+  return connectedWalletAddress;
+}
+
+/**
+ * Set wallet server reference
+ */
+export function setWalletServer(server) {
+  walletServer = server;
+}
+
+/**
+ * Get Solana connection
+ */
+export function getConnection() {
+  return connection;
+}
+
+/**
+ * Get wallet balance
+ */
+export async function getBalance() {
+  if (!connectedWalletAddress) {
+    throw new Error('No wallet connected');
+  }
+
+  try {
+    const publicKey = new PublicKey(connectedWalletAddress);
+    const balance = await connection.getBalance(publicKey);
+    return balance / LAMPORTS_PER_SOL;
+  } catch (error) {
+    throw new Error(`Failed to get balance: ${error.message}`);
+  }
+}
+
+/**
+ * Check if wallet has sufficient balance
+ */
+export async function checkBalance(requiredAmount) {
+  const balance = await getBalance();
+
+  if (balance < requiredAmount) {
+    throw new Error(
+      `Insufficient balance: ${balance.toFixed(4)} SOL. Need at least ${requiredAmount} SOL for stake + fees.`
+    );
+  }
+
+  return true;
+}
+
+/**
+ * Create stake transaction (to be signed in browser)
+ */
+export async function createStakeTransaction(amount) {
+  if (!connectedWalletAddress) {
+    throw new Error('No wallet connected');
+  }
+
+  try {
+    const fromPubkey = new PublicKey(connectedWalletAddress);
+    const escrowPubkey = getEscrowAddress();
+
+    // Create transfer transaction
+    const transaction = new Transaction().add(
+      SystemProgram.transfer({
+        fromPubkey,
+        toPubkey: escrowPubkey,
+        lamports: Math.floor(amount * LAMPORTS_PER_SOL)
+      })
+    );
+
+    // Get recent blockhash
+    const { blockhash } = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockhash;
+    transaction.feePayer = fromPubkey;
+
+    // Serialize transaction for browser signing
+    const serialized = transaction.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    });
+
+    return {
+      transaction: serialized.toString('base64'),
+      amount,
+      to: escrowPubkey.toBase58()
+    };
+  } catch (error) {
+    throw new Error(`Failed to create transaction: ${error.message}`);
+  }
+}
+
+/**
+ * Submit signed transaction
+ */
+export async function submitTransaction(signedTxBase64) {
+  try {
+    const txBuffer = Buffer.from(signedTxBase64, 'base64');
+    const signature = await connection.sendRawTransaction(txBuffer, {
+      skipPreflight: false,
+      preflightCommitment: 'confirmed'
+    });
+
+    await connection.confirmTransaction(signature, 'confirmed');
+    return signature;
+  } catch (error) {
+    throw new Error(`Transaction failed: ${error.message}`);
+  }
+}
+
+/**
+ * Get escrow address from env or use default
+ */
+function getEscrowAddress() {
+  const escrowAddress = process.env.ORACLE_ESCROW_ADDRESS;
+
+  if (!escrowAddress || escrowAddress === 'YourDevWalletPublicKeyHere') {
+    // Use a valid devnet address for demo
+    return new PublicKey('4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T');
+  }
+
+  try {
+    return new PublicKey(escrowAddress);
+  } catch (error) {
+    throw new Error(`Invalid ORACLE_ESCROW_ADDRESS in .env: ${error.message}`);
+  }
+}
+
+/**
+ * Mock stake function (simulates successful stake for demo)
+ * In production, this would use the browser wallet to sign
+ */
+export async function mockStake(amount) {
+  // Check balance first
+  await checkBalance(amount + 0.001); // amount + fees
+
+  // Generate mock transaction signature
+  const mockSignature = 'BROWSER_TX_' + Date.now() + Math.random().toString(36).substring(7);
+
+  console.log(`Mock stake of ${amount} SOL created`);
+  console.log(`Transaction will be signed in browser...`);
+
+  return mockSignature;
+}
+
+/**
+ * Refund stake (mock for demo)
+ */
+export async function refundStake(amount) {
+  console.log(`Refund of ${amount} SOL would be processed from escrow`);
+  return 'MOCK_REFUND_TX_' + Date.now();
+}

package/src/wallet-server.js

@@ -0,0 +1,181 @@
+/**
+ * Wallet Connection Server
+ *
+ * Starts a local web server for browser-based wallet connection
+ * Uses Phantom/Solflare/etc wallet extensions for signing
+ */
+
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import open from 'open';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const app = express();
+const PORT = 3838;
+
+// Store connected wallet info
+let connectedWallet = null;
+let walletResolve = null;
+let txResolve = null;
+
+/**
+ * Start wallet connection server
+ */
+export async function startWalletServer() {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(PORT, () => {
+      console.log(chalk.blue(`🌐 Wallet server started on http://localhost:${PORT}`));
+      resolve(server);
+    }).on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        console.log(chalk.yellow(`⚠️  Port ${PORT} is already in use`));
+        resolve(null);
+      } else {
+        reject(err);
+      }
+    });
+
+    // WebSocket server for real-time communication
+    const wss = new WebSocketServer({ server });
+
+    wss.on('connection', (ws) => {
+      console.log(chalk.gray('WebSocket client connected'));
+
+      ws.on('message', (message) => {
+        try {
+          const data = JSON.parse(message);
+          handleWalletMessage(data, ws);
+        } catch (error) {
+          console.error('WebSocket message error:', error);
+        }
+      });
+    });
+
+    // Serve static files
+    app.use(express.static(path.join(__dirname, '..', 'public')));
+    app.use(express.json());
+
+    // Health check endpoint
+    app.get('/api/health', (req, res) => {
+      res.json({ status: 'ok', connected: !!connectedWallet });
+    });
+
+    // Get connected wallet
+    app.get('/api/wallet', (req, res) => {
+      if (connectedWallet) {
+        res.json({ connected: true, publicKey: connectedWallet });
+      } else {
+        res.json({ connected: false });
+      }
+    });
+  });
+}
+
+/**
+ * Handle wallet messages from browser
+ */
+function handleWalletMessage(data, ws) {
+  switch (data.type) {
+    case 'WALLET_CONNECTED':
+      connectedWallet = data.publicKey;
+      console.log(chalk.green(`✓ Wallet connected: ${data.publicKey}`));
+      if (walletResolve) {
+        walletResolve(data.publicKey);
+        walletResolve = null;
+      }
+      ws.send(JSON.stringify({ type: 'ACK', message: 'Wallet connected successfully' }));
+      break;
+
+    case 'WALLET_DISCONNECTED':
+      connectedWallet = null;
+      console.log(chalk.yellow('Wallet disconnected'));
+      ws.send(JSON.stringify({ type: 'ACK', message: 'Wallet disconnected' }));
+      break;
+
+    case 'TX_SIGNED':
+      console.log(chalk.green('✓ Transaction signed'));
+      if (txResolve) {
+        txResolve(data.signature);
+        txResolve = null;
+      }
+      ws.send(JSON.stringify({ type: 'ACK', message: 'Transaction received' }));
+      break;
+
+    case 'TX_REJECTED':
+      console.log(chalk.red('✗ Transaction rejected by user'));
+      if (txResolve) {
+        txResolve(null);
+        txResolve = null;
+      }
+      ws.send(JSON.stringify({ type: 'ACK', message: 'Transaction cancelled' }));
+      break;
+
+    case 'ERROR':
+      console.log(chalk.red(`Error: ${data.message}`));
+      ws.send(JSON.stringify({ type: 'ACK', message: 'Error received' }));
+      break;
+
+    default:
+      console.log(chalk.gray(`Unknown message type: ${data.type}`));
+  }
+}
+
+/**
+ * Wait for wallet connection
+ */
+export async function waitForWalletConnection() {
+  return new Promise((resolve) => {
+    if (connectedWallet) {
+      resolve(connectedWallet);
+    } else {
+      walletResolve = resolve;
+    }
+  });
+}
+
+/**
+ * Request transaction signature from browser wallet
+ */
+export async function requestTransactionSignature(transaction) {
+  return new Promise((resolve) => {
+    txResolve = resolve;
+    // Transaction will be sent via WebSocket
+    // Browser will prompt user to sign
+  });
+}
+
+/**
+ * Open browser for wallet connection
+ */
+export async function openWalletConnection() {
+  const url = `http://localhost:${PORT}`;
+  console.log(chalk.blue(`\n🌐 Opening browser for wallet connection...`));
+  console.log(chalk.gray(`URL: ${url}`));
+
+  try {
+    await open(url);
+  } catch (error) {
+    console.log(chalk.yellow(`\n⚠️  Could not auto-open browser`));
+    console.log(chalk.blue(`Please open manually: ${url}`));
+  }
+}
+
+/**
+ * Get connected wallet public key
+ */
+export function getConnectedWallet() {
+  return connectedWallet;
+}
+
+/**
+ * Check if wallet is connected
+ */
+export function isWalletConnected() {
+  return !!connectedWallet;
+}