allh

.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'],
+}

.gitignore

@@ -0,0 +1,40 @@
+
+.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
+.git2222

.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

@@ -1,32 +1,26 @@
+# Use the official Node.js image with the desired version
 FROM node:22.13.1-slim
 
-# Install unzip
-RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
-
-# Set working directory
+# Set the working directory inside the container
 WORKDIR /usr/src/app
 
-# Copy and unzip the zip file
-COPY mousa-backend-main.zip ./
-RUN unzip mousa-backend-main.zip && rm mousa-backend-main.zip
-
-# Change to the extracted folder
-WORKDIR /usr/src/app/mousa-backend-main
-
 # Install pnpm globally
 RUN npm install -g pnpm
 
-# Install dependencies
+# Copy package.json and pnpm-lock.yaml
+COPY package.json pnpm-lock.yaml* ./
+
+# Install dependencies using pnpm
 RUN pnpm install --frozen-lockfile
 
-# Build the app
-RUN pnpm run build
+# Copy the rest of the application code
+COPY . .
 
-# Create writable logs directory
-RUN mkdir -p logs && chmod 777 logs
+# Build the TypeScript project
+RUN pnpm run build
 
-# Expose the app port
+# Expose the port your app runs on
 EXPOSE 7860
 
-# Start the app
-CMD ["pnpm", "run", "start"]
+# 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,4 @@
+git add .
+git commit -m "allh"
+git push
+

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);

mousa-backend-main.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:28273693a30c40a730d3c546792211e5fe01fcab9be89fd07e4158d98e67d10e
-size 146326

package.json

@@ -0,0 +1,54 @@
+{
+  "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"
+  },
+  "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,173 @@
+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";
+
+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;
+ 
+  settings: Record<string, any>;
+  state: Record<string, any>;
+  created_at: string;
+  updated_at: string;
+}
+
+// Update the initializeBot function to accept botData
+export const initializeBot = async (botToken: string, botData?: BotData) => {
+  try {
+    const bot = new Telegraf<BotContext>(botToken);
+    
+    // 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();
+    });
+    
+    // Setup command handlers
+    setupCommandHandlers(bot);
+    
+    // Setup callback handlers
+    setupCallbackHandlers(bot);
+    
+    // Set bot commands
+    await bot.telegram.setMyCommands(BotCommands);
+    
+    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}` };
+  }
+};
+
+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) {
+      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 supabase
+        .from('bots')
+        .update({
+          is_active: false,
+          state: {
+            status: 'stopped',
+            stoppedAt: new Date().toISOString()
+          }
+        })
+        .eq('id', botId);
+        
+      return { success: true, message: "Bot stopped successfully" };
+    }
+    return { success: false, message: "Bot instance not found" };
+  } catch (error: any) {
+    logger.error(`Error stopping bot: ${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,110 @@
+-- users_bot_telegram table
+CREATE TABLE IF NOT EXISTS public.users_bot_telegram (
+  id SERIAL PRIMARY KEY, -- Auto-incrementing primary key
+  telegram_id BIGINT UNIQUE NOT NULL, -- Unique Telegram user ID
+  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
+);
+
+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();

src/bots/handlers/balanceHandlers.ts

@@ -0,0 +1,283 @@
+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";
+
+const logger = createLogger('BalanceHandlers');
+const authService = AuthService.getInstance();
+const paypalService = PayPalService.getInstance();
+const cryptoService = CryptoService.getInstance();
+const adminService = AdminService.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 = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId);
+  
+  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 || '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 = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  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 = async (ctx: BotContext, method: PaymentMethod) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  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 = async (ctx: BotContext, amount: number) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: messageManager.getMessage('auth_required'),
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId);
+  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 paymentLink = await paypalService.createPaymentLink(user.id, 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 cryptoAddress = await cryptoService.getPaymentAddress(user.id, 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 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 amountText = ctx.message?.text;
+  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)) {
+    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);
+  
+  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'),
+      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)) {
+    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)) {
+    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);
+    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)) {
+    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)) {
+    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)) {
+    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,44 @@
+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';
+
+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);
+  });
+  
+  // 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);
+    }
+  });
+}; 

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) ;
+
+  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) : 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,145 @@
+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)) {
+      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);
+    
+    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()
+      };
+    } else {
+      try {
+        const { data: bots } = await fetchDataFromTable('bots', 1000, 0, { bot_token: botToken });
+        const botId = bots && bots.length > 0 ? bots[0].id : null;
+        
+        if (!botId) {
+          logger.error(`Bot not found for token ${botToken}`);
+          return {
+            message: messageManager.getMessage('login_error_system'),
+            options: getBackToMainMenuButton()
+          };
+        }
+        
+        const { user: newUser, password } = await authService.createUser(telegramId, firstName, botId);
+        authService.setUserLoggedIn(telegramId, true);
+        
+        logger.info(`New user ${telegramId} created successfully with bot ID ${botId}`);
+        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)) {
+    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,318 @@
+import { BotContext } from "../types/botTypes";
+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);
+  });
+
+  bot.action('account_info', async (ctx: BotContext) => {
+    const result = await handleAccountInfoAction(ctx);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('change_email', async (ctx: BotContext) => {
+    const result = await handleChangeEmailAction(ctx);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  bot.action('change_password', async (ctx: BotContext) => {
+    const result = await handleChangePasswordAction(ctx);
+    await ctx.editMessageText(result.message, result.options);
+  });
+
+  // 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);
+    }
+  });
+};
+
+const handleProfileAction = async (ctx: BotContext) => {
+  const telegramId = ctx.from?.id;
+  
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: "⚠️ الرجاء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId);
+  
+  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)) {
+    return {
+      message: "⚠️ الرجاء تسجيل الدخول أولاً",
+      options: getMainMenuKeyboard()
+    };
+  }
+
+  const user = await authService.getUserByTelegramId(telegramId);
+  
+  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)) {
+    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)) {
+    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,232 @@
+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 { serviceMapping } from './serviceHandlers';
+import { 
+  getAuthRequiredMessage,
+  getServiceUnavailableMessage,
+  getInsufficientBalanceMessage,
+  getPurchaseSuccessMessage,
+  getPurchaseFailedMessage,
+  getPurchaseErrorMessage,
+  getVerificationTimeoutMessage,
+  getProcessingPurchaseMessage
+} from "../utils/messageUtils";
+import { getLoggedInMenuKeyboard, getMainMenuKeyboard } from "../utils/keyboardUtils";
+import { messageManager } from "../utils/messageManager";
+
+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, serviceMapping, 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, 
+  serviceMapping: {[key: string]: string},
+  loadingMsgId: number
+) => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    await ctx.deleteMessage(loadingMsgId);
+    await ctx.reply(getAuthRequiredMessage(), getMainMenuKeyboard());
+    return;
+  }
+  
+  try {
+    const fiveSimService = serviceMapping[service];
+    const prices = await virtualNumberService.getPrices(fiveSimService, countryId);
+
+    // Add validation to check if the price exists for this operator
+    if (!prices || !prices[countryId] || !prices[countryId][fiveSimService] || !prices[countryId][fiveSimService][operator]) {
+      await ctx.deleteMessage(loadingMsgId);
+      await ctx.reply(
+        getServiceUnavailableMessage(service, operator, countryId),
+        getLoggedInMenuKeyboard()
+      );
+      return;
+    }
+
+    const cost = prices[countryId][fiveSimService][operator].cost;
+    
+    // 💰 Balance check
+    const user = await authService.getUserByTelegramId(telegramId);
+    if (!user || user.balance < cost) {
+      await ctx.deleteMessage(loadingMsgId);
+      await ctx.reply(
+        getInsufficientBalanceMessage(cost, user?.balance || 0),
+        getLoggedInMenuKeyboard()
+      );
+      return;
+    }
+    
+    // 🛒 Purchase number
+    const purchaseResult = await virtualNumberService.purchaseNumber(fiveSimService, countryId, operator);
+    await ctx.deleteMessage(loadingMsgId);
+    
+    if (purchaseResult && purchaseResult.phone) {
+      // ➖ Deduct balance
+      await authService.updateUserBalance(telegramId, user.balance - cost);
+      
+      // 💾 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: cost,
+        state: PurchaseState.PENDING
+      });
+      
+      // Send purchase confirmation
+      const confirmMsg = await ctx.reply(
+        getPurchaseSuccessMessage(purchaseResult, service, countryId, operator, cost),
+        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
+            );
+            
+            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: cost,
+          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!);
+      if (user) {
+        await purchaseTrackingService.createPurchase({
+          userId: user.id,
+          telegramId: telegramId!,
+          service: service,
+          countryId: countryId,
+          operator: operator,
+          cost: 0, // We don't know the cost in this error case
+          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,174 @@
+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
+} from "../utils/messageUtils";
+import { 
+  getLoggedInMenuKeyboard, 
+  getMainMenuKeyboard,
+  getCountriesKeyboard,
+  getServicePricesKeyboard
+} from "../utils/keyboardUtils";
+import { calculatePriceWithProfit, formatPrice } from "../utils/priceUtils";
+
+const logger = createLogger('ServiceHandlers');
+const authService = AuthService.getInstance();
+const virtualNumberService = VirtualNumberService.getInstance();
+
+// Service name to API code mapping
+export const serviceMapping: {[key: string]: string} = {
+  'telegram': 'telegram',
+  'whatsapp': 'whatsapp',
+  'facebook': 'facebook',
+  'instagram': 'instagram',
+  'tiktok': 'tiktok',
+  'twitter': 'twitter',
+  'snapchat': 'snapchat',
+  'google': 'google',
+  'imo': 'imo',
+  'general': 'other',
+  'royal': 'other',
+  'random': 'other'
+};
+
+export const setupServiceHandlers = (bot: any) => {
+  // 🌐 Service configuration
+  const services = [
+    'telegram', 'whatsapp', 'facebook', 'instagram', 
+    'tiktok', 'twitter', 'snapchat', 'google',
+    'imo', 'general', 'royal', 'random'
+  ];
+  
+  // Register service selection handlers
+  services.forEach(service => {
+    bot.action(`service_${service}`, callbackReplyHandler(async (ctx: BotContext) => {
+      return handleServiceSelection(ctx, service, serviceMapping);
+    }));
+  });
+  
+  // Register country selection handler
+  bot.action(/^country_(.+)_(.+)$/, callbackReplyHandler(async (ctx: BotContext) => {
+    return handleCountrySelection(ctx, serviceMapping);
+  }));
+  
+  // Register pagination handler
+  bot.action(/^page_(.+)_(\d+)$/, async (ctx: BotContext) => {
+    await ctx.answerCbQuery();
+    
+    const match = ctx.match as RegExpMatchArray;
+    const service = match[1];
+    const page = parseInt(match[2], 10);
+    
+    // 🔒 Authentication check
+    const telegramId = ctx.from?.id;
+    if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+      await ctx.reply(getAuthRequiredMessage(), getMainMenuKeyboard());
+      return;
+    }
+    
+    try {
+      // Edit the existing message instead of sending a new one
+      await (ctx as any).editMessageText(
+        getCountriesListMessage(service, page),
+        getCountriesKeyboard(service, page)
+      );
+    } catch (error: any) {
+      logger.error(`Error navigating to page ${page} for ${service}: ${error.message}`);
+      await ctx.reply(getPaginationErrorMessage(), getLoggedInMenuKeyboard());
+    }
+  });
+};
+
+// Helper function for pagination error message
+const getPaginationErrorMessage = () => {
+  return `⚠️ حدث خطأ أثناء تحميل الصفحة. يرجى المحاولة مرة أخرى.`;
+};
+
+export const handleServiceSelection = async (ctx: BotContext, service: string, serviceMapping: {[key: string]: string}) => {
+  // 🔒 Authentication check
+  const telegramId = ctx.from?.id;
+  if (!telegramId || !authService.isUserLoggedIn(telegramId)) {
+    return {
+      message: getAuthRequiredMessage(),
+      options: getMainMenuKeyboard()
+    };
+  }
+  
+  try {
+    return {
+      message: getCountriesListMessage(service),
+      options: getCountriesKeyboard(service, 0)
+    };
+    
+  } catch (error: any) {
+    logger.error(`Error fetching countries for ${service}: ${error.message}`);
+    return {
+      message: getServiceErrorMessage(service),
+      options: getLoggedInMenuKeyboard()
+    };
+  }
+};
+
+
+
+export const handleCountrySelection = async (ctx: BotContext, serviceMapping: {[key: string]: string}) => {
+    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)) {
+      return {
+        message: getAuthRequiredMessage(),
+        options: getMainMenuKeyboard()
+      };
+    }
+    
+    try {
+      const fiveSimService = serviceMapping[service];
+      const prices = await virtualNumberService.getPrices(fiveSimService, countryId);
+    //   ctx.reply(`prices: ${JSON.stringify(prices, null, 2)}`);
+
+      if (!prices || !prices[countryId] || !prices[countryId][fiveSimService] || 
+          Object.keys(prices[countryId][fiveSimService]).length === 0) {
+        return {
+          message: getNoPricesMessage(service, countryId),
+          options: getLoggedInMenuKeyboard()
+        };
+      }
+      
+      // Apply profit to prices before displaying
+      const pricesWithProfit = Object.entries(prices[countryId][fiveSimService]).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;
+      }, {});
+    
+      return {
+        message: getPricesListMessage(service, countryId, pricesWithProfit, ctx),
+        options: getServicePricesKeyboard(pricesWithProfit, service, countryId, ctx)
+      };
+      
+    } catch (error: any) {
+      logger.error(`Error fetching prices for ${service} in ${countryId}: ${error.message}`);
+ 
+      return {
+        message: getPricesErrorMessage(service, countryId),
+        options: getLoggedInMenuKeyboard()
+      };
+    }
+  };

src/bots/index.ts

@@ -0,0 +1,100 @@
+import { initializeBot } from "./botManager";
+import { telegrafBots } from "../models";
+import { supabase } from "../db/supabase";
+import { createLogger } from "../utils/logger";
+import { setupPaymentWebhookHandlers } from './handlers/paymentWebhookHandlers';
+
+const logger = createLogger('BotManager');
+
+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" } };
+    }
+
+    // Check if bot is already running
+    if (telegrafBots.has(botData.bot_token)) {
+      return { status: 400, data: { error: "Bot is already running" } };
+    }
+
+    // Validate bot token format
+    if (!botData.bot_token.includes(':')) {
+      logger.error(`Invalid bot token format for bot ${botId}`);
+      return { status: 400, data: { error: "Invalid bot token format" } };
+    }
+
+    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 {
+          // Launch the bot
+          // await result.bot.launch();
+          
+          // Update last_activity and is_active in database
+          await supabase
+            .from('bots')
+            .update({
+              is_active: true,
+              last_activity: new Date().toISOString(),
+              state: {
+                status: 'running',
+                startedAt: new Date().toISOString()
+              }
+            })
+            .eq('id', botId);
+            
+          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}`);
+          return { status: 500, data: { error: `Error launching bot: ${error.message}` } };
+        }
+      } else {
+        logger.error(`Error initializing bot: ${result.message}`);
+        return { status: 500, data: { error: result.message } };
+      }
+    } catch (error: any) {
+      logger.error(`Bot initialization error: ${error.message}`);
+      return { status: 500, data: { error: `Bot initialization error: ${error.message}` } };
+    }
+  } catch (error: any) {
+    logger.error(`Unexpected error: ${error.message}`);
+    return { status: 500, data: { error: `Unexpected error: ${error.message}` } };
+  }
+};

src/bots/services/AdminService.ts

@@ -0,0 +1,24 @@
+import { createLogger } from '../../utils/logger';
+import { supabase } from '../../db/supabase';
+
+const logger = createLogger('AdminService');
+
+export class AdminService {
+  private static instance: AdminService;
+  private readonly adminContact: string;
+
+  private constructor() {
+    this.adminContact = process.env.ADMIN_CONTACT || '';
+  }
+
+  public static getInstance(): AdminService {
+    if (!AdminService.instance) {
+      AdminService.instance = new AdminService();
+    }
+    return AdminService.instance;
+  }
+
+  async getAdminContact(): Promise<string> {
+    return this.adminContact;
+  }
+} 

src/bots/services/CryptoService.ts

@@ -0,0 +1,43 @@
+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() {
+    this.cryptoAddress = process.env.CRYPTO_WALLET_ADDRESS || '';
+  }
+
+  public static getInstance(): CryptoService {
+    if (!CryptoService.instance) {
+      CryptoService.instance = new CryptoService();
+    }
+    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,133 @@
+import { createLogger } from '../../utils/logger';
+import { supabase } from '../../db/supabase';
+
+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() {
+    this.clientId = process.env.PAYPAL_CLIENT_ID || '';
+    this.clientSecret = process.env.PAYPAL_CLIENT_SECRET || '';
+    this.isProduction = process.env.NODE_ENV === 'production';
+  }
+
+  public static getInstance(): PayPalService {
+    if (!PayPalService.instance) {
+      PayPalService.instance = new PayPalService();
+    }
+    return PayPalService.instance;
+  }
+
+  async createPaymentLink(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: 'PAYPAL'
+        })
+        .select()
+        .single();
+
+      if (error) throw error;
+
+      // Create PayPal order
+      const order = await this.createPayPalOrder(amount, payment.id);
+      
+      // Update payment record with PayPal order ID
+      await supabase
+        .from('payments')
+        .update({ payment_id: order.id })
+        .eq('id', payment.id);
+
+      const approveLink = order.links.find(link => link.rel === 'approve');
+      if (!approveLink) {
+        throw new Error('No approval link found in PayPal response');
+      }
+
+      return approveLink.href;
+    } catch (error) {
+      logger.error('Error creating PayPal payment:', error);
+      throw error;
+    }
+  }
+
+  private async createPayPalOrder(amount: number, paymentId: string): Promise<PayPalOrder> {
+    const accessToken = await this.getAccessToken();
+    
+    const response = await fetch(
+      `${this.isProduction ? 'https://api-m.paypal.com' : 'https://api-m.sandbox.paypal.com'}/v2/checkout/orders`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${accessToken}`
+        },
+        body: JSON.stringify({
+          intent: 'CAPTURE',
+          purchase_units: [{
+            amount: {
+              currency_code: 'USD',
+              value: amount.toString()
+            },
+            custom_id: paymentId
+          }]
+        })
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`PayPal API error: ${response.statusText}`);
+    }
+
+    const data = await response.json() as PayPalOrder;
+    return data;
+  }
+
+  private async getAccessToken(): Promise<string> {
+    const response = await fetch(
+      `${this.isProduction ? 'https://api-m.paypal.com' : 'https://api-m.sandbox.paypal.com'}/v1/oauth2/token`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Authorization': `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')}`
+        },
+        body: 'grant_type=client_credentials'
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`PayPal token error: ${response.statusText}`);
+    }
+
+    const data = await response.json() as PayPalTokenResponse;
+    return data.access_token;
+  }
+}

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,123 @@
+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;
+}
+
+export interface ServicePrice {
+    [country: string]: {
+        [operator: string]: PriceInfo;
+    };
+}
+
+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 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}`);
+        }
+    }
+} 

src/bots/services/auth.ts

@@ -0,0 +1,179 @@
+import { 
+    fetchDataFromTable, 
+    insertDataIntoTable, 
+    updateDataInTable 
+  } from '../../db/supabaseHelper';
+  import { createLogger } from '../../utils/logger';
+  import { v4 as uuidv4 } from 'uuid';
+  import { supabase } from '../../db/supabase';
+  
+  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): string {
+      return `user_${telegramId}@saerosms.com`;
+    }
+  
+    public async createUser(telegramId: number, name: string, botId:string): Promise<{ user: UserBotTelegraf; password: string }> {
+      try {
+        const email = this.generateEmail(telegramId);
+        const password = this.generatePassword();
+        const passwordHash = await this.hashPassword(password);
+  
+        const userData: Omit<UserBotTelegraf, 'id'> = {
+          telegramId: telegramId,
+          firstName: name,
+          email,
+          passwordHash: passwordHash,
+          botId:botId
+        };
+  
+        const user = await insertDataIntoTable<UserBotTelegraf>('users_bot_telegram', userData);
+        
+        logger.info(`User ${telegramId} created successfully`);
+        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<number, boolean> = new Map();
+  
+    public setUserLoggedIn(telegramId: number, isLoggedIn: boolean = true): void {
+      this.loggedInUsers.set(telegramId, isLoggedIn);
+      logger.info(`User ${telegramId} login state set to ${isLoggedIn}`);
+    }
+  
+    public isUserLoggedIn(telegramId: number): boolean {
+      return this.loggedInUsers.get(telegramId) || false;
+    }
+  
+    public async loginUser(telegramId: number): Promise<UserBotTelegraf | null> {
+      try {
+        const { data: users } = await fetchDataFromTable<UserBotTelegraf>('users_bot_telegram', 1000, 0, {
+          telegram_id: telegramId,
+        });
+  
+        if (!users || users.length === 0) {
+          logger.info(`Login attempt for non-existent user ${telegramId}`);
+          return null;
+        }
+  
+        const user = users[0];
+        
+        // Update last login
+        await updateDataInTable<UserBotTelegraf>('users_bot_telegram', {
+          ...user,
+          lastLogin: new Date().toISOString()
+        });
+  
+        // Set user as logged in
+        this.setUserLoggedIn(telegramId, true);
+        
+        logger.info(`User ${telegramId} logged in successfully`);
+        return user;
+  
+      } catch (error: any) {
+        logger.error(`Error logging in user ${telegramId}: ${error.message}`);
+        throw new Error(`Failed to login user: ${error.message}`);
+      }
+    }
+  
+    public async getUserById(userId: string): Promise<UserBotTelegraf | null> {
+      try {
+        const { data: users } = await fetchDataFromTable<UserBotTelegraf>('users_bot_telegram', 1000, 0, {
+          id: userId
+        });
+  
+        return users[0] || null;
+      } catch (error: any) {
+        logger.error(`Error fetching user ${userId}: ${error.message}`);
+        throw new Error(`Failed to get user: ${error.message}`);
+      }
+    }
+  
+    /**
+     * Get user by Telegram ID
+     */
+    async getUserByTelegramId(telegramId: number): Promise<any> {
+        try {
+            const { data: users, error } = await supabase
+                .from('users_bot_telegram')
+                .select('*')
+                .eq('telegram_id', telegramId)
+                .single();
+            
+            if (error) throw error;
+            return users;
+        } catch (error: any) {
+            logger.error(`Error getting user by Telegram ID: ${error.message}`);
+            return null;
+        }
+    }
+  
+    /**
+     * Update user balance
+     */
+    async updateUserBalance(telegramId: number, newBalance: number): Promise<boolean> {
+        try {
+            const { error } = await supabase
+                .from('users_bot_telegram')
+                .update({ balance: newBalance })
+                .eq('telegram_id', telegramId);
+            
+            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,171 @@
+interface CountryInfo {
+    label: string;
+    flag: string;
+}
+
+interface CountryData {
+    [key: string]: CountryInfo;
+}
+
+export const countryData: CountryData = {
+    afghanistan: { label: "Afghanistan", flag: "🇦🇫" },
+    albania: { label: "Albania", flag: "🇦🇱" },
+    algeria: { label: "Algeria", flag: "🇩🇿" },
+    angola: { label: "Angola", flag: "🇦🇴" },
+    antiguaandbarbuda: { label: "Antigua and Barbuda", flag: "🇦🇬" },
+    argentina: { label: "Argentina", flag: "🇦🇷" },
+    armenia: { label: "Armenia", flag: "🇦🇲" },
+    aruba: { label: "Aruba", flag: "🇦🇼" },
+    australia: { label: "Australia", flag: "🇦🇺" },
+    austria: { label: "Austria", flag: "🇦🇹" },
+    azerbaijan: { label: "Azerbaijan", flag: "🇦🇿" },
+    bahamas: { label: "Bahamas", flag: "🇧🇸" },
+    bahrain: { label: "Bahrain", flag: "🇧🇭" },
+    bangladesh: { label: "Bangladesh", flag: "🇧🇩" },
+    barbados: { label: "Barbados", flag: "🇧🇧" },
+    belarus: { label: "Belarus", flag: "🇧🇾" },
+    belgium: { label: "Belgium", flag: "🇧🇪" },
+    belize: { label: "Belize", flag: "🇧🇿" },
+    benin: { label: "Benin", flag: "🇧🇯" },
+    bhutane: { label: "Bhutan", flag: "🇧🇹" },
+    bih: { label: "Bosnia and Herzegovina", flag: "🇧🇦" },
+    bolivia: { label: "Bolivia", flag: "🇧🇴" },
+    botswana: { label: "Botswana", flag: "🇧🇼" },
+    brazil: { label: "Brazil", flag: "🇧🇷" },
+    bulgaria: { label: "Bulgaria", flag: "🇧🇬" },
+    burkinafaso: { label: "Burkina Faso", flag: "🇧🇫" },
+    burundi: { label: "Burundi", flag: "🇧🇮" },
+    cambodia: { label: "Cambodia", flag: "🇰🇭" },
+    cameroon: { label: "Cameroon", flag: "🇨🇲" },
+    canada: { label: "Canada", flag: "🇨🇦" },
+    capeverde: { label: "Cape Verde", flag: "🇨🇻" },
+    chad: { label: "Chad", flag: "🇹🇩" },
+    chile: { label: "Chile", flag: "🇨🇱" },
+    colombia: { label: "Colombia", flag: "🇨🇴" },
+    comoros: { label: "Comoros", flag: "🇰🇲" },
+    congo: { label: "Congo", flag: "🇨🇬" },
+    costarica: { label: "Costa Rica", flag: "🇨🇷" },
+    croatia: { label: "Croatia", flag: "🇭🇷" },
+    cyprus: { label: "Cyprus", flag: "🇨🇾" },
+    czech: { label: "Czech Republic", flag: "🇨🇿" },
+    denmark: { label: "Denmark", flag: "🇩🇰" },
+    djibouti: { label: "Djibouti", flag: "🇩🇯" },
+    dominicana: { label: "Dominican Republic", flag: "🇩🇴" },
+    easttimor: { label: "East Timor", flag: "🇹🇱" },
+    ecuador: { label: "Ecuador", flag: "🇪🇨" },
+    egypt: { label: "Egypt", flag: "🇪🇬" },
+    england: { label: "England", flag: "🏴" },
+    equatorialguinea: { label: "Equatorial Guinea", flag: "🇬🇶" },
+    estonia: { label: "Estonia", flag: "🇪🇪" },
+    ethiopia: { label: "Ethiopia", flag: "🇪🇹" },
+    finland: { label: "Finland", flag: "🇫🇮" },
+    france: { label: "France", flag: "🇫🇷" },
+    frenchguiana: { label: "French Guiana", flag: "🇬🇫" },
+    gabon: { label: "Gabon", flag: "🇬🇦" },
+    gambia: { label: "Gambia", flag: "🇬🇲" },
+    georgia: { label: "Georgia", flag: "🇬🇪" },
+    germany: { label: "Germany", flag: "🇩🇪" },
+    ghana: { label: "Ghana", flag: "🇬🇭" },
+    gibraltar: { label: "Gibraltar", flag: "🇬🇮" },
+    greece: { label: "Greece", flag: "🇬🇷" },
+    guadeloupe: { label: "Guadeloupe", flag: "🇬🇵" },
+    guatemala: { label: "Guatemala", flag: "🇬🇹" },
+    guinea: { label: "Guinea", flag: "🇬🇳" },
+    guineabissau: { label: "Guinea-Bissau", flag: "🇬🇼" },
+    guyana: { label: "Guyana", flag: "🇬🇾" },
+    haiti: { label: "Haiti", flag: "🇭🇹" },
+    honduras: { label: "Honduras", flag: "🇭🇳" },
+    hongkong: { label: "Hong Kong", flag: "🇭🇰" },
+    hungary: { label: "Hungary", flag: "🇭🇺" },
+    india: { label: "India", flag: "🇮🇳" },
+    indonesia: { label: "Indonesia", flag: "🇮🇩" },
+    ireland: { label: "Ireland", flag: "🇮🇪" },
+    israel: { label: "Israel", flag: "🇮🇱" },
+    italy: { label: "Italy", flag: "🇮🇹" },
+    ivorycoast: { label: "Ivory Coast", flag: "🇨🇮" },
+    jamaica: { label: "Jamaica", flag: "🇯🇲" },
+    jordan: { label: "Jordan", flag: "🇯🇴" },
+    kazakhstan: { label: "Kazakhstan", flag: "🇰🇿" },
+    kenya: { label: "Kenya", flag: "🇰🇪" },
+    kuwait: { label: "Kuwait", flag: "🇰🇼" },
+    kyrgyzstan: { label: "Kyrgyzstan", flag: "🇰🇬" },
+    laos: { label: "Laos", flag: "🇱🇦" },
+    latvia: { label: "Latvia", flag: "🇱🇻" },
+    lesotho: { label: "Lesotho", flag: "🇱🇸" },
+    liberia: { label: "Liberia", flag: "🇱🇷" },
+    lithuania: { label: "Lithuania", flag: "🇱🇹" },
+    luxembourg: { label: "Luxembourg", flag: "🇱🇺" },
+    macau: { label: "Macau", flag: "🇲🇴" },
+    madagascar: { label: "Madagascar", flag: "🇲🇬" },
+    malawi: { label: "Malawi", flag: "🇲🇼" },
+    malaysia: { label: "Malaysia", flag: "🇲🇾" },
+    maldives: { label: "Maldives", flag: "🇲🇻" },
+    mauritania: { label: "Mauritania", flag: "🇲🇷" },
+    mauritius: { label: "Mauritius", flag: "🇲🇺" },
+    mexico: { label: "Mexico", flag: "🇲🇽" },
+    moldova: { label: "Moldova", flag: "🇲🇩" },
+    mongolia: { label: "Mongolia", flag: "🇲🇳" },
+    montenegro: { label: "Montenegro", flag: "🇲🇪" },
+    morocco: { label: "Morocco", flag: "🇲🇦" },
+    mozambique: { label: "Mozambique", flag: "🇲🇿" },
+    namibia: { label: "Namibia", flag: "🇳🇦" },
+    nepal: { label: "Nepal", flag: "🇳🇵" },
+    netherlands: { label: "Netherlands", flag: "🇳🇱" },
+    newcaledonia: { label: "New Caledonia", flag: "🇳🇨" },
+    newzealand: { label: "New Zealand", flag: "🇳🇿" },
+    nicaragua: { label: "Nicaragua", flag: "🇳🇮" },
+    nigeria: { label: "Nigeria", flag: "🇳🇬" },
+    northmacedonia: { label: "North Macedonia", flag: "🇲🇰" },
+    norway: { label: "Norway", flag: "🇳🇴" },
+    oman: { label: "Oman", flag: "🇴🇲" },
+    pakistan: { label: "Pakistan", flag: "🇵🇰" },
+    panama: { label: "Panama", flag: "🇵🇦" },
+    papuanewguinea: { label: "Papua New Guinea", flag: "🇵🇬" },
+    paraguay: { label: "Paraguay", flag: "🇵🇾" },
+    peru: { label: "Peru", flag: "🇵🇪" },
+    philippines: { label: "Philippines", flag: "🇵🇭" },
+    poland: { label: "Poland", flag: "🇵🇱" },
+    portugal: { label: "Portugal", flag: "🇵🇹" },
+    puertorico: { label: "Puerto Rico", flag: "🇵🇷" },
+    reunion: { label: "Réunion", flag: "🇷🇪" },
+    romania: { label: "Romania", flag: "🇷🇴" },
+    russia: { label: "Russia", flag: "🇷🇺" },
+    rwanda: { label: "Rwanda", flag: "🇷🇼" },
+    saintkittsandnevis: { label: "Saint Kitts and Nevis", flag: "🇰🇳" },
+    saintlucia: { label: "Saint Lucia", flag: "🇱🇨" },
+    saintvincentandgrenadines: { label: "Saint Vincent and the Grenadines", flag: "🇻🇨" },
+    salvador: { label: "El Salvador", flag: "🇸🇻" },
+    samoa: { label: "Samoa", flag: "🇼🇸" },
+    saudiarabia: { label: "Saudi Arabia", flag: "🇸🇦" },
+    senegal: { label: "Senegal", flag: "🇸🇳" },
+    serbia: { label: "Serbia", flag: "🇷🇸" },
+    seychelles: { label: "Seychelles", flag: "🇸🇨" },
+    sierraleone: { label: "Sierra Leone", flag: "🇸🇱" },
+    singapore: { label: "Singapore", flag: "🇸🇬" },
+    slovakia: { label: "Slovakia", flag: "🇸🇰" },
+    slovenia: { label: "Slovenia", flag: "🇸🇮" },
+    solomonislands: { label: "Solomon Islands", flag: "🇸🇧" },
+    southafrica: { label: "South Africa", flag: "🇿🇦" },
+    spain: { label: "Spain", flag: "🇪🇸" },
+    srilanka: { label: "Sri Lanka", flag: "🇱🇰" },
+    suriname: { label: "Suriname", flag: "🇸🇷" },
+    swaziland: { label: "Eswatini", flag: "🇸🇿" },
+    sweden: { label: "Sweden", flag: "🇸🇪" },
+    switzerland: { label: "Switzerland", flag: "🇨🇭" },
+    taiwan: { label: "Taiwan", flag: "🇹🇼" },
+    tajikistan: { label: "Tajikistan", flag: "🇹🇯" },
+    tanzania: { label: "Tanzania", flag: "🇹🇿" },
+    thailand: { label: "Thailand", flag: "🇹🇭" },
+    tit: { label: "East Timor", flag: "🇹🇱" },
+    togo: { label: "Togo", flag: "🇹🇬" },
+    tunisia: { label: "Tunisia", flag: "🇹🇳" },
+    turkmenistan: { label: "Turkmenistan", flag: "🇹🇲" },
+    uganda: { label: "Uganda", flag: "🇺🇬" },
+    ukraine: { label: "Ukraine", flag: "🇺🇦" },
+    uruguay: { label: "Uruguay", flag: "🇺🇾" },
+    usa: { label: "United States", flag: "🇺🇸" },
+    uzbekistan: { label: "Uzbekistan", flag: "🇺🇿" },
+    venezuela: { label: "Venezuela", flag: "🇻🇪" },
+    vietnam: { label: "Vietnam", flag: "🇻🇳" },
+    zambia: { label: "Zambia", flag: "🇿🇲" }
+};

src/bots/utils/handlerUtils.ts

@@ -0,0 +1,64 @@
+// utils/handlerUtils.ts
+
+import { BotContext } from "../types/botTypes";
+import { createLogger } from '../../utils/logger';
+
+const logger = createLogger('HandlerUtils');
+
+/**
+ * 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;
+    
+    // Add reply_to_message_id to options if not already set
+    const options = {
+      ...result.options,
+      reply_to_message_id: replyToMessageId
+    };
+    
+    // Send the reply with the message and options
+    return await ctx.reply(result.message, options);
+  } 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("⚠️ حدث خطأ أثناء معالجة طلبك. الرجاء المحاولة مرة أخرى.");
+  }
+};

src/bots/utils/keyboardUtils.ts

@@ -0,0 +1,247 @@
+import { Markup } from "telegraf";
+import { countryData } from "./country";
+import { formatPrice } from "./priceUtils";
+import { BotContext } from "../types/botTypes";
+import { messageManager } from "./messageManager";
+
+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(messageManager.getMessage('btn_service_telegram'), 'service_telegram'),
+      Markup.button.callback(messageManager.getMessage('btn_service_whatsapp'), 'service_whatsapp')
+    ],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_service_facebook'), 'service_facebook'),
+      Markup.button.callback(messageManager.getMessage('btn_service_instagram'), 'service_instagram')
+    ],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_service_tiktok'), 'service_tiktok'),
+      Markup.button.callback(messageManager.getMessage('btn_service_twitter'), 'service_twitter')
+    ],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_service_snapchat'), 'service_snapchat'),
+      Markup.button.callback(messageManager.getMessage('btn_service_google'), 'service_google')
+    ],
+    [
+      Markup.button.callback(messageManager.getMessage('btn_service_imo'), 'service_imo'),
+    ],
+    [
+      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(messageManager.getMessage('btn_back'), 'main_menu')
+    ],
+  ]);
+};
+
+export const getBackToMainMenuButton = () => {
+  return Markup.inlineKeyboard([
+    [Markup.button.callback(messageManager.getMessage('btn_back'), 'main_menu')]
+  ]);
+};
+
+export const getCountriesKeyboard = (service: string, page: number = 0) => {
+    const buttons = [];
+    const rowSize = 2; // 2 buttons per row
+    const countriesPerPage = 15;
+    
+    const countries = Object.entries(countryData).map(([id, data]) => ({
+        id,
+        name: data.label,
+        flag: data.flag
+    }));
+    
+    const totalPages = Math.ceil(countries.length / countriesPerPage);
+    const startIndex = page * countriesPerPage;
+    const endIndex = Math.min(startIndex + countriesPerPage, countries.length);
+    const pageCountries = countries.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 country = pageCountries[i + j];
+            row.push(
+                Markup.button.callback(
+                    `${country.name} ${country.flag}`, 
+                    `country_${service}_${country.id}`
+                )
+            );
+        }
+        buttons.push(row);
+    }
+    
+    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'
+        )
+    ]);
+    
+    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);
+};
+
+
+// Add new profile keyboard
+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,99 @@
+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);
+      });
+
+      logger.info(`Messages loaded successfully for bot `);
+    } catch (error) {
+      logger.error('Error loading messages:', error);
+      throw error;
+    }
+  }
+
+  getMessage(key: string): string {
+    const message = this.messages.get(key);
+    if (!message) {
+      logger.warn(`Message not found for key: ${key}`);
+      return `[Message not found: ${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(); 

src/bots/utils/messageUtils.ts

@@ -0,0 +1,160 @@
+import { BotContext } from "../types/botTypes";
+import { formatPrice } from "./priceUtils";
+import { messageManager } from "./messageManager";
+
+export const getWelcomeMessage = (name: string = "عزيزي المستخدم") => {
+  return messageManager.getMessage('welcome').replace('{name}', name);
+};
+
+export const getLoginMessage = () => {
+  return messageManager.getMessage('login');
+};
+
+export const getTermsMessage = () => {
+  return messageManager.getMessage('terms');
+};
+
+export const getNewMembersMessage = () => {
+  return messageManager.getMessage('new_members');
+};
+
+export const getStatsMessage = () => {
+  return messageManager.getMessage('stats')
+    .replace('{current_datetime}', new Date().toLocaleString('ar-SA'));
+};
+
+export const getHelpMessage = () => {
+  return messageManager.getMessage('help');
+};
+
+export const getAboutMessage = () => {
+  return messageManager.getMessage('about');
+};
+
+export const getContactMessage = () => {
+  return messageManager.getMessage('contact');
+};
+
+export const getAuthRequiredMessage = () => {
+  return messageManager.getMessage('auth_required');
+};
+
+// export const getCountriesListMessage = (service: string, page: number = 0) => {
+//   return messageManager.getMessage('countries_list')
+//     .replace('{service}', service)
+//     .replace('{page > 0 ? `📑 الصفحة: {page + 1}\n` : \'\'}', 
+//              page > 0 ? `📑 الصفحة: ${page + 1}\n` : '');
+// };
+
+export const getCountriesListMessage = (service: string, page: number = 0) => {
+  return `
+🌍 *الدول المتاحة لخدمة ${service}*
+
+${page > 0 ? `📑 الصفحة: ${page + 1}\n` : ''}✨ اختر الدولة التي تريدها من القائمة التالية:
+  `;
+};
+export const getServiceErrorMessage = (service: string) => {
+  return messageManager.getMessage('service_error')
+    .replace('{service}', service);
+};
+
+export const getLoadingPricesMessage = (service: string, countryId: string) => {
+  return messageManager.getMessage('loading_prices')
+    .replace('{service}', service)
+    .replace('{countryId}', countryId);
+};
+
+export const getNoPricesMessage = (service: string, countryId: string) => {
+  return messageManager.getMessage('no_prices')
+    .replace('{service}', service)
+    .replace('{countryId}', countryId);
+};
+
+export const getPricesListMessage = (
+  service: string,
+  countryId: string,
+  prices: any,
+  ctx: BotContext
+) => {
+  const countryName = countryId; // Consider using a real mapping function like getCountryName(countryId)
+  let message = messageManager.getMessage('prices_list')
+    .replace('{service}', service)
+    .replace('{countryName}', countryName);
+
+  // If you want to include prices in the future:
+  // Object.entries(prices).forEach(([operator, priceInfo]: [string, any]) => {
+  //   const formattedPrice = formatPrice(ctx, priceInfo.cost);
+  //   const availability = priceInfo.count > 0 ? ` (${priceInfo.count} متاح)` : ' (غير متوفر)';
+  //   message += `${operator}: ${formattedPrice}${availability}\n`;
+  // });
+
+  return message;
+};
+
+export const getPricesErrorMessage = (service: string, countryId: string) => {
+  return messageManager.getMessage('prices_error')
+    .replace('{service}', service)
+    .replace('{countryId}', countryId);
+};
+
+export const getProcessingPurchaseMessage = (service: string, countryId: string) => {
+  return messageManager.getMessage('processing_purchase')
+    .replace('{service}', service)
+    .replace('{countryId}', countryId);
+};
+
+export const getServiceUnavailableMessage = (
+  service: string, 
+  operator: string, 
+  countryId: string
+) => {
+  return messageManager.getMessage('service_unavailable')
+    .replace('{service}', service)
+    .replace('{operator}', operator)
+    .replace('{countryId}', countryId);
+};
+
+export const getInsufficientBalanceMessage = (cost: number, balance: number) => {
+  return messageManager.getMessage('insufficient_balance')
+    .replace('{cost}', cost.toString())
+    .replace('{balance}', balance.toString());
+};
+
+export const getPurchaseSuccessMessage = (
+  purchaseResult: any, 
+  service: string, 
+  countryId: string, 
+  operator: string, 
+  cost: number
+) => {
+  return messageManager.getMessage('purchase_success')
+    .replace('{phone}', purchaseResult.phone)
+    .replace('{countryId}', countryId)
+    .replace('{operator}', operator)
+    .replace('{cost}', cost.toString())
+    .replace('{expires}', purchaseResult.expires.toString());
+};
+
+export const getPurchaseFailedMessage = () => {
+  return messageManager.getMessage('purchase_failed');
+};
+
+export const getPurchaseErrorMessage = (errorMessage: string) => {
+  return messageManager.getMessage('purchase_error')
+    .replace('{error_message}', errorMessage || 'سبب غير معروف');
+};
+
+export const getPaginationErrorMessage = () => {
+  return messageManager.getMessage('pagination_error');
+};
+
+export const getVerificationCodeMessage = (phone: string, code: string) => {
+  return messageManager.getMessage('verification_code')
+    .replace('{phone}', phone)
+    .replace('{code}', code)
+    .replace('{current_time}', new Date().toLocaleTimeString('ar-SA'));
+};
+
+export const getVerificationTimeoutMessage = () => {
+  return messageManager.getMessage('verification_timeout');
+};

src/bots/utils/priceUtils.ts

@@ -0,0 +1,128 @@
+import { BotContext } from "../types/botTypes";
+import { createLogger } from "../../utils/logger";
+
+const logger = createLogger('PriceUtils');
+
+// Currency exchange rates (you might want to fetch these dynamically)
+const exchangeRates: Record<string, number> = {
+    'USD_RUB': 79.6229,
+    'RUB_USD': 1 / 79.6229, // Add this
+    'EUR_RUB': 86.5,
+    'RUB_EUR': 1 / 86.5,    // Add this
+  };
+
+/**
+ * Convert price from one currency to another
+ * 
+ * @param amount The amount to convert
+ * @param fromCurrency Source currency code
+ * @param toCurrency Target currency code
+ * @returns Converted amount
+ */
+export const convertCurrency = (
+  amount: number, 
+  fromCurrency: string = 'USD', 
+  toCurrency: string = 'RUB'
+): number => {
+  try {
+    if (fromCurrency === toCurrency) {
+      return amount;
+    }
+    
+    const rateKey = `${fromCurrency}_${toCurrency}`;
+    const rate = exchangeRates[rateKey];
+    
+    if (!rate) {
+      logger.warn(`Exchange rate not found for ${rateKey}, returning original amount`);
+      return amount;
+    }
+    
+    return amount * rate;
+  } catch (error: any) {
+    logger.error(`Error converting currency: ${error.message}`);
+    return amount;
+  }
+};
+
+/**
+ * Calculate the final price with profit based on bot settings
+ * 
+ * @param ctx The bot context containing botData
+ * @param originalPrice The original price to apply profit to
+ * @param originalCurrency The currency of the original price
+ * @returns The calculated price with profit applied
+ */
+export const calculatePriceWithProfit = (
+  ctx: BotContext, 
+  originalPrice: number,
+  originalCurrency: string = 'USD'
+): number => {
+  try {
+  
+    // Check if botData exists
+    if (!ctx.botData) {
+      logger.warn('Bot data not available, returning original price');
+      return originalPrice;
+    }
+
+    const { profit_type, profit_value_percentage, profit_value_fix, currency } = ctx.botData;
+    
+    // Convert to bot's currency if needed
+    const priceInBotCurrency = currency !== originalCurrency 
+    ? convertCurrency(originalPrice, originalCurrency, currency)
+      : originalPrice;
+    
+    // Calculate price based on profit type
+    let finalPrice = priceInBotCurrency;
+    
+    if (profit_type === 'percentage' && profit_value_percentage) {
+      // Calculate percentage profit
+      const profitAmount = priceInBotCurrency * (profit_value_percentage / 100);
+      finalPrice = priceInBotCurrency + profitAmount;
+    } else if (profit_type === 'fix' && profit_value_fix) {
+      // Add fixed profit amount
+      finalPrice = priceInBotCurrency + profit_value_fix;
+    } else {
+      // Default case - return converted price if profit settings are invalid
+      logger.warn('Invalid profit configuration, returning converted price');
+    }
+    
+    return finalPrice;
+  } catch (error: any) {
+    logger.error(`Error calculating price with profit: ${error.message}`);
+    return originalPrice; // Return original price in case of error
+  }
+};
+
+/**
+ * Format price with currency symbol based on bot settings
+ * 
+ * @param ctx The bot context containing botData
+ * @param price The price to format
+ * @returns Formatted price string with currency
+ */
+export const formatPrice = (ctx: BotContext, price: number): string => {
+    try {
+    //   if (typeof price !== 'number' || isNaN(price)) {
+    //     logger.error(`Invalid price type: ${typeof price} - ${JSON.stringify(price)}`);
+    //     return 'N/A'; // or some fallback text
+    //   }
+  
+      const currency = ctx.botData?.currency || 'USD';
+  
+      switch (currency) {
+        case 'RUB':
+          return `${price.toFixed(2)} ₽`;
+        case 'USD':
+          return `$${price.toFixed(2)}`;
+        case 'EUR':
+          return `€${price.toFixed(2)}`;
+        default:
+          return `${price.toFixed(2)} ${currency}`;
+      }
+    } catch (error: any) {
+      logger.error(`Error formatting price: ${error.message}`);
+      return 'N/A';
+    }
+  };
+  

src/bots/utils/settings.ts

@@ -0,0 +1,96 @@
+import { supabase } from "../../db/supabase";
+import { createLogger } from "../../utils/logger";
+
+const logger = createLogger('BotSettings');
+
+/**
+ * Get bot settings from database
+ * @param botId Bot UUID
+ * @returns Bot settings object or null if not found
+ */
+export const getBotSettings = async (botId: string) => {
+  try {
+    const { data, error } = await supabase
+      .from('bots')
+      .select('*')
+      .eq('id', botId)
+      .single();
+      
+    if (error) {
+      logger.error(`Error fetching bot settings: ${error.message}`);
+      return null;
+    }
+    
+    return {
+      ...data.settings,
+      currency: data.currency,
+      profit: {
+        type: data.profit_type,
+        percentage: data.profit_value_percentage,
+        fix: data.profit_value_fix
+      },
+      version: data.version
+    };
+  } catch (error: any) {
+    logger.error(`Unexpected error getting bot settings: ${error.message}`);
+    return null;
+  }
+};
+
+/**
+ * Save bot state to database
+ * @param botId Bot UUID
+ * @param state State object to save
+ * @returns Success status
+ */
+export const saveBotState = async (botId: string, state: Record<string, any>) => {
+  try {
+    const { error } = await supabase
+      .from('bots')
+      .update({
+        state: state,
+        last_activity: new Date().toISOString()
+      })
+      .eq('id', botId);
+      
+    if (error) {
+      logger.error(`Error saving bot state: ${error.message}`);
+      return false;
+    }
+    
+    return true;
+  } catch (error: any) {
+    logger.error(`Unexpected error saving bot state: ${error.message}`);
+    return false;
+  }
+};
+
+/**
+ * Calculate profit based on bot settings
+ * @param botId Bot UUID
+ * @param amount Base amount
+ * @returns Amount with profit applied
+ */
+export const calculateProfit = async (botId: string, amount: number) => {
+  try {
+    const { data, error } = await supabase
+      .from('bots')
+      .select('profit_type, profit_value_percentage, profit_value_fix')
+      .eq('id', botId)
+      .single();
+      
+    if (error || !data) {
+      logger.error(`Error fetching profit settings: ${error?.message}`);
+      return amount;
+    }
+    
+    if (data.profit_type === 'percentage') {
+      return amount * (1 + data.profit_value_percentage / 100);
+    } else {
+      return amount + data.profit_value_fix;
+    }
+  } catch (error: any) {
+    logger.error(`Unexpected error calculating profit: ${error.message}`);
+    return amount;
+  }
+}; 

src/config.ts

@@ -0,0 +1,54 @@
+import * as dotenv from 'dotenv';
+import { fetchDataFromTable } from './db/supabaseHelper';
+
+dotenv.config();
+
+export const config = {
+  BOT_TOKEN: process.env.BOT_TOKEN || '',
+  API_ID: parseInt(process.env.API_ID || ''),
+  API_HASH: process.env.API_HASH || '',
+  PHONE_NUMBER: process.env.PHONE_NUMBER || '',
+  STRING_SESSION: process.env.STRING_SESSION || '',
+};
+
+export const PORT = process.env.PORT || 7860;
+
+// Default values (will be overridden by DB values when loaded)
+export let COMMANDS: Record<string, string> = {
+  GO: ".",
+};
+
+export let MESSAGES: Record<string, string> = {
+  FORWARD_SUCCESS: "أتفضل",
+};
+
+// Function to load commands and messages from the database
+export const loadCommandsAndMessages = async () => {
+  try {
+    const commands = await fetchDataFromTable('commands', 1000,0);
+    const messages = await fetchDataFromTable('messages', 1000,0);
+    
+    // Reset COMMANDS object
+    COMMANDS = {};
+    
+    // Populate COMMANDS
+    commands.forEach((cmd: any) => {
+      COMMANDS[cmd.key] = cmd.key;
+    });
+    
+    // Reset MESSAGES object
+    MESSAGES = {};
+    
+    // Populate MESSAGES
+    messages.forEach((msg: any) => {
+      MESSAGES[msg.key] = msg.value;
+    });
+    
+    console.log('Commands and messages loaded from database');
+  } catch (error) {
+    console.error('Error loading commands and messages:', error);
+  }
+};
+
+// Load commands and messages initially
+// loadCommandsAndMessages();