all

.commitlintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@commitlint/config-conventional"]
+}

.cursorignore

@@ -0,0 +1,4 @@
+node_modules
+trash
+build
+pnpm-lock.yaml

.dockerignore

@@ -0,0 +1,7 @@
+**/node_modules
+*/node_modules
+node_modules
+Dockerfile
+.*
+*/.*
+!.env

.editorconfig

@@ -0,0 +1,11 @@
+# Editor configuration, see http://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 2
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true

.eslintignore

@@ -0,0 +1,2 @@
+docker-compose
+kubernetes

.eslintrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ['@antfu'],
+}

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,39 @@
+
+.firebase
+.firebaserc
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.DS_Store
+# dist
+turch
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Editor directories and files
+.vscode/*
+!.vscode/settings.json
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# Environment variables files
+/service/.env
+trash
+logs
+.env

.npmrc

@@ -0,0 +1 @@
+strict-peer-dependencies=false

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+    "recommendations": ["dbaeumer.vscode-eslint"]
+  }

.vscode/settings.json

@@ -0,0 +1,21 @@
+{
+    "prettier.enable": false,
+    "editor.formatOnSave": false,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit"
+    },
+    "eslint.validate": [
+      "javascript",
+      "typescript",
+      "json",
+      "jsonc",
+      "json5",
+      "yaml"
+    ],
+    "cSpell.words": [
+      "antfu",
+   
+      "esno",
+    
+    ]
+  }

Dockerfile

@@ -0,0 +1,29 @@
+# Use the official Node.js image with the desired version
+FROM node:22.13.1-slim
+
+# Set the working directory inside the container
+WORKDIR /usr/src/app
+
+# Install pnpm globally
+RUN npm install -g pnpm
+
+# Copy package.json and pnpm-lock.yaml
+COPY package.json pnpm-lock.yaml* ./
+
+# Install dependencies using pnpm
+RUN pnpm install --frozen-lockfile
+
+# Copy the rest of the application code
+COPY . .
+
+# Build the TypeScript project
+RUN pnpm run build
+
+# Create writable logs directory
+RUN mkdir -p logs && chmod 777 logs
+
+# Expose the port your app runs on
+EXPOSE 7860
+
+# Start the application
+CMD ["pnpm", "run", "start"]

a.py

@@ -0,0 +1,13 @@
+import asyncio
+from fivesimapi import fivesim
+
+api_key = "YOUR_API_KEY"  # Replace with your actual API key
+
+async def main():
+    client = fivesim.FiveSim(api_key)
+    country = "any"  # You can specify a country code like 'us', 'ru', etc.
+    products = await client.get_products(country)
+    for product in products:
+        print(f"Product: {product['product']}, Price: {product['cost']}, Available: {product['count']}")
+
+asyncio.run(main())

d.sh

@@ -0,0 +1,7 @@
+git add .
+git commit -m "all"
+git push
+
+
+
+# curl -X POST https://mfoud444-bot-me.hf.space/bots/telegraf/start-specific   -H "Content-Type: application/json"   -d '{"botId": "049a92c4-7654-43f6-8e6f-7ff5cce78995"}'

db.sql

@@ -0,0 +1,185 @@
+INSERT INTO
+    "public"."blockkeyword" ("text", "created_at", "user_id")
+VALUES
+    (
+        'https://wa.me',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'أنصحكم فيها صراحة',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'اتصل بنا الآن للحصول',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'اضغط المشبك',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'اعداد البحوث باللغتين',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'اعطيك احد يحل فل مارك',
+        '2024-02-19 19:10:29.482826+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'الدفع بعد',
+        '2024-02-15 16:12:20.500052+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'انا مصمم فلسطنيي',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'بدون فلوس',
+        '2024-02-27 19:22:19.13035+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'بدون مقابل',
+        '2024-02-14 17:03:30.505531+00',
+        'dcb2d2ae-4039-4172-a347-7d324337eca8'
+    ),
+    (
+        'بلوشي',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'تواصل الآن على الوات.ساب',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'تواصل على الواتساب',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'خدماتنا مضمونة',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'دون مقابل مادي',
+        '2024-02-28 21:03:45.321797+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'سلام ذي مختصة تحل واجبات',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'ضمان الفل مارك',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'عمل سيره ذاتية',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'لتواصل عبر الواتساب',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'لجميع الخدمات الطلابية',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'لطلب الخدمة',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'لطلب المساعده',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'للتواصل',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'للتواصل أو الاستفسار عبر واتساب',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'لو احد محتاج دكتور',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'مجان ',
+        '2024-02-28 21:04:43.213204+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        '(منصة الأمتياز)',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'مواعيد اختبار التحصيلي',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'هذا رقمه',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'هذي دكتوره تساعد وحلها كويس مجربه',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    ),
+    (
+        'يتواصل ع الرقم',
+        '2024-02-28 21:04:51.610793+00',
+        '7ae51109-17d1-4c42-aa60-b222a36fc76a'
+    );
+
+
+    -- Command table
+CREATE TABLE command (
+  id SERIAL PRIMARY KEY,
+  key VARCHAR(50) NOT NULL UNIQUE,
+  value VARCHAR(255) NOT NULL,
+  description TEXT,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Message table (linked to command via one-to-many relationship)
+CREATE TABLE message (
+  id SERIAL PRIMARY KEY,
+  command_id INTEGER REFERENCES command(id) ON DELETE CASCADE,
+  key VARCHAR(50) NOT NULL,
+  value TEXT NOT NULL,
+  description TEXT,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), 
+  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- Add unique constraint for command_id + key combination
+CREATE UNIQUE INDEX message_command_key_unique ON message(command_id, key);

package.json

@@ -0,0 +1,55 @@
+{
+  "name": "telegram-dash",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "esno ./src/index.ts",
+    "dev": "esno watch ./src/index.ts",
+    "prod": "node ./build/index.mjs",
+    "build": "pnpm clean && tsup",
+    "clean": "rimraf build",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "common:cleanup": "rimraf node_modules && rimraf pnpm-lock.yaml"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.48.1",
+    "axios": "^1.3.4",
+    "big-integer": "^1.6.52",
+    "chalk": "^5.4.1",
+    "chatgpt": "^5.1.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "esno": "^4.7.0",
+    "express": "^4.21.2",
+    "express-rate-limit": "^6.7.0",
+    "https-proxy-agent": "^5.0.1",
+    "isomorphic-fetch": "^3.0.0",
+    "node-fetch": "^3.3.0",
+    "punycode": "^2.3.1",
+    "socks-proxy-agent": "^7.0.0",
+    "telegraf": "^4.16.3",
+    "telegram": "^2.26.16",
+    "uuid": "^11.1.0",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^5.0.0",
+      "playwright": "^1.43.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.35.3",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.13.0",
+    "eslint": "^8.35.0",
+    "rimraf": "^4.3.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^6.6.3",
+    "typescript": "^5.7.3",
+    "unicodedata": "^0.1.1",
+    "unorm": "^1.6.0"
+  }
+}

run.sh

@@ -0,0 +1,4 @@
+# node bot.js
+# npm run start
+# npx ts-node src/api 
+pnpm run dev

src/api/paymentWebhooks.ts

@@ -0,0 +1,47 @@
+import express from 'express';
+import { telegrafBots } from '../models';
+import { createLogger } from '../utils/logger';
+
+const logger = createLogger('PaymentWebhooks');
+const router = express.Router();
+
+// Get the first bot instance from the map
+const bot = Array.from(telegrafBots.values())[0];
+
+// PayPal webhook endpoint
+router.post('/paypal', async (req, res) => {
+  try {
+    const { paymentId, status } = req.body;
+    await bot.emit('webhook:paypal', { paymentId, status });
+    res.json({ success: true });
+  } catch (error) {
+    logger.error('PayPal webhook error:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Crypto webhook endpoint
+router.post('/crypto', async (req, res) => {
+  try {
+    const { paymentId, status } = req.body;
+    await bot.emit('webhook:crypto', { paymentId, status });
+    res.json({ success: true });
+  } catch (error) {
+    logger.error('Crypto webhook error:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Admin payment verification endpoint
+router.post('/admin', async (req, res) => {
+  try {
+    const { paymentId, status } = req.body;
+    await bot.emit('webhook:admin', { paymentId, status });
+    res.json({ success: true });
+  } catch (error) {
+    logger.error('Admin webhook error:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router; 

src/bots/botManager.ts

@@ -0,0 +1,234 @@
+import { Telegraf } from "telegraf";
+import { telegrafBots } from "../models";
+import { setupCommandHandlers } from "./handlers/commandHandlers";
+import { setupCallbackHandlers } from "./handlers/index";
+import { BotContext } from "./types/botTypes";
+import { supabase } from "../db/supabase";
+import { createLogger } from "../utils/logger";
+import { messageManager } from "./utils/messageManager";
+import { handleLanguageSelection, handleLanguageChange } from "./handlers/languageHandlers";
+import { getBotIdFromToken, saveBotTokenMapping, isValidBotToken } from "../utils/botUtils";
+import { groupCheckMiddleware } from "./middleware/groupCheckMiddleware";
+// import { balanceUpdateService } from "./services/BalanceUpdateService";
+
+const logger = createLogger('BotManager');
+
+export const BotCommands: { command: string; description: string }[] = [
+  { command: 'start', description: 'بدء البوت' },
+  { command: 'help', description: 'يعرض قائمة المساعدة' },
+  { command: 'about', description: 'معلومات عن البوت' },
+  { command: 'contact', description: 'تواصل معنا' },
+  { command: 'balance', description: 'رصيدي' },
+  { command: 'change_language', description: 'تغيير اللغة / Change language' },
+];
+
+// Add this interface to match your database schema
+export interface BotData {
+  id: string;
+  name: string;
+  user_id: string;
+  bot_token: string;
+  is_active: boolean;
+  currency: string;
+  profit_type: 'fix' | 'percentage';
+  profit_value_percentage: number;
+  profit_value_fix: number;
+  last_activity: string | null;
+  version: string;
+ 
+  // API Keys and External Service Configuration
+  fivesim_api_key: string;
+  paypal_client_id: string;
+  paypal_client_secret: string;
+  crypto_wallet_address: string;
+  admin_contact: string;
+ 
+  // Group Join Settings
+  join_group_required: boolean;
+  group_channel_username: string;
+ 
+  settings: Record<string, any>;
+  state: Record<string, any>;
+  suffix_email: string;
+  created_at: string;
+  updated_at: string;
+}
+
+// Update the initializeBot function to use our utilities
+export const initializeBot = async (botToken: string, botData?: BotData) => {
+  try {
+    // Validate bot token
+    if (!isValidBotToken(botToken)) {
+      throw new Error('Invalid bot token format');
+    }
+
+    const bot = new Telegraf<BotContext>(botToken);
+    
+    // Extract and save bot ID mapping
+    const botId = getBotIdFromToken(botToken);
+    saveBotTokenMapping(botToken, botId);
+    
+    // Set bot ID and load messages
+    await messageManager.loadMessages();
+    
+    // Set language based on bot settings or default to Arabic
+    messageManager.setLanguage(botData?.settings?.language || 'en');
+    
+    // Add bot data to context for use in handlers
+    bot.context.botData = botData || null;
+    
+    // Setup middleware to track activity
+    bot.use(async (ctx, next) => {
+      if (botData?.id) {
+        // Update last_activity in database
+        await supabase
+          .from('bots')
+          .update({
+            last_activity: new Date().toISOString()
+          })
+          .eq('id', botData.id);
+      }
+      return next();
+    });
+    
+    // Add group check middleware
+    bot.use(groupCheckMiddleware);
+    
+    // Setup command handlers
+    setupCommandHandlers(bot);
+    
+    // Setup callback handlers
+    setupCallbackHandlers(bot);
+    
+    // Initialize balance update service and ensure it's properly set up
+    try {
+
+      // balanceUpdateService.setBot(bot);
+      
+      logger.info('Balance update service initialized successfully');
+    } catch (error: any) {
+      logger.error(`Failed to initialize balance update service: ${error.message}`);
+      // Continue initialization even if balance service fails
+    }
+    
+    // Set bot commands
+    try {
+      await bot.telegram.setMyCommands(BotCommands, {
+        scope: { type: 'default' }
+      });
+      logger.info('Bot commands set successfully');
+    } catch (error: any) {
+      logger.error(`Failed to set bot commands: ${error.message}`);
+      // Continue initialization even if setting commands fails
+    }
+    
+    return { 
+      success: true, 
+      message: botData?.name ? `Bot "${botData.name}" initialized successfully` : "Bot initialized successfully", 
+      bot 
+    };
+  } catch (error: any) {
+    logger.error(`Failed to initialize bot: ${error.message}`);
+    return { success: false, message: `Failed to initialize bot: ${error.message}` };
+  }
+};
+
+// Utility function to update bot status in database
+const updateBotStatus = async (botId: string, isActive: boolean, error?: string) => {
+  try {
+    await supabase
+      .from('bots')
+      .update({
+        is_active: isActive,
+        last_activity: new Date().toISOString(),
+        state: {
+          status: isActive ? 'running' : 'error',
+          startedAt: isActive ? new Date().toISOString() : undefined,
+          error: error
+        }
+      })
+      .eq('id', botId);
+  } catch (error: any) {
+    logger.error(`Error updating bot status: ${error.message}`);
+  }
+};
+
+export const stopBot = async (botId: string) => {
+  try {
+    // Get bot token from database
+    const { data: botData, error } = await supabase
+      .from('bots')
+      .select('bot_token')
+      .eq('id', botId)
+      .single();
+      
+    if (error || !botData) {
+      await updateBotStatus(botId, false, "Bot not found in database");
+      return { success: false, message: "Bot not found in database" };
+    }
+    
+    const botToken = botData.bot_token;
+    const bot = telegrafBots.get(botToken);
+    
+    if (bot) {
+      await bot.stop();
+      telegrafBots.delete(botToken);
+      
+      // Update database
+      await updateBotStatus(botId, false);
+      return { success: true, message: "Bot stopped successfully" };
+    }
+    
+    // Bot instance not found
+    await updateBotStatus(botId, false, "Bot instance not found");
+  
+    return { success: false, message: "Bot instance not found" };
+  } catch (error: any) {
+    logger.error(`Error stopping bot: ${error.message}`);
+    await updateBotStatus(botId, false, error.message);
+    return { success: false, message: `Failed to stop bot: ${error.message}` };
+  }
+};
+
+// New function to update bot settings
+export const updateBotSettings = async (botId: string, settings: Record<string, any>) => {
+  try {
+    // Get bot data from database
+    const { data: botData, error } = await supabase
+      .from('bots')
+      .select('bot_token, settings')
+      .eq('id', botId)
+      .single();
+      
+    if (error || !botData) {
+      return { success: false, message: "Bot not found in database" };
+    }
+    
+    // Merge existing settings with new ones
+    const updatedSettings = { ...(botData.settings || {}), ...settings };
+    
+    // Update database
+    await supabase
+      .from('bots')
+      .update({
+        settings: updatedSettings,
+        updated_at: new Date().toISOString()
+      })
+      .eq('id', botId);
+      
+    // Update running bot if it exists
+    const bot = telegrafBots.get(botData.bot_token);
+    if (bot && bot.context) {
+      bot.context.botData = {
+        ...(bot.context.botData || {}),
+        settings: updatedSettings
+      };
+    }
+    
+    return { success: true, message: "Bot settings updated successfully" };
+  } catch (error: any) {
+    logger.error(`Error updating bot settings: ${error.message}`);
+    return { success: false, message: `Failed to update bot settings: ${error.message}` };
+  }
+};
+

src/bots/db.sql

@@ -0,0 +1,153 @@
+-- users_bot_telegram table
+CREATE TABLE IF NOT EXISTS public.users_bot_telegram (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  telegram_id BIGINT NOT NULL, -- Telegram user ID (not unique)
+  username VARCHAR(255), -- Telegram username
+  first_name VARCHAR(255), -- User's first name
+  last_name VARCHAR(255), -- User's last name
+  email VARCHAR(255) UNIQUE NOT NULL, -- User's email address
+  password_hash VARCHAR(255) NOT NULL, -- Hashed password for authentication
+  language VARCHAR(10) NOT NULL DEFAULT 'en', -- User's preferred language
+  role VARCHAR(10) NOT NULL DEFAULT 'user', -- User role (user/admin/etc.)
+  balance DECIMAL(10, 2) NOT NULL DEFAULT 0, -- User's account balance
+  is_banned BOOLEAN NOT NULL DEFAULT false, -- Whether the user is banned
+  last_login TIMESTAMPTZ, -- Timestamp of last login
+  bot_id UUID REFERENCES public.bots(id) ON DELETE SET NULL, -- Reference to associated bot
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- Timestamp when record was created
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- Timestamp when record was last updated
+  UNIQUE(telegram_id, bot_id) -- Composite unique constraint
+);
+
+COMMENT ON TABLE public.users_bot_telegram IS 'Stores Telegram user accounts and their associated data.';
+
+-- Enable Row Level Security
+ALTER TABLE public.users_bot_telegram ENABLE ROW LEVEL SECURITY;
+
+-- Policies
+CREATE POLICY "Users can manage their own data." ON public.users_bot_telegram
+  FOR ALL USING (true);
+
+-- Trigger for updating timestamps
+CREATE TRIGGER update_users_bot_telegram_timestamp BEFORE UPDATE ON public.users_bot_telegram
+  FOR EACH ROW EXECUTE FUNCTION update_timestamp();
+
+-- Transactions table
+CREATE TABLE IF NOT EXISTS public.transactions (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  user_id INTEGER NOT NULL REFERENCES public.users_bot_telegram(id) ON DELETE CASCADE, -- Reference to user
+  agent_id INTEGER REFERENCES public.users_bot_telegram(id) ON DELETE SET NULL, -- Reference to agent who processed transaction
+  type VARCHAR(20) NOT NULL, -- Type of transaction (deposit/withdrawal/etc.)
+  amount DECIMAL(10, 2) NOT NULL, -- Transaction amount
+  reference_id VARCHAR(255), -- External reference ID
+  description TEXT, -- Transaction description
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() -- Timestamp when transaction was created
+);
+
+COMMENT ON TABLE public.transactions IS 'Stores financial transactions for users.';
+
+-- Recharge cards table
+CREATE TABLE IF NOT EXISTS public.recharge_cards (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  code VARCHAR(50) UNIQUE NOT NULL, -- Unique card code
+  amount DECIMAL(10, 2) NOT NULL, -- Card value amount
+  is_used BOOLEAN NOT NULL DEFAULT false, -- Whether card has been used
+  is_reusable BOOLEAN NOT NULL DEFAULT false, -- Whether card can be reused
+  created_by INTEGER NOT NULL REFERENCES public.users_bot_telegram(id) ON DELETE CASCADE, -- Who created the card
+  used_by INTEGER REFERENCES public.users_bot_telegram(id) ON DELETE SET NULL, -- Who used the card
+  used_at TIMESTAMPTZ, -- When card was used
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- When card was created
+  expires_at TIMESTAMPTZ -- When card expires
+);
+
+COMMENT ON TABLE public.recharge_cards IS 'Stores recharge cards for user balance top-ups.';
+
+-- Phone numbers table
+CREATE TABLE IF NOT EXISTS public.phone_numbers (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  user_id INTEGER NOT NULL REFERENCES public.users_bot_telegram(id) ON DELETE CASCADE, -- Owner of the number
+  country_code VARCHAR(10) NOT NULL, -- Country code for number
+  service VARCHAR(50) NOT NULL, -- Service the number is for
+  number VARCHAR(50) NOT NULL, -- Phone number
+  price DECIMAL(10, 2) NOT NULL, -- Cost of the number
+  status VARCHAR(20) NOT NULL DEFAULT 'pending', -- Current status of number
+  fivesim_id VARCHAR(50) NOT NULL, -- Reference to 5sim.net ID
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- When number was acquired
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- When number was last updated
+  expires_at TIMESTAMPTZ -- When number expires
+);
+
+COMMENT ON TABLE public.phone_numbers IS 'Stores phone numbers acquired for verification services.';
+
+-- Trigger for updating timestamps
+CREATE TRIGGER update_phone_numbers_timestamp BEFORE UPDATE ON public.phone_numbers
+  FOR EACH ROW EXECUTE FUNCTION update_timestamp();
+
+-- SMS messages table
+CREATE TABLE IF NOT EXISTS public.sms_messages (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  phone_number_id INTEGER NOT NULL REFERENCES public.phone_numbers(id) ON DELETE CASCADE, -- Associated phone number
+  code VARCHAR(50) NOT NULL, -- Verification code from SMS
+  text TEXT NOT NULL, -- Full SMS text
+  received_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- When SMS was received
+  is_delivered BOOLEAN NOT NULL DEFAULT false, -- Whether SMS was delivered to user
+  delivered_at TIMESTAMPTZ -- When SMS was delivered to user
+);
+
+COMMENT ON TABLE public.sms_messages IS 'Stores SMS messages received for verification services.';
+
+-- Settings table
+CREATE TABLE IF NOT EXISTS public.settings (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  key VARCHAR(50) UNIQUE NOT NULL, -- Setting key
+  value TEXT NOT NULL, -- Setting value
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), -- When setting was created
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() -- When setting was last updated
+);
+
+COMMENT ON TABLE public.settings IS 'Stores system configuration settings.';
+
+-- Trigger for updating timestamps
+CREATE TRIGGER update_settings_timestamp BEFORE UPDATE ON public.settings
+  FOR EACH ROW EXECUTE FUNCTION update_timestamp();
+
+-- Add bots table if it doesn't exist
+CREATE TABLE IF NOT EXISTS public.bots (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name VARCHAR(255) NOT NULL,
+  user_id UUID NOT NULL,
+  bot_token VARCHAR(255) NOT NULL UNIQUE,
+  is_active BOOLEAN NOT NULL DEFAULT true,
+  currency VARCHAR(10) NOT NULL DEFAULT 'USD',
+  profit_type VARCHAR(10) NOT NULL DEFAULT 'percentage',
+  profit_value_percentage DECIMAL(5,2) DEFAULT 0,
+  profit_value_fix DECIMAL(10,2) DEFAULT 0,
+  last_activity TIMESTAMPTZ,
+  version VARCHAR(20) NOT NULL DEFAULT '1.0.0',
+  
+  -- API Keys and External Service Configuration
+  fivesim_api_key VARCHAR(255),
+  paypal_client_id VARCHAR(255),
+  paypal_client_secret VARCHAR(255),
+  crypto_wallet_address VARCHAR(255),
+  admin_contact VARCHAR(255),
+  
+  -- Group Join Settings
+  join_group_required BOOLEAN DEFAULT false,
+  group_channel_username VARCHAR(255),
+  
+  settings JSONB DEFAULT '{}',
+  state JSONB DEFAULT '{}',
+  suffix_email VARCHAR(255) DEFAULT 'saerosms.com',
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+COMMENT ON TABLE public.bots IS 'Stores bot configurations and settings';
+
+-- Enable Row Level Security
+ALTER TABLE public.bots ENABLE ROW LEVEL SECURITY;
+
+-- Trigger for updating timestamps
+CREATE TRIGGER update_bots_timestamp BEFORE UPDATE ON public.bots
+  FOR EACH ROW EXECUTE FUNCTION update_timestamp();
+

src/bots/handlers/balanceHandlers.ts

@@ -0,0 +1,252 @@
+import { BotContext } from "../types/botTypes";
+import { Markup } from "telegraf";
+import { getLoggedInMenuKeyboard, getMainMenuKeyboard } from "../utils/keyboardUtils";
+import { AuthService } from '../services/auth';
+import { PayPalService } from '../services/PayPalService';
+import { CryptoService } from '../services/CryptoService';
+import { AdminService } from '../services/AdminService';
+import { createLogger } from '../../utils/logger';
+import { PaymentMethod } from '../types/paymentTypes';
+import { messageManager } from "../utils/messageManager";
+import { authCheckHandler } from "../utils/handlerUtils";
+
+const logger = createLogger('BalanceHandlers');
+const authService = AuthService.getInstance();
+
+// Add state management for custom amount
+const customAmountStates = new Map<number, boolean>();
+
+// Add payment method states
+const paymentMethodStates = new Map<number, PaymentMethod>();
+
+export const handleTopUpAction = authCheckHandler(async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  const user = await authService.getUserByTelegramId(telegramId!, ctx);
+  
+  if (!user) {
+    return {
+      message: messageManager.getMessage('user_not_found'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  return {
+    message: messageManager.getMessage('balance_top_up_title') + '\n\n' +
+      messageManager.getMessage('balance_current_balance')
+        .replace('{balance}', user.balance?.toString() || '0') + '\n\n' +
+      messageManager.getMessage('balance_choose_payment_method'),
+    options: {
+      ...Markup.inlineKeyboard([
+        [Markup.button.callback(messageManager.getMessage('btn_payment_paypal'), 'payment_paypal')],
+        [Markup.button.callback(messageManager.getMessage('btn_payment_crypto'), 'payment_crypto')],
+        [Markup.button.callback(messageManager.getMessage('btn_payment_admin'), 'payment_admin')],
+        [Markup.button.callback(messageManager.getMessage('btn_back_to_main'), 'main_menu')]
+      ]),
+      parse_mode: 'HTML'
+    }
+  };
+});
+
+export const handleCustomAmountRequest = authCheckHandler(async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  customAmountStates.set(telegramId!, true);
+
+  return {
+    message: messageManager.getMessage('balance_custom_amount_title') + '\n\n' +
+      messageManager.getMessage('balance_enter_custom_amount'),
+    options: {
+      ...Markup.inlineKeyboard([
+        [Markup.button.callback(messageManager.getMessage('btn_cancel'), 'top_up_balance')]
+      ]),
+      parse_mode: 'HTML'
+    }
+  };
+});
+
+export const handlePaymentMethodSelection = authCheckHandler(async (ctx: BotContext, method: PaymentMethod) => {
+  const telegramId = ctx.from?.id;
+  paymentMethodStates.set(telegramId!, method);
+
+  return {
+    message: messageManager.getMessage('balance_top_up_title') + '\n\n' +
+      messageManager.getMessage('balance_choose_amount'),
+    options: {
+      ...Markup.inlineKeyboard([
+        [
+          Markup.button.callback(messageManager.getMessage('btn_amount_5'), 'top_up_5'),
+          Markup.button.callback(messageManager.getMessage('btn_amount_10'), 'top_up_10'),
+          Markup.button.callback(messageManager.getMessage('btn_amount_20'), 'top_up_20')
+        ],
+        [
+          Markup.button.callback(messageManager.getMessage('btn_amount_50'), 'top_up_50'),
+          Markup.button.callback(messageManager.getMessage('btn_amount_100'), 'top_up_100')
+        ],
+        [Markup.button.callback(messageManager.getMessage('btn_custom_amount'), 'top_up_custom')],
+        [Markup.button.callback(messageManager.getMessage('btn_back_to_balance'), 'top_up_balance')]
+      ]),
+      parse_mode: 'HTML'
+    }
+  };
+});
+
+export const handleTopUpAmount = authCheckHandler(async (ctx: BotContext, amount: number) => {
+  const telegramId = ctx.from?.id;
+  const user = await authService.getUserByTelegramId(telegramId!, ctx);
+  const paymentMethod = paymentMethodStates.get(telegramId!);
+  
+  if (!user) {
+    return {
+      message: messageManager.getMessage('user_not_found'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  try {
+    let message: string;
+
+    switch (paymentMethod) {
+      case 'PAYPAL':
+        const paypalService = PayPalService.getInstance(ctx);
+        const paymentLink = await paypalService.createPaymentLink(user.id.toString(), amount);
+        message = messageManager.getMessage('payment_paypal_title') + '\n\n' +
+          `المبلغ المطلوب: $${amount}\n\n` +
+          messageManager.getMessage('payment_paypal_instructions')
+            .replace('{payment_link}', paymentLink);
+        break;
+
+      case 'CRYPTO':
+        const cryptoService = CryptoService.getInstance(ctx);
+        const cryptoAddress = await cryptoService.getPaymentAddress(user.id.toString(), amount);
+        message = messageManager.getMessage('payment_crypto_title') + '\n\n' +
+          `المبلغ المطلوب: $${amount}\n\n` +
+          messageManager.getMessage('payment_crypto_instructions')
+            .replace('{wallet_address}', cryptoAddress);
+        break;
+
+      case 'ADMIN':
+        const adminService = AdminService.getInstance(ctx);
+        const adminContact = await adminService.getAdminContact();
+        message = messageManager.getMessage('payment_admin_title') + '\n\n' +
+          `المبلغ المطلوب: $${amount}\n\n` +
+          messageManager.getMessage('payment_admin_instructions')
+            .replace('{admin_contact}', adminContact);
+        break;
+
+      default:
+        throw new Error('Invalid payment method');
+    }
+
+    return {
+      message: message,
+      options: {
+        ...Markup.inlineKeyboard([
+          [Markup.button.callback(messageManager.getMessage('btn_back_to_main'), 'main_menu')]
+        ]),
+        parse_mode: 'HTML'
+      }
+    };
+  } catch (error) {
+    logger.error('Error creating payment:', error);
+    return {
+      message: messageManager.getMessage('payment_error'),
+      options: getLoggedInMenuKeyboard()
+    };
+  }
+});
+
+// Add handler for custom amount input
+export const handleCustomAmountInput = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !customAmountStates.get(telegramId)) {
+    return;
+  }
+
+  const message = ctx.message;
+  const amountText = (message && 'text' in message) ? message.text : undefined;
+  if (!amountText) return;
+
+  // Remove state
+  customAmountStates.delete(telegramId)
+
+  // Parse amount
+  const amount = parseFloat(amountText);
+  if (isNaN(amount) || amount <= 0) {
+    return {
+      message: "⚠️ المبلغ غير صالح. الرجاء إدخال رقم صحيح أو عشري موجب.",
+      options: {
+        ...Markup.inlineKeyboard([
+          [Markup.button.callback('🔙 العودة', 'top_up_balance')]
+        ]),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+
+  // Handle the custom amount
+  return await handleTopUpAmount(ctx, amount);
+};
+
+export const setupBalanceHandlers = (bot: any) => {
+  // Handle top-up button click
+  bot.action('top_up_balance', async (ctx: BotContext) => {
+    const result = await handleTopUpAction(ctx);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  // Add custom amount handler
+  bot.action('top_up_custom', async (ctx: BotContext) => {
+    const result = await handleCustomAmountRequest(ctx);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  // Handle text messages for custom amount
+  bot.on('text', async (ctx: BotContext) => {
+    const result = await handleCustomAmountInput(ctx);
+    if (result) {
+      await ctx.reply(result.message, result.options);
+    }
+  });
+
+  // Handle specific amount selections
+  bot.action('top_up_5', async (ctx: BotContext) => {
+    const result = await handleTopUpAmount(ctx, 5);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('top_up_10', async (ctx: BotContext) => {
+    const result = await handleTopUpAmount(ctx, 10);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('top_up_20', async (ctx: BotContext) => {
+    const result = await handleTopUpAmount(ctx, 20);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('top_up_50', async (ctx: BotContext) => {
+    const result = await handleTopUpAmount(ctx, 50);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('top_up_100', async (ctx: BotContext) => {
+    const result = await handleTopUpAmount(ctx, 100);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  // Add payment method handlers
+  bot.action('payment_paypal', async (ctx: BotContext) => {
+    const result = await handlePaymentMethodSelection(ctx, 'PAYPAL');
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('payment_crypto', async (ctx: BotContext) => {
+    const result = await handlePaymentMethodSelection(ctx, 'CRYPTO');
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('payment_admin', async (ctx: BotContext) => {
+    const result = await handlePaymentMethodSelection(ctx, 'ADMIN');
+    await ctx.editMessageText(result.message, result.options);
+  });
+}; 

src/bots/handlers/commandHandlers.ts

@@ -0,0 +1,150 @@
+import { getWelcomeMessage , getHelpMessage, getAboutMessage, getContactMessage} from "../utils/messageUtils";
+import { getMainMenuKeyboard, getLoggedInMenuKeyboard, getHistoryKeyboard } from "../utils/keyboardUtils";
+import { BotContext } from "../types/botTypes";
+import { AuthService } from '../services/auth';
+import { PurchaseTrackingService, PurchaseState } from '../services/PurchaseTrackingService';
+import { createLogger } from '../../utils/logger';
+import { messageReplyHandler } from "../utils/handlerUtils";
+import { handleLanguageSelection } from "./languageHandlers";
+import { messageManager } from "../utils/messageManager";
+// import { logger } from "../../utils/logger";
+
+const logger = createLogger('CommandHandlers');
+const authService = AuthService.getInstance();
+const purchaseTrackingService = PurchaseTrackingService.getInstance();
+
+export const setupCommandHandlers = (bot: any) => {
+  // /start command handler
+  bot.start(messageReplyHandler(handleStartCommand));
+  
+  // Other commands using the new messageReplyHandler
+  bot.command('help', messageReplyHandler(handleHelpCommand));
+  bot.command('about', messageReplyHandler(handleAboutCommand));
+  bot.command('contact', messageReplyHandler(handleContactCommand));
+  bot.command('balance', messageReplyHandler(handleBalanceCommand));
+  bot.command('history', messageReplyHandler(handleHistoryCommand));
+  
+  // Add language command handler
+  bot.command('change_language', messageReplyHandler(handleLanguageCommand));
+};
+
+const handleStartCommand = (ctx: BotContext) => {
+  const name = ctx.from?.first_name || "عزيزي المستخدم";
+  const telegramId = ctx.from?.id;
+  
+  if (telegramId && authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('start_welcome_back').replace('{name}', name),
+      options: getLoggedInMenuKeyboard()
+    };
+  } else {
+    return {
+      message: messageManager.getMessage('start_welcome_new').replace('{name}', name),
+      options: getMainMenuKeyboard()
+    };
+  }
+};
+
+const handleAboutCommand = (ctx: BotContext) => {
+  const botData = ctx.botData;
+  
+  return {
+    message: [
+      messageManager.getMessage('about_title'),
+      messageManager.getMessage('about_bot_name').replace('{bot_name}', botData?.name || 'بوت الأرقام الافتراضية'),
+      messageManager.getMessage('about_version').replace('{version}', botData?.version || '1.0.0'),
+      messageManager.getMessage('about_currency').replace('{currency}', botData?.currency || 'USD'),
+      '',
+      messageManager.getMessage('about_features'),
+      '',
+      messageManager.getMessage('about_copyright')
+    ].join('\n'),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+
+const handleHelpCommand = (ctx: BotContext) => {
+  return {
+    message: getHelpMessage(),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+const handleContactCommand = (ctx: BotContext) => {
+  return {
+    message: getContactMessage(),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+const handleBalanceCommand = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId) {
+    return {
+      message: messageManager.getMessage('error_user_not_found'),
+      options: {}
+    };
+  }
+  
+  const user = await authService.getUserByTelegramId(telegramId,ctx);
+  
+  if (!user) {
+    return {
+      message: messageManager.getMessage('balance_auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  return {
+    message: [
+      messageManager.getMessage('balance_title'),
+      '',
+      messageManager.getMessage('balance_current').replace('{balance}', (user.balance || 0).toString()),
+      messageManager.getMessage('balance_last_updated').replace('{update_time}', new Date().toLocaleString('ar-SA'))
+    ].join('\n'),
+    options: { 
+      ...getLoggedInMenuKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+const handleHistoryCommand = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId) {
+    return {
+      message: messageManager.getMessage('error_user_not_found'),
+      options: {}
+    };
+  }
+  
+  if (!authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('history_auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  return {
+    message: [
+      messageManager.getMessage('history_title'),
+      '',
+      messageManager.getMessage('history_description')
+    ].join('\n'),
+    options: {
+      ...getHistoryKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+
+const handleLanguageCommand = (ctx: BotContext) => {
+  return handleLanguageSelection(ctx);
+};
+
+
+

src/bots/handlers/giftHandlers.ts

@@ -0,0 +1,175 @@
+import { BotContext } from '../types/botTypes';
+import { Markup } from 'telegraf';
+import { authService } from '../services/auth';
+import { supabase } from '../../db/supabase';
+import { createLogger } from '../../utils/logger';
+import { messageManager } from '../utils/messageManager';
+import { getMainMenuKeyboard, getProfileKeyboard } from '../utils/keyboardUtils';
+const logger = createLogger('GiftHandlers');
+// Store gift states
+export const giftStates = new Map<number, { step: number; recipientEmail?: string; amount?: number }>();
+
+export const handleGiftBalanceAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  // Set initial gift state
+  giftStates.set(telegramId, { step: 1 });
+
+  return {
+    message: "🎁 <b>إرسال هدية</b>\n\n" +
+      "الرجاء إدخال البريد الإلكتروني للمستلم:",
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+export const handleGiftEmailInput = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !giftStates.get(telegramId)) {
+    return;
+  }
+
+  const message = ctx.message;
+  const email = (message && 'text' in message) ? message.text : undefined;
+  if (!email) return;
+
+  // Validate email
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return {
+      message: "❌ البريد الإلكتروني غير صالح. الرجاء إدخال بريد إلكتروني صحيح.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+
+  // Update state with recipient email
+  giftStates.set(telegramId, { step: 2, recipientEmail: email });
+
+  return {
+    message: "💰 <b>إدخال المبلغ</b>\n\n" +
+      "الرجاء إدخال المبلغ الذي تريد إرساله:",
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+export const handleGiftAmountInput = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !giftStates.get(telegramId)) {
+    return;
+  }
+
+  const message = ctx.message;
+  const amountText = (message && 'text' in message) ? message.text : undefined;
+  if (!amountText) return;
+
+  const amount = parseFloat(amountText);
+  if (isNaN(amount) || amount <= 0) {
+    return {
+      message: "❌ المبلغ غير صالح. الرجاء إدخال رقم صحيح أكبر من صفر.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+
+  const state = giftStates.get(telegramId);
+  if (!state?.recipientEmail) return;
+
+  try {
+    // Get sender's current balance
+    const sender = await authService.getUserByTelegramId(telegramId,ctx);
+    if (!sender || (sender.balance || 0) < amount) {
+      return {
+        message: "❌ رصيدك غير كافي لإتمام هذه العملية.",
+        options: {
+          ...getProfileKeyboard(),
+          parse_mode: 'HTML'
+        }
+      };
+    }
+
+    // Get recipient's information
+    const { data: recipient, error: recipientError } = await supabase
+      .from('users_bot_telegram')
+      .select('*')
+      .eq('email', state.recipientEmail)
+      .single();
+
+    if (recipientError || !recipient) {
+      return {
+        message: "❌ لم يتم العثور على المستخدم بهذا البريد الإلكتروني.",
+        options: {
+          ...getProfileKeyboard(),
+          parse_mode: 'HTML'
+        }
+      };
+    }
+
+    // Update balances
+    const { error: updateError } = await supabase
+      .from('users_bot_telegram')
+      .update({ 
+        balance: (sender.balance || 0) - amount 
+      })
+      .eq('telegram_id', telegramId);
+
+    if (updateError) throw updateError;
+
+    const { error: recipientUpdateError } = await supabase
+      .from('users_bot_telegram')
+      .update({ 
+        balance: (recipient.balance || 0) + amount 
+      })
+      .eq('id', recipient.id);
+
+    if (recipientUpdateError) throw recipientUpdateError;
+
+    // Clear gift state
+    giftStates.delete(telegramId);
+
+    // Notify recipient
+    if (recipient.telegram_id) {
+      await ctx.telegram.sendMessage(
+        recipient.telegram_id,
+        `🎁 <b>لقد تلقيت هدية!</b>\n\n` +
+        `تم إضافة ${amount}$ إلى رصيدك من ${sender.firstName}.`,
+        { parse_mode: 'HTML' }
+      );
+    }
+
+    return {
+      message: `✅ تم إرسال الهدية بنجاح!\n\nتم خصم ${amount}$ من رصيدك وإرسالها إلى ${state.recipientEmail}`,
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  } catch (error) {
+    logger.error(`Error processing gift: ${error}`);
+    return {
+      message: "❌ حدث خطأ أثناء معالجة الهدية. الرجاء المحاولة مرة أخرى.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+}; 

src/bots/handlers/historyHandlers.ts

@@ -0,0 +1,155 @@
+import { BotContext } from "../types/botTypes";
+import { AuthService } from '../services/auth';
+import { PurchaseTrackingService, PurchaseState } from '../services/PurchaseTrackingService';
+import { createLogger } from '../../utils/logger';
+import { callbackReplyHandler } from "../utils/handlerUtils";
+import { getAuthRequiredMessage } from "../utils/messageUtils";
+import { 
+  getLoggedInMenuKeyboard, 
+  getMainMenuKeyboard,
+  getHistoryKeyboard 
+} from "../utils/keyboardUtils";
+import { messageManager } from "../utils/messageManager";
+
+const logger = createLogger('HistoryHandlers');
+const authService = AuthService.getInstance();
+const purchaseTrackingService = PurchaseTrackingService.getInstance();
+
+export const setupHistoryHandlers = (bot: any) => {
+  // History handlers
+  bot.action('history', callbackReplyHandler(handleHistoryAction));
+  bot.action('numbers_history', callbackReplyHandler(handleNumbersHistoryAction));
+  bot.action('purchases_history', callbackReplyHandler(handlePurchasesHistoryAction));
+};
+export const handleHistoryAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  return {
+    message: messageManager.getMessage('history_title') + '\n\n' + 
+             messageManager.getMessage('history_description'),
+    options: getHistoryKeyboard()
+  };
+};
+
+export const handleNumbersHistoryAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  try {
+    const purchases = await purchaseTrackingService.getUserPurchasesByState(telegramId, PurchaseState.SUCCESS);
+    
+    if (!purchases || purchases.length === 0) {
+      return {
+        message: messageManager.getMessage('history_numbers_title') + '\n\n' + 
+                 messageManager.getMessage('history_numbers_empty'),
+        options: getLoggedInMenuKeyboard()
+      };
+    }
+    
+    let message = messageManager.getMessage('history_numbers_title') + '\n\n';
+    
+    purchases.slice(0, 10).forEach((purchase, index) => {
+      message += messageManager.getMessage('history_item_format')
+        .replace('{index}', (index + 1).toString())
+        .replace('{service}', purchase.service)
+        .replace('{state_emoji}', messageManager.getMessage('purchase_state_success'))
+        .replace('{phone_number}', purchase.phoneNumber || 'N/A')
+        .replace('{country}', purchase.countryId)
+        .replace('{operator}', purchase.operator)
+        .replace('{cost}', purchase.cost.toString())
+        .replace('{purchase_date}', new Date(purchase.createdAt || '').toLocaleString('ar-SA')) + '\n\n';
+    });
+    
+    if (purchases.length > 10) {
+      message += messageManager.getMessage('history_more_items')
+        .replace('{count}', (purchases.length - 10).toString())
+        .replace('{type}', 'أرقام') + '\n\n';
+    }
+    
+    return {
+      message: message,
+      options: {
+        parse_mode: 'HTML',
+        ...getHistoryKeyboard()
+      }
+    };
+    
+  } catch (error: any) {
+    logger.error(`Error fetching numbers history for user ${telegramId}: ${error.message}`);
+    return {
+      message: messageManager.getMessage('history_numbers_error'),
+      options: getLoggedInMenuKeyboard()
+    };
+  }
+};
+
+export const handlePurchasesHistoryAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  try {
+    const purchases = await purchaseTrackingService.getUserPurchases(telegramId);
+    
+    if (!purchases || purchases.length === 0) {
+      return {
+        message: messageManager.getMessage('history_purchases_title') + '\n\n' + 
+                 messageManager.getMessage('history_purchases_empty'),
+        options: getLoggedInMenuKeyboard()
+      };
+    }
+    
+    let message = messageManager.getMessage('history_purchases_title') + '\n\n';
+    
+    purchases.slice(0, 10).forEach((purchase, index) => {
+      const stateEmoji = messageManager.getMessage(`purchase_state_${purchase.state.toLowerCase()}`) || 
+                         messageManager.getMessage('purchase_state_unknown');
+      
+      message += messageManager.getMessage('history_item_format')
+        .replace('{index}', (index + 1).toString())
+        .replace('{service}', purchase.service)
+        .replace('{state_emoji}', stateEmoji)
+        .replace('{phone_number}', purchase.phoneNumber || 'N/A')
+        .replace('{country}', purchase.countryId)
+        .replace('{operator}', purchase.operator)
+        .replace('{cost}', purchase.cost.toString())
+        .replace('{purchase_date}', new Date(purchase.createdAt || '').toLocaleString('ar-SA')) + '\n\n';
+    });
+    
+    if (purchases.length > 10) {
+      message += messageManager.getMessage('history_more_items')
+        .replace('{count}', (purchases.length - 10).toString())
+        .replace('{type}', 'عمليات') + '\n\n';
+    }
+    
+    return {
+      message: message,
+      options: {
+        parse_mode: 'HTML',
+        ...getHistoryKeyboard()
+      }
+    };
+    
+  } catch (error: any) {
+    logger.error(`Error fetching purchases history for user ${telegramId}: ${error.message}`);
+    return {
+      message: messageManager.getMessage('history_purchases_error'),
+      options: getLoggedInMenuKeyboard()
+    };
+  }
+};

src/bots/handlers/index.ts

@@ -0,0 +1,45 @@
+import { setupMainMenuHandlers } from './mainMenuHandlers';
+import { setupServiceHandlers } from './serviceHandlers';
+import { setupPurchaseHandlers } from './purchaseHandlers';
+import { setupHistoryHandlers } from './historyHandlers';
+import { setupBalanceHandlers } from './balanceHandlers';
+import { setupLanguageHandlers } from './languageHandlers';
+import { setupProfileHandlers } from './profileHandlers';
+import { handleGiftAmountInput, handleGiftEmailInput, giftStates, handleGiftBalanceAction } from './giftHandlers';
+import { BotContext } from '../types/botTypes';
+import type { ParseMode } from 'telegraf/types';
+
+export const setupCallbackHandlers = (bot: any) => {
+  setupMainMenuHandlers(bot);
+  setupServiceHandlers(bot);
+  setupPurchaseHandlers(bot);
+  setupHistoryHandlers(bot);
+  setupBalanceHandlers(bot);
+  setupLanguageHandlers(bot);
+  setupProfileHandlers(bot);
+
+  bot.action('gift_balance', async (ctx: BotContext) => {
+    const result = await handleGiftBalanceAction(ctx);
+    await ctx.editMessageText(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+  });
+  
+  // Handle text messages for gift process
+  bot.on('text', async (ctx: BotContext) => {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) return;
+  
+    const giftState = giftStates.get(telegramId);
+    if (!giftState) return;
+  
+    let result;
+    if (giftState.step === 1) {
+      result = await handleGiftEmailInput(ctx);
+    } else if (giftState.step === 2) {
+      result = await handleGiftAmountInput(ctx);
+    }
+  
+    if (result) {
+      await ctx.reply(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+    }
+  });
+}; 

src/bots/handlers/languageHandlers.ts

@@ -0,0 +1,74 @@
+import { BotContext } from '../types/botTypes';
+import { Markup } from 'telegraf';
+import { getLanguageSelectionKeyboard, getMainMenuKeyboard, getLoggedInMenuKeyboard } from '../utils/keyboardUtils';
+import { authService } from '../services/auth';
+import { messageManager } from '../utils/messageManager';
+import { supabase } from '../../db/supabase';
+
+export const setupLanguageHandlers = (bot: any) => {
+  
+    
+    // Language selection handlers
+    bot.action('change_language', async (ctx) => {
+      const result = await handleLanguageSelection(ctx);
+      await ctx.editMessageText(result.message, result.options);
+    });
+  
+    bot.action('set_language_en', async (ctx) => {
+      const result = await handleLanguageChange(ctx, 'en');
+      await ctx.editMessageText(result.message, result.options);
+    });
+  
+    bot.action('set_language_ar', async (ctx) => {
+      const result = await handleLanguageChange(ctx, 'ar');
+      await ctx.editMessageText(result.message, result.options);
+    });
+  };
+
+export const handleLanguageSelection = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  const isLoggedIn =  authService.isUserLoggedIn(telegramId,ctx) ;
+
+  return {
+    message: "🌐 Choose your preferred language:\nاختر لغتك المفضلة:",
+    options: getLanguageSelectionKeyboard(isLoggedIn)
+  };
+};
+
+export const handleLanguageChange = async (ctx: BotContext, language: 'en' | 'ar') => {
+  const telegramId = ctx.from?.id;
+  const isLoggedIn = telegramId ? authService.isUserLoggedIn(telegramId,ctx) : false;
+
+  try {
+    // Update message manager language for current session
+    messageManager.setLanguage(language);
+
+    // If user is logged in, update their language preference in database
+    if (isLoggedIn && telegramId) {
+      const { error } = await supabase
+        .from('users_bot_telegram')
+        .update({ language })
+        .eq('telegram_id', telegramId);
+
+      if (error) throw error;
+    }
+
+    const successMessage = language === 'en' 
+      ? "✅ Language changed to English"
+      : "✅ تم تغيير اللغة إلى العربية";
+
+    return {
+      message: successMessage,
+      options: isLoggedIn ? getLoggedInMenuKeyboard() : getMainMenuKeyboard()
+    };
+  } catch (error: any) {
+    const errorMessage = language === 'en'
+      ? "❌ Failed to change language"
+      : "❌ فشل تغيير اللغة";
+    
+    return {
+      message: errorMessage,
+      options: isLoggedIn ? getLoggedInMenuKeyboard() : getMainMenuKeyboard()
+    };
+  }
+}; 

src/bots/handlers/mainMenuHandlers.ts

@@ -0,0 +1,139 @@
+import { BotContext } from "../types/botTypes";
+import { AuthService } from '../services/auth';
+import { createLogger } from '../../utils/logger';
+import { callbackReplyHandler } from "../utils/handlerUtils";
+import { 
+  getWelcomeMessage, 
+  getTermsMessage, 
+  getNewMembersMessage, 
+  getStatsMessage,
+  getAuthRequiredMessage
+} from "../utils/messageUtils";
+import { 
+  getBackToMainMenuButton, 
+  getLoggedInMenuKeyboard, 
+  getMainMenuKeyboard 
+} from "../utils/keyboardUtils";
+import { fetchDataFromTable } from '../../db/supabaseHelper';
+import { messageManager } from "../utils/messageManager";
+
+const logger = createLogger('MainMenuHandlers');
+const authService = AuthService.getInstance();
+
+export const setupMainMenuHandlers = (bot: any) => {
+  bot.action('login', callbackReplyHandler(handleLoginAction));
+  bot.action('terms', callbackReplyHandler(handleTermsAction));
+  bot.action('new_members', callbackReplyHandler(handleNewMembersAction));
+  bot.action('stats', callbackReplyHandler(handleStatsAction));
+  bot.action('main_menu', callbackReplyHandler(handleMainMenuAction));
+};
+export const handleLoginAction = async (ctx: BotContext) => {
+  try {
+    const telegramId = ctx.from?.id;
+    const firstName = ctx.from?.first_name || '';
+    
+    if (!telegramId) {
+      return {
+        message: messageManager.getMessage('login_error_user_info'),
+        options: getBackToMainMenuButton()
+      };
+    }
+    
+    if (authService.isUserLoggedIn(telegramId,ctx)) {
+      return {
+        message: messageManager.getMessage('login_already_logged_in'),
+        options: getLoggedInMenuKeyboard()
+      };
+    }
+    
+    const botToken = (ctx as any).telegram?.token;
+    if (!botToken) {
+      logger.error('Bot token not found in context');
+      return {
+        message: messageManager.getMessage('login_error_system'),
+        options: getBackToMainMenuButton()
+      };
+    }
+    
+    let user = await authService.loginUser(telegramId,ctx );
+    
+    if (user) {
+      logger.info(`User ${telegramId} logged in successfully`);
+      return {
+        message: messageManager.getMessage('login_success')
+          .replace('{firstName}', user.firstName)
+          .replace('{email}', user.email)
+          .replace('{balance}', user.balance?.toString() || '0'),
+        options: {
+          ...getLoggedInMenuKeyboard(),
+          parse_mode: 'HTML'
+        }
+      };
+    } else {
+      try {
+     
+        
+        const { user: newUser, password } = await authService.createUser(telegramId, firstName, ctx);
+        authService.setUserLoggedIn(telegramId,ctx, true);
+        
+
+        return {
+          message: messageManager.getMessage('account_created_success')
+            .replace('{firstName}', firstName)
+            .replace('{email}', newUser.email)
+            .replace('{password}', password),
+          options: getLoggedInMenuKeyboard()
+        };
+      } catch (error: any) {
+        logger.error(`Error creating new user: ${error.message}`);
+        return {
+          message: messageManager.getMessage('login_error_create_account'),
+          options: getBackToMainMenuButton()
+        };
+      }
+    }
+  } catch (error: any) {
+    logger.error(`Error in login action: ${error.message}`);
+    return {
+      message: messageManager.getMessage('login_error_general'),
+      options: getBackToMainMenuButton()
+    };
+  }
+};
+export const handleTermsAction = async (ctx: BotContext) => {
+  return {
+    message: getTermsMessage(),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+export const handleNewMembersAction = async (ctx: BotContext) => {
+  return {
+    message: getNewMembersMessage(),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+export const handleStatsAction = async (ctx: BotContext) => {
+  return {
+    message: getStatsMessage(),
+    options: { parse_mode: 'HTML' }
+  };
+};
+
+export const handleMainMenuAction = async (ctx: BotContext) => {
+  const name = ctx.from?.first_name || messageManager.getMessage('default_user_name');
+  const telegramId = ctx.from?.id;
+  
+  if (telegramId && authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: messageManager.getMessage('main_menu_welcome_back').replace('{name}', name),
+      options: getLoggedInMenuKeyboard()
+    };
+  } else {
+    return {
+      message: getWelcomeMessage(name),
+      options: getMainMenuKeyboard()
+    };
+  }
+};

src/bots/handlers/paymentWebhookHandlers.ts

@@ -0,0 +1,47 @@
+import { BotContext } from '../types/botTypes';
+import { PaymentVerificationService } from '../services/PaymentVerificationService';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('PaymentWebhookHandlers');
+const paymentVerificationService = PaymentVerificationService.getInstance();
+
+export const setupPaymentWebhookHandlers = (bot: any) => {
+  // Set bot instance in verification service
+  paymentVerificationService.setBot(bot);
+
+  // PayPal webhook handler
+  bot.on('webhook:paypal', async (ctx: BotContext) => {
+    try {
+      const { paymentId, status } = ctx.webhookData;
+      await paymentVerificationService.verifyAndUpdatePayment(paymentId, status);
+      return { success: true };
+    } catch (error) {
+      logger.error('PayPal webhook error:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Crypto payment verification handler
+  bot.on('webhook:crypto', async (ctx: BotContext) => {
+    try {
+      const { paymentId, status } = ctx.webhookData;
+      await paymentVerificationService.verifyAndUpdatePayment(paymentId, status);
+      return { success: true };
+    } catch (error) {
+      logger.error('Crypto webhook error:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Admin payment verification handler
+  bot.on('webhook:admin', async (ctx: BotContext) => {
+    try {
+      const { paymentId, status } = ctx.webhookData;
+      await paymentVerificationService.verifyAndUpdatePayment(paymentId, status);
+      return { success: true };
+    } catch (error) {
+      logger.error('Admin webhook error:', error);
+      return { success: false, error: error.message };
+    }
+  });
+}; 

src/bots/handlers/profileHandlers.ts

@@ -0,0 +1,320 @@
+import { BotContext } from "../types/botTypes";
+import { Markup } from "telegraf";
+import type { ParseMode } from "telegraf/types";
+import { getProfileKeyboard, getLoggedInMenuKeyboard, getMainMenuKeyboard } from "../utils/keyboardUtils";
+import { authService } from "../services/auth";
+import { supabase } from "../../db/supabase";
+import { createLogger } from "../../utils/logger";
+import { messageReplyHandler } from "../utils/handlerUtils";
+
+const logger = createLogger('ProfileHandlers');
+
+// State management for profile actions
+const profileStates = new Map<number, {
+  action: 'change_email' | 'change_password' | null;
+  step: number;
+}>();
+
+export const setupProfileHandlers = (bot: any) => {
+  // Profile menu handlers
+  bot.action('profile', async (ctx: BotContext) => {
+    const result = await handleProfileAction(ctx);
+    await ctx.editMessageText(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+  });
+
+  bot.action('account_info', async (ctx: BotContext) => {
+    const result = await handleAccountInfoAction(ctx);
+    await ctx.editMessageText(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+  });
+
+  bot.action('change_email', async (ctx: BotContext) => {
+    const result = await handleChangeEmailAction(ctx);
+    await ctx.editMessageText(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+  });
+
+  bot.action('change_password', async (ctx: BotContext) => {
+    const result = await handleChangePasswordAction(ctx);
+    await ctx.editMessageText(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+  });
+
+  // Message handlers for input processing
+  bot.on('text', async (ctx: BotContext) => {
+    const telegramId = ctx.from?.id;
+    if (!telegramId) return;
+
+    const userState = profileStates.get(telegramId);
+    if (!userState) return;
+
+    let result;
+    switch (userState.action) {
+      case 'change_email':
+        result = await handleEmailInput(ctx);
+        break;
+      case 'change_password':
+        result = await handlePasswordInput(ctx);
+        break;
+    }
+
+    if (result) {
+      await ctx.reply(result.message, { ...result.options, parse_mode: 'HTML' as ParseMode });
+    }
+  });
+};
+
+const handleProfileAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: "⚠️ الرجاء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId,ctx);
+  
+  if (!user) {
+    return {
+      message: "⚠️ حدث خطأ في تحديد المستخدم",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  return {
+    message: `👤 <b>الملف الشخصي</b>\n\n` +
+      `اختر الإجراء الذي تريد تنفيذه:`,
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+const handleAccountInfoAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: "⚠️ الرجاء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId,ctx);
+  
+  if (!user) {
+    return {
+      message: "⚠️ حدث خطأ في تحديد المستخدم",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  return {
+    message: `👤 <b>معلومات الحساب</b>\n\n` +
+      `الاسم: ${user.firstName}\n` +
+      `البريد الإلكتروني: ${user.email}\n` +
+      `الرصيد: ${user.balance || 0}$\n` +
+      `تاريخ التسجيل: ${new Date(user.createdAt).toLocaleDateString()}`,
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+const handleChangeEmailAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: "⚠️ الرجاء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  // Set user state for email change
+  profileStates.set(telegramId, { action: 'change_email', step: 1 });
+  logger.info(`Set profile state for ${telegramId}:`, profileStates.get(telegramId));
+
+  return {
+    message: "📧 <b>تغيير البريد الإلكتروني</b>\n\n" +
+      "الرجاء إدخال البريد الإلكتروني الجديد:\n" +
+      "يجب أن يكون البريد الإلكتروني صالحاً ويحتوي على @",
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+const handleChangePasswordAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    return {
+      message: "⚠️ الر��اء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  // Set user state for password change
+  profileStates.set(telegramId, { action: 'change_password', step: 1 });
+
+  return {
+    message: "🔑 <b>تغيير كلمة المرور</b>\n\n" +
+      "الرجاء إدخال كلمة المرور الجديدة:\n" +
+      "يجب أن تكون كلمة المرور 8 أحرف على الأقل وتحتوي على:\n" +
+      "- حرف كبير\n" +
+      "- حرف صغير\n" +
+      "- رقم\n" +
+      "- رمز خاص",
+    options: {
+      ...getProfileKeyboard(),
+      parse_mode: 'HTML'
+    }
+  };
+};
+
+// Input handlers
+export const handleEmailInput = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !profileStates.get(telegramId)) {
+    return;
+  }
+
+  // Use a type guard to check for text message
+  const message = ctx.message;
+  const email = (message && 'text' in message) ? message.text : undefined;
+  if (!email) return;
+
+  // Remove state
+  profileStates.delete(telegramId);
+
+  // Validate email
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return {
+      message: "❌ البريد الإلكتروني غير صالح. الرجاء إدخال بريد إلكتروني صحيح.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+
+  try {
+    // Check if email is already in use
+    const { data: existingUser, error: checkError } = await supabase
+      .from('users_bot_telegram')
+      .select('id')
+      .eq('email', email)
+      .single();
+
+    if (checkError) {
+      logger.error(`Error checking existing email: ${checkError}`);
+      throw checkError;
+    }
+
+    if (existingUser) {
+      return {
+        message: "❌ هذا البريد الإلكتروني مستخدم بالفعل. الرجاء استخدام بريد إلكتروني آخر.",
+        options: {
+          ...getProfileKeyboard(),
+          parse_mode: 'HTML'
+        }
+      };
+    }
+
+    // Update email in database
+    const { error: updateError } = await supabase
+      .from('users_bot_telegram')
+      .update({ email })
+      .eq('telegram_id', telegramId);
+
+    if (updateError) {
+      logger.error(`Error updating email: ${updateError}`);
+      throw updateError;
+    }
+
+    return {
+      message: "✅ تم تغيير البريد الإلكتروني بنجاح!",
+      options: {
+        ...getLoggedInMenuKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  } catch (error) {
+    logger.error(`Error updating email for user ${telegramId}: ${error}`);
+    return {
+      message: "❌ حدث خطأ أثناء تحديث البريد الإلكتروني. الرجاء المحاولة مرة أخرى.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+};
+
+export const handlePasswordInput = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !profileStates.get(telegramId)) {
+    return;
+  }
+
+  // Use a type guard to check for text message
+  const message = ctx.message;
+  const password = (message && 'text' in message) ? message.text : undefined;
+  if (!password) return;
+
+  // Remove state
+  profileStates.delete(telegramId);
+
+  // Validate password
+  const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+  if (!passwordRegex.test(password)) {
+    return {
+      message: "❌ كلمة المرور غير صالحة. الرجاء التأكد من أن كلمة المرور:\n" +
+        "- 8 أحرف على الأقل\n" +
+        "- تحتوي على حرف كبير\n" +
+        "- تحتوي على حرف صغير\n" +
+        "- تحتوي على رقم\n" +
+        "- تحتوي على رمز خاص",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+
+  try {
+    // Hash the new password
+    const passwordHash = await authService.hashPassword(password);
+
+    // Update password in database
+    const { error } = await supabase
+      .from('users_bot_telegram')
+      .update({ passwordHash })
+      .eq('telegram_id', telegramId);
+
+    if (error) throw error;
+
+    return {
+      message: "✅ تم تغيير كلمة المرور بنجاح!",
+      options: {
+        ...getLoggedInMenuKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  } catch (error) {
+    logger.error(`Error updating password for user ${telegramId}: ${error}`);
+    return {
+      message: "❌ حدث خطأ أثناء تحديث كلمة المرور. الرجاء المحاولة مرة أخرى.",
+      options: {
+        ...getProfileKeyboard(),
+        parse_mode: 'HTML'
+      }
+    };
+  }
+}; 

src/bots/handlers/purchaseHandlers.ts

@@ -0,0 +1,241 @@
+import { BotContext } from "../types/botTypes";
+import { AuthService } from '../services/auth';
+import { VirtualNumberService } from '../services/VirtualNumberService';
+import { PurchaseTrackingService, PurchaseState } from '../services/PurchaseTrackingService';
+import { createLogger } from '../../utils/logger';
+import { 
+  getAuthRequiredMessage,
+  getServiceUnavailableMessage,
+  getInsufficientBalanceMessage,
+  getPurchaseSuccessMessage,
+  getPurchaseFailedMessage,
+  getPurchaseErrorMessage,
+  getVerificationTimeoutMessage,
+  getProcessingPurchaseMessage
+} from "../utils/messageUtils";
+import { getLoggedInMenuKeyboard, getMainMenuKeyboard } from "../utils/keyboardUtils";
+import { messageManager } from "../utils/messageManager";
+import { calculatePriceWithProfit } from "../utils/priceUtils";
+
+const logger = createLogger('PurchaseHandlers');
+const authService = AuthService.getInstance();
+const virtualNumberService = VirtualNumberService.getInstance();
+const purchaseTrackingService = PurchaseTrackingService.getInstance();
+
+export const setupPurchaseHandlers = (bot: any) => {
+  // Register purchase handler
+  bot.action(/^buy_(.+)_(.+)_(.+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    
+    const match = ctx.match as RegExpMatchArray;
+    const service = match[1];
+    const countryId = match[2];
+    const operator = match[3];
+    
+    // First send the processing message
+    const loadingMsg = await ctx.reply(getProcessingPurchaseMessage(service, countryId));
+    
+    // Then execute the actual purchase logic
+    try {
+      await executePurchase(ctx, service, countryId, operator, loadingMsg.message_id);
+    } catch (error: any) {
+      logger.error(`Error in purchase execution: ${error.message}`);
+      await ctx.deleteMessage(loadingMsg.message_id);
+      await ctx.reply(getPurchaseErrorMessage(error.message), getLoggedInMenuKeyboard());
+    }
+  });
+};
+
+export const executePurchase = async (
+  ctx: BotContext, 
+  service: string, 
+  countryId: string, 
+  operator: string, 
+  loadingMsgId: number
+) => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId,ctx)) {
+    await ctx.deleteMessage(loadingMsgId);
+    await ctx.reply(getAuthRequiredMessage(), getMainMenuKeyboard());
+    return;
+  }
+  
+  let costWithProfit = 0;
+  try {
+    const prices = await virtualNumberService.getPrices(service, countryId);
+
+    // Add validation to check if the price exists for this operator
+    if (!prices || !prices[countryId] || !prices[countryId][service] || !prices[countryId][service][operator]) {
+      await ctx.deleteMessage(loadingMsgId);
+      await ctx.reply(
+        getServiceUnavailableMessage(service, operator, countryId),
+        getLoggedInMenuKeyboard()
+      );
+      return;
+    }
+
+    const cost = prices[countryId][service][operator].cost;
+    
+    // Apply profit to the cost
+    costWithProfit = calculatePriceWithProfit(ctx, cost, 'RUB');
+    
+    // 💰 Balance check
+    const user = await authService.getUserByTelegramId(telegramId,ctx);
+    if (!user || user.balance < costWithProfit) {
+      await ctx.deleteMessage(loadingMsgId);
+      await ctx.reply(
+        getInsufficientBalanceMessage(costWithProfit, user?.balance || 0),
+        getLoggedInMenuKeyboard()
+      );
+      return;
+    }
+    
+    // 🛒 Purchase number
+    const purchaseResult = await virtualNumberService.purchaseNumber(service, countryId, operator);
+    await ctx.deleteMessage(loadingMsgId);
+    
+    if (purchaseResult && purchaseResult.phone) {
+      // ➖ Deduct balance
+      await authService.updateUserBalance(telegramId,ctx, user.balance - costWithProfit);
+      
+      // 💾 Create purchase record in database with PENDING state
+      const purchaseRecord = await purchaseTrackingService.createPurchase({
+        userId: user.id,
+        telegramId: telegramId,
+        service: service,
+        countryId: countryId,
+        operator: operator,
+        phoneNumber: purchaseResult.phone,
+        orderId: purchaseResult.id,
+        cost: costWithProfit,
+        state: PurchaseState.PENDING
+      });
+      
+      // Send purchase confirmation
+      const confirmMsg = await ctx.reply(
+        getPurchaseSuccessMessage(purchaseResult, service, countryId, operator, costWithProfit),
+        getLoggedInMenuKeyboard()
+      );
+      
+      
+      // Start checking for verification code
+      const orderId = purchaseResult.id;
+      const maxAttempts = 30; // Check for up to 15 minutes (30 × 30s = 15min)
+      let attempts = 0;
+      
+      const checkInterval = setInterval(async () => {
+        try {
+          attempts++;
+          
+          // Check if we've reached max attempts
+          if (attempts >= maxAttempts) {
+            clearInterval(checkInterval);
+            
+            // Update purchase record to TIMEOUT state
+            await purchaseTrackingService.updatePurchaseState(
+              orderId, 
+              PurchaseState.TIMEOUT
+            );
+            
+            // Return the cost to user's balance on timeout
+            await authService.updateUserBalance(telegramId,ctx, user.balance + costWithProfit);
+            
+            await ctx.reply(
+              getVerificationTimeoutMessage(),
+              getLoggedInMenuKeyboard()
+            );
+            return;
+          }
+          
+          // Check for SMS
+          const smsResult = await virtualNumberService.checkSMS(orderId);
+          
+          // If SMS received
+          if (smsResult && smsResult.sms && smsResult.sms.length > 0) {
+            clearInterval(checkInterval);
+            
+            // Get the latest SMS
+            const latestSMS = smsResult.sms[smsResult.sms.length - 1];
+            
+            // Extract verification code (this is a simple pattern, might need adjustment)
+            let verificationCode = latestSMS.text;
+            
+            // Try to extract numeric code if it exists
+            const codeMatch = verificationCode.match(/\b\d{4,8}\b/);
+            if (codeMatch) {
+              verificationCode = `${codeMatch[0]} (${verificationCode})`;
+            }
+            
+            // Create verification message
+            const verificationMessage =  messageManager.getMessage('verification_received')
+            .replace('{phone}', purchaseResult.phone)
+            .replace('{code}', verificationCode)
+            .replace('{time}', new Date().toLocaleTimeString('ar-SA'));
+            
+            // Update purchase record to SUCCESS state
+            await purchaseTrackingService.updatePurchaseState(
+              orderId, 
+              PurchaseState.SUCCESS, 
+              {
+                verificationCode: verificationCode,
+                verificationMessage: verificationMessage
+              }
+            );
+            
+            await ctx.reply(
+              verificationMessage,
+              getLoggedInMenuKeyboard()
+            );
+          }
+        } catch (error: any) {
+          logger.error(`Error checking SMS for order ${orderId}: ${error.message}`);
+          // Don't stop checking on error, just log it
+        }
+      }, 30000); // Check every 30 seconds
+      
+    } else {
+      // Create purchase record with FAILED state
+      if (user) {
+        await purchaseTrackingService.createPurchase({
+          userId: user.id,
+          telegramId: telegramId,
+          service: service,
+          countryId: countryId,
+          operator: operator,
+          cost: costWithProfit,
+          state: PurchaseState.FAILED
+        });
+      }
+      
+      await ctx.reply(getPurchaseFailedMessage(), getLoggedInMenuKeyboard());
+    }
+    
+  } catch (error: any) {
+    logger.error(`Error purchasing number for ${service} in ${countryId}: ${error.message}`);
+    
+    // Create purchase record with FAILED state if we have user info
+    // try {
+    //   const user = await authService.getUserByTelegramId(telegramId!,ctx);
+    //   if (user) {
+    //     // Return the cost to user's balance on error
+    //     await authService.updateUserBalance(telegramId!,ctx, user.balance + costWithProfit);
+        
+    //     await purchaseTrackingService.createPurchase({
+    //       userId: user.id,
+    //       telegramId: telegramId!,
+    //       service: service,
+    //       countryId: countryId,
+    //       operator: operator,
+    //       cost: costWithProfit,
+    //       state: PurchaseState.FAILED
+    //     });
+    //   }
+    // } catch (dbError) {
+    //   logger.error(`Error creating failed purchase record: ${dbError}`);
+    // }
+    
+    await ctx.deleteMessage(loadingMsgId);
+    await ctx.reply(getPurchaseErrorMessage(error.message), getLoggedInMenuKeyboard());
+  }
+}; 

src/bots/handlers/serviceHandlers.ts

@@ -0,0 +1,878 @@
+import { BotContext } from "../types/botTypes";
+import { AuthService } from '../services/auth';
+import { VirtualNumberService } from '../services/VirtualNumberService';
+import { createLogger } from '../../utils/logger';
+import { callbackReplyHandler } from "../utils/handlerUtils";
+import { 
+  getAuthRequiredMessage, 
+  getCountriesListMessage, 
+  getServiceErrorMessage,
+  getNoPricesMessage,
+  getPricesListMessage,
+  getPricesErrorMessage,
+  getSearchProductPromptMessage,
+  getNoSearchResultsMessage,
+  getInvalidSearchInputMessage,
+  getSearchCountryPromptMessage,
+  getNoCountrySearchResultsMessage,
+  getNoAffordableProductsMessage,
+  getAffordableProductsMessage
+} from "../utils/messageUtils";
+import { 
+  getLoggedInMenuKeyboard, 
+  getMainMenuKeyboard,
+  getCountriesKeyboard,
+  getServicePricesKeyboard,
+  getServicesKeyboard,
+  getServicesPaginationInfo
+} from "../utils/keyboardUtils";
+import { calculatePriceWithProfit, formatPrice } from "../utils/priceUtils";
+import fiveSimProducts from "../utils/5sim_products.json";
+import { countryData } from "../utils/country";
+import { Markup } from 'telegraf';
+import { Message } from 'telegraf/typings/core/types/typegram';
+
+const logger = createLogger('ServiceHandlers');
+const authService = AuthService.getInstance();
+const virtualNumberService = VirtualNumberService.getInstance();
+
+// Temporary in-memory state to track if a user is searching for a product
+interface UserSearchState {
+  waitingForProductSearch?: boolean;
+  waitingForCountrySearch?: { // If searching for a country
+    serviceId: string;
+    sortBy?: 'price_asc'; // Preserve sorting preference
+    page: number; // Preserve current page
+  };
+}
+const userSearchStates = new Map<number, UserSearchState>();
+
+export const setupServiceHandlers = (bot: any) => {
+  // Add handler for browse services button
+  bot.action('browse_services', async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    await handleBrowseServices(ctx, undefined); // Pass undefined for initial sortBy
+  });
+
+  // Add handler for services pagination
+  bot.action(/^services_page_(\d+)(_([a-zA-Z]+))?$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const page = parseInt(match[1], 10);
+    const sortBy = match[3] as 'az' | 'za' | undefined;
+    await handleServicesPagination(ctx, page, sortBy);
+  });
+
+  // Add handler for sorting services by A-Z
+  bot.action(/^sort_services_az_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const page = parseInt(match[1], 10);
+    await handleServicesPagination(ctx, page, 'az');
+  });
+
+  // Add handler for sorting services by Z-A
+  bot.action(/^sort_services_za_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const page = parseInt(match[1], 10);
+    await handleServicesPagination(ctx, page, 'za');
+  });
+
+  // Add handler for sorting countries by price
+  bot.action(/^sort_countries_price_asc_(.+)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const service = match[1];
+    const page = parseInt(match[2], 10);
+    await handleServiceSelection(ctx, service, 'price_asc', page);
+  });
+
+  // Add handler for country pagination
+  bot.action(/^country_page_(.+)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const service = match[1];
+    const page = parseInt(match[2], 10);
+    await handleServiceSelection(ctx, service, undefined, page);
+  });
+
+  // Add handler for search product button
+  bot.action('search_product', async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+      try {
+        await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+      } catch (editError: any) {
+        if (editError.message && editError.message.includes('message is not modified')) {
+          logger.info(`Auth required message not modified (search_product). No action needed.`);
+        } else {
+          logger.error(`Error editing auth required message (search_product): ${editError.message}`);
+        }
+      }
+      return;
+    }
+
+    userSearchStates.set(telegramId, { waitingForProductSearch: true });
+    try {
+      await ctx.editMessageText(getSearchProductPromptMessage(), {
+        reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', 'cancel_search')]).reply_markup
+      });
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Search product prompt not modified. No action needed.`);
+      } else {
+        logger.error(`Error editing search product prompt: ${editError.message}`);
+      }
+    }
+  });
+
+  // Add handler for search country button
+  bot.action(/^search_country_(.+)_([a-zA-Z0-9]+|default)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+      try {
+        await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+      } catch (editError: any) {
+        if (editError.message && editError.message.includes('message is not modified')) {
+          logger.info(`Auth required message not modified (search_country). No action needed.`);
+        } else {
+          logger.error(`Error editing auth required message (search_country): ${editError.message}`);
+        }
+      }
+      return;
+    }
+
+    const match = ctx.match as RegExpMatchArray;
+    const serviceId = match[1];
+    const sortBy = match[2] === 'default' ? undefined : match[2] as 'price_asc';
+    const page = parseInt(match[3], 10);
+
+    userSearchStates.set(telegramId, { waitingForCountrySearch: { serviceId, sortBy, page } });
+    try {
+      await ctx.editMessageText(getSearchCountryPromptMessage(), {
+        reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]).reply_markup
+      });
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Search country prompt not modified. No action needed.`);
+      } else {
+        logger.error(`Error editing search country prompt: ${editError.message}`);
+      }
+    }
+  });
+
+  // Add handler for canceling search
+  bot.action('cancel_search', async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (telegramId) {
+      userSearchStates.delete(telegramId);
+    }
+    try {
+      await handleBrowseServices(ctx, undefined); // Pass undefined to reset sort
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Browse services message not modified (cancel_search). No action needed.`);
+      } else {
+        logger.error(`Error editing browse services message (cancel_search): ${editError.message}`);
+      }
+    }
+  });
+
+  // Add handler for canceling country search
+  bot.action(/^cancel_country_search_(.+)_([a-zA-Z0-9]+|default)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (telegramId) {
+      userSearchStates.delete(telegramId);
+    }
+    const match = ctx.match as RegExpMatchArray;
+    const serviceId = match[1];
+    const sortBy = match[2] === 'default' ? undefined : match[2] as 'price_asc';
+    const page = parseInt(match[3], 10);
+    try {
+      await handleServiceSelection(ctx, serviceId, sortBy, page);
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Service selection message not modified (cancel_country_search). No action needed.`);
+      } else {
+        logger.error(`Error editing service selection message (cancel_country_search): ${editError.message}`);
+      }
+    }
+  });
+
+  // Add handler for 'buy_with_balance' button
+  bot.action('buy_with_balance', async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const telegramId = ctx.from?.id;
+    if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+      try {
+        await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+      } catch (editError: any) {
+        if (editError.message && editError.message.includes('message is not modified')) {
+          logger.info(`Auth required message not modified (buy_with_balance). No action needed.`);
+        } else {
+          logger.error(`Error editing auth required message (buy_with_balance): ${editError.message}`);
+        }
+      }
+      return;
+    }
+
+    try {
+      const user = await authService.getUserByTelegramId(telegramId, ctx);
+      if (!user) {
+        try {
+          await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+        } catch (editError: any) {
+          if (editError.message && editError.message.includes('message is not modified')) {
+            logger.info(`Auth required message not modified (buy_with_balance - user not found). No action needed.`);
+          } else {
+            logger.error(`Error editing auth required message (buy_with_balance - user not found): ${editError.message}`);
+          }
+        }
+        return;
+      }
+
+      const userBalance = user.balance;
+      const maxPrices = await virtualNumberService.getMaxPrices();
+
+      const affordableProducts = maxPrices.filter(product => {
+        // Convert product price to bot's currency (USD, assuming max-prices are in USD)
+        // And then apply profit calculation
+        const productPriceInBotCurrency = product.price;
+        const finalPrice = calculatePriceWithProfit(ctx, productPriceInBotCurrency, 'USD');
+        return userBalance >= finalPrice;
+      }).sort((a, b) => a.product.localeCompare(b.product)); // Sort alphabetically
+
+      if (affordableProducts.length === 0) {
+        try {
+          await ctx.editMessageText(getNoAffordableProductsMessage(userBalance, ctx), {
+            parse_mode: 'HTML',
+            reply_markup: getLoggedInMenuKeyboard().reply_markup
+          });
+        } catch (editError: any) {
+          if (editError.message && editError.message.includes('message is not modified')) {
+            logger.info(`No affordable products message not modified. No action needed.`);
+          } else {
+            logger.error(`Error editing no affordable products message: ${editError.message}`);
+          }
+        }
+        return;
+      }
+
+      const buttons = [];
+      const rowSize = 2;
+
+      for (let i = 0; i < affordableProducts.length; i += rowSize) {
+        const row = [];
+        for (let j = 0; j < rowSize && i + j < affordableProducts.length; j++) {
+          const product = affordableProducts[i + j];
+          const serviceData = fiveSimProducts[product.product];
+          if (serviceData) {
+            // Apply profit to the price for display
+            const displayPrice = calculatePriceWithProfit(ctx, product.price, 'USD');
+            row.push(
+              Markup.button.callback(
+                `${serviceData.icon} ${serviceData.label_en} (${formatPrice(ctx, displayPrice)})`,
+                `service_${product.product}`
+              )
+            );
+          } else {
+            logger.warn(`Service data not found for product: ${product.product}`);
+          }
+        }
+        if (row.length > 0) {
+          buttons.push(row);
+        }
+      }
+
+      buttons.push([Markup.button.callback('🔙 Back to Menu', 'logged_in_menu')]);
+
+      try {
+        await ctx.editMessageText(getAffordableProductsMessage(userBalance, ctx), {
+          parse_mode: 'HTML',
+          reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+        });
+      } catch (editError: any) {
+        if (editError.message && editError.message.includes('message is not modified')) {
+          logger.info(`Affordable products message not modified. No action needed.`);
+        } else {
+          logger.error(`Error editing affordable products message: ${editError.message}`);
+        }
+      }
+
+    } catch (error: any) {
+      logger.error(`Error handling buy_with_balance: ${error.message}`);
+      try {
+        await ctx.editMessageText('⚠️ An error occurred while fetching affordable products. Please try again later.', {
+          reply_markup: getLoggedInMenuKeyboard().reply_markup
+        });
+      } catch (editError: any) {
+        if (editError.message && editError.message.includes('message is not modified')) {
+          logger.info(`Error message for affordable products not modified. No action needed.`);
+        } else {
+          logger.error(`Error editing error message for affordable products: ${editError.message}`);
+        }
+      }
+    }
+  });
+
+  // Text handler for product/country search input
+  bot.on('text', async (ctx: BotContext) => {
+    try {
+      const telegramId = ctx.from?.id;
+      const userState = userSearchStates.get(telegramId);
+
+      if (!telegramId || (!userState?.waitingForProductSearch && !userState?.waitingForCountrySearch)) {
+        return; // Not in search state, let other text handlers process or ignore
+      }
+
+      // Ensure ctx.message is a text message. Telegraf's `bot.on('text')` guarantees this, but TypeScript needs explicit narrowing.
+      const message = ctx.message as Message.TextMessage; 
+
+      // Now 'text' property is safely accessible
+      const query = message.text?.toLowerCase().trim();
+
+      if (!query || query.length < 2) { // Require at least 2 characters for search
+        try {
+          await ctx.reply(getInvalidSearchInputMessage(), {
+            reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', userState.waitingForProductSearch ? 'cancel_search' : `cancel_country_search_${userState.waitingForCountrySearch?.serviceId}_${userState.waitingForCountrySearch?.sortBy || 'default'}_${userState.waitingForCountrySearch?.page}`)]).reply_markup
+          });
+        } catch (replyError: any) {
+          logger.error(`Error replying with invalid search input message: ${replyError.message}`);
+        }
+        return;
+      }
+
+      userSearchStates.delete(telegramId); // Clear search state after processing
+
+      if (userState.waitingForProductSearch) {
+        // Filter products based on search query
+        const searchResults = Object.entries(fiveSimProducts).filter(([serviceId, serviceData]) => {
+          return serviceId.toLowerCase().includes(query) || serviceData.label_en.toLowerCase().includes(query);
+        });
+
+        if (searchResults.length === 0) {
+          try {
+            await ctx.reply(getNoSearchResultsMessage(), {
+              reply_markup: Markup.inlineKeyboard([Markup.button.callback('🔙 Back to Services', 'browse_services')]).reply_markup
+            });
+          } catch (replyError: any) {
+            logger.error(`Error replying with no search results message: ${replyError.message}`);
+          }
+          return;
+        }
+
+        const buttons = [];
+        const rowSize = 2; // 2 buttons per row
+        const servicesPerPage = 20; 
+
+        const currentPage = 0; // Always start search results on the first page
+
+        const startIndex = currentPage * servicesPerPage;
+        const endIndex = Math.min(startIndex + servicesPerPage, searchResults.length);
+        const pageServices = searchResults.slice(startIndex, endIndex);
+
+        // Generate service buttons in pairs
+        for (let i = 0; i < pageServices.length; i += rowSize) {
+          const row = [];
+          for (let j = 0; j < rowSize && i + j < pageServices.length; j++) {
+            const [serviceId, serviceData] = pageServices[i + j];
+            row.push(
+              Markup.button.callback(
+                `${serviceData.icon} ${serviceData.label_en}`,
+                `service_${serviceId}`
+              )
+            );
+          }
+          buttons.push(row);
+        }
+
+        buttons.push([Markup.button.callback('🔙 Back to Services', 'browse_services')]);
+
+        try {
+          await ctx.reply(getServicesPaginationInfo(currentPage), {
+            parse_mode: 'HTML',
+            reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+          });
+        } catch (replyError: any) {
+          logger.error(`Error replying with product search results: ${replyError.message}`);
+        }
+
+      } else if (userState.waitingForCountrySearch) {
+        const { serviceId, sortBy, page } = userState.waitingForCountrySearch;
+        const allCountries = Object.entries(countryData); // Use all countries for search
+
+        const queryResults = allCountries.filter(([countryShortId, countryInfo]) => {
+          const searchTarget = `${countryInfo.label.toLowerCase()} ${countryInfo.flag.toLowerCase()} ${countryInfo.code.toLowerCase()} ${countryShortId.toLowerCase()}`;
+          return searchTarget.includes(query);
+        });
+
+        // Get prices for the selected service to filter countries by availability and get min/max prices
+        let productPricesForService: any = {};
+        try {
+          const fullProductPrices = await virtualNumberService.getProductPrices(serviceId);
+          if (fullProductPrices && fullProductPrices[serviceId]) {
+            productPricesForService = fullProductPrices[serviceId];
+          }
+        } catch (error: any) {
+          logger.error(`Error fetching prices for service ${serviceId} during country search: ${error.message}`);
+          try {
+            await ctx.reply(getServiceErrorMessage(serviceId), {
+              parse_mode: 'HTML',
+              reply_markup: Markup.inlineKeyboard([Markup.button.callback('🔙 Back to Services', 'browse_services')]).reply_markup
+            });
+          } catch (replyError: any) {
+            logger.error(`Error replying with service error message during country search: ${replyError.message}`);
+          }
+          return;
+        }
+
+        const searchResults = queryResults.filter(([countryShortId, _]) => {
+          const countryOperators = productPricesForService[countryShortId];
+          // Only include countries that have available numbers for the current service
+          return countryOperators && Object.values(countryOperators).some((op: any) => op.count > 0);
+        }).map(([countryId, countryInfo]) => {
+          const operators = productPricesForService[countryId];
+          const prices = Object.values(operators)
+            .filter((op: any) => op.count > 0)
+            .map((op: any) => calculatePriceWithProfit(ctx, op.cost, 'RUB'));
+          
+          const minPrice = prices.length > 0 ? parseFloat(Math.min(...prices).toFixed(2)) : 0;
+          const maxPrice = prices.length > 0 ? parseFloat(Math.max(...prices).toFixed(2)) : 0;
+          
+          return { countryId, countryInfo, minPrice, maxPrice };
+        });
+
+        if (searchResults.length === 0) {
+          try {
+            await ctx.reply(getNoCountrySearchResultsMessage(), {
+              reply_markup: Markup.inlineKeyboard([Markup.button.callback('↩️ Cancel Search', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]).reply_markup
+            });
+          } catch (replyError: any) {
+            logger.error(`Error replying with no country search results message: ${replyError.message}`);
+          }
+          return;
+        }
+
+        const buttons = [];
+        const rowSize = 2;
+        const countriesPerPage = 10; 
+
+        const currentPage = 0; 
+
+        const startIndex = currentPage * countriesPerPage;
+        const endIndex = Math.min(startIndex + countriesPerPage, searchResults.length);
+        const pageCountries = searchResults.slice(startIndex, endIndex);
+
+        for (let i = 0; i < pageCountries.length; i += rowSize) {
+          const row = [];
+          for (let j = 0; j < rowSize && i + j < pageCountries.length; j++) {
+            const { countryId, countryInfo, minPrice, maxPrice } = pageCountries[i + j];
+            
+            const priceText = minPrice === maxPrice 
+              ? `${minPrice}$`
+              : `${minPrice}$-${maxPrice}$`;
+
+            row.push(
+              Markup.button.callback(
+                `${countryInfo.flag} ${countryInfo.label} (${priceText})`,
+                `country_${serviceId}_${countryId}`
+              )
+            );
+          }
+          buttons.push(row);
+        }
+
+        buttons.push([Markup.button.callback('↩️ Back to Countries', `cancel_country_search_${serviceId}_${sortBy || 'default'}_${page}`)]);
+
+        try {
+          await ctx.reply(getCountriesListMessage(serviceId), {
+            parse_mode: 'HTML',
+            reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+          });
+        } catch (replyError: any) {
+          logger.error(`Error replying with country search results: ${replyError.message}`);
+        }
+      }
+    } catch (handlerError: any) {
+      logger.error(`Unhandled error in text handler: ${handlerError.message}`);
+      try {
+        await ctx.reply('⚠️ An unexpected error occurred. Please try again or go back to the main menu.', {
+          reply_markup: getLoggedInMenuKeyboard().reply_markup
+        });
+      } catch (finalReplyError: any) {
+        logger.error(`Error sending final error message: ${finalReplyError.message}`);
+      }
+    }
+  });
+
+  // Register service selection handlers
+  bot.action(/^service_(.+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    const match = ctx.match as RegExpMatchArray;
+    const service = match[1];
+    await handleServiceSelection(ctx, service);
+  });
+
+  // Register country selection handler
+  bot.action(/^country_(.+)_(.+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    await handleCountrySelection(ctx);
+  });
+};
+
+export const handleBrowseServices = async (ctx: BotContext, sortBy?: 'az' | 'za') => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+    try {
+      await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Auth required message not modified. No action needed.`);
+      } else {
+        logger.error(`Error editing auth required message: ${editError.message}`);
+      }
+    }
+    return; 
+  }
+
+  try {
+    await ctx.editMessageText(
+      getServicesPaginationInfo(0),
+      {
+        parse_mode: 'HTML',
+        reply_markup: getServicesKeyboard(0, sortBy).reply_markup
+      }
+    );
+  } catch (editError: any) {
+    if (editError.message && editError.message.includes('message is not modified')) {
+      logger.info(`Services menu message not modified. No action needed.`);
+    } else {
+      logger.error(`Error editing services menu message: ${editError.message}`);
+    }
+  }
+};
+
+export const handleServicesPagination = async (ctx: BotContext, page: number, sortBy?: 'az' | 'za') => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+    try {
+      await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Auth required message not modified. No action needed.`);
+      } else {
+        logger.error(`Error editing auth required message: ${editError.message}`);
+      }
+    }
+    return; // Explicitly return nothing after editing
+  }
+
+  try {
+    // Edit the existing message instead of sending a new one
+    try {
+      await ctx.editMessageText(
+        getServicesPaginationInfo(page),
+        {
+          parse_mode: 'HTML',
+          reply_markup: getServicesKeyboard(page, sortBy).reply_markup // Pass sortBy here
+        }
+      );
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Services page message not modified for page ${page}. No action needed.`);
+      } else {
+        throw editError; // Re-throw other errors to be caught by the outer catch
+      }
+    }
+  } catch (error: any) {
+    logger.error(`Error updating services page ${page}: ${error.message}`);
+    try {
+      await ctx.editMessageText(
+        '⚠️ Error updating services list. Please try again.',
+        {
+          parse_mode: 'HTML',
+          reply_markup: getLoggedInMenuKeyboard().reply_markup
+        }
+      );
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Services page message not modified for page ${page}. No action needed.`);
+      } else {
+        logger.error(`Error editing message in services pagination error handler for page ${page}: ${editError.message}`);
+      }
+    }
+  }
+};
+
+export const handleServiceSelection = async (ctx: BotContext, service: string, sortBy?: 'price_asc', page: number = 0) => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+    try {
+      await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Auth required message not modified (handleServiceSelection). No action needed.`);
+      } else {
+        logger.error(`Error editing auth required message (handleServiceSelection): ${editError.message}`);
+      }
+    }
+    return; // Explicitly return nothing after editing
+  }
+  
+  try {
+    // Get all prices for the selected service
+    const productPrices = await virtualNumberService.getProductPrices(service);
+    const servicePrices = productPrices[service];
+
+    if (!servicePrices) {
+      try {
+        await ctx.editMessageText(
+          getServiceErrorMessage(service),
+          {
+            parse_mode: 'HTML',
+            reply_markup: Markup.inlineKeyboard([
+              [Markup.button.callback('🔙 Back to Services', 'browse_services')],
+            ]).reply_markup
+          }
+        );
+      } catch (editError: any) {
+        if (editError.response && editError.response.error_code === 400 && editError.response.description.includes('message is not modified')) {
+          logger.info(`Error message already displayed for service ${service}. No action needed.`);
+        } else {
+          logger.error(`Error editing message when service prices not found for service ${service}: ${editError.message}`);
+        }
+      }
+      return; // Return after attempting to edit the message
+    }
+
+    // Create buttons for countries with available numbers
+    const buttons = [];
+    const rowSize = 2; // 2 buttons per row
+    const countriesPerPage = 20; // 10 countries per page
+    let countries = Object.entries(servicePrices)
+      .filter(([_, operators]) => {
+        // Check if any operator has available numbers
+        return Object.values(operators).some(op => op.count > 0);
+      })
+      .map(([countryId, operators]) => {
+        // Get all prices with profit applied
+        const prices = Object.values(operators)
+          .filter(op => op.count > 0)
+          .map(op => calculatePriceWithProfit(ctx, op.cost, 'RUB'));
+        
+        // Calculate min and max prices
+        const minPrice = Math.min(...prices);
+        const maxPrice = Math.max(...prices);
+        
+        // Round prices to 2 decimal places
+        const roundedMinPrice = parseFloat(minPrice.toFixed(2));
+        const roundedMaxPrice = parseFloat(maxPrice.toFixed(2));
+
+        return { countryId, minPrice: roundedMinPrice, maxPrice: roundedMaxPrice };
+      });
+
+    // Apply sorting based on sortBy parameter
+    if (sortBy === 'price_asc') {
+      countries.sort((a, b) => a.minPrice - b.minPrice);
+    } else {
+      // Default sort by countryId
+      countries.sort((a, b) => a.countryId.localeCompare(b.countryId));
+    }
+
+    const totalPages = Math.ceil(countries.length / countriesPerPage);
+  
+    // Get countries for current page
+    const startIndex = page * countriesPerPage;
+    const endIndex = Math.min(startIndex + countriesPerPage, countries.length);
+    const pageCountries = countries.slice(startIndex, endIndex);
+
+    // Add sort button
+    buttons.push([Markup.button.callback('Price ⬇️ (Cheapest)', `sort_countries_price_asc_${service}_${page}`)]);
+
+    // Add search country button
+    buttons.push([Markup.button.callback('🔍 Search Country', `search_country_${service}_${sortBy || 'default'}_${page}`)]);
+
+    // Generate country buttons in pairs
+    for (let i = 0; i < pageCountries.length; i += rowSize) {
+      const row = [];
+      for (let j = 0; j < rowSize && i + j < pageCountries.length; j++) {
+        const { countryId, minPrice, maxPrice } = pageCountries[i + j];
+        const countryInfo = countryData[countryId.toLowerCase()];
+        if (countryInfo) {
+          const priceText = minPrice === maxPrice 
+            ? `${minPrice}$`
+            : `${minPrice}$-${maxPrice}$`;
+            
+          row.push(
+            Markup.button.callback(
+              `${countryInfo.flag} ${countryInfo.label} (${priceText})`,
+              `country_${service}_${countryId}`
+            )
+          );
+        }
+      }
+      if (row.length > 0) {
+        buttons.push(row);
+      }
+    }
+
+    // Add pagination buttons
+    const paginationRow = [];
+    if (page > 0) {
+      paginationRow.push(
+        Markup.button.callback(
+          '⬅️ Previous',
+          `country_page_${service}_${page - 1}`
+        )
+      );
+    }
+    
+    paginationRow.push(
+      Markup.button.callback(
+        `📄 ${page + 1}/${totalPages}`,
+        'noop'
+      )
+    );
+    
+    if (page < totalPages - 1) {
+      paginationRow.push(
+        Markup.button.callback(
+          'Next ➡️',
+          `country_page_${service}_${page + 1}`
+        )
+      );
+    }
+    
+    if (paginationRow.length > 0) {
+      buttons.push(paginationRow);
+    }
+
+    // Add back button
+    buttons.push([
+      Markup.button.callback('🔙 Back to Services', 'browse_services')
+    ]);
+
+    // Edit the existing message instead of sending a new one
+    try {
+      await ctx.editMessageText(
+        getCountriesListMessage(service),
+        {
+          parse_mode: 'HTML',
+          reply_markup: Markup.inlineKeyboard(buttons).reply_markup
+        }
+      );
+      return; // Explicitly return after successful edit
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Message not modified for service ${service} on page ${page}. No action needed.`);
+      } else {
+        logger.error(`Error editing message for service ${service} on page ${page}: ${editError.message}`);
+      }
+      return; // Explicitly return after handling edit error
+    }
+  } catch (error: any) {
+    logger.error(`Error fetching countries for ${service}: ${error.message}`);
+    try {
+      await ctx.editMessageText(
+        getServiceErrorMessage(service),
+        {
+          parse_mode: 'HTML',
+          reply_markup: Markup.inlineKeyboard([
+            [Markup.button.callback('🔙 Back to Services', 'browse_services')],
+          ]).reply_markup
+        }
+      );
+      return; // Explicitly return after displaying service error message
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Error message already displayed for service ${service}. No action needed.`);
+      } else {
+        logger.error(`Error editing message in error handler for service ${service}: ${editError.message}`);
+      }
+      return; // Explicitly return after handling error message edit error
+    }
+  }
+};
+
+export const handleCountrySelection = async (ctx: BotContext) => {
+  const match = ctx.match as RegExpMatchArray;
+  const service = match[1];
+  const countryId = match[2];
+  
+  // Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+    await ctx.editMessageText(getAuthRequiredMessage(), { reply_markup: getMainMenuKeyboard().reply_markup });
+    return;
+  }
+  
+  try {
+    const prices = await virtualNumberService.getPrices(service, countryId);
+
+    if (!prices || !prices[countryId] || !prices[countryId][service] || 
+        Object.keys(prices[countryId][service]).length === 0) {
+      await ctx.editMessageText(
+        getNoPricesMessage(service, countryId),
+        {
+          parse_mode: 'HTML',
+          reply_markup: getLoggedInMenuKeyboard().reply_markup
+        }
+      );
+      return;
+    }
+    
+    // Apply profit to prices before displaying
+    const pricesWithProfit = Object.entries(prices[countryId][service]).reduce((acc: any, [operator, operatorData]) => {
+      // operatorData contains cost and count properties
+      if (operatorData && typeof operatorData === 'object' && 'cost' in operatorData) {
+        acc[operator] = {
+          ...operatorData,
+          cost: calculatePriceWithProfit(ctx, Number(operatorData.cost), 'RUB')
+        };
+      }
+      return acc;
+    }, {});
+  
+    try {
+      await ctx.editMessageText(
+        getPricesListMessage(service, countryId, pricesWithProfit, ctx),
+        {
+          parse_mode: 'HTML',
+          reply_markup: getServicePricesKeyboard(pricesWithProfit, service, countryId, ctx).reply_markup
+        }
+      );
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Prices list message not modified for service ${service} in country ${countryId}. No action needed.`);
+      } else {
+        logger.error(`Error editing prices list message for service ${service} in country ${countryId}: ${editError.message}`);
+      }
+    }
+    
+  } catch (error: any) {
+    logger.error(`Error fetching prices for ${service} in ${countryId}: ${error.message}`);
+    try {
+      await ctx.editMessageText(
+        getPricesErrorMessage(service, countryId),
+        {
+          parse_mode: 'HTML',
+          reply_markup: getLoggedInMenuKeyboard().reply_markup
+        }
+      );
+    } catch (editError: any) {
+      if (editError.message && editError.message.includes('message is not modified')) {
+        logger.info(`Error message already displayed for service ${service} in country ${countryId}. No action needed.`);
+      } else {
+        logger.error(`Error editing message in country selection error handler for service ${service} in country ${countryId}: ${editError.message}`);
+      }
+    }
+  }
+};

src/bots/index.ts

@@ -0,0 +1,112 @@
+import { initializeBot } from "./botManager";
+import { telegrafBots } from "../models";
+import { supabase } from "../db/supabase";
+import { createLogger } from "../utils/logger";
+import { setupPaymentWebhookHandlers } from './handlers/paymentWebhookHandlers';
+import { getBotIdFromToken, isValidBotToken } from "../utils/botUtils";
+
+const logger = createLogger('BotManager');
+
+// Utility function to update bot status in database
+const updateBotStatus = async (botId: string, isActive: boolean, error?: string) => {
+  try {
+    await supabase
+      .from('bots')
+      .update({
+        is_active: isActive,
+        last_activity: new Date().toISOString(),
+        state: {
+          status: isActive ? 'running' : 'error',
+          startedAt: isActive ? new Date().toISOString() : undefined,
+          error: error
+        }
+      })
+      .eq('id', botId);
+  } catch (error: any) {
+    logger.error(`Error updating bot status: ${error.message}`);
+  }
+};
+
+export const handleAddTelegrafBot = async (botId: string) => {
+  if (!botId) {
+    return { status: 400, data: { error: "Bot ID is required" } };
+  }
+
+  try {
+    logger.info(`Fetching bot data for bot ID: ${botId}`);
+    // Fetch bot data from database
+    const { data: botData, error } = await supabase
+      .from('bots')
+      .select('*')
+      .eq('id', botId)
+      .single();
+
+    if (error) {
+      logger.error(`Error fetching bot data: ${error.message}`);
+      return { status: 404, data: { error: `Bot not found: ${error.message}` } };
+    }
+
+    if (!botData || !botData.bot_token) {
+      return { status: 404, data: { error: "Bot token not found in database" } };
+    }
+
+    // Validate bot token format
+    if (!isValidBotToken(botData.bot_token)) {
+      logger.error(`Invalid bot token format for bot ${botId}`);
+      return { status: 400, data: { error: "Invalid bot token format" } };
+    }
+
+    // Check if bot is already running
+    if (telegrafBots.has(botData.bot_token)) {
+      return { status: 200, data: { error: "Bot is already running" } };
+    }
+
+    try {
+      // Initialize the bot with settings from database
+      const result = await initializeBot(botData.bot_token, botData);
+
+      if (result.success && result.bot) {
+        // Store the bot instance in the map
+        telegrafBots.set(botData.bot_token, result.bot);
+        
+        try {
+          // Update bot status to active
+          await updateBotStatus(botId, true);
+          
+          logger.info(`Bot ${botData.name} (${botId}) launched successfully`);
+
+          await result.bot.launch();
+          
+          // Setup payment webhook handlers
+          // setupPaymentWebhookHandlers(result.bot);
+          
+          return { status: 200, data: { 
+            message: result.message,
+            bot: {
+              id: botData.id,
+              name: botData.name,
+              is_active: true
+            }
+          }};
+
+        } catch (error: any) {
+          logger.error(`Error launching bot: ${error.message}`);
+          await updateBotStatus(botId, false, error.message);
+          return { status: 500, data: { error: `Error launching bot: ${error.message}` } };
+        }
+      } else {
+        logger.error(`Error initializing bot: ${result.message}`);
+        await updateBotStatus(botId, false, result.message);
+        return { status: 500, data: { error: result.message } };
+      }
+    } catch (error: any) {
+      logger.error(`Bot initialization error: ${error.message}`);
+      await updateBotStatus(botId, false, error.message);
+      return { status: 500, data: { error: `Bot initialization error: ${error.message}` } };
+    }
+  } catch (error: any) {
+    logger.error(`Unexpected error: ${error.message}`);
+    await updateBotStatus(botId, false, error.message);
+    return { status: 500, data: { error: `Unexpected error: ${error.message}` } };
+  }
+};

src/bots/middleware/groupCheckMiddleware.ts

@@ -0,0 +1,52 @@
+import { BotContext } from '../types/botTypes';
+import { createLogger } from '../../utils/logger';
+import { messageManager } from '../utils/messageManager';
+
+const logger = createLogger('GroupCheckMiddleware');
+
+export const groupCheckMiddleware = async (ctx: BotContext, next: () => Promise<void>) => {
+  try {
+    // Skip check for non-message updates
+    if (!ctx.message || !ctx.from) {
+      return next();
+    }
+
+    const botData = ctx.botData;
+    if (!botData?.join_group_required || !botData?.group_channel_username) {
+      return next();
+    }
+
+    // Skip check for admin commands
+    if ('text' in ctx.message && ctx.message.text?.startsWith('/')) {
+      return next();
+    }
+
+    try {
+      // Check if user is a member of the required group
+      const chatMember = await ctx.telegram.getChatMember(
+        botData.group_channel_username,
+        ctx.from.id
+      );
+
+      if (['member', 'administrator', 'creator'].includes(chatMember.status)) {
+        return next();
+      }
+
+      // User is not a member of the required group
+      const message = messageManager.getMessage('join_group_required');
+
+      await ctx.reply(message, {
+        parse_mode: 'HTML',
+        link_preview_options: { is_disabled: true }
+      });
+
+    } catch (error: any) {
+      logger.error(`Error checking group membership: ${error.message}`);
+      // If there's an error checking membership, allow the user to proceed
+      return next();
+    }
+  } catch (error: any) {
+    logger.error(`Error in group check middleware: ${error.message}`);
+    return next();
+  }
+}; 

src/bots/services/AdminService.ts

@@ -0,0 +1,24 @@
+import { BotContext } from '../types/botTypes';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('AdminService');
+
+export class AdminService {
+  private static instance: AdminService;
+  private readonly adminContact: string;
+
+  private constructor(ctx: BotContext) {
+    this.adminContact = ctx.botData?.admin_contact || '';
+  }
+
+  public static getInstance(ctx: BotContext): AdminService {
+    if (!AdminService.instance) {
+      AdminService.instance = new AdminService(ctx);
+    }
+    return AdminService.instance;
+  }
+
+  async getAdminContact(): Promise<string> {
+    return this.adminContact;
+  }
+} 

src/bots/services/BalanceUpdateService.ts

@@ -0,0 +1,266 @@
+import { supabase } from '../../db/supabase';
+import { createLogger } from '../../utils/logger';
+import { BotContext } from '../types/botTypes';
+import { messageManager } from '../utils/messageManager';
+import { initializeBot, stopBot } from '../botManager';
+
+const logger = createLogger('BalanceUpdateService');
+
+export class BalanceUpdateService {
+  private static instance: BalanceUpdateService;
+  private bot: any;
+  private subscription: any;
+  private botsSubscription: any;
+
+  private constructor() {
+    // Delay the initial subscription setup to ensure bot is ready
+    setTimeout(() => {
+      //this.setupRealtimeSubscription();
+      //this.setupBotsSubscription();
+    }, 1000);
+  }
+
+  public static getInstance(): BalanceUpdateService {
+    if (!BalanceUpdateService.instance) {
+      BalanceUpdateService.instance = new BalanceUpdateService();
+    }
+    return BalanceUpdateService.instance;
+  }
+
+  public setBot(bot: any) {
+    this.bot = bot;
+    logger.info('Bot instance set in BalanceUpdateService');
+    // Setup subscription after bot is set
+    this.setupRealtimeSubscription();
+  }
+
+  private async setupRealtimeSubscription() {
+    try {
+      logger.info('Starting realtime subscription setup...');
+
+      // Unsubscribe from any existing subscription
+      if (this.subscription) {
+        await this.subscription.unsubscribe();
+        logger.info('Unsubscribed from previous subscription');
+      }
+
+      // Create a new channel
+      const channel = supabase.channel('balance_changes', {
+        config: {
+          broadcast: { self: true }
+        }
+      });
+
+      // Subscribe to changes
+      channel
+        .on(
+          'postgres_changes',
+          {
+            event: 'UPDATE',
+            schema: 'public',
+            table: 'users_bot_telegram'
+          },
+          async (payload: any) => {
+            logger.info('Received database change:', JSON.stringify(payload, null, 2));
+            
+            // Check if balance was actually changed
+            if (payload.old.balance !== payload.new.balance) {
+              logger.info('Balance change detected, processing update...');
+              try {
+                await this.handleBalanceUpdate(payload);
+              } catch (error) {
+                logger.error('Error handling balance update:', error);
+              }
+            } else {
+              logger.info('No balance change detected in update');
+            }
+          }
+        )
+        .subscribe((status: string) => {
+          logger.info('Subscription status changed:', status);
+          if (status === 'SUBSCRIBED') {
+            logger.info('Successfully subscribed to balance changes');
+            this.subscription = channel;
+          } else if (status === 'CLOSED') {
+            logger.error('Subscription closed unexpectedly');
+            setTimeout(() => this.setupRealtimeSubscription(), 5000);
+          } else if (status === 'CHANNEL_ERROR') {
+            logger.error('Channel error occurred');
+            setTimeout(() => this.setupRealtimeSubscription(), 5000);
+          }
+        });
+
+      // Add connection status listener
+      supabase
+        .channel('system')
+        .on('system', { event: '*' }, (payload) => {
+          logger.info('System event:', payload);
+        })
+        .subscribe();
+
+      logger.info('Balance update subscription setup completed');
+    } catch (error) {
+      logger.error('Error setting up realtime subscription:', error);
+      setTimeout(() => this.setupRealtimeSubscription(), 5000);
+    }
+  }
+
+  private async setupBotsSubscription() {
+    try {
+      logger.info('Starting bots subscription setup...');
+
+      // Unsubscribe from any existing subscription
+      if (this.botsSubscription) {
+        await this.botsSubscription.unsubscribe();
+        logger.info('Unsubscribed from previous bots subscription');
+      }
+
+      // Create a new channel for bots
+      const channel = supabase.channel('bots_changes', {
+        config: {
+          broadcast: { self: true }
+        }
+      });
+
+      // Subscribe to changes in bots table
+      channel
+        .on(
+          'postgres_changes',
+          {
+            event: '*', // Listen to all events (INSERT, UPDATE, DELETE)
+            schema: 'public',
+            table: 'bots'
+          },
+          async (payload: any) => {
+            logger.info('Received bots table change:', JSON.stringify(payload, null, 2));
+            
+            try {
+              const botId = payload.new?.id || payload.old?.id;
+              if (!botId) {
+                logger.error('No bot ID found in payload');
+                return;
+              }
+
+              // Stop the bot first
+              await stopBot(botId);
+              logger.info(`Stopped bot ${botId}`);
+
+              // If it's an UPDATE or INSERT, restart the bot with new data
+              if (payload.eventType === 'UPDATE' || payload.eventType === 'INSERT') {
+                const { data: botData, error } = await supabase
+                  .from('bots')
+                  .select('*')
+                  .eq('id', botId)
+                  .single();
+
+                if (error) {
+                  logger.error(`Error fetching bot data: ${error.message}`);
+                  return;
+                }
+
+                if (botData) {
+                  const result = await initializeBot(botData.bot_token, botData);
+                  if (result.success) {
+                    logger.info(`Bot ${botId} restarted successfully`);
+                  } else {
+                    logger.error(`Failed to restart bot ${botId}: ${result.message}`);
+                  }
+                }
+              }
+            } catch (error) {
+              logger.error('Error handling bot update:', error);
+            }
+          }
+        )
+        .subscribe((status: string) => {
+          logger.info('Bots subscription status changed:', status);
+          if (status === 'SUBSCRIBED') {
+            logger.info('Successfully subscribed to bots changes');
+            this.botsSubscription = channel;
+          } else if (status === 'CLOSED') {
+            logger.error('Bots subscription closed unexpectedly');
+            setTimeout(() => this.setupBotsSubscription(), 5000);
+          } else if (status === 'CHANNEL_ERROR') {
+            logger.error('Bots channel error occurred');
+            setTimeout(() => this.setupBotsSubscription(), 5000);
+          }
+        });
+
+      logger.info('Bots subscription setup completed');
+    } catch (error) {
+      logger.error('Error setting up bots subscription:', error);
+      setTimeout(() => this.setupBotsSubscription(), 5000);
+    }
+  }
+
+  private async handleBalanceUpdate(payload: any) {
+    logger.info('Processing balance update payload:', JSON.stringify(payload, null, 2));
+
+    if (!this.bot) {
+      logger.error('Bot instance not set in BalanceUpdateService');
+      return;
+    }
+
+    const { old: oldRecord, new: newRecord } = payload;
+    
+    if (!oldRecord || !newRecord) {
+      logger.error('Invalid payload format:', payload);
+      return;
+    }
+
+    const telegramId = newRecord.telegram_id;
+    const oldBalance = Number(oldRecord.balance) || 0;
+    const newBalance = Number(newRecord.balance) || 0;
+
+    logger.info(`Balance change detected for user ${telegramId}: ${oldBalance} -> ${newBalance}`);
+
+    // Only send notification if balance actually changed
+    if (oldBalance !== newBalance) {
+      try {
+        const balanceChange = newBalance - oldBalance;
+        const changeType = balanceChange > 0 ? 'increase' : 'decrease';
+        
+        const message = messageManager.getMessage('balance_update_notification')
+          .replace('{old_balance}', oldBalance.toFixed(2))
+          .replace('{new_balance}', newBalance.toFixed(2))
+          .replace('{change_type}', changeType)
+          .replace('{change_amount}', Math.abs(balanceChange).toFixed(2));
+
+        logger.info(`Sending balance update message to user ${telegramId}:`, message);
+
+        await this.bot.telegram.sendMessage(telegramId, message, { parse_mode: 'HTML' });
+        logger.info(`Balance update notification sent to user ${telegramId}`);
+      } catch (error) {
+        logger.error(`Failed to send balance update notification to user ${telegramId}:`, error);
+      }
+    } else {
+      logger.info(`No balance change detected for user ${telegramId}`);
+    }
+  }
+
+  // Method to manually trigger a balance update notification
+  public async sendBalanceUpdateNotification(telegramId: number, oldBalance: number, newBalance: number) {
+    try {
+      const balanceChange = newBalance - oldBalance;
+      const changeType = balanceChange > 0 ? 'increase' : 'decrease';
+      
+      const message = messageManager.getMessage('balance_update_notification')
+        .replace('{old_balance}', oldBalance.toFixed(2))
+        .replace('{new_balance}', newBalance.toFixed(2))
+        .replace('{change_type}', changeType)
+        .replace('{change_amount}', Math.abs(balanceChange).toFixed(2));
+
+      await this.bot.telegram.sendMessage(telegramId, message, { parse_mode: 'HTML' });
+      logger.info(`Manual balance update notification sent to user ${telegramId}`);
+    } catch (error) {
+      logger.error(`Failed to send manual balance update notification to user ${telegramId}:`, error);
+    }
+  }
+
+  // Method to check subscription status
+  public getSubscriptionStatus(): string {
+    return this.subscription?.state || 'NOT_INITIALIZED';
+  }
+}
+
+// export const balanceUpdateService = BalanceUpdateService.getInstance(); 

src/bots/services/CryptoService.ts

@@ -0,0 +1,44 @@
+import { BotContext } from '../types/botTypes';
+import { createLogger } from '../../utils/logger';
+import { supabase } from '../../db/supabase';
+
+const logger = createLogger('CryptoService');
+
+export class CryptoService {
+  private static instance: CryptoService;
+  private readonly cryptoAddress: string;
+
+  private constructor(ctx: BotContext) {
+    this.cryptoAddress = ctx.botData?.crypto_wallet_address || '';
+  }
+
+  public static getInstance(ctx: BotContext): CryptoService {
+    if (!CryptoService.instance) {
+      CryptoService.instance = new CryptoService(ctx);
+    }
+    return CryptoService.instance;
+  }
+
+  async getPaymentAddress(userId: string, amount: number): Promise<string> {
+    try {
+      // Create payment record in database
+      const { data: payment, error } = await supabase
+        .from('payments')
+        .insert({
+          user_id: userId,
+          amount: amount,
+          status: 'PENDING',
+          payment_method: 'CRYPTO'
+        })
+        .select()
+        .single();
+
+      if (error) throw error;
+
+      return this.cryptoAddress;
+    } catch (error) {
+      logger.error('Error creating crypto payment:', error);
+      throw error;
+    }
+  }
+} 

src/bots/services/PayPalService.ts

@@ -0,0 +1,121 @@
+import { BotContext } from '../types/botTypes';
+import axios from 'axios';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('PayPalService');
+
+// PayPal API Response Types
+interface PayPalLink {
+  href: string;
+  rel: string;
+  method: string;
+}
+
+interface PayPalOrder {
+  id: string;
+  status: string;
+  links: PayPalLink[];
+}
+
+interface PayPalTokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+}
+
+export class PayPalService {
+  private static instance: PayPalService;
+  private readonly clientId: string;
+  private readonly clientSecret: string;
+  private readonly isProduction: boolean;
+
+  private constructor(ctx: BotContext) {
+    this.clientId = ctx.botData?.paypal_client_id || '';
+    this.clientSecret = ctx.botData?.paypal_client_secret || '';
+    this.isProduction = ctx.botData?.settings?.paypal_environment === 'production';
+  }
+
+  public static getInstance(ctx: BotContext): PayPalService {
+    if (!PayPalService.instance) {
+      PayPalService.instance = new PayPalService(ctx);
+    }
+    return PayPalService.instance;
+  }
+
+  async createPaymentLink(userId: string, amount: number): Promise<string> {
+    try {
+      const accessToken = await this.getAccessToken();
+      const order = await this.createPayPalOrder(amount, userId);
+      
+      // Find the approval URL from the order links
+      const approvalLink = order.links.find(link => link.rel === 'approve');
+      if (!approvalLink) {
+        throw new Error('No approval URL found in PayPal order');
+      }
+      
+      return approvalLink.href;
+    } catch (error: any) {
+      logger.error(`Error creating PayPal payment link: ${error.message}`);
+      throw new Error(`Failed to create payment link: ${error.message}`);
+    }
+  }
+
+  private async createPayPalOrder(amount: number, paymentId: string): Promise<PayPalOrder> {
+    try {
+      const accessToken = await this.getAccessToken();
+      const baseUrl = this.isProduction 
+        ? 'https://api-m.paypal.com' 
+        : 'https://api-m.sandbox.paypal.com';
+
+      const response = await axios.post(
+        `${baseUrl}/v2/checkout/orders`,
+        {
+          intent: 'CAPTURE',
+          purchase_units: [{
+            amount: {
+              currency_code: 'USD',
+              value: amount.toString()
+            },
+            custom_id: paymentId
+          }]
+        },
+        {
+          headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+          }
+        }
+      );
+
+      return response.data;
+    } catch (error: any) {
+      logger.error(`Error creating PayPal order: ${error.message}`);
+      throw new Error(`Failed to create PayPal order: ${error.message}`);
+    }
+  }
+
+  private async getAccessToken(): Promise<string> {
+    try {
+      const baseUrl = this.isProduction 
+        ? 'https://api-m.paypal.com' 
+        : 'https://api-m.sandbox.paypal.com';
+
+      const response = await axios.post(
+        `${baseUrl}/v1/oauth2/token`,
+        'grant_type=client_credentials',
+        {
+          headers: {
+            'Authorization': `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`,
+            'Content-Type': 'application/x-www-form-urlencoded'
+          }
+        }
+      );
+
+      const data = response.data as PayPalTokenResponse;
+      return data.access_token;
+    } catch (error: any) {
+      logger.error(`Error getting PayPal access token: ${error.message}`);
+      throw new Error(`Failed to get PayPal access token: ${error.message}`);
+    }
+  }
+}

src/bots/services/PaymentVerificationService.ts

@@ -0,0 +1,83 @@
+import { createLogger } from '../../utils/logger';
+import { supabase } from '../../db/supabase';
+import { AuthService } from './auth';
+import { Telegraf } from 'telegraf';
+
+const logger = createLogger('PaymentVerificationService');
+
+export class PaymentVerificationService {
+  private static instance: PaymentVerificationService;
+  private bot: Telegraf;
+
+  private constructor() {}
+
+  public static getInstance(): PaymentVerificationService {
+    if (!PaymentVerificationService.instance) {
+      PaymentVerificationService.instance = new PaymentVerificationService();
+    }
+    return PaymentVerificationService.instance;
+  }
+
+  public setBot(bot: Telegraf) {
+    this.bot = bot;
+  }
+
+  async verifyAndUpdatePayment(paymentId: string, status: 'COMPLETED' | 'FAILED') {
+    try {
+      // Get payment details
+      const { data: payment, error: paymentError } = await supabase
+        .from('payments')
+        .select('*, users_bot_telegram!inner(telegram_id, balance)')
+        .eq('id', paymentId)
+        .single();
+
+      if (paymentError) throw paymentError;
+      if (!payment) throw new Error('Payment not found');
+
+      // Update payment status
+      const { error: updateError } = await supabase
+        .from('payments')
+        .update({
+          status: status,
+          completed_at: status === 'COMPLETED' ? new Date().toISOString() : null
+        })
+        .eq('id', paymentId);
+
+      if (updateError) throw updateError;
+
+      if (status === 'COMPLETED') {
+        // Update user balance
+        const { error: balanceError } = await supabase
+          .from('users_bot_telegram')
+          .update({
+            balance: payment.users_bot_telegram.balance + payment.amount
+          })
+          .eq('id', payment.user_id);
+
+        if (balanceError) throw balanceError;
+
+        // Notify user
+        await this.notifyUser(payment.users_bot_telegram.telegram_id, payment.amount);
+      }
+
+      return true;
+    } catch (error) {
+      logger.error('Error verifying payment:', error);
+      throw error;
+    }
+  }
+
+  private async notifyUser(telegramId: number, amount: number) {
+    try {
+      await this.bot.telegram.sendMessage(
+        telegramId,
+        `✅ <b>تم إتمام عملية الدفع بنجاح!</b>\n\n` +
+        `تم إضافة ${amount}$ إلى رصيدك.\n` +
+        `يمكنك الآن استخدام الخدمات المتاحة.`,
+        { parse_mode: 'HTML' }
+      );
+    } catch (error) {
+      logger.error('Error notifying user:', error);
+    }
+  }
+} 

src/bots/services/PurchaseTrackingService.ts

@@ -0,0 +1,174 @@
+import { createLogger } from '../../utils/logger';
+import { supabase } from '../../db/supabase';
+import { camelToSnake, snakeToCamel } from '../../utils';
+
+const logger = createLogger('PurchaseTrackingService');
+
+export enum PurchaseState {
+  PENDING = 'pending',
+  SUCCESS = 'success',
+  FAILED = 'failed',
+  CANCELED = 'canceled',
+  TIMEOUT = 'timeout'
+}
+
+export interface PurchaseRecord {
+  id?: number;
+  userId: number;
+  telegramId: number;
+  service: string;
+  countryId: string;
+  operator: string;
+  phoneNumber?: string;
+  orderId?: string;
+  cost: number;
+  state: PurchaseState;
+  verificationCode?: string;
+  verificationMessage?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export class PurchaseTrackingService {
+  private static instance: PurchaseTrackingService;
+
+  private constructor() {}
+
+  public static getInstance(): PurchaseTrackingService {
+    if (!PurchaseTrackingService.instance) {
+      PurchaseTrackingService.instance = new PurchaseTrackingService();
+    }
+    return PurchaseTrackingService.instance;
+  }
+
+  /**
+   * Create a new purchase record
+   */
+  async createPurchase(purchaseData: Omit<PurchaseRecord, 'id' | 'createdAt' | 'updatedAt'>): Promise<PurchaseRecord> {
+    try {
+      // Convert camelCase to snake_case for database
+      const snakeData = camelToSnake(purchaseData);
+      
+      const { data, error } = await supabase
+        .from('purchases')
+        .insert(snakeData)
+        .select();
+      
+      if (error) {
+        logger.error(`Error creating purchase record: ${error.message}`);
+        throw new Error(`Failed to create purchase record: ${error.message}`);
+      }
+      
+      // Convert snake_case back to camelCase
+      return snakeToCamel(data[0]) as PurchaseRecord;
+    } catch (error: any) {
+      logger.error(`Error in createPurchase: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Update purchase state and related information
+   */
+  async updatePurchaseState(
+    orderId: string, 
+    state: PurchaseState, 
+    additionalData: Partial<PurchaseRecord> = {}
+  ): Promise<PurchaseRecord> {
+    try {
+      const updateData = camelToSnake({
+        state,
+        updatedAt: new Date().toISOString(),
+        ...additionalData
+      });
+      
+      const { data, error } = await supabase
+        .from('purchases')
+        .update(updateData)
+        .eq('order_id', orderId)
+        .select();
+      
+      if (error) {
+        logger.error(`Error updating purchase state: ${error.message}`);
+        throw new Error(`Failed to update purchase state: ${error.message}`);
+      }
+      
+      return data && data.length > 0 ? snakeToCamel(data[0]) as PurchaseRecord : {} as PurchaseRecord;
+    } catch (error: any) {
+      logger.error(`Error in updatePurchaseState: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get purchase by order ID
+   */
+  async getPurchaseByOrderId(orderId: string): Promise<PurchaseRecord | null> {
+    try {
+      const { data, error } = await supabase
+        .from('purchases')
+        .select('*')
+        .eq('order_id', orderId)
+        .limit(1);
+      
+      if (error) {
+        logger.error(`Error fetching purchase: ${error.message}`);
+        throw new Error(`Failed to fetch purchase: ${error.message}`);
+      }
+      
+      return data && data.length > 0 ? snakeToCamel(data[0]) as PurchaseRecord : null;
+    } catch (error: any) {
+      logger.error(`Error in getPurchaseByOrderId: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get user's purchase history
+   */
+  async getUserPurchases(telegramId: number, limit: number = 10, offset: number = 0): Promise<PurchaseRecord[]> {
+    try {
+      const { data, error } = await supabase
+        .from('purchases')
+        .select('*')
+        .eq('telegram_id', telegramId)
+        .order('created_at', { ascending: false })
+        .range(offset, offset + limit - 1);
+      
+      if (error) {
+        logger.error(`Error fetching user purchases: ${error.message}`);
+        throw new Error(`Failed to fetch user purchases: ${error.message}`);
+      }
+      
+      return data ? data.map(record => snakeToCamel(record) as PurchaseRecord) : [];
+    } catch (error: any) {
+      logger.error(`Error in getUserPurchases: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Get user's purchase history filtered by state
+   */
+  async getUserPurchasesByState(telegramId: number, state: PurchaseState, limit: number = 10, offset: number = 0): Promise<PurchaseRecord[]> {
+    try {
+      const { data, error } = await supabase
+        .from('purchases')
+        .select('*')
+        .eq('telegram_id', telegramId)
+        .eq('state', state)
+        .order('created_at', { ascending: false })
+        .range(offset, offset + limit - 1);
+      
+      if (error) {
+        logger.error(`Error fetching user purchases by state: ${error.message}`);
+        throw new Error(`Failed to fetch user purchases by state: ${error.message}`);
+      }
+      
+      return data ? data.map(record => snakeToCamel(record) as PurchaseRecord) : [];
+    } catch (error: any) {
+      logger.error(`Error in getUserPurchasesByState: ${error.message}`);
+      throw error;
+    }
+  }
+} 

src/bots/services/VirtualNumberService.ts

@@ -0,0 +1,176 @@
+import axios from 'axios';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('VirtualNumberService');
+
+export interface Country {
+    id: string;
+    name: string;
+    count: number;
+}
+
+export interface PriceInfo {
+    cost: number;
+    count: number;
+    rate?: number;
+}
+
+export interface ServicePrice {
+    [country: string]: {
+        [operator: string]: PriceInfo;
+    };
+}
+
+export interface ProductPrices {
+    [service: string]: {
+        [country: string]: {
+            [operator: string]: PriceInfo;
+        };
+    };
+}
+
+export interface MaxPrice {
+    id: number;
+    product: string;
+    price: number;
+    CreatedAt: string; // date string
+}
+
+export class VirtualNumberService {
+    private static instance: VirtualNumberService;
+    private apiKey: string;
+    private baseUrl: string = 'https://5sim.net/v1';
+    
+    private constructor() {
+        this.apiKey = process.env.FIVESIM_API_KEY || '';
+        if (!this.apiKey) {
+            logger.error('5sim API key not found in environment variables');
+        }
+    }
+
+    public static getInstance(): VirtualNumberService {
+        if (!VirtualNumberService.instance) {
+            VirtualNumberService.instance = new VirtualNumberService();
+        }
+        return VirtualNumberService.instance;
+    }
+
+    /**
+     * Get available countries for a specific service
+     */
+    async getAvailableCountries(service: string): Promise<Country[]> {
+        try {
+            const response = await axios.get(`${this.baseUrl}/guest/countries/${service}`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Accept': 'application/json',
+                }
+            });
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error fetching countries for ${service}: ${error.message}`);
+            throw new Error(`Failed to fetch available countries: ${error.message}`);
+        }
+    }
+
+    /**
+     * Get all prices for a specific product
+     */
+    async getProductPrices(product: string): Promise<ProductPrices> {
+        try {
+            const response = await axios.get(`${this.baseUrl}/guest/prices?product=${product}`, {
+                headers: {
+                    'Accept': 'application/json',
+                }
+            });
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error fetching prices for product ${product}: ${error.message}`);
+            throw new Error(`Failed to fetch product prices: ${error.message}`);
+        }
+    }
+
+    /**
+     * Get prices for a specific service and country
+     */
+    async getPrices(service: string, country: string): Promise<ServicePrice> {
+        try {
+            const response = await axios.get(`${this.baseUrl}/guest/prices?product=${service}&country=${country}`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Accept': 'application/json',
+                }
+            });
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error fetching prices for ${service} in ${country}: ${error.message}`);
+            throw new Error(`Failed to fetch prices: ${error.message}`);
+        }
+    }
+
+    /**
+     * Purchase a number for a specific service and country
+     */
+    async purchaseNumber(service: string, country: string, operator: string): Promise<any> {
+        try {
+            const response = await axios.get(
+                `${this.baseUrl}/user/buy/activation/${country}/${operator}/${service}`, 
+                {
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'Accept': 'application/json',
+                    }
+                }
+            );
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error purchasing number for ${service} in ${country}: ${error.message}`);
+            throw new Error(`Failed to purchase number: ${error.message}`);
+        }
+    }
+
+    /**
+     * Check for SMS received for a specific order
+     */
+    async checkSMS(orderId: string | number): Promise<any> {
+        try {
+            const response = await axios.get(
+                `${this.baseUrl}/user/check/${orderId}`, 
+                {
+                    headers: {
+                        'Authorization': `Bearer ${this.apiKey}`,
+                        'Accept': 'application/json',
+                    }
+                }
+            );
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error checking SMS for order ${orderId}: ${error.message}`);
+            throw new Error(`Failed to check SMS: ${error.message}`);
+        }
+    }
+
+    /**
+     * Get a list of established price limits.
+     */
+    async getMaxPrices(): Promise<MaxPrice[]> {
+        try {
+            const response = await axios.get(`${this.baseUrl}/user/max-prices`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Accept': 'application/json',
+                }
+            });
+            
+            return response.data;
+        } catch (error: any) {
+            logger.error(`Error fetching max prices: ${error.message}`);
+            throw new Error(`Failed to fetch max prices: ${error.message}`);
+        }
+    }
+} 

src/bots/services/auth.ts

@@ -0,0 +1,226 @@
+import { 
+    fetchDataFromTable, 
+    insertDataIntoTable, 
+    updateDataInTable 
+  } from '../../db/supabaseHelper';
+  import { createLogger } from '../../utils/logger';
+  import { v4 as uuidv4 } from 'uuid';
+  import { supabase } from '../../db/supabase';
+  import { BotContext } from '../types/botTypes';
+  import { getBotIdFromContext } from '../../utils/botUtils';
+  
+  const logger = createLogger('AuthService');
+
+  interface UserBotTelegraf {
+    id?: number; // SERIAL in SQL becomes number in TypeScript
+    telegramId: number; // BIGINT in SQL becomes number in TypeScript
+    username?: string | null; // VARCHAR(255), optional
+    firstName?: string | null; // VARCHAR(255), matches SQL column name
+    lastName?: string | null; // VARCHAR(255), matches SQL column name
+    email: string; // VARCHAR(255) NOT NULL
+    passwordHash: string; // VARCHAR(255) NOT NULL, matches SQL column name
+    language?: string; // VARCHAR(10) DEFAULT 'en'
+    role?: string; // VARCHAR(10) DEFAULT 'user'
+    balance?: number; // DECIMAL(10, 2) DEFAULT 0
+    isBanned?: boolean; // BOOLEAN DEFAULT false
+    lastLogin?: Date | string | null; // TIMESTAMPTZ (can be Date, ISO string, or null)
+    botId?: string | null; // UUID (string in TypeScript)
+    createdAt?: Date | string; // TIMESTAMPTZ DEFAULT NOW()
+    updatedAt?: Date | string; // TIMESTAMPTZ DEFAULT NOW()
+  }
+  
+  export class AuthService {
+    private static instance: AuthService;
+  
+    private constructor() {
+      // Private constructor for singleton pattern
+    }
+  
+    public static getInstance(): AuthService {
+      if (!AuthService.instance) {
+        AuthService.instance = new AuthService();
+      }
+      return AuthService.instance;
+    }
+  
+    private generatePassword(): string {
+      return uuidv4().replace(/-/g, '').substring(0, 12);
+    }
+  
+    public async hashPassword(password: string): Promise<string> {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(password);
+      const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+  
+    private generateEmail(telegramId: number, ctx: BotContext): string {
+      const botData = ctx.botData;
+      const suffix = botData?.suffix_email || 'saerosms.com';
+      return `user_${telegramId}@${suffix}`;
+    }
+  
+    public async createUser(telegramId: number, name: string, ctx: BotContext): Promise<{ user: UserBotTelegraf; password: string }> {
+      try {
+        const botId = getBotIdFromContext(ctx);
+        if (!botId) {
+          throw new Error('Could not determine bot ID from context');
+        }
+
+        const email = this.generateEmail(telegramId, ctx);
+        const password = this.generatePassword();
+        const passwordHash = await this.hashPassword(password);
+  
+        const userData: Omit<UserBotTelegraf, 'id'> = {
+          telegramId: telegramId,
+          firstName: name,
+          email,
+          passwordHash: passwordHash,
+          botId: botId,
+          balance: 0,
+          language: 'ar',
+          role: 'user',
+          isBanned: false
+        };
+  
+        const user = await insertDataIntoTable('users_bot_telegram', userData);
+        
+        logger.info(`User ${telegramId} created successfully for bot ${botId}`);
+        return { user, password };
+  
+      } catch (error: any) {
+        logger.error(`Error creating user ${telegramId}: ${error.message}`);
+        throw new Error(`Failed to create user: ${error.message}`);
+      }
+    }
+  
+    private loggedInUsers: Map<string, boolean> = new Map();
+  
+    private generateUserKey(telegramId: number, ctx: BotContext): string {
+      const botId = getBotIdFromContext(ctx);
+      if (!botId) {
+        throw new Error('Could not determine bot ID from context');
+      }
+      return `${telegramId}_${botId}`;
+    }
+  
+    public setUserLoggedIn(telegramId: number, ctx: BotContext, isLoggedIn: boolean = true): void {
+      const key = this.generateUserKey(telegramId, ctx);
+      const botId = getBotIdFromContext(ctx);
+      this.loggedInUsers.set(key, isLoggedIn);
+      logger.info(`User ${telegramId} for bot ${botId} login state set to ${isLoggedIn}`);
+    }
+  
+    public isUserLoggedIn(telegramId: number, ctx: BotContext): boolean {
+      const key = this.generateUserKey(telegramId, ctx);
+      return this.loggedInUsers.get(key) || false;
+    }
+  
+    public async loginUser(telegramId: number, ctx: BotContext): Promise<UserBotTelegraf | null> {
+      try {
+        const botId = getBotIdFromContext(ctx);
+        if (!botId) {
+          throw new Error('Could not determine bot ID from context');
+        }
+
+        const { data: user, error } = await supabase
+          .from('users_bot_telegram')
+          .select('*')
+          .eq('telegram_id', telegramId)
+          .eq('bot_id', botId)
+          .single();
+
+        if (error) {
+          if (error.code === 'PGRST116') {
+            return null; // User not found
+          }
+          throw error;
+        }
+
+        if (user) {
+          this.setUserLoggedIn(telegramId, ctx, true);
+          return user;
+        }
+
+        return null;
+      } catch (error) {
+        logger.error('Error in loginUser:', error);
+        return null;
+      }
+    }
+  
+    public async getUserById(userId: string): Promise<UserBotTelegraf | null> {
+      try {
+        const { data: user, error } = await supabase
+          .from('users_bot_telegram')
+          .select('*')
+          .eq('id', userId)
+          .single();
+
+        if (error) {
+          if (error.code === 'PGRST116') {
+            return null;
+          }
+          throw error;
+        }
+
+        return user;
+      } catch (error: any) {
+        logger.error(`Error fetching user ${userId}: ${error.message}`);
+        throw new Error(`Failed to get user: ${error.message}`);
+      }
+    }
+  
+    async getUserByTelegramId(telegramId: number, ctx: BotContext): Promise<UserBotTelegraf | null> {
+      try {
+        const botId = getBotIdFromContext(ctx);
+        if (!botId) {
+          throw new Error('Could not determine bot ID from context');
+        }
+
+        const { data: user, error } = await supabase
+          .from('users_bot_telegram')
+          .select('*')
+          .eq('telegram_id', telegramId)
+          .eq('bot_id', botId)
+          .single();
+        
+        if (error) {
+          if (error.code === 'PGRST116') {
+            return null;
+          }
+          throw error;
+        }
+
+        return user;
+      } catch (error: any) {
+        logger.error(`Error getting user by Telegram ID: ${error.message}`);
+        return null;
+      }
+    }
+  
+    async updateUserBalance(telegramId: number, ctx: BotContext, newBalance: number): Promise<boolean> {
+      try {
+        const botId = getBotIdFromContext(ctx);
+        if (!botId) {
+          throw new Error('Could not determine bot ID from context');
+        }
+
+        const { error } = await supabase
+          .from('users_bot_telegram')
+          .update({ balance: newBalance })
+          .eq('telegram_id', telegramId)
+          .eq('bot_id', botId);
+        
+        if (error) throw error;
+        return true;
+      } catch (error: any) {
+        logger.error(`Error updating user balance: ${error.message}`);
+        return false;
+      }
+    }
+  }
+  
+  // Singleton instance
+  export const authService = AuthService.getInstance();

src/bots/types/botTypes.ts

@@ -0,0 +1,17 @@
+import { Context } from 'telegraf';
+import { Update } from 'telegraf/typings/core/types/typegram';
+
+export type BotCommand = {
+    command: string;
+    description: string;
+  };
+  
+export interface BotContext extends Context<Update> {
+  botData?: any;
+  match?: RegExpMatchArray;
+  customData?: any;
+  webhookData?: {
+    paymentId: string;
+    status: 'COMPLETED' | 'FAILED';
+  };
+}

src/bots/types/paymentTypes.ts

@@ -0,0 +1,11 @@
+export type PaymentMethod = 'PAYPAL' | 'CRYPTO' | 'ADMIN';
+
+export interface PaymentInfo {
+  id: string;
+  userId: string;
+  amount: number;
+  method: PaymentMethod;
+  status: 'PENDING' | 'COMPLETED' | 'FAILED';
+  createdAt: Date;
+  updatedAt: Date;
+} 

src/bots/utils/country.ts

@@ -0,0 +1,172 @@
+interface CountryInfo {
+    label: string;
+    flag: string;
+    code: string;
+}
+
+interface CountryData {
+    [key: string]: CountryInfo;
+}
+
+export const countryData: CountryData = {
+    afghanistan: { label: "Afghanistan", flag: "🇦🇫", code: "+93" },
+    albania: { label: "Albania", flag: "🇦🇱", code: "+355" },
+    algeria: { label: "Algeria", flag: "🇩🇿", code: "+213" },
+    angola: { label: "Angola", flag: "🇦🇴", code: "+244" },
+    antiguaandbarbuda: { label: "Antigua and Barbuda", flag: "🇦🇬", code: "+1" },
+    argentina: { label: "Argentina", flag: "🇦🇷", code: "+54" },
+    armenia: { label: "Armenia", flag: "🇦🇲", code: "+374" },
+    aruba: { label: "Aruba", flag: "🇦🇼", code: "+297" },
+    australia: { label: "Australia", flag: "🇦🇺", code: "+61" },
+    austria: { label: "Austria", flag: "🇦🇹", code: "+43" },
+    azerbaijan: { label: "Azerbaijan", flag: "🇦🇿", code: "+994" },
+    bahamas: { label: "Bahamas", flag: "🇧🇸", code: "+1" },
+    bahrain: { label: "Bahrain", flag: "🇧🇭", code: "+973" },
+    bangladesh: { label: "Bangladesh", flag: "🇧🇩", code: "+880" },
+    barbados: { label: "Barbados", flag: "🇧🇧", code: "+1" },
+    belarus: { label: "Belarus", flag: "🇧🇾", code: "+375" },
+    belgium: { label: "Belgium", flag: "🇧🇪", code: "+32" },
+    belize: { label: "Belize", flag: "🇧🇿", code: "+501" },
+    benin: { label: "Benin", flag: "🇧🇯", code: "+229" },
+    bhutane: { label: "Bhutan", flag: "🇧🇹", code: "+975" },
+    bih: { label: "Bosnia and Herzegovina", flag: "🇧🇦", code: "+387" },
+    bolivia: { label: "Bolivia", flag: "🇧🇴", code: "+591" },
+    botswana: { label: "Botswana", flag: "🇧🇼", code: "+267" },
+    brazil: { label: "Brazil", flag: "🇧🇷", code: "+55" },
+    bulgaria: { label: "Bulgaria", flag: "🇧🇬", code: "+359" },
+    burkinafaso: { label: "Burkina Faso", flag: "🇧🇫", code: "+226" },
+    burundi: { label: "Burundi", flag: "🇧🇮", code: "+257" },
+    cambodia: { label: "Cambodia", flag: "🇰🇭", code: "+855" },
+    cameroon: { label: "Cameroon", flag: "🇨🇲", code: "+237" },
+    canada: { label: "Canada", flag: "🇨🇦", code: "+1" },
+    capeverde: { label: "Cape Verde", flag: "🇨🇻", code: "+238" },
+    chad: { label: "Chad", flag: "🇹🇩", code: "+235" },
+    chile: { label: "Chile", flag: "🇨🇱", code: "+56" },
+    colombia: { label: "Colombia", flag: "🇨🇴", code: "+57" },
+    comoros: { label: "Comoros", flag: "🇰🇲", code: "+269" },
+    congo: { label: "Congo", flag: "🇨🇬", code: "+242" },
+    costarica: { label: "Costa Rica", flag: "🇨🇷", code: "+506" },
+    croatia: { label: "Croatia", flag: "🇭🇷", code: "+385" },
+    cyprus: { label: "Cyprus", flag: "🇨🇾", code: "+357" },
+    czech: { label: "Czech Republic", flag: "🇨🇿", code: "+420" },
+    denmark: { label: "Denmark", flag: "🇩🇰", code: "+45" },
+    djibouti: { label: "Djibouti", flag: "🇩🇯", code: "+253" },
+    dominicana: { label: "Dominican Republic", flag: "🇩🇴", code: "+1" },
+    easttimor: { label: "East Timor", flag: "🇹🇱", code: "+670" },
+    ecuador: { label: "Ecuador", flag: "🇪🇨", code: "+593" },
+    egypt: { label: "Egypt", flag: "🇪🇬", code: "+20" },
+    england: { label: "England", flag: "🏴", code: "+44" },
+    equatorialguinea: { label: "Equatorial Guinea", flag: "🇬🇶", code: "+240" },
+    estonia: { label: "Estonia", flag: "🇪🇪", code: "+372" },
+    ethiopia: { label: "Ethiopia", flag: "🇪🇹", code: "+251" },
+    finland: { label: "Finland", flag: "🇫🇮", code: "+358" },
+    france: { label: "France", flag: "🇫🇷", code: "+33" },
+    frenchguiana: { label: "French Guiana", flag: "🇬🇫", code: "+594" },
+    gabon: { label: "Gabon", flag: "🇬🇦", code: "+241" },
+    gambia: { label: "Gambia", flag: "🇬🇲", code: "+220" },
+    georgia: { label: "Georgia", flag: "🇬🇪", code: "+995" },
+    germany: { label: "Germany", flag: "🇩🇪", code: "+49" },
+    ghana: { label: "Ghana", flag: "🇬🇭", code: "+233" },
+    gibraltar: { label: "Gibraltar", flag: "🇬🇮", code: "+350" },
+    greece: { label: "Greece", flag: "🇬🇷", code: "+30" },
+    guadeloupe: { label: "Guadeloupe", flag: "🇬🇵", code: "+590" },
+    guatemala: { label: "Guatemala", flag: "🇬🇹", code: "+502" },
+    guinea: { label: "Guinea", flag: "🇬🇳", code: "+224" },
+    guineabissau: { label: "Guinea-Bissau", flag: "🇬🇼", code: "+245" },
+    guyana: { label: "Guyana", flag: "🇬🇾", code: "+592" },
+    haiti: { label: "Haiti", flag: "🇭🇹", code: "+509" },
+    honduras: { label: "Honduras", flag: "🇭🇳", code: "+504" },
+    hongkong: { label: "Hong Kong", flag: "🇭🇰", code: "+852" },
+    hungary: { label: "Hungary", flag: "🇭🇺", code: "+36" },
+    india: { label: "India", flag: "🇮🇳", code: "+91" },
+    indonesia: { label: "Indonesia", flag: "🇮🇩", code: "+62" },
+    ireland: { label: "Ireland", flag: "🇮🇪", code: "+353" },
+    israel: { label: "Israel", flag: "🇮🇱", code: "+972" },
+    italy: { label: "Italy", flag: "🇮🇹", code: "+39" },
+    ivorycoast: { label: "Ivory Coast", flag: "🇨🇮", code: "+225" },
+    jamaica: { label: "Jamaica", flag: "🇯🇲", code: "+1" },
+    jordan: { label: "Jordan", flag: "🇯🇴", code: "+962" },
+    kazakhstan: { label: "Kazakhstan", flag: "🇰🇿", code: "+7" },
+    kenya: { label: "Kenya", flag: "🇰🇪", code: "+254" },
+    kuwait: { label: "Kuwait", flag: "🇰🇼", code: "+965" },
+    kyrgyzstan: { label: "Kyrgyzstan", flag: "🇰🇬", code: "+996" },
+    laos: { label: "Laos", flag: "🇱🇦", code: "+856" },
+    latvia: { label: "Latvia", flag: "🇱🇻", code: "+371" },
+    lesotho: { label: "Lesotho", flag: "🇱🇸", code: "+266" },
+    liberia: { label: "Liberia", flag: "🇱🇷", code: "+231" },
+    lithuania: { label: "Lithuania", flag: "🇱🇹", code: "+370" },
+    luxembourg: { label: "Luxembourg", flag: "🇱🇺", code: "+352" },
+    macau: { label: "Macau", flag: "🇲🇴", code: "+853" },
+    madagascar: { label: "Madagascar", flag: "🇲🇬", code: "+261" },
+    malawi: { label: "Malawi", flag: "🇲🇼", code: "+265" },
+    malaysia: { label: "Malaysia", flag: "🇲🇾", code: "+60" },
+    maldives: { label: "Maldives", flag: "🇲🇻", code: "+960" },
+    mauritania: { label: "Mauritania", flag: "🇲🇷", code: "+222" },
+    mauritius: { label: "Mauritius", flag: "🇲🇺", code: "+230" },
+    mexico: { label: "Mexico", flag: "🇲🇽", code: "+52" },
+    moldova: { label: "Moldova", flag: "🇲🇩", code: "+373" },
+    mongolia: { label: "Mongolia", flag: "🇲🇳", code: "+976" },
+    montenegro: { label: "Montenegro", flag: "🇲🇪", code: "+382" },
+    morocco: { label: "Morocco", flag: "🇲🇦", code: "+212" },
+    mozambique: { label: "Mozambique", flag: "🇲🇿", code: "+258" },
+    namibia: { label: "Namibia", flag: "🇳🇦", code: "+264" },
+    nepal: { label: "Nepal", flag: "🇳🇵", code: "+977" },
+    netherlands: { label: "Netherlands", flag: "🇳🇱", code: "+31" },
+    newcaledonia: { label: "New Caledonia", flag: "🇳🇨", code: "+687" },
+    newzealand: { label: "New Zealand", flag: "🇳🇿", code: "+64" },
+    nicaragua: { label: "Nicaragua", flag: "🇳🇮", code: "+505" },
+    nigeria: { label: "Nigeria", flag: "🇳🇬", code: "+234" },
+    northmacedonia: { label: "North Macedonia", flag: "🇲🇰", code: "+389" },
+    norway: { label: "Norway", flag: "🇳🇴", code: "+47" },
+    oman: { label: "Oman", flag: "🇴🇲", code: "+968" },
+    pakistan: { label: "Pakistan", flag: "🇵🇰", code: "+92" },
+    panama: { label: "Panama", flag: "🇵🇦", code: "+507" },
+    papuanewguinea: { label: "Papua New Guinea", flag: "🇵🇬", code: "+675" },
+    paraguay: { label: "Paraguay", flag: "🇵🇾", code: "+595" },
+    peru: { label: "Peru", flag: "🇵🇪", code: "+51" },
+    philippines: { label: "Philippines", flag: "🇵🇭", code: "+63" },
+    poland: { label: "Poland", flag: "🇵🇱", code: "+48" },
+    portugal: { label: "Portugal", flag: "🇵🇹", code: "+351" },
+    puertorico: { label: "Puerto Rico", flag: "🇵🇷", code: "+1" },
+    reunion: { label: "Réunion", flag: "🇷🇪", code: "+262" },
+    romania: { label: "Romania", flag: "🇷🇴", code: "+40" },
+    russia: { label: "Russia", flag: "🇷🇺", code: "+7" },
+    rwanda: { label: "Rwanda", flag: "🇷🇼", code: "+250" },
+    saintkittsandnevis: { label: "Saint Kitts and Nevis", flag: "🇰🇳", code: "+1" },
+    saintlucia: { label: "Saint Lucia", flag: "🇱🇨", code: "+1" },
+    saintvincentandgrenadines: { label: "Saint Vincent and the Grenadines", flag: "🇻🇨", code: "+1" },
+    salvador: { label: "El Salvador", flag: "🇸🇻", code: "+503" },
+    samoa: { label: "Samoa", flag: "🇼🇸", code: "+685" },
+    saudiarabia: { label: "Saudi Arabia", flag: "🇸🇦", code: "+966" },
+    senegal: { label: "Senegal", flag: "🇸🇳", code: "+221" },
+    serbia: { label: "Serbia", flag: "🇷🇸", code: "+381" },
+    seychelles: { label: "Seychelles", flag: "🇸🇨", code: "+248" },
+    sierraleone: { label: "Sierra Leone", flag: "🇸🇱", code: "+232" },
+    singapore: { label: "Singapore", flag: "🇸🇬", code: "+65" },
+    slovakia: { label: "Slovakia", flag: "🇸🇰", code: "+421" },
+    slovenia: { label: "Slovenia", flag: "🇸🇮", code: "+386" },
+    solomonislands: { label: "Solomon Islands", flag: "🇸🇧", code: "+677" },
+    southafrica: { label: "South Africa", flag: "🇿🇦", code: "+27" },
+    spain: { label: "Spain", flag: "🇪🇸", code: "+34" },
+    srilanka: { label: "Sri Lanka", flag: "🇱🇰", code: "+94" },
+    suriname: { label: "Suriname", flag: "🇸🇷", code: "+597" },
+    swaziland: { label: "Eswatini", flag: "🇸🇿", code: "+268" },
+    sweden: { label: "Sweden", flag: "🇸🇪", code: "+46" },
+    switzerland: { label: "Switzerland", flag: "🇨🇭", code: "+41" },
+    taiwan: { label: "Taiwan", flag: "🇹🇼", code: "+886" },
+    tajikistan: { label: "Tajikistan", flag: "🇹🇯", code: "+992" },
+    tanzania: { label: "Tanzania", flag: "🇹🇿", code: "+255" },
+    thailand: { label: "Thailand", flag: "🇹🇭", code: "+66" },
+    tit: { label: "East Timor", flag: "🇹🇱", code: "+670" },
+    togo: { label: "Togo", flag: "🇹🇬", code: "+228" },
+    tunisia: { label: "Tunisia", flag: "🇹🇳", code: "+216" },
+    turkmenistan: { label: "Turkmenistan", flag: "🇹🇲", code: "+993" },
+    uganda: { label: "Uganda", flag: "🇺🇬", code: "+256" },
+    ukraine: { label: "Ukraine", flag: "🇺🇦", code: "+380" },
+    uruguay: { label: "Uruguay", flag: "🇺🇾", code: "+598" },
+    usa: { label: "United States", flag: "🇺🇸", code: "+1" },
+    uzbekistan: { label: "Uzbekistan", flag: "🇺🇿", code: "+998" },
+    venezuela: { label: "Venezuela", flag: "🇻🇪", code: "+58" },
+    vietnam: { label: "Vietnam", flag: "🇻🇳", code: "+84" },
+    zambia: { label: "Zambia", flag: "🇿🇲", code: "+260" }
+};

src/bots/utils/handlerUtils.ts

@@ -0,0 +1,90 @@
+// utils/handlerUtils.ts
+
+import { BotContext } from "../types/botTypes";
+import { createLogger } from '../../utils/logger';
+import { AuthService } from '../services/auth';
+import { messageManager } from './messageManager';
+import { getMainMenuKeyboard } from './keyboardUtils';
+
+const logger = createLogger('HandlerUtils');
+const authService = AuthService.getInstance();
+
+/**
+ * Creates a standardized message reply handler with error handling
+ * @param replyFunction Function that returns the message and options to send
+ * @returns A function that handles the reply with proper error handling
+ */
+export const messageReplyHandler = (
+  replyFunction: (ctx: BotContext) => Promise<{message: string, options?: any}> | {message: string, options?: any}
+) => async (ctx: BotContext) => {
+  try {
+    // Execute the reply function to get message content and options
+    const result = await Promise.resolve(replyFunction(ctx));
+    
+    // Get the message ID to reply to
+    const replyToMessageId = ctx.message?.message_id;
+    
+    // Define default options including parse_mode
+    const defaultOptions = {
+      parse_mode: 'HTML'
+    };
+    
+    // Add reply_to_message_id to options if not already set
+    const finalOptions = {
+      ...defaultOptions,
+      ...result.options,
+      reply_to_message_id: replyToMessageId
+    };
+    
+    // Send the reply with the message and options
+    return await ctx.reply(result.message, finalOptions);
+  } catch (error: any) {
+    // Log the error
+    logger.error(`Error in message reply handler: ${error.message}`);
+    
+    // Send a generic error message to the user
+    return ctx.reply("⚠️ حدث خطأ أثناء معالجة طلبك. الرجاء المحاولة مرة أخرى.");
+  }
+};
+
+/**
+ * Creates a standardized callback query handler with error handling
+ * @param replyFunction Function that returns the message and options to send after answering callback
+ * @returns A function that handles the callback with proper error handling
+ */
+export const callbackReplyHandler = (
+  replyFunction: (ctx: BotContext) => Promise<{message: string, options?: any}> | {message: string, options?: any}
+) => async (ctx: BotContext) => {
+  try {
+    // Answer the callback query first
+    await ctx.answerCbQuery();
+    
+    
+    // Execute the reply function to get message content and options
+    const result = await Promise.resolve(replyFunction(ctx));
+    
+    // Send the reply with the message and any provided options
+    return await ctx.reply(result.message, result.options);
+  } catch (error: any) {
+    // Log the error
+    logger.error(`Error in callback reply handler: ${error.message}`);
+    
+    // Send a generic error message to the user
+    return ctx.reply("⚠️ حدث خطأ أثناء معالجة طلبك. الرجاء المحاولة مرة أخرى.");
+  }
+};
+
+export const authCheckHandler = <T extends any[]>(
+  handler: (ctx: BotContext, ...args: T) => Promise<{message: string, options?: any}> | {message: string, options?: any}
+) => async (ctx: BotContext, ...args: T) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId, ctx)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  return handler(ctx, ...args);
+};

src/bots/utils/keyboardUtils.ts

@@ -0,0 +1,355 @@
+import { Markup } from "telegraf";
+import { countryData } from "./country";
+import { formatPrice } from "./priceUtils";
+import { BotContext } from "../types/botTypes";
+import { messageManager } from "./messageManager";
+import fiveSimProducts from "./5sim_products.json";
+import { VirtualNumberService } from "../services/VirtualNumberService";
+import { createLogger } from "../../utils/logger";
+
+const logger = createLogger('KeyboardUtils');
+
+export const getMainMenuKeyboard = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback(messageManager.getMessage('btn_login'), 'login')],
+    [Markup.button.callback(messageManager.getMessage('btn_terms'), 'terms')],
+    [Markup.button.callback(messageManager.getMessage('btn_new_members'), 'new_members')],
+    // [Markup.button.callback(messageManager.getMessage('btn_stats'), 'stats')],
+    [Markup.button.callback(messageManager.getMessage('btn_change_language'), 'change_language')],
+  ]);
+};
+
+export const getLoggedInMenuKeyboard = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback('🔍 Browse Services', 'browse_services')],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_profile'), 'profile'),
+      Markup.button.callback(messageManager.getMessage('btn_change_language'), 'change_language')
+    ],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_top_up'), 'top_up_balance'),
+      Markup.button.callback(messageManager.getMessage('btn_history'), 'history')
+    ],
+    // [Markup.button.callback('💰 Buy with Balance', 'buy_with_balance')],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_back'), 'main_menu')
+    ],
+  ]);
+};
+
+export const getServicesKeyboard = (page: number = 0, sortBy?: 'az' | 'za') => {
+  const buttons = [];
+  const services = Object.entries(fiveSimProducts);
+  const rowSize = 2; // 2 buttons per row
+  const servicesPerPage = 20;
+  
+
+  // Apply sorting for all services first
+  let sortedServices = [...services];
+  if (sortBy === 'az') {
+
+    sortedServices.sort((a, b) => a[1].label_en.localeCompare(b[1].label_en));
+  } else if (sortBy === 'za') {
+    sortedServices.sort((a, b) => b[1].label_en.localeCompare(a[1].label_en));
+  }
+  
+  const totalPages = Math.ceil(sortedServices.length / servicesPerPage);
+  
+  // Get services for current page from the sorted array
+  const startIndex = page * servicesPerPage;
+  const endIndex = Math.min(startIndex + servicesPerPage, sortedServices.length);
+  const pageServices = sortedServices.slice(startIndex, endIndex);
+
+  // Add sort button
+  const sortButtonText = sortBy === 'az' ? 'Sort Z-A ⬇️' : 'Sort A-Z ⬆️';
+  const sortButtonCallback = sortBy === 'az' ? `sort_services_za_${page}` : `sort_services_az_${page}`;
+  buttons.push([Markup.button.callback(sortButtonText, sortButtonCallback)]);
+
+  // Generate service buttons in pairs
+  for (let i = 0; i < pageServices.length; i += rowSize) {
+    const row = [];
+    for (let j = 0; j < rowSize && i + j < pageServices.length; j++) {
+      const [serviceId, serviceData] = pageServices[i + j];
+      row.push(
+        Markup.button.callback(
+          `${serviceData.icon} ${serviceData.label_en}`,
+          `service_${serviceId}`
+        )
+      );
+    }
+    buttons.push(row);
+  }
+
+  // Add pagination buttons
+  const paginationRow = [];
+  if (page > 0) {
+    paginationRow.push(
+      Markup.button.callback(
+        '⬅️ Previous',
+        `services_page_${page - 1}${sortBy ? `_${sortBy}` : ''}`
+      )
+    );
+  }
+  
+  paginationRow.push(
+    Markup.button.callback(
+      `📄 ${page + 1}/${totalPages}`,
+      'noop'
+    )
+  );
+  
+  if (page < totalPages - 1) {
+    paginationRow.push(
+      Markup.button.callback(
+        'Next ➡️',
+        `services_page_${page + 1}${sortBy ? `_${sortBy}` : ''}`
+      )
+    );
+  }
+  
+  if (paginationRow.length > 0) {
+    buttons.push(paginationRow);
+  }
+
+  // Add search button
+  buttons.push([Markup.button.callback('🔍 Search Product', 'search_product')]);
+
+  // Add back button to return to main menu
+  buttons.push([
+    Markup.button.callback('🔙 Back to Menu', 'logged_in_menu')
+  ]);
+
+  return Markup.inlineKeyboard(buttons);
+};
+
+export const getServicesPaginationInfo = (page: number = 0) => {
+  const services = Object.entries(fiveSimProducts);
+  const servicesPerPage = 10;
+  const totalPages = Math.ceil(services.length / servicesPerPage);
+  const startIndex = page * servicesPerPage;
+  const endIndex = Math.min(startIndex + servicesPerPage, services.length);
+  
+  return `<b>Services List</b>\n` +
+         `📋 Showing services ${startIndex + 1}-${endIndex} of ${services.length}\n` +
+         `📄 Page ${page + 1} of ${totalPages}`;
+};
+
+export const getBackToMainMenuButton = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback(messageManager.getMessage('btn_back'), 'main_menu')]
+  ]);
+};
+
+export const mapApiCountriesToButtons = (apiCountries: any[], service: string) => {
+    const buttons = [];
+    const rowSize = 2; // 2 buttons per row
+    
+    // Sort countries by name for better UX
+    const sortedCountries = apiCountries.sort((a, b) => a.name.localeCompare(b.name));
+    
+    for (let i = 0; i < sortedCountries.length; i += rowSize) {
+        const row = [];
+        for (let j = 0; j < rowSize && i + j < sortedCountries.length; j++) {
+            const country = sortedCountries[i + j];
+            const countryInfo = countryData[country.id.toLowerCase()];
+            if (countryInfo) {
+                row.push(
+                    Markup.button.callback(
+                        `${countryInfo.label} ${countryInfo.flag} ${countryInfo.code}`, 
+                        `country_${service}_${country.id}`
+                    )
+                );
+            }
+        }
+        if (row.length > 0) {
+            buttons.push(row);
+        }
+    }
+    
+    return buttons;
+};
+
+export const getCountriesKeyboard = async (service: string, page: number = 0) => {
+    const buttons = [];
+    const countriesPerPage = 15;
+    
+    try {
+        // Get countries from API
+        const virtualNumberService = VirtualNumberService.getInstance();
+        const apiCountries = await virtualNumberService.getAvailableCountries(service);
+        
+        const mappedButtons = mapApiCountriesToButtons(apiCountries, service);
+        const totalPages = Math.ceil(mappedButtons.length / countriesPerPage);
+        const startIndex = page * countriesPerPage;
+        const endIndex = Math.min(startIndex + countriesPerPage, mappedButtons.length);
+        const pageButtons = mappedButtons.slice(startIndex, endIndex);
+        
+        buttons.push(...pageButtons);
+        
+        const paginationRow = [];
+        if (page > 0) {
+            paginationRow.push(
+                Markup.button.callback(
+                    messageManager.getMessage('btn_previous'),
+                    `page_${service}_${page - 1}`
+                )
+            );
+        }
+        
+        paginationRow.push(
+            Markup.button.callback(
+                messageManager.getMessage('btn_page_info')
+                    .replace('{current}', (page + 1).toString())
+                    .replace('{total}', totalPages.toString()),
+                'noop'
+            )
+        );
+        
+        if (page < totalPages - 1) {
+            paginationRow.push(
+                Markup.button.callback(
+                    messageManager.getMessage('btn_next'),
+                    `page_${service}_${page + 1}`
+                )
+            );
+        }
+        
+        if (paginationRow.length > 0) {
+            buttons.push(paginationRow);
+        }
+        
+        buttons.push([
+            Markup.button.callback(
+                messageManager.getMessage('btn_main_menu'),
+                'main_menu'
+            )
+        ]);
+    } catch (error: any) {
+        logger.error(`Error fetching countries: ${error.message}`);
+        buttons.push([
+            Markup.button.callback(
+                messageManager.getMessage('btn_error_loading_countries'),
+                'main_menu'
+            )
+        ]);
+    }
+    
+    return Markup.inlineKeyboard(buttons);
+};
+
+export const getServicePricesKeyboard = (
+  prices: any,
+  service: string,
+  country: string,
+  ctx: BotContext
+) => {
+  const buttons = [];
+
+  const hasValidPrices = prices && Object.values(prices).some(
+    (priceInfo: any) => priceInfo && priceInfo.count > 0
+  );
+
+  if (!hasValidPrices) {
+    buttons.push([
+      Markup.button.callback(
+        messageManager.getMessage('btn_no_prices'),
+        'noop'
+      ),
+    ]);
+  } else {
+    Object.entries(prices).forEach(([operator, priceInfo]: [string, any]) => {
+      if (priceInfo.count > 0) {
+        buttons.push([
+          Markup.button.callback(
+            messageManager.getMessage('btn_buy_format')
+              .replace('{price}', priceInfo.cost.toFixed(2))
+              .replace('{count}', priceInfo.count.toString()),
+            `buy_${service}_${country}_${operator}`
+          ),
+        ]);
+      }
+    });
+  }
+
+  buttons.push([
+    Markup.button.callback(
+      messageManager.getMessage('btn_back_to_services'),
+      `service_${service}`
+    ),
+  ]);
+  
+  buttons.push([
+    Markup.button.callback(
+      messageManager.getMessage('btn_main_menu'),
+      'main_menu'
+    )
+  ]);
+
+  return Markup.inlineKeyboard(buttons);
+};
+
+export const getHistoryKeyboard = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback(
+      messageManager.getMessage('btn_numbers_history'),
+      'numbers_history'
+    )],
+    [Markup.button.callback(
+      messageManager.getMessage('btn_purchases_history'),
+      'purchases_history'
+    )],
+    [Markup.button.callback(
+      messageManager.getMessage('btn_back_to_main'),
+      'main_menu'
+    )]
+  ]);
+};
+
+export const getLanguageSelectionKeyboard = (isLoggedIn: boolean = false) => {
+  const buttons = [
+    [
+      Markup.button.callback(
+        messageManager.getMessage('btn_lang_english'),
+        'set_language_en'
+      ),
+      Markup.button.callback(
+        messageManager.getMessage('btn_lang_arabic'),
+        'set_language_ar'
+      )
+    ]
+  ];
+
+  buttons.push([
+    Markup.button.callback(
+      messageManager.getMessage('btn_back'),
+      isLoggedIn ? 'logged_in_menu' : 'main_menu'
+    )
+  ]);
+
+  return Markup.inlineKeyboard(buttons);
+};
+
+export const getProfileKeyboard = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback(
+      messageManager.getMessage('btn_change_email'),
+      'change_email'
+    )],
+    [Markup.button.callback(
+      messageManager.getMessage('btn_change_password'),
+      'change_password'
+    )],
+    [Markup.button.callback(
+      messageManager.getMessage('btn_account_info'),
+      'account_info'
+    )],
+    // [Markup.button.callback(
+    //   messageManager.getMessage('btn_gift_balance'),
+    //   'gift_balance'
+    // )],
+    [Markup.button.callback(
+      messageManager.getMessage('btn_back_to_logged_in'),
+      'logged_in_menu'
+    )]
+  ]);
+};

src/bots/utils/messageManager.ts

@@ -0,0 +1,155 @@
+import { supabase } from '../../db/supabase';
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('MessageManager');
+
+interface BotMessage {
+  id: string;
+  bot_id: string;
+  key: string;
+  ar_value: string;
+  en_value: string;
+  description?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+class MessageManager {
+  private static instance: MessageManager;
+  private messages: Map<string, BotMessage> = new Map();
+  private language: 'ar' | 'en' = 'ar';
+
+  private constructor() {}
+
+  static getInstance(): MessageManager {
+    if (!MessageManager.instance) {
+      MessageManager.instance = new MessageManager();
+    }
+    return MessageManager.instance;
+  }
+
+  setLanguage(lang: 'ar' | 'en') {
+    this.language = lang;
+  }
+
+  async loadMessages() {
+    try {
+      const { data, error } = await supabase
+        .from('bot_messages')
+        .select('*')
+
+      if (error) throw error;
+
+      this.messages.clear();
+      data.forEach((message: BotMessage) => {
+        this.messages.set(message.key, message);
+      });
+
+      // Add default messages if not in database
+      this.addDefaultMessages();
+
+      logger.info(`Messages loaded successfully for bot `);
+    } catch (error) {
+      logger.error('Error loading messages:', error);
+      throw error;
+    }
+  }
+
+  private addDefaultMessages() {
+    const defaultMessages = {
+      'balance_update_notification': {
+        ar_value: '💰 <b>تحديث الرصيد</b>\n\n' +
+                 'تم تحديث رصيدك:\n' +
+                 'الرصيد السابق: {old_balance}$\n' +
+                 'الرصيد الجديد: {new_balance}$\n' +
+                 'نوع التغيير: {change_type}\n' +
+                 'قيمة التغيير: {change_amount}$',
+        en_value: '💰 <b>Balance Update</b>\n\n' +
+                 'Your balance has been updated:\n' +
+                 'Previous balance: ${old_balance}\n' +
+                 'New balance: ${new_balance}\n' +
+                 'Change type: {change_type}\n' +
+                 'Change amount: ${change_amount}'
+      },
+      'search_product_prompt': {
+        ar_value: 'الرجاء إدخال اسم الخدمة التي تبحث عنها:',
+        en_value: 'Please enter the name of the service you are looking for:'
+      },
+      'no_search_results': {
+        ar_value: 'عذراً، لم يتم العثور على نتائج لبحثك.',
+        en_value: 'Sorry, no results found for your search.'
+      },
+      'invalid_search_input': {
+        ar_value: 'الرجاء إدخال ما لا يقل عن حرفين للبحث.',
+        en_value: 'Please enter at least 2 characters to search.'
+      },
+      'search_country_prompt': {
+        ar_value: 'الرجاء إدخال اسم الدولة أو رمزها أو علمها:',
+        en_value: 'Please enter the country name, code, or flag:'
+      },
+      'no_country_search_results': {
+        ar_value: 'عذراً، لم يتم العثور على دول مطابقة لبحثك.',
+        en_value: 'Sorry, no matching countries found for your search.'
+      },
+      'affordable_products_list': {
+        ar_value: 'المنتجات التي يمكنك شراؤها برصيدك الحالي ({balance}):',
+        en_value: 'Products you can buy with your current balance ({balance}):'
+      },
+      'no_affordable_products': {
+        ar_value: 'عذراً، لا توجد منتجات يمكنك شراؤها برصيدك الحالي ({balance}).',
+        en_value: 'Sorry, no products can be bought with your current balance ({balance}).'
+      }
+    };
+
+    Object.entries(defaultMessages).forEach(([key, value]) => {
+      if (!this.messages.has(key)) {
+        this.messages.set(key, {
+          id: key,
+          bot_id: 'default',
+          key,
+          ar_value: value.ar_value,
+          en_value: value.en_value,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString()
+        });
+      }
+    });
+  }
+
+  getMessage(key: string): string {
+    const message = this.messages.get(key);
+    if (!message) {
+      logger.warn(`Message not found for key: ${key}`);
+      return `${key}`;
+    }
+    return this.language === 'ar' ? message.ar_value : message.en_value;
+  }
+
+  async updateMessage(key: string, arValue: string, enValue: string, description?: string) {
+    try {
+      const { data, error } = await supabase
+        .from('bot_messages')
+        .upsert({
+          key,
+          ar_value: arValue,
+          en_value: enValue,
+          description
+        })
+        .select()
+        .single();
+
+      if (error) throw error;
+
+      if (data) {
+        this.messages.set(key, data);
+      }
+
+      return data;
+    } catch (error) {
+      logger.error('Error updating message:', error);
+      throw error;
+    }
+  }
+}
+
+export const messageManager = MessageManager.getInstance();