dubs-server 1.0.0

package/scripts/jackpot/status.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const { Connection, PublicKey } = require('@solana/web3.js');
+const axios = require('axios');
+
+const PROGRAM_ID = new PublicKey('BHidyz25KWkNPdTHgeANzMg25MM2KEiNnG4yE5F46XUz');
+const RPC = process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com';
+const API_BASE = process.env.API_BASE || 'http://localhost:3001';
+
+(async () => {
+  const conn = new Connection(RPC);
+
+  console.log('🎰 DUBS JACKPOT - COMPLETE STATUS\n');
+  console.log('='.repeat(70));
+  console.log('   RPC:', RPC.includes('devnet') ? 'Devnet' : RPC.slice(0, 50) + '...');
+  console.log('   API:', API_BASE);
+
+  // Config
+  const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], PROGRAM_ID);
+  const configInfo = await conn.getAccountInfo(configPda);
+  const configRoundId = configInfo.data.readBigUInt64LE(82);
+
+  console.log('\n📝 CONFIG ACCOUNT:');
+  console.log('   Current Round ID:', configRoundId.toString());
+  console.log('   Fee:', configInfo.data.readUInt16LE(72), 'bps');
+  const durationSlots = Number(configInfo.data.readBigUInt64LE(74));
+  const durationSecs = Math.floor(durationSlots * 0.4);
+  const durationLabel = durationSecs >= 86400
+    ? `${(durationSecs / 86400).toFixed(1)} days`
+    : durationSecs >= 3600
+      ? `${(durationSecs / 3600).toFixed(1)} hours`
+      : `${(durationSecs / 60).toFixed(1)} min`;
+  console.log('   Round Duration:', durationSlots.toLocaleString(), `slots (~${durationLabel})`);
+
+  // Round 1 Account (Reused)
+  const [round1Pda] = PublicKey.findProgramAddressSync([Buffer.from('round'), Buffer.from([1,0,0,0,0,0,0,0])], PROGRAM_ID);
+  const roundInfo = await conn.getAccountInfo(round1Pda);
+  const currentSlot = await conn.getSlot();
+
+  const roundId = roundInfo.data.readBigUInt64LE(8);
+  const status = roundInfo.data[16];
+  const startSlot = roundInfo.data.readBigUInt64LE(17);
+  const endSlot = roundInfo.data.readBigUInt64LE(25);
+  const pot = Number(roundInfo.data.readBigUInt64LE(33));
+
+  console.log('\n🎲 ROUND 1 ACCOUNT (Reused):');
+  console.log('   Stored Round ID:', roundId.toString());
+  console.log('   Status:', ['Open', 'Locked', 'Resolved'][status]);
+  console.log('   Pot:', (pot/1e9).toFixed(4), 'SOL');
+  console.log('   Start Slot:', startSlot.toString());
+  console.log('   End Slot:', endSlot.toString());
+  console.log('   Current Slot:', currentSlot);
+  const timeLeft = Math.max(0, Number(endSlot) - currentSlot);
+  const secsLeft = Math.floor(timeLeft * 0.4);
+  const timeLabel = secsLeft >= 86400
+    ? `${(secsLeft / 86400).toFixed(2)} days`
+    : secsLeft >= 3600
+      ? `${(secsLeft / 3600).toFixed(1)} hours`
+      : `${secsLeft}s`;
+  console.log('   Time Left:', timeLeft.toLocaleString(), `slots (~${timeLabel})`);
+
+  // Entries
+  const [entries1Pda] = PublicKey.findProgramAddressSync([Buffer.from('entries'), Buffer.from([1,0,0,0,0,0,0,0])], PROGRAM_ID);
+  const entriesInfo = await conn.getAccountInfo(entries1Pda);
+  const vecLength = entriesInfo.data.readUInt32LE(16);
+
+  console.log('\n👥 ENTRIES ACCOUNT:');
+  console.log('   Entry Count:', vecLength);
+
+  if (vecLength > 0 && vecLength < 100) {
+    console.log('   Players:');
+    for (let i = 0; i < vecLength; i++) {
+      const offset = 20 + (i * 56);
+      const player = new PublicKey(entriesInfo.data.slice(offset, offset + 32));
+      const weight = Number(entriesInfo.data.readBigUInt64LE(offset + 32));
+      const chance = pot > 0 ? (weight / pot * 100).toFixed(2) : '0';
+      console.log(`     ${i+1}. ${player.toString().slice(0,6)}...${player.toString().slice(-4)} - ${(weight/1e9).toFixed(3)} SOL (${chance}%)`);
+    }
+  }
+
+  console.log('\n' + '='.repeat(70));
+  console.log('\n✅ SYSTEM STATUS:');
+  if (status === 0 && timeLeft > 0 && vecLength > 0) {
+    console.log('   🎮 ACTIVE - Players betting, timer running');
+  } else if (status === 0 && timeLeft === 0 && vecLength > 0) {
+    console.log('   ⏰ EXPIRED - Ready to lock, reveal, and resolve');
+  } else if (status === 1) {
+    console.log('   🔒 LOCKED - Waiting for oracle randomness / resolve');
+  } else if (status === 2) {
+    console.log('   ✅ RESOLVED - Ready to reset for next round');
+  } else if (vecLength === 0 && timeLeft > 0) {
+    console.log('   💤 OPEN - No entries yet, timer running');
+  } else if (vecLength === 0 && timeLeft === 0) {
+    console.log('   💤 NO ENTRIES + EXPIRED - Will auto-reset');
+  }
+
+  console.log('\n🌐 API:');
+  try {
+    const { data } = await axios.get(`${API_BASE}/jackpot/round/current`);
+    console.log('   API Round ID:', data.round?.roundId || 'null');
+    console.log('   API Status:', data.round?.status || 'null');
+  } catch (e) {
+    console.log('   API ERROR:', e.message);
+  }
+
+  console.log();
+})();

package/scripts/jackpot/update-round-duration.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * Update on-chain jackpot round duration
+ *
+ * Usage:
+ *   node scripts/jackpot/update-round-duration.js --weekly          # 1,512,000 slots (~7 days)
+ *   node scripts/jackpot/update-round-duration.js --daily           # 216,000 slots (~1 day)
+ *   node scripts/jackpot/update-round-duration.js --hourly          # 9,000 slots (~1 hour)
+ *   node scripts/jackpot/update-round-duration.js --minute          # 150 slots (~1 min, for testing)
+ *   node scripts/jackpot/update-round-duration.js --slots 1512000   # Custom slot count
+ *
+ * Environment:
+ *   API_BASE  - Server URL (default: http://localhost:3001)
+ */
+
+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';
+
+const PRESETS = {
+  '--weekly':  { slots: 1512000, label: '~7 days' },
+  '--daily':   { slots: 216000,  label: '~1 day' },
+  '--hourly':  { slots: 9000,    label: '~1 hour' },
+  '--minute':  { slots: 150,     label: '~1 min (testing)' },
+};
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Usage:');
+    console.log('  node scripts/jackpot/update-round-duration.js --weekly');
+    console.log('  node scripts/jackpot/update-round-duration.js --daily');
+    console.log('  node scripts/jackpot/update-round-duration.js --hourly');
+    console.log('  node scripts/jackpot/update-round-duration.js --minute');
+    console.log('  node scripts/jackpot/update-round-duration.js --slots <number>');
+    process.exit(1);
+  }
+
+  // Check presets
+  for (const [flag, preset] of Object.entries(PRESETS)) {
+    if (args.includes(flag)) {
+      return { slots: preset.slots, label: preset.label };
+    }
+  }
+
+  // Custom --slots <number>
+  const slotsIdx = args.indexOf('--slots');
+  if (slotsIdx !== -1 && args[slotsIdx + 1]) {
+    const slots = parseInt(args[slotsIdx + 1], 10);
+    if (isNaN(slots) || slots <= 0) {
+      console.error('Error: --slots must be a positive integer');
+      process.exit(1);
+    }
+    const seconds = Math.floor(slots * 0.4);
+    const label = seconds >= 86400
+      ? `~${(seconds / 86400).toFixed(1)} days`
+      : seconds >= 3600
+        ? `~${(seconds / 3600).toFixed(1)} hours`
+        : `~${(seconds / 60).toFixed(1)} min`;
+    return { slots, label };
+  }
+
+  console.error('Error: unrecognized arguments:', args.join(' '));
+  process.exit(1);
+}
+
+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 { slots, label } = parseArgs();
+  const wallet = loadWallet();
+  const connection = new Connection(RPC_URL, 'confirmed');
+
+  console.log(`\nUpdating round duration to ${slots.toLocaleString()} slots (${label})`);
+  console.log(`  Authority: ${wallet.publicKey.toString()}`);
+  console.log(`  API:       ${API_BASE}`);
+  console.log(`  RPC:       ${RPC_URL}\n`);
+
+  try {
+    // Fetch current config for comparison
+    const configRes = await axios.get(`${API_BASE}/jackpot/config`);
+    const currentSlots = configRes.data.config.roundDurationSlots;
+    console.log(`  Current:   ${Number(currentSlots).toLocaleString()} slots`);
+    console.log(`  New:       ${slots.toLocaleString()} slots\n`);
+
+    // Build update-config transaction
+    const { data } = await axios.post(`${API_BASE}/jackpot/build/update-config`, {
+      authorityAddress: wallet.publicKey.toString(),
+      roundDurationSlots: slots,
+    });
+
+    // Sign and send
+    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(`\nRound duration updated to ${slots.toLocaleString()} slots (${label})`);
+  } catch (error) {
+    console.error('Error:', error.response?.data || error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/keeper-bot.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+/**
+ * 🤖 Jackpot Keeper Bot
+ * 
+ * Automatically manages round lifecycle:
+ * 1. Monitors round timers
+ * 2. Locks rounds when timer expires
+ * 3. Submits oracle randomness
+ * 4. Resolves rounds and pays winners
+ * 5. Opens new rounds immediately
+ * 
+ * Keeps the jackpot running 24/7!
+ */
+
+const { Connection, Keypair, Transaction } = require('@solana/web3.js');
+const axios = require('axios');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const RPC_URL = process.env.SOLANA_NETWORK || 'https://api.devnet.solana.com';
+const API_BASE = process.env.API_BASE || 'http://localhost:3001';
+
+class JackpotKeeper {
+  constructor() {
+    this.connection = new Connection(RPC_URL, 'confirmed');
+    
+    // Load keeper wallet
+    const mainWalletPath = path.join(require('os').homedir(), '.config/solana/id.json');
+    const secretKey = JSON.parse(fs.readFileSync(mainWalletPath, 'utf-8'));
+    this.wallet = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    
+    console.log('🤖 Jackpot Keeper Bot');
+    console.log('   Wallet:', this.wallet.publicKey.toString());
+    console.log('   RPC:', RPC_URL);
+    console.log('   API:', API_BASE);
+    console.log();
+  }
+
+  async checkAndOpenRound() {
+    try {
+      const { data: stats } = await axios.get(`${API_BASE}/jackpot/stats`);
+      
+      if (!stats.initialized) {
+        console.log('⏳ Protocol not initialized');
+        return;
+      }
+      
+      // Check if there's an active round
+      try {
+        const { data: roundData } = await axios.get(`${API_BASE}/jackpot/round/current`);
+        console.log(`✅ Round ${roundData.round.roundId} active (${roundData.round.status})`);
+        return roundData.round;
+      } catch (error) {
+        if (error.response?.status === 404) {
+          console.log('📂 No active round, opening new one...');
+          await this.openRound();
+        }
+      }
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+    }
+  }
+
+  async openRound() {
+    try {
+      const { data } = await axios.post(`${API_BASE}/jackpot/build/open-round`, {
+        keeperAddress: this.wallet.publicKey.toString(),
+      });
+      
+      const tx = Transaction.from(Buffer.from(data.transaction, 'base64'));
+      tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+      tx.feePayer = this.wallet.publicKey;
+      tx.sign(this.wallet);
+      
+      const signature = await this.connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: true,
+      });
+      
+      await this.connection.confirmTransaction(signature);
+      
+      console.log(`🎉 Round ${data.roundId} opened! Signature: ${signature.slice(0, 8)}...`);
+    } catch (error) {
+      console.error('❌ Failed to open round:', error.message);
+    }
+  }
+
+  async run() {
+    console.log('🚀 Starting keeper bot...\n');
+    
+    // Open initial round if needed
+    await this.checkAndOpenRound();
+    
+    // Run every 10 seconds
+    setInterval(async () => {
+      await this.checkAndOpenRound();
+    }, 10000);
+    
+    // Keep process alive
+    console.log('✅ Keeper bot running. Press Ctrl+C to stop.\n');
+  }
+}
+
+const keeper = new JackpotKeeper();
+keeper.run().catch(console.error);
+
+
+
+
+
+

package/scripts/list-pending-games.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * List Pending Games
+ * Quick script to see what games are waiting to be resolved
+ * 
+ * Usage: node list-pending-games.js
+ */
+
+require('dotenv').config();
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+
+async function listPendingGames() {
+  try {
+    const apiUrl = process.env.DUBS_GAMES_API_URL || 'https://dubs-games-api-dev-76c556653fa3.herokuapp.com';
+    
+    console.log('🔍 Fetching all automatic games...\n');
+    
+    // Fetch games from Firebase - get ALL games and filter
+    let games = [];
+    
+    try {
+      // Try the pending endpoint first
+      const pendingResponse = await axios.get(`${apiUrl}/api/auth/games/automatic/pending`);
+      games = pendingResponse.data.games || [];
+    } catch (err) {
+      console.log('⚠️  Pending endpoint failed, trying direct Firebase query...\n');
+    }
+    
+    // If we got no games, try fetching all games directly from Firebase
+    if (games.length === 0) {
+      try {
+        // Direct Firebase query for automatic games
+        const admin = require('firebase-admin');
+        
+        // Try to load service account from dubs-games-api directory
+        const firebasePath = path.join(__dirname, '../../dubs-games-api/firebase/dubs-a835d-firebase-adminsdk-fbsvc-e84002f7e9.json');
+        
+        if (!fs.existsSync(firebasePath)) {
+          throw new Error('Firebase credentials not found. Using API endpoint only.');
+        }
+        
+        const serviceAccount = require(firebasePath);
+        
+        if (!admin.apps.length) {
+          admin.initializeApp({
+            credential: admin.credential.cert(serviceAccount)
+          });
+        }
+        
+        const snapshot = await admin.firestore()
+          .collection('games')
+          .where('gameMode', '==', 4)
+          .where('isResolved', '==', false)
+          .get();
+        
+        games = snapshot.docs.map(doc => ({
+          gameId: doc.id,
+          ...doc.data()
+        }));
+        
+      } catch (fbErr) {
+        console.error('❌ Direct Firebase query failed:', fbErr.message);
+        console.log('Using API endpoint data only\n');
+      }
+    }
+    
+    if (games.length === 0) {
+      console.log('❌ No automatic games found\n');
+      return;
+    }
+    
+    const readyCount = games.filter(g => {
+      if (!g.lockTime) return false;
+      const lockDate = g.lockTime._seconds ? new Date(g.lockTime._seconds * 1000) : new Date(g.lockTime);
+      return lockDate < new Date();
+    }).length;
+    
+    console.log(`Found ${games.length} automatic game(s) (${readyCount} ready to resolve):\n`);
+    console.log('='.repeat(80));
+    
+    games.forEach((game, index) => {
+      console.log(`\n${index + 1}. ${game.title || 'Untitled'}`);
+      console.log(`   Game ID: ${game.gameId}`);
+      console.log(`   Event: ${game.sportsEvent?.strEvent || 'N/A'}`);
+      console.log(`   Status: ${game.automaticStatus || game.status}`);
+      console.log(`   Players: ${game.participants?.length || 0}`);
+      console.log(`   Chat ID: ${game.telegramChatId || '❌ NOT SET'}`);
+      console.log(`   Created: ${game.createdAt ? new Date(game.createdAt._seconds * 1000 || game.createdAt).toLocaleString() : 'N/A'}`);
+      
+      if (game.lockTime) {
+        // Handle both Timestamp and ISO string formats
+        let lockDate;
+        if (game.lockTime._seconds) {
+          lockDate = new Date(game.lockTime._seconds * 1000);
+        } else if (typeof game.lockTime === 'string') {
+          lockDate = new Date(game.lockTime);
+        } else {
+          lockDate = new Date(game.lockTime);
+        }
+        
+        const isPast = lockDate < new Date();
+        const status = isPast ? '✅ READY TO RESOLVE' : '⏳ NOT READY YET';
+        console.log(`   Lock Time: ${lockDate.toLocaleString()} ${status}`);
+        
+        if (!isPast) {
+          const minutesUntil = Math.ceil((lockDate - new Date()) / 60000);
+          console.log(`   ⏰ Wait ${minutesUntil} minute(s) or use --winner to force`);
+        }
+      }
+      
+      // Show command to resolve
+      console.log(`\n   Resolve: node test-resolve-game.js ${game.gameId}`);
+      console.log(`   Force:   node test-resolve-game.js ${game.gameId} --winner=home`);
+    });
+    
+    console.log('\n' + '='.repeat(80));
+    console.log(`\nTo resolve all: node test-resolve-game.js --all\n`);
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    if (error.response?.data) {
+      console.error('Response:', error.response.data);
+    }
+    process.exit(1);
+  }
+}
+
+listPendingGames();
+

package/scripts/migrate-chat-v2.js

@@ -0,0 +1,127 @@
+/**
+ * 🔄 Chat Tables Migration to V2
+ * 
+ * Drops old chat tables and creates new v2 schema
+ * Run this once to upgrade to the new chat system
+ */
+
+const { Pool } = require('pg');
+require('dotenv').config();
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.DATABASE_URL && (process.env.DATABASE_URL.includes('amazonaws') || process.env.DATABASE_URL.includes('heroku'))
+    ? { rejectUnauthorized: false } 
+    : false,
+});
+
+async function migrateChatTables() {
+  console.log('🔄 Starting chat tables migration to v2...');
+  
+  try {
+    // Drop old tables (cascade to remove dependencies)
+    console.log('📦 Dropping old chat tables...');
+    await pool.query(`
+      DROP TABLE IF EXISTS chat_reactions CASCADE;
+      DROP TABLE IF EXISTS chat_notifications CASCADE;
+      DROP TABLE IF EXISTS user_relationships CASCADE;
+      DROP TABLE IF EXISTS chat_messages CASCADE;
+    `);
+    console.log('✅ Old tables dropped');
+
+    // Create new v2 tables
+    console.log('🆕 Creating new v2 chat tables...');
+    await pool.query(`
+      -- Main chat messages table (enhanced)
+      CREATE TABLE chat_messages (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        wallet_address VARCHAR(100) NOT NULL,
+        username VARCHAR(50) NOT NULL,
+        avatar TEXT,
+        message TEXT NOT NULL,
+        reply_to_id INTEGER REFERENCES chat_messages(id) ON DELETE SET NULL,
+        is_winner_announcement BOOLEAN DEFAULT FALSE,
+        win_amount NUMERIC(20, 9),
+        round_id INTEGER,
+        edited BOOLEAN DEFAULT FALSE,
+        edited_at TIMESTAMP,
+        deleted BOOLEAN DEFAULT FALSE,
+        deleted_at TIMESTAMP,
+        timestamp TIMESTAMP DEFAULT NOW(),
+        created_at TIMESTAMP DEFAULT NOW()
+      );
+      
+      -- Message reactions (for future)
+      CREATE TABLE chat_reactions (
+        id SERIAL PRIMARY KEY,
+        message_id INTEGER REFERENCES chat_messages(id) ON DELETE CASCADE,
+        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        wallet_address VARCHAR(100) NOT NULL,
+        reaction VARCHAR(20) NOT NULL,
+        created_at TIMESTAMP DEFAULT NOW(),
+        UNIQUE(message_id, user_id, reaction)
+      );
+      
+      -- User relationships (friends/blocks)
+      CREATE TABLE user_relationships (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        target_user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        relationship_type VARCHAR(20) NOT NULL CHECK (relationship_type IN ('friend', 'block')),
+        created_at TIMESTAMP DEFAULT NOW(),
+        UNIQUE(user_id, target_user_id)
+      );
+      
+      -- Chat notifications
+      CREATE TABLE chat_notifications (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+        message_id INTEGER REFERENCES chat_messages(id) ON DELETE CASCADE,
+        notification_type VARCHAR(20) NOT NULL CHECK (notification_type IN ('reply', 'mention', 'friend_message')),
+        read BOOLEAN DEFAULT FALSE,
+        created_at TIMESTAMP DEFAULT NOW()
+      );
+      
+      -- Indexes for performance
+      CREATE INDEX idx_chat_timestamp ON chat_messages(timestamp DESC);
+      CREATE INDEX idx_chat_wallet ON chat_messages(wallet_address);
+      CREATE INDEX idx_chat_user_id ON chat_messages(user_id);
+      CREATE INDEX idx_chat_reply_to ON chat_messages(reply_to_id);
+      CREATE INDEX idx_chat_deleted ON chat_messages(deleted) WHERE deleted = false;
+      CREATE INDEX idx_reactions_message ON chat_reactions(message_id);
+      CREATE INDEX idx_relationships_user ON user_relationships(user_id);
+      CREATE INDEX idx_relationships_type ON user_relationships(relationship_type);
+      CREATE INDEX idx_notifications_user ON chat_notifications(user_id);
+      CREATE INDEX idx_notifications_read ON chat_notifications(read) WHERE read = false;
+    `);
+    console.log('✅ New v2 tables created');
+
+    console.log('🎉 Migration complete!');
+    console.log('');
+    console.log('New tables created:');
+    console.log('  - chat_messages (with user_id, replies, editing, soft delete)');
+    console.log('  - chat_reactions (for future emoji reactions)');
+    console.log('  - user_relationships (friends/blocks)');
+    console.log('  - chat_notifications (reply notifications)');
+    
+  } catch (error) {
+    console.error('❌ Migration failed:', error);
+    throw error;
+  } finally {
+    await pool.end();
+  }
+}
+
+// Run migration
+migrateChatTables()
+  .then(() => {
+    console.log('✅ Done! Restart your server now.');
+    process.exit(0);
+  })
+  .catch((err) => {
+    console.error('❌ Migration failed:', err);
+    process.exit(1);
+  });
+
+