dubs-server 1.0.0

package/services/chatService.js

@@ -0,0 +1,1612 @@
+/**
+ * 💬 Degen Chat Service (Postgres + Redis)
+ * 
+ * Real-time chat for jackpot players - wallet-gated TRON vibes!
+ * 
+ * Performance: Uses Redis for high-speed notification caching with
+ * PostgreSQL as the source of truth.
+ */
+
+const { pool } = require('./db'); // Shared database pool
+const { forwardChatNotification } = require('./telegramNotifications');
+const notificationCacheService = require('./notificationCacheService');
+
+class ChatService {
+  constructor() {
+    // Use shared pool from services/db.js
+    this.pool = pool;
+    
+    // Note: initializeTable must be called from server.js before server starts
+    this.initialized = false;
+  }
+
+  /**
+   * Cache a notification to Redis after PostgreSQL insert
+   * Non-blocking - errors are logged but don't fail the operation
+   */
+  async _cacheNotificationAsync(userId, notification) {
+    try {
+      await notificationCacheService.cacheNotification(userId, notification);
+    } catch (error) {
+      console.error('[ChatService] Failed to cache notification:', error.message);
+      // Don't throw - Redis is a cache, PostgreSQL is source of truth
+    }
+  }
+
+  async initializeTable() {
+    try {
+      // NOTE: This only CREATES tables if they don't exist
+      // It does NOT drop existing tables to preserve data
+      // If you need to migrate schema, use a separate migration script
+
+      // Create new v2 tables (IF NOT EXISTS - preserves data)
+      await this.pool.query(`
+        -- Main chat messages table (enhanced)
+        CREATE TABLE IF NOT EXISTS 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,
+          game_invite_metadata JSONB,
+          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 IF NOT EXISTS 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 IF NOT EXISTS 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 IF NOT EXISTS 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,
+          sender_user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+          notification_type VARCHAR(30) NOT NULL CHECK (notification_type IN ('reply', 'mention', 'friend_message', 'reaction', 'friend_request', 'friend_request_accepted', 'friend_request_declined', 'referral', 'game_joined', 'game_invite', 'game_starting_soon', 'game_starting_now', 'game_won', 'game_lost', 'payment_received', 'payment_sent', 'dm', 'whats_new')),
+          notification_data JSONB,
+          read BOOLEAN DEFAULT FALSE,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        -- Indexes for performance
+        CREATE INDEX IF NOT EXISTS idx_chat_timestamp ON chat_messages(timestamp DESC);
+        CREATE INDEX IF NOT EXISTS idx_chat_wallet ON chat_messages(wallet_address);
+        CREATE INDEX IF NOT EXISTS idx_chat_user_id ON chat_messages(user_id);
+        CREATE INDEX IF NOT EXISTS idx_chat_reply_to ON chat_messages(reply_to_id);
+        CREATE INDEX IF NOT EXISTS idx_chat_deleted ON chat_messages(deleted) WHERE deleted = false;
+        CREATE INDEX IF NOT EXISTS idx_reactions_message ON chat_reactions(message_id);
+        CREATE INDEX IF NOT EXISTS idx_relationships_user ON user_relationships(user_id);
+        CREATE INDEX IF NOT EXISTS idx_relationships_type ON user_relationships(relationship_type);
+        CREATE INDEX IF NOT EXISTS idx_notifications_user ON chat_notifications(user_id);
+        CREATE INDEX IF NOT EXISTS idx_notifications_read ON chat_notifications(read) WHERE read = false;
+      `);
+      
+      // Add sender_user_id column if it doesn't exist (safe migration)
+      try {
+        await this.pool.query(`
+          DO $$ 
+          BEGIN 
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns 
+              WHERE table_name = 'chat_notifications' AND column_name = 'sender_user_id'
+            ) THEN
+              ALTER TABLE chat_notifications 
+              ADD COLUMN sender_user_id INTEGER REFERENCES users(id) ON DELETE CASCADE;
+              
+              RAISE NOTICE 'Added sender_user_id column to chat_notifications';
+            END IF;
+          END $$;
+        `);
+        console.log('✅ Chat notifications schema updated');
+      } catch (columnError) {
+        console.log('⚠️  Chat column migration error:', columnError.message);
+      }
+
+      // NOTE: Notification type constraint is now managed by migration file:
+      // scripts/migrations/004_add_whats_new_notification_type.sql
+      // Do not update the constraint here - run the migration instead.
+
+      // Add game_invite_metadata column if it doesn't exist (for existing databases)
+      try {
+        await this.pool.query(`
+          DO $$ 
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns 
+              WHERE table_name = 'chat_messages' AND column_name = 'game_invite_metadata'
+            ) THEN
+              ALTER TABLE chat_messages ADD COLUMN game_invite_metadata JSONB;
+              CREATE INDEX idx_chat_messages_game_invite 
+              ON chat_messages ((game_invite_metadata->>'gameId')) 
+              WHERE game_invite_metadata IS NOT NULL;
+            END IF;
+          END $$;
+        `);
+        console.log('✅ Game invite metadata column ready');
+      } catch (migrateError) {
+        console.log('⚠️  Game invite migration error:', migrateError.message);
+      }
+
+      // Add pnl_share_metadata column if it doesn't exist (for PNL sharing in chat)
+      try {
+        await this.pool.query(`
+          DO $$ 
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns 
+              WHERE table_name = 'chat_messages' AND column_name = 'pnl_share_metadata'
+            ) THEN
+              ALTER TABLE chat_messages ADD COLUMN pnl_share_metadata JSONB;
+            END IF;
+          END $$;
+        `);
+        console.log('✅ PNL share metadata column ready');
+      } catch (migrateError) {
+        console.log('⚠️  PNL share migration error:', migrateError.message);
+      }
+
+      // Add notification_data column to chat_notifications if it doesn't exist
+      try {
+        await this.pool.query(`
+          DO $$ 
+          BEGIN
+            IF NOT EXISTS (
+              SELECT 1 FROM information_schema.columns 
+              WHERE table_name = 'chat_notifications' AND column_name = 'notification_data'
+            ) THEN
+              ALTER TABLE chat_notifications ADD COLUMN notification_data JSONB;
+            END IF;
+          END $$;
+        `);
+        console.log('✅ Notification data column ready');
+      } catch (notifDataError) {
+        console.log('⚠️  Notification data migration error:', notifDataError.message);
+      }
+
+      
+      console.log('✅ Chat tables initialized (v2 - production ready)');
+    } catch (error) {
+      console.error('❌ Failed to initialize chat tables:', error.message);
+      console.error('   Full error:', error);
+    }
+  }
+
+  /**
+   * Get recent chat messages (with replies)
+   * @param {number} limit - Max messages to return
+   * @param {number|null} userId - Current user ID (for filtering blocked users)
+   * @param {number|null} before - Message ID cursor (fetch messages older than this)
+   */
+  async getRecentMessages(limit = 50, userId = null, before = null) {
+    try {
+      // Get blocked users if userId provided
+      let blockedUsers = [];
+      if (userId) {
+        const blockResult = await this.pool.query(
+          `SELECT target_user_id FROM user_relationships
+           WHERE user_id = $1 AND relationship_type = 'block'`,
+          [userId]
+        );
+        blockedUsers = blockResult.rows.map(r => r.target_user_id);
+      }
+
+      // Build query with optional cursor
+      const params = [limit + 1]; // Fetch one extra to check if there are more
+      let paramIndex = 2;
+      let beforeClause = '';
+
+      if (before) {
+        beforeClause = `AND m.id < $${paramIndex}`;
+        params.push(before);
+        paramIndex++;
+      }
+
+      const result = await this.pool.query(
+        `SELECT
+          m.*,
+          m.game_invite_metadata,
+          m.pnl_share_metadata,
+          reply.message as reply_message,
+          reply.username as reply_username,
+          reply.wallet_address as reply_wallet_address,
+          g.matchup_image_url as game_matchup_image_url
+         FROM chat_messages m
+         LEFT JOIN chat_messages reply ON m.reply_to_id = reply.id
+         LEFT JOIN games g ON g.game_id = m.game_invite_metadata->>'gameId'
+         WHERE m.deleted = false
+         ${blockedUsers.length > 0 ? 'AND m.user_id NOT IN (' + blockedUsers.join(',') + ')' : ''}
+         ${beforeClause}
+         ORDER BY m.timestamp DESC
+         LIMIT $1`,
+        params
+      );
+
+      // Check if there are more messages
+      const hasMore = result.rows.length > limit;
+      const rows = hasMore ? result.rows.slice(0, limit) : result.rows;
+
+      const messages = rows.map(row => ({
+        id: row.id,
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        message: row.message,
+        replyTo: row.reply_to_id ? {
+          id: row.reply_to_id,
+          message: row.reply_message,
+          username: row.reply_username,
+          walletAddress: row.reply_wallet_address,
+        } : null,
+        timestamp: row.timestamp,
+        edited: row.edited || false,
+        editedAt: row.edited_at,
+        isWinnerAnnouncement: row.is_winner_announcement || false,
+        winAmount: row.win_amount ? parseFloat(row.win_amount) : undefined,
+        roundId: row.round_id || undefined,
+        gameInvite: row.game_invite_metadata
+          ? {
+              ...row.game_invite_metadata,
+              // Use fresh matchupImageUrl from games table if available
+              matchupImageUrl: row.game_matchup_image_url || row.game_invite_metadata.matchupImageUrl,
+            }
+          : undefined,
+        pnlShare: row.pnl_share_metadata || undefined,
+        gifUrl: row.gif_url || undefined,
+        reactions: {}, // Will be populated below
+        mentions: [], // Will be populated below
+      })).reverse(); // Reverse so oldest is first (chat order)
+
+      // Get reactions for all messages
+      const messageIds = messages.map(m => m.id);
+      console.log('[ChatService] Getting reactions for', messageIds.length, 'messages');
+      const reactionsMap = await this.getReactionsForMessages(messageIds);
+      console.log('[ChatService] Reactions map:', Object.keys(reactionsMap).length, 'messages have reactions');
+      
+      // Get mentions for all messages
+      const mentionsMap = await this.getMentionsForMessages(messageIds);
+      console.log('[ChatService] Mentions map:', Object.keys(mentionsMap).length, 'messages have mentions');
+      
+      // Get payments for all messages
+      const paymentsMap = await this.getPaymentsForMessages(messageIds);
+      console.log('[ChatService] Payments map:', Object.keys(paymentsMap).length, 'messages have payments');
+      
+      // Attach reactions, mentions, and payments to messages
+      messages.forEach(msg => {
+        msg.reactions = reactionsMap[msg.id] || {};
+        msg.mentions = mentionsMap[msg.id] || [];
+        msg.payment = paymentsMap[msg.id] || null;
+      });
+
+      return { messages, hasMore };
+    } catch (error) {
+      console.error('Error getting messages:', error);
+      return { messages: [], hasMore: false };
+    }
+  }
+
+  /**
+   * Parse @mentions from message text
+   */
+  parseMentions(messageText) {
+    const mentionRegex = /@(\w+)/g;
+    const matches = [...messageText.matchAll(mentionRegex)];
+    const usernames = [...new Set(matches.map(m => m[1]))]; // Remove duplicates
+    return usernames;
+  }
+
+  /**
+   * Validate and get user IDs for mentioned usernames (case-insensitive)
+   */
+  async validateMentions(usernames) {
+    if (!usernames || usernames.length === 0) {
+      return [];
+    }
+
+    try {
+      // Use LOWER() for case-insensitive matching
+      const result = await this.pool.query(
+        'SELECT id as user_id, username, wallet_address FROM users WHERE LOWER(username) = ANY($1)',
+        [usernames.map(u => u.toLowerCase())]
+      );
+      
+      return result.rows.map(row => ({
+        userId: row.user_id,
+        username: row.username,
+        walletAddress: row.wallet_address
+      }));
+    } catch (error) {
+      console.error('[ChatService] Error validating mentions:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Save mentions to database
+   */
+  async saveMentions(messageId, mentionedUserIds) {
+    if (!mentionedUserIds || mentionedUserIds.length === 0) {
+      return;
+    }
+
+    try {
+      // Insert all mentions (ignore duplicates)
+      const values = mentionedUserIds.map((userId, index) => 
+        `($1, $${index + 2})`
+      ).join(',');
+      
+      const query = `
+        INSERT INTO message_mentions (message_id, mentioned_user_id)
+        VALUES ${values}
+        ON CONFLICT (message_id, mentioned_user_id) DO NOTHING
+      `;
+      
+      await this.pool.query(query, [messageId, ...mentionedUserIds]);
+      console.log(`[ChatService] Saved ${mentionedUserIds.length} mention(s) for message ${messageId}`);
+    } catch (error) {
+      console.error('[ChatService] Error saving mentions:', error);
+    }
+  }
+
+  /**
+   * Create mention notifications for mentioned users
+   */
+  async createMentionNotifications(messageId, mentionedUsers, senderId, senderUsername, messageText) {
+    if (!mentionedUsers || mentionedUsers.length === 0) {
+      return [];
+    }
+
+    try {
+      const notificationIds = [];
+      
+      for (const mentionedUser of mentionedUsers) {
+        // Don't notify if user mentioned themselves
+        if (mentionedUser.userId === senderId) {
+          continue;
+        }
+
+        // Check if mentioned user has blocked the sender
+        const blockCheck = await this.pool.query(
+          `SELECT 1 FROM user_relationships 
+           WHERE user_id = $1 AND target_user_id = $2 AND relationship_type = 'block'`,
+          [mentionedUser.userId, senderId]
+        );
+
+        if (blockCheck.rows.length > 0) {
+          console.log(`[ChatService] User ${mentionedUser.userId} has blocked ${senderId}, skipping mention notification`);
+          continue;
+        }
+
+        // Create notification
+        const result = await this.pool.query(
+          `INSERT INTO chat_notifications (user_id, message_id, sender_user_id, notification_type, created_at)
+           VALUES ($1, $2, $3, 'mention', NOW())
+           RETURNING id, created_at`,
+          [mentionedUser.userId, messageId, senderId]
+        );
+
+        const notificationId = result.rows[0].id;
+        const createdAt = result.rows[0].created_at;
+        notificationIds.push(notificationId);
+
+        // Cache notification to Redis (non-blocking)
+        notificationCacheService.cacheNotification(mentionedUser.userId, {
+          id: notificationId,
+          type: 'mention',
+          read: false,
+          messageId: messageId,
+          message: messageText,
+          senderUsername: senderUsername,
+          senderWallet: '',
+          senderAvatar: null,
+          createdAt: createdAt,
+        }).catch(err => console.error('[ChatService] Failed to cache mention notification:', err.message));
+
+        // Forward to Telegram if connected
+        forwardChatNotification(
+          this.pool, 
+          mentionedUser.userId, 
+          'mention', 
+          senderUsername, 
+          messageText
+        ).catch(err => 
+          console.error('[ChatService] Error forwarding mention notification to Telegram:', err.message)
+        );
+      }
+
+      console.log(`[ChatService] Created ${notificationIds.length} mention notification(s)`);
+      return notificationIds;
+    } catch (error) {
+      console.error('[ChatService] Error creating mention notifications:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get users by their IDs (for mention lookup from client-provided IDs)
+   */
+  async getUsersByIds(userIds) {
+    if (!userIds || userIds.length === 0) {
+      return [];
+    }
+
+    try {
+      const result = await this.pool.query(
+        'SELECT id as user_id, username, wallet_address FROM users WHERE id = ANY($1)',
+        [userIds]
+      );
+      
+      return result.rows.map(row => ({
+        userId: row.user_id,
+        username: row.username,
+        walletAddress: row.wallet_address
+      }));
+    } catch (error) {
+      console.error('[ChatService] Error getting users by IDs:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Add a new message (v2 - with user info, replies, and mentions)
+   */
+  async addMessage(userId, walletAddress, username, avatar, message, options = {}) {
+    try {
+      // Sanitize message (max 500 chars, no XSS) - allow empty for GIF-only messages
+      const sanitized = (message || '').trim().substring(0, 500);
+
+      // Validate gifUrl if provided
+      const gifUrl = options.gifUrl || null;
+
+      if ((!sanitized || sanitized.length === 0) && !gifUrl) {
+        throw new Error('Message cannot be empty');
+      }
+
+      // Get mentioned users - prefer client-provided IDs (from autocomplete) over text parsing
+      let mentionedUsers = [];
+      if (options.mentionUserIds && options.mentionUserIds.length > 0) {
+        // Client provided mention user IDs (more reliable - from autocomplete)
+        mentionedUsers = await this.getUsersByIds(options.mentionUserIds);
+        console.log(`[ChatService] Found ${mentionedUsers.length} mention(s) from client-provided IDs`);
+      } else {
+        // Fallback: parse @mentions from message text (case-insensitive)
+        const mentionedUsernames = this.parseMentions(sanitized);
+        mentionedUsers = await this.validateMentions(mentionedUsernames);
+        console.log(`[ChatService] Found ${mentionedUsers.length} valid mention(s) from text parsing`);
+      }
+
+
+      // If replying to a message, verify it exists and create notification
+      let replyToId = options.replyToId || null;
+      let notificationId = null;
+      if (replyToId) {
+        // Get original message author - check if message exists and not deleted
+        const originalMsg = await this.pool.query(
+          'SELECT user_id FROM chat_messages WHERE id = $1 AND deleted = false',
+          [replyToId]
+        );
+        
+        if (originalMsg.rows.length > 0) {
+          // Message exists, we can safely reference it
+          if (originalMsg.rows[0].user_id !== userId) {
+            // Create notification for reply with sender info
+            const notifResult = await this.pool.query(
+              `INSERT INTO chat_notifications (user_id, message_id, sender_user_id, notification_type, created_at)
+               VALUES ($1, $2, $3, 'reply', NOW())
+               RETURNING id, created_at`,
+              [originalMsg.rows[0].user_id, replyToId, userId]
+            );
+            notificationId = notifResult.rows[0].id;
+            const notifCreatedAt = notifResult.rows[0].created_at;
+            
+            // Cache notification to Redis (non-blocking)
+            notificationCacheService.cacheNotification(originalMsg.rows[0].user_id, {
+              id: notificationId,
+              type: 'reply',
+              read: false,
+              messageId: replyToId,
+              message: message,
+              senderUsername: username,
+              senderWallet: walletAddress,
+              senderAvatar: avatar,
+              createdAt: notifCreatedAt,
+            }).catch(err => console.error('[ChatService] Failed to cache reply notification:', err.message));
+            
+            // Forward to Telegram if connected
+            forwardChatNotification(this.pool, originalMsg.rows[0].user_id, 'reply', username, message).catch(err => 
+              console.error('[ChatService] Error forwarding reply notification to Telegram:', err.message)
+            );
+          }
+        } else {
+          // Message doesn't exist or was deleted - clear the replyToId to prevent FK violation
+          console.log(`[ChatService] Warning: Cannot reply to message ${replyToId} - message not found or deleted`);
+          replyToId = null;
+        }
+      }
+
+      const result = await this.pool.query(
+        `INSERT INTO chat_messages (
+          user_id,
+          wallet_address,
+          username,
+          avatar,
+          message,
+          reply_to_id,
+          is_winner_announcement,
+          win_amount,
+          round_id,
+          game_invite_metadata,
+          pnl_share_metadata,
+          gif_url,
+          timestamp
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, NOW())
+        RETURNING *`,
+        [
+          userId,
+          walletAddress,
+          username,
+          avatar,
+          sanitized,
+          replyToId,
+          options.isWinnerAnnouncement || false,
+          options.winAmount || null,
+          options.roundId || null,
+          options.gameInvite ? JSON.stringify(options.gameInvite) : null,
+          options.pnlShare ? JSON.stringify(options.pnlShare) : null,
+          gifUrl,
+        ]
+      );
+      
+      const row = result.rows[0];
+      console.log(`💬 Message from ${username} (${walletAddress.slice(0, 8)}...)`);
+
+      // Save mentions to database
+      if (mentionedUsers.length > 0) {
+        const mentionedUserIds = mentionedUsers.map(u => u.userId);
+        await this.saveMentions(row.id, mentionedUserIds);
+        
+        // Create mention notifications ONLY if this is not a payment message
+        // Payment messages will create payment_received notifications instead
+        if (!options.paymentSignature) {
+          await this.createMentionNotifications(
+            row.id,
+            mentionedUsers,
+            userId,
+            username,
+            sanitized
+          );
+        } else {
+          console.log(`[ChatService] Skipping mention notification - this is a payment message`);
+        }
+      }
+      
+      return {
+        id: row.id,
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        message: row.message,
+        replyToId: row.reply_to_id,
+        notificationId: notificationId, // Include notification ID if this was a reply
+        timestamp: row.timestamp,
+        edited: false,
+        isWinnerAnnouncement: row.is_winner_announcement || false,
+        winAmount: row.win_amount ? parseFloat(row.win_amount) : undefined,
+        mentions: mentionedUsers, // Include mentions in response
+        roundId: row.round_id || undefined,
+        gameInvite: row.game_invite_metadata || undefined,
+        pnlShare: row.pnl_share_metadata || undefined,
+        gifUrl: row.gif_url || undefined,
+      };
+    } catch (error) {
+      console.error('Error adding message:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 🏆 Post EPIC winner announcement to chat!
+   * Posts as "Jackpot" system identity and @mentions the winner.
+   */
+  async postWinnerAnnouncement({ winner, winAmount, roundId }) {
+    try {
+      // Look up winner's username for the @mention
+      let winnerUsername = winner.slice(0, 8) + '...';
+      let winnerUserId = null;
+      try {
+        const userResult = await this.pool.query(
+          'SELECT id, username FROM users WHERE wallet_address = $1',
+          [winner]
+        );
+        if (userResult.rows.length > 0) {
+          winnerUserId = userResult.rows[0].id;
+          winnerUsername = userResult.rows[0].username || winnerUsername;
+        }
+      } catch (lookupErr) {
+        console.warn('⚠️ Could not look up winner profile:', lookupErr.message);
+      }
+
+      const message = `🎰 @${winnerUsername} just won the Jackpot! 🎉`;
+
+      // Post as system "Jackpot" identity (null userId = system message)
+      const result = await this.pool.query(
+        `INSERT INTO chat_messages (
+          user_id,
+          wallet_address,
+          username,
+          avatar,
+          message,
+          is_winner_announcement,
+          win_amount,
+          round_id,
+          timestamp
+        )
+        VALUES ($1, $2, $3, $4, $5, TRUE, $6, $7, NOW())
+        RETURNING *`,
+        [null, 'system', 'Jackpot', '/dubs-jackpot.png', message, winAmount, roundId]
+      );
+
+      const row = result.rows[0];
+      console.log(`🏆 WINNER ANNOUNCEMENT posted for ${winnerUsername} (${winner.slice(0, 8)}...) - ◎${winAmount}`);
+
+      return {
+        id: row.id,
+        userId: row.user_id,
+        walletAddress: 'system',
+        username: 'Jackpot',
+        avatar: '/dubs-jackpot.png',
+        message: row.message,
+        timestamp: row.timestamp,
+        isWinnerAnnouncement: true,
+        winAmount: parseFloat(row.win_amount),
+        roundId: row.round_id,
+      };
+    } catch (error) {
+      console.error('Error posting winner announcement:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete old messages (keep last 1000)
+   */
+  async cleanup() {
+    try {
+      await this.pool.query(`
+        DELETE FROM chat_messages
+        WHERE id NOT IN (
+          SELECT id FROM chat_messages
+          ORDER BY timestamp DESC
+          LIMIT 1000
+        )
+      `);
+      console.log('🧹 Cleaned up old chat messages');
+    } catch (error) {
+      console.error('Error cleaning up messages:', error);
+    }
+  }
+
+  /**
+   * Get message count for a user (rate limiting)
+   */
+  async getRecentMessageCount(userId, minutes = 1) {
+    try {
+      const result = await this.pool.query(
+        `SELECT COUNT(*) as count
+         FROM chat_messages
+         WHERE user_id = $1
+         AND timestamp > NOW() - INTERVAL '${minutes} minutes'`,
+        [userId]
+      );
+      
+      return parseInt(result.rows[0].count);
+    } catch (error) {
+      console.error('Error counting messages:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Delete a message (soft delete)
+   */
+  async deleteMessage(messageId, userId) {
+    try {
+      const result = await this.pool.query(
+        `UPDATE chat_messages 
+         SET deleted = true, deleted_at = NOW()
+         WHERE id = $1 AND user_id = $2
+         RETURNING id`,
+        [messageId, userId]
+      );
+      
+      return result.rows.length > 0;
+    } catch (error) {
+      console.error('Error deleting message:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Edit a message
+   */
+  async editMessage(messageId, userId, newMessage) {
+    try {
+      const sanitized = newMessage.trim().substring(0, 500);
+      
+      const result = await this.pool.query(
+        `UPDATE chat_messages 
+         SET message = $1, edited = true, edited_at = NOW()
+         WHERE id = $2 AND user_id = $3
+         RETURNING *`,
+        [sanitized, messageId, userId]
+      );
+      
+      if (result.rows.length === 0) return null;
+      
+      const row = result.rows[0];
+      return {
+        id: row.id,
+        message: row.message,
+        edited: true,
+        editedAt: row.edited_at,
+      };
+    } catch (error) {
+      console.error('Error editing message:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Block a user
+   */
+  async blockUser(userId, targetUserId) {
+    try {
+      await this.pool.query(
+        `INSERT INTO user_relationships (user_id, target_user_id, relationship_type)
+         VALUES ($1, $2, 'block')
+         ON CONFLICT (user_id, target_user_id) 
+         DO UPDATE SET relationship_type = 'block'`,
+        [userId, targetUserId]
+      );
+      return true;
+    } catch (error) {
+      console.error('Error blocking user:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Unblock a user
+   */
+  async unblockUser(userId, targetUserId) {
+    try {
+      await this.pool.query(
+        `DELETE FROM user_relationships 
+         WHERE user_id = $1 AND target_user_id = $2 AND relationship_type = 'block'`,
+        [userId, targetUserId]
+      );
+      return true;
+    } catch (error) {
+      console.error('Error unblocking user:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get user's notifications with cursor-based pagination
+   * 
+   * @param {number} userId - User ID
+   * @param {Object} options - Pagination options
+   * @param {number} options.limit - Number of notifications (default: 10)
+   * @param {number|null} options.cursor - Timestamp cursor for pagination
+   * @returns {Object} - { notifications, nextCursor, hasMore, total }
+   */
+  async getNotifications(userId, { limit = 10, cursor = null } = {}) {
+    try {
+      // Try Redis cache first
+      if (notificationCacheService.isEnabled()) {
+        const cached = await notificationCacheService.getNotifications(userId, { limit, cursor });
+        if (cached) {
+          console.log(`[ChatService] ⚡ Cache hit: ${cached.notifications.length} notifications for user ${userId}`);
+          return cached;
+        }
+        console.log(`[ChatService] Cache miss for user ${userId} - fetching from PostgreSQL`);
+      }
+
+      // PostgreSQL fallback with cursor-based pagination
+      const notifications = await this._getNotificationsFromDB(userId, { limit, cursor });
+      
+      // Warm the cache if Redis is available and this is the first page
+      if (notificationCacheService.isEnabled() && !cursor) {
+        // Fetch more for cache warming (up to 100)
+        const cacheNotifications = await this._getNotificationsFromDB(userId, { limit: 100, cursor: null });
+        notificationCacheService.bulkCacheNotifications(userId, cacheNotifications.notifications)
+          .catch(err => console.error('[ChatService] Cache warming failed:', err.message));
+      }
+
+      return notifications;
+    } catch (error) {
+      console.error('Error getting notifications:', error);
+      return { notifications: [], nextCursor: null, hasMore: false, total: 0 };
+    }
+  }
+
+  /**
+   * Fetch notifications from PostgreSQL with cursor-based pagination
+   * @private
+   */
+  async _getNotificationsFromDB(userId, { limit = 10, cursor = null } = {}) {
+    try {
+      // Build query with optional cursor
+      // JOIN with games table to get current matchup_image_url (fixes old notifications)
+      let query = `
+        SELECT 
+          n.id,
+          n.user_id,
+          n.message_id,
+          n.sender_user_id,
+          n.notification_type,
+          n.read,
+          n.created_at,
+          n.notification_data,
+          m.message,
+          -- Get the most recent reaction emoji for reaction notifications
+          (SELECT reaction FROM chat_reactions 
+           WHERE message_id = n.message_id 
+             AND user_id = n.sender_user_id 
+           ORDER BY created_at DESC
+           LIMIT 1) as reaction,
+          -- Get sender info from sender_user_id
+          sender.username as sender_username,
+          sender.wallet_address as sender_wallet,
+          sender.avatar as sender_avatar,
+          -- Get current matchup image URL from games table (enriches old notifications)
+          g.matchup_image_url as game_matchup_image_url
+         FROM chat_notifications n
+         LEFT JOIN chat_messages m ON n.message_id = m.id
+         LEFT JOIN users sender ON n.sender_user_id = sender.id
+         LEFT JOIN games g ON g.game_id = n.notification_data->'gameInvite'->>'gameId'
+         WHERE n.user_id = $1`;
+
+      const params = [userId];
+      
+      if (cursor) {
+        // Cursor is a timestamp - fetch notifications before this time
+        query += ` AND n.created_at < $2`;
+        params.push(new Date(parseInt(cursor)));
+      }
+
+      query += ` ORDER BY n.created_at DESC LIMIT $${params.length + 1}`;
+      params.push(limit + 1); // Fetch one extra to detect hasMore
+
+      const result = await this.pool.query(query, params);
+      
+      // Deduplicate reactions (keep most recent per message+sender)
+      const seenReactions = new Map();
+      const deduplicatedRows = [];
+      
+      for (const row of result.rows) {
+        if (row.notification_type === 'reaction') {
+          const key = `${row.message_id}-${row.sender_user_id}`;
+          if (!seenReactions.has(key)) {
+            seenReactions.set(key, row);
+            deduplicatedRows.push(row);
+          }
+        } else {
+          deduplicatedRows.push(row);
+        }
+      }
+
+      // Check if there are more results
+      const hasMore = deduplicatedRows.length > limit;
+      const limitedRows = hasMore ? deduplicatedRows.slice(0, limit) : deduplicatedRows;
+      
+      // Calculate next cursor
+      let nextCursor = null;
+      if (hasMore && limitedRows.length > 0) {
+        const lastRow = limitedRows[limitedRows.length - 1];
+        nextCursor = new Date(lastRow.created_at).getTime();
+      }
+
+      // Transform rows to notification objects
+      const notifications = limitedRows.map(row => this._transformNotificationRow(row));
+
+      console.log(`[ChatService] 📊 Fetched ${notifications.length} notifications from DB (hasMore: ${hasMore})`);
+
+      return {
+        notifications,
+        nextCursor,
+        hasMore,
+      };
+    } catch (error) {
+      console.error('Error fetching notifications from DB:', error);
+      return { notifications: [], nextCursor: null, hasMore: false };
+    }
+  }
+
+  /**
+   * Transform a database row to a notification object
+   * @private
+   */
+  _transformNotificationRow(row) {
+    const notification = {
+      id: row.id,
+      messageId: row.message_id,
+      type: row.notification_type,
+      read: row.read,
+      message: row.notification_type === 'reaction' 
+        ? (row.reaction || '') 
+        : row.notification_type === 'game_joined' && row.notification_data?.teamChoice
+          ? row.notification_data.teamChoice
+          : (row.message || ''),
+      senderUsername: row.sender_username || 'Unknown',
+      senderWallet: row.sender_wallet || '',
+      senderAvatar: row.sender_avatar || null,
+      createdAt: row.created_at,
+    };
+
+    // Add game invite for game-related notifications
+    if (['game_joined', 'game_invite', 'game_starting_soon', 'game_starting_now', 'game_won', 'game_lost', 'connect4_your_turn']
+        .includes(row.notification_type) && row.notification_data?.gameInvite) {
+      notification.gameInvite = { ...row.notification_data.gameInvite };
+      
+      // Use S3 matchupImageUrl from games table (JOIN) if available
+      if (row.game_matchup_image_url) {
+        notification.gameInvite.matchupImageUrl = row.game_matchup_image_url;
+      }
+    }
+
+    // Add message from notification_data for game notifications
+    if (['game_starting_soon', 'game_starting_now', 'game_won', 'game_lost']
+        .includes(row.notification_type) && row.notification_data?.message) {
+      notification.message = row.notification_data.message;
+    }
+
+    // Add final score for game result notifications
+    if (['game_won', 'game_lost'].includes(row.notification_type) && row.notification_data?.finalScore) {
+      notification.finalScore = row.notification_data.finalScore;
+    }
+
+    // Add jackpot data (win or loss)
+    if ((row.notification_type === 'game_won' || row.notification_type === 'game_lost') && row.notification_data?.jackpotWin) {
+      notification.jackpotWin = row.notification_data.jackpotWin;
+    }
+
+    // Add amount for game_joined notifications (pari-mutuel: joiner's actual bet amount)
+    if (row.notification_type === 'game_joined' && row.notification_data?.amount !== undefined) {
+      notification.amount = row.notification_data.amount;
+    }
+
+    // Add message preview for DM notifications
+    if (row.notification_type === 'dm_message' && row.notification_data?.preview) {
+      notification.message = row.notification_data.preview;
+    }
+
+    return notification;
+  }
+
+
+  /**
+   * Mark notifications as read
+   * Updates PostgreSQL and syncs with Redis cache
+   */
+  async markNotificationsRead(userId, notificationIds) {
+    try {
+      // Update PostgreSQL (source of truth)
+      await this.pool.query(
+        `UPDATE chat_notifications 
+         SET read = true
+         WHERE user_id = $1 AND id = ANY($2)`,
+        [userId, notificationIds]
+      );
+
+      // Sync with Redis cache (non-blocking)
+      notificationCacheService.markAsRead(userId, notificationIds)
+        .catch(err => console.error('[ChatService] Failed to sync read status to cache:', err.message));
+
+      return true;
+    } catch (error) {
+      console.error('Error marking notifications read:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get unread notification count
+   * Uses Redis cache for high-speed access, falls back to PostgreSQL
+   */
+  async getUnreadCount(userId) {
+    try {
+      // Try Redis cache first
+      if (notificationCacheService.isEnabled()) {
+        const cached = await notificationCacheService.getUnreadCount(userId);
+        if (cached !== null) {
+          console.log(`[ChatService] ⚡ Cache hit: unread count = ${cached} for user ${userId}`);
+          return cached;
+        }
+      }
+
+      // PostgreSQL fallback
+      const result = await this.pool.query(
+        `SELECT COUNT(*) as count
+         FROM chat_notifications
+         WHERE user_id = $1 AND read = false`,
+        [userId]
+      );
+      
+      const count = parseInt(result.rows[0].count);
+
+      // Cache the count for next time
+      if (notificationCacheService.isEnabled()) {
+        notificationCacheService.setUnreadCount(userId, count)
+          .catch(err => console.error('[ChatService] Failed to cache unread count:', err.message));
+      }
+
+      return count;
+    } catch (error) {
+      console.error('Error getting unread count:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Add reaction to a message
+   */
+  async addReaction(messageId, userId, walletAddress, reaction) {
+    try {
+      console.log('[ChatService] Adding reaction:', { messageId, userId, walletAddress, reaction });
+      
+      // Add reaction
+      const reactionResult = await this.pool.query(
+        `INSERT INTO chat_reactions (message_id, user_id, wallet_address, reaction)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT (message_id, user_id, reaction) DO NOTHING
+         RETURNING id`,
+        [messageId, userId, walletAddress, reaction]
+      );
+      
+      console.log('[ChatService] Reaction inserted, rows returned:', reactionResult.rows.length);
+
+      // If new reaction was added (not duplicate), create notification for message author
+      if (reactionResult.rows.length > 0) {
+        // Get message author
+        const msgResult = await this.pool.query(
+          'SELECT user_id FROM chat_messages WHERE id = $1',
+          [messageId]
+        );
+
+        if (msgResult.rows.length > 0) {
+          const authorUserId = msgResult.rows[0].user_id;
+          
+          // Don't notify yourself
+          if (authorUserId !== userId) {
+            const notifResult = await this.pool.query(
+              `INSERT INTO chat_notifications (user_id, message_id, sender_user_id, notification_type, created_at)
+               VALUES ($1, $2, $3, 'reaction', NOW())
+               RETURNING id, created_at`,
+              [authorUserId, messageId, userId]
+            );
+            
+            const notificationId = notifResult.rows[0].id;
+            const notifCreatedAt = notifResult.rows[0].created_at;
+            
+            // Get username for Telegram notification
+            const userResult = await this.pool.query('SELECT username, wallet_address, avatar FROM users WHERE id = $1', [userId]);
+            const senderUsername = userResult.rows[0]?.username || 'Someone';
+            const senderWallet = userResult.rows[0]?.wallet_address || '';
+            const senderAvatar = userResult.rows[0]?.avatar || null;
+            
+            // Cache notification to Redis (non-blocking)
+            notificationCacheService.cacheNotification(authorUserId, {
+              id: notificationId,
+              type: 'reaction',
+              read: false,
+              messageId: messageId,
+              message: reaction,
+              senderUsername: senderUsername,
+              senderWallet: senderWallet,
+              senderAvatar: senderAvatar,
+              createdAt: notifCreatedAt,
+            }).catch(err => console.error('[ChatService] Failed to cache reaction notification:', err.message));
+            
+            // Forward to Telegram if connected
+            forwardChatNotification(this.pool, authorUserId, 'reaction', senderUsername, reaction).catch(err => 
+              console.error('[ChatService] Error forwarding reaction notification to Telegram:', err.message)
+            );
+            
+            return {
+              success: true,
+              notificationId: notifResult.rows[0]?.id,
+              authorUserId,
+            };
+          }
+        }
+      }
+      
+      return { success: true };
+    } catch (error) {
+      console.error('Error adding reaction:', error);
+      return { success: false };
+    }
+  }
+
+  /**
+   * Remove reaction from a message
+   */
+  async removeReaction(messageId, userId, reaction) {
+    try {
+      await this.pool.query(
+        `DELETE FROM chat_reactions 
+         WHERE message_id = $1 AND user_id = $2 AND reaction = $3`,
+        [messageId, userId, reaction]
+      );
+      return true;
+    } catch (error) {
+      console.error('Error removing reaction:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get reactions for messages
+   */
+  async getReactionsForMessages(messageIds) {
+    try {
+      if (messageIds.length === 0) return {};
+
+      const result = await this.pool.query(
+        `SELECT 
+          message_id,
+          reaction,
+          COUNT(*) as count,
+          array_agg(wallet_address) as reactors
+         FROM chat_reactions
+         WHERE message_id = ANY($1)
+         GROUP BY message_id, reaction`,
+        [messageIds]
+      );
+
+      // Transform into map: messageId -> { emoji: { count, reactors } }
+      const reactionsMap = {};
+      result.rows.forEach(row => {
+        if (!reactionsMap[row.message_id]) {
+          reactionsMap[row.message_id] = {};
+        }
+        reactionsMap[row.message_id][row.reaction] = {
+          count: parseInt(row.count),
+          reactors: row.reactors,
+        };
+      });
+
+      console.log('[ChatService] Built reactions map:', reactionsMap);
+      return reactionsMap;
+    } catch (error) {
+      console.error('Error getting reactions:', error);
+      return {};
+    }
+  }
+
+  /**
+   * Get mentions for messages
+   */
+  async getMentionsForMessages(messageIds) {
+    try {
+      if (messageIds.length === 0) return {};
+
+      const result = await this.pool.query(
+        `SELECT 
+          mm.message_id,
+          u.id as user_id,
+          u.username,
+          u.wallet_address
+         FROM message_mentions mm
+         JOIN users u ON mm.mentioned_user_id = u.id
+         WHERE mm.message_id = ANY($1)`,
+        [messageIds]
+      );
+
+      // Transform into map: messageId -> [{ userId, username, walletAddress }]
+      const mentionsMap = {};
+      result.rows.forEach(row => {
+        if (!mentionsMap[row.message_id]) {
+          mentionsMap[row.message_id] = [];
+        }
+        mentionsMap[row.message_id].push({
+          userId: row.user_id,
+          username: row.username,
+          walletAddress: row.wallet_address,
+        });
+      });
+
+      console.log('[ChatService] Built mentions map:', Object.keys(mentionsMap).length, 'messages with mentions');
+      return mentionsMap;
+    } catch (error) {
+      console.error('Error getting mentions:', error);
+      return {};
+    }
+  }
+
+  /**
+   * Save payment to database
+   */
+  async savePayment({
+    messageId,
+    senderUserId,
+    senderWallet,
+    recipientUserId,
+    recipientWallet,
+    amountSol,
+    transactionSignature
+  }) {
+    try {
+      // Validate payment before saving
+      await this.validatePayment({
+        senderUserId,
+        recipientUserId,
+        amount: amountSol,
+        transactionSignature
+      });
+
+      const result = await this.pool.query(
+        `INSERT INTO chat_payments (
+          message_id, 
+          sender_user_id, 
+          sender_wallet,
+          recipient_user_id,
+          recipient_wallet,
+          amount_sol,
+          transaction_signature,
+          status,
+          created_at
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, 'confirmed', NOW())
+        RETURNING id`,
+        [messageId, senderUserId, senderWallet, recipientUserId, recipientWallet, amountSol, transactionSignature]
+      );
+
+      const paymentId = result.rows[0].id;
+      console.log(`[ChatService] 💰 Payment saved as CONFIRMED: ${paymentId} (◎${amountSol} SOL)`);
+
+      // Create notification for recipient
+      const notifResult = await this.pool.query(
+        `INSERT INTO chat_notifications (
+          user_id, 
+          message_id, 
+          sender_user_id, 
+          notification_type, 
+          notification_data,
+          created_at
+        )
+        VALUES ($1, $2, $3, 'payment_received', $4, NOW())
+        RETURNING id, created_at`,
+        [
+          recipientUserId, 
+          messageId, 
+          senderUserId, 
+          JSON.stringify({ amount: amountSol, signature: transactionSignature })
+        ]
+      );
+
+      const notificationId = notifResult.rows[0].id;
+      const notifCreatedAt = notifResult.rows[0].created_at;
+
+      // Forward to Telegram if connected
+      const recipientResult = await this.pool.query(
+        'SELECT username FROM users WHERE id = $1',
+        [recipientUserId]
+      );
+      const senderResult = await this.pool.query(
+        'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+        [senderUserId]
+      );
+
+      if (recipientResult.rows.length > 0 && senderResult.rows.length > 0) {
+        const recipientUsername = recipientResult.rows[0].username;
+        const senderUsername = senderResult.rows[0].username;
+        const senderWalletAddr = senderResult.rows[0].wallet_address;
+        const senderAvatarUrl = senderResult.rows[0].avatar;
+        
+        // Cache notification to Redis (non-blocking)
+        notificationCacheService.cacheNotification(recipientUserId, {
+          id: notificationId,
+          type: 'payment_received',
+          read: false,
+          messageId: messageId,
+          message: `◎${amountSol} SOL`,
+          senderUsername: senderUsername,
+          senderWallet: senderWalletAddr,
+          senderAvatar: senderAvatarUrl,
+          createdAt: notifCreatedAt,
+          notificationData: { amount: amountSol, signature: transactionSignature },
+        }).catch(err => console.error('[ChatService] Failed to cache payment_received notification:', err.message));
+        
+        forwardChatNotification(
+          this.pool, 
+          recipientUserId, 
+          'payment_received', 
+          senderUsername, 
+          `Sent you ◎${amountSol} SOL`
+        ).catch(err => 
+          console.error('[ChatService] Error forwarding payment notification to Telegram:', err.message)
+        );
+      }
+
+      return paymentId;
+    } catch (error) {
+      console.error('[ChatService] Error saving payment:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Validate payment before saving
+   */
+  async validatePayment({
+    senderUserId,
+    recipientUserId,
+    amount,
+    transactionSignature
+  }) {
+    // 1. Prevent self-payment
+    if (senderUserId === recipientUserId) {
+      throw new Error('Cannot send payment to yourself');
+    }
+
+    // 2. Validate amount
+    if (amount < 0.001 || amount > 1000) {
+      throw new Error('Invalid amount (must be between 0.001 and 1000 SOL)');
+    }
+
+    // 4. Check for duplicate transaction
+    const existingPayment = await this.pool.query(
+      'SELECT id FROM chat_payments WHERE transaction_signature = $1',
+      [transactionSignature]
+    );
+
+    if (existingPayment.rows.length > 0) {
+      throw new Error('Transaction already recorded');
+    }
+
+    return true;
+  }
+
+  /**
+   * Update payment status (called after Solana confirmation)
+   */
+  async updatePaymentStatus(transactionSignature, status, errorMessage = null) {
+    try {
+      const result = await this.pool.query(
+        `UPDATE chat_payments 
+         SET status = $1, error_message = $2, confirmed_at = NOW()
+         WHERE transaction_signature = $3
+         RETURNING id, sender_user_id, recipient_user_id, amount_sol`,
+        [status, errorMessage, transactionSignature]
+      );
+
+      if (result.rows.length > 0) {
+        const payment = result.rows[0];
+        console.log(`[ChatService] Payment ${payment.id} updated to ${status}`);
+
+        // If confirmed, create additional notification for sender
+        if (status === 'confirmed') {
+          const notifResult = await this.pool.query(
+            `INSERT INTO chat_notifications (
+              user_id, 
+              sender_user_id, 
+              notification_type, 
+              notification_data,
+              created_at
+            )
+            VALUES ($1, $2, 'payment_sent', $3, NOW())
+            RETURNING id, created_at`,
+            [
+              payment.sender_user_id,
+              payment.recipient_user_id,
+              JSON.stringify({ 
+                amount: parseFloat(payment.amount_sol), 
+                signature: transactionSignature 
+              })
+            ]
+          );
+          
+          const notificationId = notifResult.rows[0].id;
+          const notifCreatedAt = notifResult.rows[0].created_at;
+          
+          // Get recipient info for the notification
+          const recipientResult = await this.pool.query(
+            'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+            [payment.recipient_user_id]
+          );
+          const recipientUsername = recipientResult.rows[0]?.username || 'Someone';
+          const recipientWallet = recipientResult.rows[0]?.wallet_address || '';
+          const recipientAvatar = recipientResult.rows[0]?.avatar || null;
+          
+          // Cache notification to Redis (non-blocking)
+          notificationCacheService.cacheNotification(payment.sender_user_id, {
+            id: notificationId,
+            type: 'payment_sent',
+            read: false,
+            messageId: null,
+            message: `◎${parseFloat(payment.amount_sol)} SOL`,
+            senderUsername: recipientUsername,
+            senderWallet: recipientWallet,
+            senderAvatar: recipientAvatar,
+            createdAt: notifCreatedAt,
+            notificationData: { amount: parseFloat(payment.amount_sol), signature: transactionSignature },
+          }).catch(err => console.error('[ChatService] Failed to cache payment_sent notification:', err.message));
+        }
+
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('[ChatService] Error updating payment status:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get payment info for a message
+   */
+  async getPaymentForMessage(messageId) {
+    try {
+      const result = await this.pool.query(
+        `SELECT 
+          p.*,
+          sender.username as sender_username,
+          recipient.username as recipient_username
+         FROM chat_payments p
+         JOIN users sender ON p.sender_user_id = sender.id
+         JOIN users recipient ON p.recipient_user_id = recipient.id
+         WHERE p.message_id = $1`,
+        [messageId]
+      );
+
+      if (result.rows.length > 0) {
+        return {
+          id: result.rows[0].id,
+          senderUsername: result.rows[0].sender_username,
+          recipientUsername: result.rows[0].recipient_username,
+          amount: parseFloat(result.rows[0].amount_sol),
+          signature: result.rows[0].transaction_signature,
+          status: result.rows[0].status,
+          errorMessage: result.rows[0].error_message,
+          createdAt: result.rows[0].created_at,
+          confirmedAt: result.rows[0].confirmed_at,
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error('[ChatService] Error getting payment:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get payments for multiple messages
+   */
+  async getPaymentsForMessages(messageIds) {
+    try {
+      if (messageIds.length === 0) return {};
+
+      const result = await this.pool.query(
+        `SELECT 
+          p.message_id,
+          p.amount_sol,
+          p.transaction_signature,
+          p.status,
+          p.error_message,
+          sender.username as sender_username,
+          recipient.username as recipient_username
+         FROM chat_payments p
+         JOIN users sender ON p.sender_user_id = sender.id
+         JOIN users recipient ON p.recipient_user_id = recipient.id
+         WHERE p.message_id = ANY($1)`,
+        [messageIds]
+      );
+
+      // Transform into map: messageId -> payment data
+      const paymentsMap = {};
+      result.rows.forEach(row => {
+        paymentsMap[row.message_id] = {
+          amount: parseFloat(row.amount_sol),
+          signature: row.transaction_signature,
+          status: row.status,
+          errorMessage: row.error_message,
+          senderUsername: row.sender_username,
+          recipientUsername: row.recipient_username,
+        };
+      });
+
+      console.log('[ChatService] Built payments map:', Object.keys(paymentsMap).length, 'messages with payments');
+      return paymentsMap;
+    } catch (error) {
+      console.error('[ChatService] Error getting payments:', error);
+      return {};
+    }
+  }
+
+  /**
+   * Get user's payment history
+   */
+  async getPaymentHistory(userId, limit = 50) {
+    try {
+      const result = await this.pool.query(
+        `SELECT 
+          p.id,
+          p.message_id,
+          p.amount_sol,
+          p.transaction_signature,
+          p.status,
+          p.created_at,
+          p.confirmed_at,
+          sender.username as sender_username,
+          sender.wallet_address as sender_wallet,
+          recipient.username as recipient_username,
+          recipient.wallet_address as recipient_wallet,
+          CASE 
+            WHEN p.sender_user_id = $1 THEN 'sent'
+            WHEN p.recipient_user_id = $1 THEN 'received'
+          END as direction
+         FROM chat_payments p
+         JOIN users sender ON p.sender_user_id = sender.id
+         JOIN users recipient ON p.recipient_user_id = recipient.id
+         WHERE p.sender_user_id = $1 OR p.recipient_user_id = $1
+         ORDER BY p.created_at DESC
+         LIMIT $2`,
+        [userId, limit]
+      );
+
+      return result.rows.map(row => ({
+        id: row.id,
+        messageId: row.message_id,
+        amount: parseFloat(row.amount_sol),
+        signature: row.transaction_signature,
+        status: row.status,
+        direction: row.direction,
+        senderUsername: row.sender_username,
+        senderWallet: row.sender_wallet,
+        recipientUsername: row.recipient_username,
+        recipientWallet: row.recipient_wallet,
+        createdAt: row.created_at,
+        confirmedAt: row.confirmed_at,
+      }));
+    } catch (error) {
+      console.error('[ChatService] Error getting payment history:', error);
+      return [];
+    }
+  }
+}
+
+module.exports = ChatService;
+
+