dubs-server 1.0.0

package/services/promoTreasuryService.js

@@ -0,0 +1,239 @@
+/**
+ * 💰 Promo Treasury Service
+ *
+ * Manages the treasury wallet for sponsored game joins.
+ * This wallet pays buy-ins on behalf of users who have promo codes.
+ *
+ * Security considerations:
+ *   - Treasury keypair should be loaded from secure environment variable in production
+ *   - File-based loading only for local development/testing
+ *   - Treasury balance should be monitored and alerts set for low balance
+ */
+
+const { Connection, Keypair, PublicKey, LAMPORTS_PER_SOL } = require('@solana/web3.js');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const DEFAULT_KEYPAIR_PATH = path.join(__dirname, '../../dubs/secure_backups/promo_treasury_devnet.json');
+const MIN_BALANCE_WARNING_SOL = 1.0; // Warn when below this balance
+
+let treasuryKeypair = null;
+let connection = null;
+
+/**
+ * Initialize the treasury service
+ * @param {Connection} conn - Solana connection
+ * @param {Object} options - Initialization options
+ */
+function initialize(conn, options = {}) {
+  connection = conn;
+
+  const {
+    keypairPath = process.env.PROMO_TREASURY_KEYPAIR_PATH || DEFAULT_KEYPAIR_PATH,
+    keypairJson = process.env.PROMO_TREASURY_KEYPAIR // JSON string of secret key array
+  } = options;
+
+  // Try loading from environment variable first (production)
+  if (keypairJson) {
+    try {
+      const secretKey = JSON.parse(keypairJson);
+      treasuryKeypair = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+      console.log(`[PromoTreasury] ✅ Treasury loaded from environment variable`);
+      console.log(`[PromoTreasury]    Address: ${treasuryKeypair.publicKey.toBase58()}`);
+      return true;
+    } catch (error) {
+      console.error('[PromoTreasury] ❌ Error loading from env:', error.message);
+    }
+  }
+
+  // Fall back to file-based loading (development)
+  if (fs.existsSync(keypairPath)) {
+    try {
+      const secretKey = JSON.parse(fs.readFileSync(keypairPath, 'utf-8'));
+      treasuryKeypair = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+      console.log(`[PromoTreasury] ✅ Treasury loaded from file: ${keypairPath}`);
+      console.log(`[PromoTreasury]    Address: ${treasuryKeypair.publicKey.toBase58()}`);
+      return true;
+    } catch (error) {
+      console.error(`[PromoTreasury] ❌ Error loading from file:`, error.message);
+    }
+  }
+
+  console.warn(`[PromoTreasury] ⚠️ Treasury not initialized - promo codes will not work`);
+  console.warn(`[PromoTreasury]    Set PROMO_TREASURY_KEYPAIR env var or provide keypair file`);
+  return false;
+}
+
+/**
+ * Check if treasury is initialized and ready
+ * @returns {boolean}
+ */
+function isReady() {
+  return treasuryKeypair !== null && connection !== null;
+}
+
+/**
+ * Get treasury public key
+ * @returns {PublicKey|null}
+ */
+function getPublicKey() {
+  return treasuryKeypair?.publicKey || null;
+}
+
+/**
+ * Get treasury keypair for signing transactions
+ * WARNING: Handle with care - this returns the full keypair with private key
+ * @returns {Keypair|null}
+ */
+function getKeypair() {
+  return treasuryKeypair;
+}
+
+/**
+ * Get current treasury balance
+ * @returns {Object} - Balance in lamports and SOL
+ */
+async function getBalance() {
+  if (!isReady()) {
+    throw new Error('Treasury not initialized');
+  }
+
+  try {
+    const lamports = await connection.getBalance(treasuryKeypair.publicKey);
+    const sol = lamports / LAMPORTS_PER_SOL;
+
+    // Log warning if balance is low
+    if (sol < MIN_BALANCE_WARNING_SOL) {
+      console.warn(`[PromoTreasury] ⚠️ LOW BALANCE: ${sol.toFixed(4)} SOL`);
+    }
+
+    return {
+      lamports,
+      sol,
+      isLow: sol < MIN_BALANCE_WARNING_SOL,
+      address: treasuryKeypair.publicKey.toBase58()
+    };
+
+  } catch (error) {
+    console.error('[PromoTreasury] Error getting balance:', error.message);
+    throw error;
+  }
+}
+
+/**
+ * Check if treasury has enough balance for a sponsored join
+ * @param {number} amountLamports - Required amount in lamports
+ * @returns {Object} - Check result
+ */
+async function hasEnoughBalance(amountLamports) {
+  if (!isReady()) {
+    return { enough: false, error: 'Treasury not initialized' };
+  }
+
+  try {
+    const balance = await getBalance();
+
+    // Need extra for transaction fees (~5000 lamports per tx + rent if realloc)
+    const requiredWithBuffer = amountLamports + 100_000; // 0.0001 SOL buffer for fees
+
+    if (balance.lamports < requiredWithBuffer) {
+      return {
+        enough: false,
+        error: 'Treasury has insufficient funds',
+        currentBalance: balance.lamports,
+        required: requiredWithBuffer,
+        shortfall: requiredWithBuffer - balance.lamports
+      };
+    }
+
+    return {
+      enough: true,
+      currentBalance: balance.lamports,
+      required: requiredWithBuffer,
+      remaining: balance.lamports - requiredWithBuffer
+    };
+
+  } catch (error) {
+    console.error('[PromoTreasury] Error checking balance:', error.message);
+    return { enough: false, error: error.message };
+  }
+}
+
+/**
+ * Get treasury info for admin dashboard
+ * @returns {Object} - Treasury wallet info
+ */
+async function getTreasuryInfo() {
+  if (!isReady()) {
+    throw new Error('Treasury not initialized');
+  }
+
+  try {
+    const lamports = await connection.getBalance(treasuryKeypair.publicKey);
+    const sol = lamports / LAMPORTS_PER_SOL;
+
+    // Determine network from connection endpoint
+    const endpoint = connection.rpcEndpoint || '';
+    let network = 'unknown';
+    if (endpoint.includes('devnet')) network = 'devnet';
+    else if (endpoint.includes('mainnet')) network = 'mainnet-beta';
+    else if (endpoint.includes('localhost') || endpoint.includes('127.0.0.1')) network = 'localnet';
+
+    return {
+      address: treasuryKeypair.publicKey.toBase58(),
+      balanceLamports: lamports,
+      balanceSOL: sol,
+      isLow: sol < MIN_BALANCE_WARNING_SOL,
+      minBalanceWarning: MIN_BALANCE_WARNING_SOL,
+      network,
+    };
+
+  } catch (error) {
+    console.error('[PromoTreasury] Error getting treasury info:', error.message);
+    throw error;
+  }
+}
+
+/**
+ * Get treasury status/health check
+ * @returns {Object} - Status information
+ */
+async function getStatus() {
+  const status = {
+    initialized: isReady(),
+    address: getPublicKey()?.toBase58() || null,
+    balance: null,
+    healthy: false
+  };
+
+  if (status.initialized) {
+    try {
+      status.balance = await getBalance();
+      status.healthy = !status.balance.isLow;
+    } catch (error) {
+      status.error = error.message;
+    }
+  }
+
+  return status;
+}
+
+module.exports = {
+  // Configuration
+  MIN_BALANCE_WARNING_SOL,
+
+  // Initialization
+  initialize,
+  isReady,
+
+  // Wallet access
+  getPublicKey,
+  getKeypair,
+
+  // Balance checks
+  getBalance,
+  hasEnoughBalance,
+  getStatus,
+  getTreasuryInfo,
+};

package/services/pushNotifications.js

@@ -0,0 +1,353 @@
+// 🔔 Web Push Notification Service
+// Sends push notifications to PWA/seeker mode users
+
+const webpush = require('web-push');
+const urlHelper = require('../utils/urlHelper');
+
+// VAPID keys for Web Push authentication
+const VAPID_PUBLIC_KEY = process.env.VAPID_PUBLIC_KEY;
+const VAPID_PRIVATE_KEY = process.env.VAPID_PRIVATE_KEY;
+const VAPID_SUBJECT = process.env.VAPID_SUBJECT || 'mailto:support@dubs.app';
+
+let isInitialized = false;
+
+/**
+ * Initialize web-push with VAPID keys
+ * Call this once on server startup
+ */
+function initializeWebPush() {
+  if (!VAPID_PUBLIC_KEY || !VAPID_PRIVATE_KEY) {
+    console.log('[PushNotif] ⚠️ VAPID keys not set - push notifications disabled');
+    console.log('[PushNotif] ℹ️  Generate keys with: npx web-push generate-vapid-keys');
+    return false;
+  }
+
+  try {
+    webpush.setVapidDetails(
+      VAPID_SUBJECT,
+      VAPID_PUBLIC_KEY,
+      VAPID_PRIVATE_KEY
+    );
+    isInitialized = true;
+    console.log('[PushNotif] ✅ Web Push initialized with VAPID keys');
+    return true;
+  } catch (error) {
+    console.error('[PushNotif] ❌ Failed to initialize web-push:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Get the VAPID public key (needed by client to subscribe)
+ */
+function getVapidPublicKey() {
+  return VAPID_PUBLIC_KEY;
+}
+
+/**
+ * Send a push notification to a subscription
+ * @param {object} subscription - Push subscription object { endpoint, keys: { p256dh, auth } }
+ * @param {object} payload - Notification payload { title, body, icon, data }
+ * @returns {Promise<boolean>} - true if sent successfully
+ */
+async function sendPushNotification(subscription, payload) {
+  if (!isInitialized) {
+    console.log('[PushNotif] ⚠️ Web Push not initialized - skipping notification');
+    return false;
+  }
+
+  try {
+    const pushPayload = JSON.stringify({
+      title: payload.title || 'Dubs',
+      body: payload.body || '',
+      icon: payload.icon || '/icon-192.png',
+      badge: payload.badge || '/badge-72.png',
+      data: payload.data || {},
+      tag: payload.tag || 'dubs-notification',
+      requireInteraction: payload.requireInteraction || false,
+    });
+
+    console.log(`[PushNotif] 🚀 Sending push to endpoint: ${subscription.endpoint.substring(0, 50)}...`);
+
+    await webpush.sendNotification(subscription, pushPayload);
+
+    console.log('[PushNotif] ✅ Push notification sent successfully');
+    return true;
+  } catch (error) {
+    // Handle specific error codes
+    if (error.statusCode === 410 || error.statusCode === 404) {
+      // Subscription has expired or is invalid
+      console.log('[PushNotif] ⚠️ Subscription expired/invalid (will be cleaned up)');
+      return { expired: true, endpoint: subscription.endpoint };
+    }
+
+    console.error('[PushNotif] ❌ Failed to send push notification:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Forward notification to push if user has subscriptions
+ * Mirrors telegramNotifications.forwardChatNotification()
+ *
+ * @param {object} pool - Database pool
+ * @param {number} userId - User ID to send notification to
+ * @param {string} notificationType - Type of notification (game_invite, game_joined, etc.)
+ * @param {string} senderUsername - Username of the sender
+ * @param {string} message - Notification message text
+ * @param {object} metadata - Optional metadata (e.g., { gameId: 'sport-xxx' })
+ */
+async function forwardPushNotification(pool, userId, notificationType, senderUsername, message = '', metadata = {}) {
+  try {
+    console.log(`[PushNotif] 📤 Attempting to forward ${notificationType} notification to user ${userId} from @${senderUsername}`);
+
+    // Get user's push subscriptions and preferences
+    const result = await pool.query(
+      `SELECT s.id, s.endpoint, s.p256dh, s.auth, s.device_type, u.username,
+              COALESCE(p.notify_reply, true) as notify_reply,
+              COALESCE(p.notify_reaction, true) as notify_reaction,
+              COALESCE(p.notify_friend_request, true) as notify_friend_request,
+              COALESCE(p.notify_friend_request_accepted, true) as notify_friend_request_accepted,
+              COALESCE(p.notify_friend_request_declined, true) as notify_friend_request_declined,
+              COALESCE(p.notify_referral, true) as notify_referral,
+              COALESCE(p.notify_mention, true) as notify_mention,
+              COALESCE(p.notify_friend_message, true) as notify_friend_message,
+              COALESCE(p.notify_game_joined, true) as notify_game_joined,
+              COALESCE(p.notify_game_invite, true) as notify_game_invite
+       FROM push_subscriptions s
+       JOIN users u ON s.user_id = u.id
+       LEFT JOIN push_notification_preferences p ON u.id = p.user_id
+       WHERE s.user_id = $1`,
+      [userId]
+    );
+
+    if (result.rows.length === 0) {
+      console.log(`[PushNotif] ⏭️ User ${userId} doesn't have any push subscriptions - skipping`);
+      return false;
+    }
+
+    const subscriptions = result.rows;
+    const prefs = subscriptions[0]; // All rows have same prefs
+    const recipientUsername = prefs.username;
+
+    console.log(`[PushNotif] 👤 Found user @${recipientUsername} with ${subscriptions.length} push subscription(s)`);
+
+    // Check if user wants this notification type
+    const prefMap = {
+      'reply': prefs.notify_reply,
+      'reaction': prefs.notify_reaction,
+      'friend_request': prefs.notify_friend_request,
+      'friend_request_accepted': prefs.notify_friend_request_accepted,
+      'friend_request_declined': prefs.notify_friend_request_declined,
+      'referral': prefs.notify_referral,
+      'mention': prefs.notify_mention,
+      'friend_message': prefs.notify_friend_message,
+      'game_joined': prefs.notify_game_joined,
+      'game_invite': prefs.notify_game_invite,
+      'dm_message': prefs.notify_friend_message, // Use friend_message pref for DMs
+    };
+
+    if (prefMap[notificationType] === false) {
+      console.log(`[PushNotif] 🔇 User @${recipientUsername} has disabled ${notificationType} notifications - skipping`);
+      return false;
+    }
+
+    // Format notification payload based on type
+    let title = 'Dubs';
+    let body = '';
+    let icon = '/icon-192.png';
+    let tag = 'dubs-notification';
+    let url = 'https://dubs.app';
+
+    switch (notificationType) {
+      case 'reply':
+        title = `${senderUsername} replied`;
+        body = message || 'Replied to your message';
+        tag = 'dubs-reply';
+        break;
+      case 'reaction':
+        title = `${senderUsername} reacted ${message}`;
+        body = 'To your message';
+        tag = 'dubs-reaction';
+        break;
+      case 'friend_request':
+        title = 'New Friend Request';
+        body = `${senderUsername} sent you a friend request`;
+        tag = 'dubs-friend-request';
+        break;
+      case 'friend_request_accepted':
+        title = 'Friend Request Accepted';
+        body = `${senderUsername} accepted your friend request!`;
+        tag = 'dubs-friend-accepted';
+        break;
+      case 'friend_request_declined':
+        title = 'Friend Request Declined';
+        body = `${senderUsername} declined your friend request`;
+        tag = 'dubs-friend-declined';
+        break;
+      case 'referral':
+        title = 'New Referral!';
+        body = `${senderUsername} joined using your referral code!`;
+        tag = 'dubs-referral';
+        break;
+      case 'game_joined':
+        title = `${senderUsername} joined your bet!`;
+        body = message || 'Someone joined your game';
+        tag = 'dubs-game-joined';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'game_invite':
+        title = `${senderUsername} invited you!`;
+        body = message || 'You\'ve been invited to join a bet';
+        tag = 'dubs-game-invite';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'mention':
+        title = `${senderUsername} mentioned you`;
+        body = message || 'You were mentioned in a message';
+        tag = 'dubs-mention';
+        break;
+      case 'friend_message':
+        title = `Message from ${senderUsername}`;
+        body = message || 'New message';
+        tag = 'dubs-message';
+        break;
+      case 'dm_message':
+        title = `DM from ${senderUsername}`;
+        body = message || 'New direct message';
+        tag = 'dubs-dm';
+        break;
+      case 'game_won':
+        title = 'You Won!';
+        body = message || 'Congratulations on your win!';
+        tag = 'dubs-game-won';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'game_lost':
+        title = 'Game Finished';
+        body = message || 'Better luck next time!';
+        tag = 'dubs-game-lost';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'game_starting_soon':
+        title = 'Game Starting Soon!';
+        body = message || 'Your game is about to start';
+        tag = 'dubs-game-starting';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'game_starting_now':
+        title = 'Game Starting NOW!';
+        body = message || 'Betting is now closed';
+        tag = 'dubs-game-live';
+        if (metadata.gameId) {
+          url = urlHelper.getGameShareUrl(metadata.gameId);
+        }
+        break;
+      case 'whats_new':
+        title = "What's New on Dubs!";
+        body = message || 'Check out the latest updates';
+        tag = 'dubs-whats-new';
+        if (metadata.postId) {
+          url = urlHelper.getWhatsNewUrl(metadata.postId);
+        }
+        break;
+      default:
+        title = 'Dubs Notification';
+        body = `${senderUsername}: ${notificationType}`;
+    }
+
+    const payload = {
+      title,
+      body,
+      icon,
+      tag,
+      data: {
+        url,
+        notificationType,
+        ...metadata
+      },
+      requireInteraction: ['game_invite', 'friend_request', 'game_won'].includes(notificationType),
+    };
+
+    console.log(`[PushNotif] 📨 Sending ${notificationType} to ${subscriptions.length} device(s)...`);
+
+    // Send to all user's subscriptions
+    const expiredEndpoints = [];
+    let successCount = 0;
+
+    for (const sub of subscriptions) {
+      const subscription = {
+        endpoint: sub.endpoint,
+        keys: {
+          p256dh: sub.p256dh,
+          auth: sub.auth
+        }
+      };
+
+      const result = await sendPushNotification(subscription, payload);
+
+      if (result === true) {
+        successCount++;
+      } else if (result && result.expired) {
+        expiredEndpoints.push(sub.id);
+      }
+    }
+
+    // Clean up expired subscriptions
+    if (expiredEndpoints.length > 0) {
+      console.log(`[PushNotif] 🧹 Cleaning up ${expiredEndpoints.length} expired subscription(s)`);
+      await pool.query(
+        'DELETE FROM push_subscriptions WHERE id = ANY($1)',
+        [expiredEndpoints]
+      );
+    }
+
+    if (successCount > 0) {
+      console.log(`[PushNotif] ✅ Successfully sent ${notificationType} to ${successCount}/${subscriptions.length} device(s) for @${recipientUsername}`);
+      return true;
+    } else {
+      console.log(`[PushNotif] ❌ Failed to send ${notificationType} to any device for @${recipientUsername}`);
+      return false;
+    }
+  } catch (error) {
+    console.error(`[PushNotif] ❌ Error forwarding ${notificationType} notification:`, error.message);
+    return false;
+  }
+}
+
+/**
+ * Check if a user has push notifications enabled
+ * @param {object} pool - Database pool
+ * @param {number} userId - User ID to check
+ * @returns {Promise<boolean>}
+ */
+async function userHasPushSubscription(pool, userId) {
+  try {
+    const result = await pool.query(
+      'SELECT COUNT(*) as count FROM push_subscriptions WHERE user_id = $1',
+      [userId]
+    );
+    return parseInt(result.rows[0].count) > 0;
+  } catch (error) {
+    console.error('[PushNotif] Error checking push subscription:', error.message);
+    return false;
+  }
+}
+
+module.exports = {
+  initializeWebPush,
+  getVapidPublicKey,
+  sendPushNotification,
+  forwardPushNotification,
+  userHasPushSubscription
+};