dubs-server 1.0.0

package/services/connect4NotificationService.js

@@ -0,0 +1,374 @@
+/**
+ * Connect4 Notification Service
+ * Handles in-database notifications and Telegram forwarding for Connect4 games
+ */
+
+const { forwardChatNotification } = require('./telegramNotifications');
+
+/**
+ * Send "Your Turn" notification to the opponent after a move
+ * @param {object} pool - Database pool
+ * @param {object} chatNamespace - Socket.io chat namespace
+ * @param {object} params - Notification parameters
+ * @param {string} params.gameId - Connect4 game ID
+ * @param {string} params.opponentWallet - Wallet address of opponent (who needs to move)
+ * @param {string} params.moverWallet - Wallet address of player who just moved
+ * @param {string} params.moverUsername - Username of player who just moved
+ * @param {number} params.buyIn - Game buy-in amount
+ */
+async function notifyYourTurn(pool, chatNamespace, params) {
+  const { gameId, opponentWallet, moverWallet, moverUsername, buyIn } = params;
+
+  try {
+    // Look up opponent's user ID
+    const userResult = await pool.query(
+      'SELECT id, username FROM users WHERE wallet_address = $1',
+      [opponentWallet]
+    );
+
+    if (userResult.rows.length === 0) {
+      console.log(`[Connect4Notif] Opponent ${opponentWallet.slice(0, 8)} not found in users table - skipping notification`);
+      return;
+    }
+
+    const opponentUserId = userResult.rows[0].id;
+    const opponentUsername = userResult.rows[0].username;
+
+    // Look up mover's user ID
+    const moverResult = await pool.query(
+      'SELECT id FROM users WHERE wallet_address = $1',
+      [moverWallet]
+    );
+    const moverUserId = moverResult.rows.length > 0 ? moverResult.rows[0].id : null;
+
+    // Build notification data with gameInvite structure (frontend expects this)
+    const notificationData = {
+      gameInvite: {
+        gameId,
+        gameAddress: '', // Not needed for notification display
+        title: '4 the Pot',
+        gameType: 'connect4',
+        buyIn,
+        creatorUsername: moverUsername,
+        creatorWallet: moverWallet,
+        status: 'playing',
+      },
+    };
+
+    // Insert notification into database
+    const insertResult = await pool.query(
+      `INSERT INTO chat_notifications (
+        user_id, sender_user_id, notification_type, notification_data, read, created_at
+      ) VALUES ($1, $2, 'connect4_your_turn', $3, false, NOW())
+      RETURNING id, created_at`,
+      [opponentUserId, moverUserId, JSON.stringify(notificationData)]
+    );
+
+    const notificationId = insertResult.rows[0].id;
+    const notificationCreatedAt = insertResult.rows[0].created_at;
+
+    console.log(`[Connect4Notif] Sent connect4_your_turn notification to ${opponentUsername} (ID: ${notificationId})`);
+
+    // Send real-time notification via WebSocket
+    if (chatNamespace) {
+      const notification = {
+        id: notificationId,
+        type: 'connect4_your_turn',
+        senderUsername: moverUsername,
+        senderWallet: moverWallet,
+        message: '',
+        gameInvite: notificationData.gameInvite,
+        createdAt: notificationCreatedAt.toISOString(),
+        read: false,
+      };
+
+      chatNamespace.to(`user-${opponentUserId}`).emit('notification', notification);
+      console.log(`[Connect4Notif] Real-time notification sent to user-${opponentUserId}`);
+    }
+
+    // Forward to Telegram
+    try {
+      const message = `${moverUsername} made a move - it's your turn!`;
+      await forwardChatNotification(pool, opponentUserId, 'connect4_your_turn', moverUsername, message, { gameId });
+    } catch (telegramError) {
+      console.log(`[Connect4Notif] Telegram forward failed:`, telegramError.message);
+    }
+
+  } catch (error) {
+    console.error('[Connect4Notif] Error sending your turn notification:', error.message);
+  }
+}
+
+/**
+ * Send game result notifications (win/lose) to both players
+ * @param {object} pool - Database pool
+ * @param {object} chatNamespace - Socket.io chat namespace
+ * @param {object} params - Notification parameters
+ * @param {string} params.gameId - Connect4 game ID
+ * @param {string} params.winnerWallet - Winner's wallet address (null for draw)
+ * @param {string} params.winnerUsername - Winner's username
+ * @param {string} params.loserWallet - Loser's wallet address (null for draw)
+ * @param {string} params.loserUsername - Loser's username
+ * @param {number} params.buyIn - Game buy-in amount
+ * @param {number} params.winnerPrize - Prize amount for winner
+ * @param {boolean} params.isDraw - Whether the game was a draw
+ */
+async function notifyGameResult(pool, chatNamespace, params) {
+  const { gameId, winnerWallet, winnerUsername, loserWallet, loserUsername, buyIn, winnerPrize, isDraw } = params;
+
+  try {
+    // Build gameInvite structure for notification display
+    const gameInvite = {
+      gameId,
+      gameAddress: '',
+      title: '4 the Pot',
+      gameType: 'connect4',
+      buyIn,
+      status: 'completed',
+    };
+
+    // For draws, notify both players with game_lost (they can claim refund)
+    if (isDraw) {
+      await notifyPlayer(pool, chatNamespace, {
+        walletAddress: winnerWallet, // In draw context, this is player1
+        notificationType: 'game_lost',
+        gameInvite,
+        finalScore: { winner: null, homeScore: 0, awayScore: 0 },
+        message: 'Game ended in a draw - claim your refund!',
+        gameId,
+      });
+
+      await notifyPlayer(pool, chatNamespace, {
+        walletAddress: loserWallet, // In draw context, this is player2
+        notificationType: 'game_lost',
+        gameInvite,
+        finalScore: { winner: null, homeScore: 0, awayScore: 0 },
+        message: 'Game ended in a draw - claim your refund!',
+        gameId,
+      });
+
+      return;
+    }
+
+    // Notify winner
+    if (winnerWallet) {
+      await notifyPlayer(pool, chatNamespace, {
+        walletAddress: winnerWallet,
+        notificationType: 'game_won',
+        gameInvite,
+        finalScore: { winner: 'home', homeScore: 1, awayScore: 0 }, // Simplified for Connect4
+        message: `You won ${winnerPrize?.toFixed(2) || buyIn * 2 * 0.95} SOL!`,
+        gameId,
+        senderUsername: loserUsername,
+        senderWallet: loserWallet,
+      });
+    }
+
+    // Notify loser
+    if (loserWallet) {
+      await notifyPlayer(pool, chatNamespace, {
+        walletAddress: loserWallet,
+        notificationType: 'game_lost',
+        gameInvite,
+        finalScore: { winner: 'away', homeScore: 0, awayScore: 1 },
+        message: 'Better luck next time!',
+        gameId,
+        senderUsername: winnerUsername,
+        senderWallet: winnerWallet,
+      });
+    }
+
+  } catch (error) {
+    console.error('[Connect4Notif] Error sending game result notifications:', error.message);
+  }
+}
+
+/**
+ * Helper to notify a single player
+ */
+async function notifyPlayer(pool, chatNamespace, params) {
+  const { walletAddress, notificationType, gameInvite, finalScore, message, gameId, senderUsername, senderWallet } = params;
+
+  try {
+    // Look up user
+    const userResult = await pool.query(
+      'SELECT id, username FROM users WHERE wallet_address = $1',
+      [walletAddress]
+    );
+
+    if (userResult.rows.length === 0) {
+      console.log(`[Connect4Notif] User ${walletAddress.slice(0, 8)} not found - skipping`);
+      return;
+    }
+
+    const userId = userResult.rows[0].id;
+    const username = userResult.rows[0].username;
+
+    // Look up sender's user ID if provided
+    let senderUserId = null;
+    if (senderWallet) {
+      const senderResult = await pool.query(
+        'SELECT id FROM users WHERE wallet_address = $1',
+        [senderWallet]
+      );
+      senderUserId = senderResult.rows.length > 0 ? senderResult.rows[0].id : null;
+    }
+
+    // Build notification data
+    const notificationData = {
+      gameInvite,
+      finalScore,
+      message,
+    };
+
+    // Insert notification
+    const insertResult = await pool.query(
+      `INSERT INTO chat_notifications (
+        user_id, sender_user_id, notification_type, notification_data, read, created_at
+      ) VALUES ($1, $2, $3, $4, false, NOW())
+      RETURNING id, created_at`,
+      [userId, senderUserId, notificationType, JSON.stringify(notificationData)]
+    );
+
+    const notificationId = insertResult.rows[0].id;
+    const notificationCreatedAt = insertResult.rows[0].created_at;
+
+    console.log(`[Connect4Notif] Sent ${notificationType} notification to ${username} (ID: ${notificationId})`);
+
+    // Send real-time notification via WebSocket
+    if (chatNamespace) {
+      const notification = {
+        id: notificationId,
+        type: notificationType,
+        senderUsername: senderUsername || '4 the Pot',
+        senderWallet: senderWallet || '',
+        message: message || '',
+        gameInvite,
+        finalScore,
+        createdAt: notificationCreatedAt.toISOString(),
+        read: false,
+      };
+
+      chatNamespace.to(`user-${userId}`).emit('notification', notification);
+      console.log(`[Connect4Notif] Real-time ${notificationType} sent to user-${userId}`);
+    }
+
+    // Forward to Telegram
+    try {
+      await forwardChatNotification(pool, userId, notificationType, senderUsername || '4 the Pot', message, { gameId });
+    } catch (telegramError) {
+      console.log(`[Connect4Notif] Telegram forward failed for ${username}:`, telegramError.message);
+    }
+
+  } catch (error) {
+    console.error(`[Connect4Notif] Error notifying player ${walletAddress.slice(0, 8)}:`, error.message);
+  }
+}
+
+/**
+ * Send cancellation notification to the invited player when creator cancels
+ * @param {object} pool - Database pool
+ * @param {object} chatNamespace - Socket.io chat namespace
+ * @param {object} params - Notification parameters
+ * @param {string} params.gameId - Connect4 game ID
+ * @param {string} params.invitedPlayerWallet - Wallet address of invited player
+ * @param {string} params.creatorWallet - Creator's wallet address
+ * @param {string} params.creatorUsername - Creator's username
+ * @param {number} params.buyIn - Game buy-in amount
+ */
+async function notifyGameCancelled(pool, chatNamespace, params) {
+  const { gameId, invitedPlayerWallet, creatorWallet, creatorUsername, buyIn } = params;
+
+  if (!invitedPlayerWallet) {
+    console.log(`[Connect4Notif] No invited player for game ${gameId} - skipping cancel notification`);
+    return;
+  }
+
+  try {
+    // Look up invited player's user ID
+    const userResult = await pool.query(
+      'SELECT id, username FROM users WHERE wallet_address = $1',
+      [invitedPlayerWallet]
+    );
+
+    if (userResult.rows.length === 0) {
+      console.log(`[Connect4Notif] Invited player ${invitedPlayerWallet.slice(0, 8)} not found - skipping`);
+      return;
+    }
+
+    const invitedUserId = userResult.rows[0].id;
+    const invitedUsername = userResult.rows[0].username;
+
+    // Look up creator's user ID and avatar
+    const creatorResult = await pool.query(
+      'SELECT id, avatar FROM users WHERE wallet_address = $1',
+      [creatorWallet]
+    );
+    const creatorUserId = creatorResult.rows.length > 0 ? creatorResult.rows[0].id : null;
+    const creatorAvatar = creatorResult.rows.length > 0 ? creatorResult.rows[0].avatar : null;
+
+    // Build notification data with gameInvite structure
+    const notificationData = {
+      gameInvite: {
+        gameId,
+        gameAddress: '',
+        title: '4 the Pot',
+        gameType: 'connect4',
+        buyIn,
+        creatorUsername,
+        creatorWallet,
+        status: 'cancelled',
+      },
+      message: `${creatorUsername} cancelled the game`,
+    };
+
+    // Insert notification into database
+    const insertResult = await pool.query(
+      `INSERT INTO chat_notifications (
+        user_id, sender_user_id, notification_type, notification_data, read, created_at
+      ) VALUES ($1, $2, 'game_cancelled', $3, false, NOW())
+      RETURNING id, created_at`,
+      [invitedUserId, creatorUserId, JSON.stringify(notificationData)]
+    );
+
+    const notificationId = insertResult.rows[0].id;
+    const notificationCreatedAt = insertResult.rows[0].created_at;
+
+    console.log(`[Connect4Notif] Sent game_cancelled notification to ${invitedUsername} (ID: ${notificationId})`);
+
+    // Send real-time notification via WebSocket
+    if (chatNamespace) {
+      const notification = {
+        id: notificationId,
+        type: 'game_cancelled',
+        senderUsername: creatorUsername,
+        senderWallet: creatorWallet,
+        senderAvatar: creatorAvatar,
+        message: `${creatorUsername} cancelled the game`,
+        gameInvite: notificationData.gameInvite,
+        createdAt: notificationCreatedAt.toISOString(),
+        read: false,
+      };
+
+      chatNamespace.to(`user-${invitedUserId}`).emit('notification', notification);
+      console.log(`[Connect4Notif] Real-time cancel notification sent to user-${invitedUserId}`);
+    }
+
+    // Forward to Telegram
+    try {
+      const message = `${creatorUsername} cancelled the Connect 4 game invite`;
+      await forwardChatNotification(pool, invitedUserId, 'game_lost', creatorUsername, message, { gameId });
+    } catch (telegramError) {
+      console.log(`[Connect4Notif] Telegram forward failed:`, telegramError.message);
+    }
+
+  } catch (error) {
+    console.error('[Connect4Notif] Error sending cancel notification:', error.message);
+  }
+}
+
+module.exports = {
+  notifyYourTurn,
+  notifyGameResult,
+  notifyGameCancelled,
+};

package/services/cryptoPriceService.js

@@ -0,0 +1,223 @@
+const axios = require('axios');
+const { pool } = require('./db'); // Shared database pool
+
+class CryptoPriceService {
+  constructor() {
+    this.coingeckoApiUrl = 'https://api.coingecko.com/api/v3';
+    this.cacheTTL = parseInt(process.env.CRYPTO_PRICE_CACHE_TTL) || 300; // 5 minutes in seconds
+    this.supportedCryptos = ['solana']; // CoinGecko IDs
+    
+    // Initialize cache table on startup
+    this.initializeCacheTable();
+  }
+
+  /**
+   * Initialize the crypto_prices_cache table if it doesn't exist
+   */
+  async initializeCacheTable() {
+    try {
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS crypto_prices_cache (
+          id SERIAL PRIMARY KEY,
+          crypto_id VARCHAR(50) NOT NULL UNIQUE,
+          prices JSONB NOT NULL,
+          last_updated TIMESTAMP NOT NULL DEFAULT NOW(),
+          expires_at TIMESTAMP NOT NULL,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+        
+        CREATE INDEX IF NOT EXISTS idx_crypto_prices_id ON crypto_prices_cache(crypto_id);
+        CREATE INDEX IF NOT EXISTS idx_crypto_prices_expires ON crypto_prices_cache(expires_at);
+      `);
+      console.log('[Crypto Prices] Cache table initialized');
+    } catch (error) {
+      console.error('[Crypto Prices] Error initializing cache table:', error);
+    }
+  }
+
+  /**
+   * Get crypto price in multiple fiat currencies
+   * @param {string} cryptoId - CoinGecko crypto ID (e.g., 'solana')
+   * @param {string[]} vsCurrencies - Array of currency codes to get prices in
+   * @returns {Object} Prices object
+   */
+  async getCryptoPrice(cryptoId = 'solana', vsCurrencies = ['usd', 'eur', 'gbp', 'cad', 'jpy', 'aud']) {
+    try {
+      // Try to get from cache first
+      const cachedPrice = await this.getCachedPrice(cryptoId);
+      if (cachedPrice) {
+        console.log(`[Crypto Prices] Retrieved ${cryptoId} from cache`);
+        return {
+          ...cachedPrice,
+          source: 'cache'
+        };
+      }
+
+      // If not in cache, fetch from CoinGecko
+      console.log(`[Crypto Prices] Fetching fresh price for ${cryptoId} from CoinGecko`);
+      const freshPrice = await this.fetchFromCoinGecko(cryptoId, vsCurrencies);
+      
+      // Cache the fresh price
+      await this.cachePrice(cryptoId, freshPrice);
+      
+      return {
+        ...freshPrice,
+        source: 'api'
+      };
+    } catch (error) {
+      console.error('[Crypto Prices] Error getting crypto price:', error);
+      throw new Error('Failed to retrieve crypto price');
+    }
+  }
+
+  /**
+   * Get SOL price in USD (convenience method)
+   * @returns {number} SOL price in USD
+   */
+  async getSOLPriceUSD() {
+    const priceData = await this.getCryptoPrice('solana', ['usd']);
+    return priceData.prices.usd;
+  }
+
+  /**
+   * Get cached crypto price from PostgreSQL
+   * @param {string} cryptoId - Crypto ID
+   * @returns {Object|null} Cached price or null
+   */
+  async getCachedPrice(cryptoId) {
+    try {
+      const result = await pool.query(
+        'SELECT prices, last_updated FROM crypto_prices_cache WHERE crypto_id = $1 AND expires_at > NOW()',
+        [cryptoId]
+      );
+
+      if (result.rows.length > 0) {
+        const row = result.rows[0];
+        return {
+          cryptoId,
+          prices: row.prices,
+          lastUpdated: row.last_updated,
+          timestamp: new Date(row.last_updated).getTime()
+        };
+      }
+      
+      return null;
+    } catch (error) {
+      console.error('[Crypto Prices] Error getting cached price:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Cache crypto price in PostgreSQL
+   * @param {string} cryptoId - Crypto ID
+   * @param {Object} priceData - Price data
+   */
+  async cachePrice(cryptoId, priceData) {
+    try {
+      const expiresAt = new Date(Date.now() + this.cacheTTL * 1000);
+      
+      await pool.query(`
+        INSERT INTO crypto_prices_cache (crypto_id, prices, last_updated, expires_at)
+        VALUES ($1, $2, NOW(), $3)
+        ON CONFLICT (crypto_id) 
+        DO UPDATE SET 
+          prices = $2,
+          last_updated = NOW(),
+          expires_at = $3
+      `, [cryptoId, JSON.stringify(priceData.prices), expiresAt]);
+      
+      console.log(`[Crypto Prices] Cached ${cryptoId} prices with TTL: ${this.cacheTTL}s`);
+    } catch (error) {
+      console.error('[Crypto Prices] Error caching price:', error);
+      // Don't throw error, caching failure shouldn't break the service
+    }
+  }
+
+  /**
+   * Fetch crypto prices from CoinGecko API
+   * @param {string} cryptoId - CoinGecko crypto ID
+   * @param {string[]} vsCurrencies - Array of currency codes
+   * @returns {Object} Fresh crypto prices
+   */
+  async fetchFromCoinGecko(cryptoId, vsCurrencies) {
+    try {
+      const currenciesParam = vsCurrencies.join(',');
+      const url = `${this.coingeckoApiUrl}/simple/price?ids=${cryptoId}&vs_currencies=${currenciesParam}`;
+      
+      const response = await axios.get(url, {
+        timeout: 10000, // 10 second timeout
+        headers: {
+          'User-Agent': 'Dubs-Crypto-Price-API/1.0',
+          'Accept': 'application/json'
+        }
+      });
+
+      if (!response.data || !response.data[cryptoId]) {
+        throw new Error('Invalid response from CoinGecko API');
+      }
+
+      const prices = response.data[cryptoId];
+
+      return {
+        cryptoId,
+        prices,
+        timestamp: Date.now(),
+        lastUpdated: new Date().toISOString()
+      };
+    } catch (error) {
+      if (error.response) {
+        console.error('[Crypto Prices] CoinGecko API Error:', error.response.status, error.response.data);
+        
+        // Handle specific API errors
+        if (error.response.status === 429) {
+          throw new Error('CoinGecko API: Rate limit exceeded');
+        }
+        
+        throw new Error(`CoinGecko API error: ${error.response.status}`);
+      } else if (error.request) {
+        console.error('[Crypto Prices] Network Error:', error.message);
+        throw new Error('Network error connecting to CoinGecko API');
+      } else {
+        console.error('[Crypto Prices] Error:', error.message);
+        throw new Error('Failed to fetch crypto prices');
+      }
+    }
+  }
+
+  /**
+   * Clear cache for a specific crypto
+   * @param {string} cryptoId - Crypto ID
+   */
+  async clearCache(cryptoId = 'solana') {
+    try {
+      await pool.query(
+        'DELETE FROM crypto_prices_cache WHERE crypto_id = $1',
+        [cryptoId]
+      );
+      console.log(`[Crypto Prices] Cache cleared for ${cryptoId}`);
+    } catch (error) {
+      console.error('[Crypto Prices] Error clearing cache:', error);
+      throw new Error('Failed to clear cache');
+    }
+  }
+
+  /**
+   * Clean up expired cache entries
+   */
+  async cleanupExpiredCache() {
+    try {
+      const result = await pool.query(
+        'DELETE FROM crypto_prices_cache WHERE expires_at < NOW()'
+      );
+      if (result.rowCount > 0) {
+        console.log(`[Crypto Prices] Cleaned up ${result.rowCount} expired cache entries`);
+      }
+    } catch (error) {
+      console.error('[Crypto Prices] Error cleaning up cache:', error);
+    }
+  }
+}
+
+module.exports = new CryptoPriceService();
+