@2byte/tgbot-framework 1.0.3 → 1.0.5

package/src/libs/TelegramAccountControl.ts

@@ -1,738 +1,1140 @@
-import { TelegramClient, Api } from "telegram";
-import { StringSession } from "telegram/sessions";
-import fs from "fs";
-import { TelegramClientParams } from "telegram/client/telegramBaseClient";
-import { ProxyInterface } from "telegram/network/connection/TCPMTProxy";
-
-interface TelegramRegistrarInit {
-  appId: string;
-  appHash: string;
-  credetialsManager: TelegramManagerCredentials;
-}
-
-type TelegramClientProxy = {
-  ip: string;
-  port: number;
-  username?: string;
-  password?: string;
-  secret?: string,
-  socksType?: 5 | 4;
-  MTProxy?: boolean;
-} & ProxyInterface;
-
-interface TelegramInitClient {
-  phone: string;
-  proxy?: any;
-}
-
-export interface TelegramCredentials {
-  phone: string;
-  proxy?: TelegramClientProxy;
-  password?: string;
-  session?: string;
-}
-
-interface TelegramCredentialsManagerInit {
-  pathFileStorage: string;
-  pathFileProxyList: string;
-  pathFileCounterOffset: string;
-}
-
-export class TelegramManagerCredentials {
-  private requiredProxyForCredentials: boolean = false;
-  private credentials: TelegramCredentials[] = [];
-  private proxyList: string[] = [];
-
-  static init(options: TelegramCredentialsManagerInit) {
-    return new TelegramManagerCredentials(options);
-  }
-
-  constructor(private options: TelegramCredentialsManagerInit) {
-    this.ensureStorageDirectory();
-    this.loadCredentials();
-    this.loadProxyList();
-  }
-
-  /**
-   * Ensure storage directory exists
-   */
-  private ensureStorageDirectory(): void {
-    const storageDir = this.options.pathFileStorage.split("/").slice(0, -1).join("/");
-    if (!fs.existsSync(storageDir)) {
-      fs.mkdirSync(storageDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Load credentials from JSON file
-   */
-  private loadCredentials(): void {
-    try {
-      if (fs.existsSync(this.options.pathFileStorage)) {
-        const data = fs.readFileSync(this.options.pathFileStorage, "utf8");
-        this.credentials = JSON.parse(data) || [];
-      } else {
-        this.credentials = [];
-        this.saveCredentials();
-      }
-    } catch (error) {
-      console.error("Error loading credentials:", error);
-      this.credentials = [];
-    }
-  }
-
-  /**
-   * Загрузить список прокси из файла
-   */
-  private loadProxyList(): void {
-    try {
-      if (fs.existsSync(this.options.pathFileProxyList)) {
-        const data = fs.readFileSync(this.options.pathFileProxyList, "utf8");
-        this.proxyList = data.split('\n').filter(line => line.trim() !== '');
-      } else {
-        this.proxyList = [];
-      }
-    } catch (error) {
-      console.error("Ошибка загрузки списка прокси:", error);
-      this.proxyList = [];
-    }
-  }
-
-  /**
-   * Получить текущий offset из файла счетчика
-   */
-  private getCurrentOffset(): number {
-    try {
-      if (fs.existsSync(this.options.pathFileCounterOffset)) {
-        const data = fs.readFileSync(this.options.pathFileCounterOffset, "utf8");
-        return parseInt(data.trim()) || 0;
-      }
-      return 0;
-    } catch (error) {
-      console.error("Ошибка чтения offset:", error);
-      return 0;
-    }
-  }
-
-  /**
-   * Сохранить новый offset в файл счетчика
-   */
-  private saveOffset(offset: number): void {
-    try {
-      fs.writeFileSync(this.options.pathFileCounterOffset, offset.toString(), "utf8");
-    } catch (error) {
-      console.error("Ошибка сохранения offset:", error);
-      throw new Error("Не удалось сохранить offset");
-    }
-  }
-
-  /**
-   * Парсинг строки прокси в формат TelegramClientProxy
-   * Поддерживаемые форматы: 
-   * - socks4://username:password@host:port
-   * - socks5://username:password@host:port
-   * - http://username:password@host:port (будет использоваться как SOCKS5)
-   */
-  private parseProxyString(proxyString: string): TelegramClientProxy {
-    // Проверяем SOCKS4 формат
-    let match = proxyString.match(/^socks4:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
-    if (match) {
-      const [, username, password, ip, port] = match;
-      return {
-        ip,
-        port: parseInt(port),
-        username,
-        password,
-        socksType: 4
-      };
-    }
-
-    // Проверяем SOCKS5 формат
-    match = proxyString.match(/^socks5:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
-    if (match) {
-      const [, username, password, ip, port] = match;
-      return {
-        ip,
-        port: parseInt(port),
-        username,
-        password,
-        socksType: 5
-      };
-    }
-
-    // Проверяем HTTP формат (используем как SOCKS5)
-    match = proxyString.match(/^http:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
-    if (match) {
-      const [, username, password, ip, port] = match;
-      return {
-        ip,
-        port: parseInt(port),
-        username,
-        password,
-        socksType: 5  // HTTP прокси используем как SOCKS5
-      };
-    }
-
-    throw new Error(`Неверный формат прокси: ${proxyString}. Поддерживаемые форматы: socks4://, socks5://, http://`);
-  }
-
-  /**
-   * Получить следующий прокси из списка
-   */
-  private getNextProxy(): TelegramClientProxy {
-    if (this.proxyList.length === 0) {
-      throw new Error("Список прокси пуст");
-    }
-
-    const currentOffset = this.getCurrentOffset();
-    
-    if (currentOffset >= this.proxyList.length) {
-      throw new Error("Прокси закончились");
-    }
-
-    const proxyString = this.proxyList[currentOffset];
-    const proxy = this.parseProxyString(proxyString);
-    
-    // Увеличиваем offset для следующего использования
-    this.saveOffset(currentOffset + 1);
-    
-    return proxy;
-  }
-
-  /**
-   * Save credentials to JSON file
-   */
-  private saveCredentials(): void {
-    try {
-      fs.writeFileSync(
-        this.options.pathFileStorage,
-        JSON.stringify(this.credentials, null, 2),
-        "utf8"
-      );
-    } catch (error) {
-      console.error("Error saving credentials:", error);
-      throw new Error("Failed to save credentials");
-    }
-  }
-
-  /**
-   * Add or update credential
-   */
-  addCredential(credential: TelegramCredentials): void {
-    
-    // Attach proxy to credential
-    if (this.requiredProxyForCredentials && !credential.proxy) {
-      try {
-        credential.proxy = this.getNextProxy();
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        throw new Error(`Не удалось назначить прокси: ${errorMessage}`);
-      }
-    }
-
-    const existingIndex =  this.credentials.findIndex((c) => c != null && c.phone === credential.phone);
-
-    if (existingIndex !== -1) {
-      // Update existing credential
-      this.credentials[existingIndex] = { ...this.credentials[existingIndex], ...credential };
-    } else {
-      // Add new credential
-      this.credentials.push(credential);
-    }
-
-    this.credentials = this.credentials.filter((c) => c != null);
-
-    this.saveCredentials();
-  }
-
-  /**
-   * Get credential by phone number
-   */
-  getCredential(phone: string): TelegramCredentials | null {
-    return this.credentials.find((c) => c != null && c.phone === phone) || null;
-  }
-
-  /**
-   * Delete credential by phone number
-   */
-  deleteCredential(phone: string): boolean {
-    const initialLength = this.credentials.length;
-    this.credentials = this.credentials.filter((c) => c.phone !== phone);
-
-    if (this.credentials.length < initialLength) {
-      this.saveCredentials();
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Get all credentials
-   */
-  getAllCredentials(): TelegramCredentials[] {
-    return [...this.credentials];
-  }
-
-  /**
-   * Check if credential exists
-   */
-  hasCredential(phone: string): boolean {
-    return this.credentials.some((c) => c.phone === phone);
-  }
-
-  /**
-   * Update session for existing credential
-   */
-  updateSession(phone: string, session: string): boolean {
-    const credential = this.credentials.find((c) => c.phone === phone);
-    if (credential) {
-      credential.session = session;
-      this.saveCredentials();
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Get credentials count
-   */
-  getCredentialsCount(): number {
-    return this.credentials.length;
-  }
-
-  /**
-   * Clear all credentials
-   */
-  clearAllCredentials(): void {
-    this.credentials = [];
-    this.saveCredentials();
-  }
-
-  /**
-   * Get credentials by proxy configuration
-   */
-  getCredentialsByProxy(proxyHost: string, proxyPort: number): TelegramCredentials[] {
-    return this.credentials.filter(
-      (c) => c.proxy && c.proxy.ip === proxyHost && c.proxy.port === proxyPort
-    );
-  }
-
-  /**
-   * Get credentials without proxy
-   */
-  getCredentialsWithoutProxy(): TelegramCredentials[] {
-    return this.credentials.filter((c) => !c.proxy);
-  }
-}
-
-export class TelegramAccountRemote {
-  private initOptions: TelegramRegistrarInit;
-  private tgClient!: TelegramClient; // Используем definite assignment assertion
-  private credentialsManager: TelegramManagerCredentials;
-
-  static init(initOptions: TelegramRegistrarInit) {
-    return new TelegramAccountRemote(initOptions);
-  }
-
-  constructor(initOptions: TelegramRegistrarInit) {
-    this.initOptions = initOptions;
-    this.credentialsManager = initOptions.credetialsManager;
-  }
-
-  async attemptRestoreSession(credentials: TelegramCredentials): Promise<boolean> {
-    const { phone, proxy, session, password } = credentials;
-    const { appId, appHash } = this.initOptions;
-    
-    if (session) {
-      const clientParams: TelegramClientParams = {connectionRetries: 5};
-
-      if (credentials.proxy) {
-        clientParams.proxy = credentials.proxy;
-      }
-
-      this.tgClient = new TelegramClient(new StringSession(session), Number(appId), appHash, clientParams);
-
-      return await this.tgClient.connect();
-    }
-
-    return false;
-  }
-
-  async login(
-    credentials: TelegramCredentials,
-    cbRequestCode: CallableFunction,
-    cbRequestPassword: CallableFunction,
-    cbError: CallableFunction,
-  ): Promise<void> {
-    const { phone, proxy, session, password } = credentials;
-    const { appId, appHash } = this.initOptions;
-
-    if (session) {
-      throw new Error("Account is already registered");
-    }
-
-    try {
-      this.tgClient = new TelegramClient(new StringSession(""), Number(appId), appHash, {
-        connectionRetries: 5,
-        proxy: credentials.proxy,
-        timeout: 10000 * 60 * 10,
-      });
-      console.log('Login cresentials:', credentials)
-      // @ts-ignore
-      await this.tgClient.start({
-        phoneNumber: async () => phone,
-        password: async () => {
-          if (!password) {
-            return await cbRequestPassword();
-          }
-          return password;
-        },
-        phoneCode: async () => {
-          return await cbRequestCode();
-        },
-        onError: (err: Error) => {
-            cbError('Error for wait authentiction', err);
-        },
-      });
-
-      const session = this.tgClient.session.save() as unknown as string;
-
-      this.credentialsManager.addCredential({
-        phone,
-        proxy,
-        session,
-        password,
-      });
-
-      console.log("Регистрация успешна!");
-      console.log("Сессия:\n", session);
-
-    } catch (err) {
-      throw new Error("Failed to register account", { cause: err });
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    await this.tgClient.disconnect();
-  }
-
-  async disconnectWhenConnect() {
-    await this.tgClient.disconnect();
-  }
-
-  /**
-   * Отправляет команду /start боту
-   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
-   * @returns true если команда успешно отправлена
-   */
-  async sendStartCommand(botUsername: string): Promise<boolean> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Убираем @ из username если он есть
-      const normalizedUsername = botUsername.startsWith('@') ? botUsername.substring(1) : botUsername;
-      
-      // Ищем бота по username
-      const result = await this.tgClient.sendMessage(normalizedUsername, {
-        message: '/start'
-      });
-      
-      return result ? true : false;
-    } catch (error) {
-      console.error('Error sending /start command:', error);
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`Failed to send /start command to @${botUsername}: ${errorMessage}`);
-    }
-  }
-
-  /**
-   * Получает ID чата с ботом
-   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
-   * @returns ID чата с ботом
-   */
-  async getBotChatId(botUsername: string): Promise<number> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Убираем @ из username если он есть
-      const normalizedUsername = botUsername.startsWith('@') ? botUsername.substring(1) : botUsername;
-      
-      // Получаем информацию о диалоге с ботом
-      const dialog = await this.tgClient.getDialogs({
-        limit: 1
-      });
-
-      if (!dialog || dialog.length === 0 || !dialog[0] || !dialog[0].id) {
-        throw new Error(`Chat with bot @${normalizedUsername} not found`);
-      }
-
-      return dialog[0].id!.toJSNumber();
-    } catch (error) {
-      console.error('Error getting bot chat ID:', error);
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`Failed to get chat ID for @${botUsername}: ${errorMessage}`);
-    }
-  }
-
-  /**
-   * Отправляет жалобу на бота
-   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
-   * @param reason причина жалобы: 'spam' | 'violence' | 'pornography' | 'custompromoting' | 'other'
-   * @returns true если жалоба успешно отправлена
-   */
-  async reportBot(
-    botUsername: string, 
-    reason: 'spam' | 'violence' | 'pornography' | 'custompromoting' | 'other' = 'spam'
-  ): Promise<boolean> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      const chatId = await this.getBotChatId(botUsername);
-      
-      // Получаем сообщения от бота для репорта
-      const messages = await this.tgClient.getMessages(chatId, { limit: 1 });
-      if (!messages || messages.length === 0) {
-        throw new Error('No messages found to report');
-      }
-
-      // Формируем причину жалобы
-      let reportReason = reason;
-      if (reason === 'custompromoting') {
-        reportReason = 'spam';
-      }
-
-      // Отправляем жалобу на последнее сообщение
-      await this.tgClient.sendMessage(chatId, {
-        message: `/report ${reportReason}`,
-        replyTo: messages[0].id
-      });
-
-      return true;
-    } catch (error) {
-      console.error('Error reporting bot:', error);
-      if (error instanceof Error) {
-        throw new Error(`Failed to report @${botUsername}: ${error.message}`);
-      }
-      throw new Error(`Failed to report @${botUsername}: Unknown error`);
-    }
-  }
-
-  /**
-   * Проверяет, зарегистрирован ли номер телефона в Telegram
-   * @param phoneNumber номер телефона в международном формате (например: '+380123456789')
-   * @returns true если номер зарегистрирован в Telegram, false если нет
-   */
-  async isPhoneRegistered(phoneNumber: string): Promise<boolean> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Попытаемся найти пользователя, отправив сообщение самому себе с информацией о номере
-      // Это безопасный способ проверки без отправки реальных сообщений
-      const me = await this.tgClient.getMe();
-      
-      // Используем поиск по username если номер содержит буквы, иначе считаем что это номер
-      if (phoneNumber.includes('@')) {
-        try {
-          const entity = await this.tgClient.getEntity(phoneNumber);
-          return entity ? true : false;
-        } catch {
-          return false;
-        }
-      }
-
-      // Для номеров телефонов возвращаем true по умолчанию
-      // В реальном приложении здесь должен быть более сложный API вызов
-      console.log(`Проверка номера ${phoneNumber} - предполагаем что зарегистрирован`);
-      return true;
-    } catch (error) {
-      console.error('Error checking phone registration:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Добавляет контакт в адресную книгу Telegram
-   * @param phoneNumber номер телефона в международном формате
-   * @param firstName имя контакта
-   * @param lastName фамилия контакта (необязательно)
-   * @returns true если контакт успешно добавлен
-   */
-  async addContact(phoneNumber: string, firstName: string, lastName?: string): Promise<boolean> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Импортируем API для работы с контактами
-      const bigInteger = (await import('big-integer')).default;
-      
-      // Нормализуем номер телефона (убираем все символы кроме цифр и +)
-      const normalizedPhone = phoneNumber.replace(/[^\d+]/g, '');
-      
-      // Создаем контакт для импорта
-      const contact = new Api.InputPhoneContact({
-        clientId: bigInteger(Math.floor(Math.random() * 1000000000)), // Генерируем случайный ID
-        phone: normalizedPhone.replace(/^\+/, ''), // Убираем + для API
-        firstName: firstName,
-        lastName: lastName || ''
-      });
-
-      console.log(`🔍 Попытка добавить контакт: ${firstName} ${lastName || ''} (${phoneNumber})`);
-
-      // Импортируем контакт через API
-      const result = await this.tgClient.invoke(
-        new Api.contacts.ImportContacts({
-          contacts: [contact]
-        })
-      );
-
-      // Проверяем результат импорта
-      if (result.imported && result.imported.length > 0) {
-        console.log(`✅ Контакт ${firstName} ${lastName || ''} (${phoneNumber}) успешно добавлен`);
-        
-        // Если есть информация о пользователе
-        if (result.users && result.users.length > 0) {
-          const user = result.users[0];
-          const username = (user as any).username;
-          console.log(`📱 Найден пользователь Telegram: @${username || 'без username'}`);
-          console.log(`🆔 ID пользователя: ${user.id}`);
-        }
-        
-        return true;
-      } else if (result.retryContacts && result.retryContacts.length > 0) {
-        console.log(`⚠️ Контакт ${phoneNumber} требует повторной попытки`);
-        throw new Error(`Contact ${phoneNumber} requires retry`);
-      } else {
-        // Проверяем, найден ли пользователь в результате (контакт уже существует)
-        if (result.users && result.users.length > 0) {
-          const user = result.users[0];
-          const username = (user as any).username;
-          console.log(`� Пользователь уже существует в контактах: @${username || 'без username'}`);
-          return true;
-        }
-        
-        console.log(`ℹ️ Контакт ${phoneNumber} не найден в Telegram или не удалось добавить`);
-        throw new Error(`Contact ${phoneNumber} not found or could not be added`);
-      }
-    } catch (error) {
-      console.error('Error adding contact:', error);
-      
-      // Если пользователь не найден, это не критическая ошибка
-      if (error instanceof Error && (
-        error.message.includes('USER_NOT_FOUND') ||
-        error.message.includes('PHONE_NOT_OCCUPIED') ||
-        error.message.includes('USERNAME_NOT_OCCUPIED')
-      )) {
-        console.log(`ℹ️ Пользователь с номером ${phoneNumber} не зарегистрирован в Telegram`);
-        throw new Error(`User with phone ${phoneNumber} is not registered in Telegram`);
-      }
-      
-      throw error;
-    }
-  }
-
-  /**
-   * Получает информацию о пользователе по номеру телефона или username
-   * @param identifier номер телефона или username
-   * @returns информация о пользователе или null если не найден
-   */
-  async getUserByPhone(identifier: string): Promise<any | null> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Пытаемся получить информацию о пользователе
-      let entity;
-      
-      if (identifier.startsWith('@') || !identifier.startsWith('+')) {
-        // Если это username, пытаемся найти по username
-        entity = await this.tgClient.getEntity(identifier);
-      } else {
-        // Если это номер телефона, логируем попытку поиска
-        console.log(`Поиск пользователя по номеру: ${identifier}`);
-        return null; // В упрощенной версии возвращаем null для номеров
-      }
-
-      if (entity) {
-        return {
-          id: entity.id?.toString() || '',
-          firstName: (entity as any).firstName || '',
-          lastName: (entity as any).lastName || '',
-          username: (entity as any).username || '',
-          phone: identifier.startsWith('+') ? identifier : '',
-          isBot: (entity as any).bot || false,
-          isVerified: (entity as any).verified || false,
-          isPremium: (entity as any).premium || false
-        };
-      }
-
-      return null;
-    } catch (error) {
-      console.error('Error getting user info:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Массовая проверка номеров телефонов на регистрацию в Telegram
-   * @param phoneNumbers массив номеров телефонов
-   * @returns объект с результатами проверки для каждого номера
-   */
-  async checkMultiplePhones(phoneNumbers: string[]): Promise<{[phone: string]: boolean}> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    const results: {[phone: string]: boolean} = {};
-
-    // Проверяем каждый номер по очереди
-    for (const phone of phoneNumbers) {
-      try {
-        results[phone] = await this.isPhoneRegistered(phone);
-        
-        // Небольшая задержка между запросами для избежания rate limit
-        await new Promise(resolve => setTimeout(resolve, 200));
-      } catch (error) {
-        console.error(`Error checking phone ${phone}:`, error);
-        results[phone] = false;
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Отправляет сообщение пользователю по ID или username
-   * @param target ID пользователя или username
-   * @param message текст сообщения
-   * @returns true если сообщение отправлено успешно
-   */
-  async sendMessageToUser(target: string, message: string): Promise<boolean> {
-    if (!this.tgClient) {
-      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
-    }
-
-    try {
-      // Отправляем сообщение
-      const result = await this.tgClient.sendMessage(target, {
-        message: message
-      });
-
-      console.log(`✅ Сообщение отправлено пользователю ${target}`);
-      return result ? true : false;
-    } catch (error) {
-      console.error('Error sending message:', error);
-      throw new Error(`Failed to send message to ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}
+import { TelegramClient, Api } from "telegram";
+import { StringSession } from "telegram/sessions";
+import fs from "fs";
+import { TelegramClientParams } from "telegram/client/telegramBaseClient";
+import { ProxyInterface } from "telegram/network/connection/TCPMTProxy";
+import type { Database } from "bun:sqlite";
+import { TgAccount, Proxy, TgAccountStatus, ProxyStatus } from '../models';
+
+interface TelegramAccountRemoteInit {
+  appId: string;
+  appHash: string;
+  credetialsManager: TelegramManagerCredentialsDriver;
+}
+
+type TelegramClientProxy = {
+  ip: string;
+  port: number;
+  username?: string;
+  password?: string;
+  secret?: string,
+  socksType?: 5 | 4;
+  MTProxy?: boolean;
+} & ProxyInterface;
+
+interface TelegramInitClient {
+  phone: string;
+  proxy?: any;
+}
+
+export interface TelegramCredentials {
+  phone: string;
+  proxy?: TelegramClientProxy;
+  password?: string;
+  session?: string;
+}
+
+interface TelegramCredentialsManagerInit {
+  pathFileStorage: string;
+  pathFileProxyList: string;
+  pathFileCounterOffset: string;
+}
+
+export type TelegramManagerCredentialsDriver = TelegramManagerCredentials | TelegramManagerCredentialsDB;
+
+export class TelegramManagerCredentials {
+  private requiredProxyForCredentials: boolean = false;
+  private credentials: TelegramCredentials[] = [];
+  private proxyList: string[] = [];
+
+  static init(options: TelegramCredentialsManagerInit) {
+    return new TelegramManagerCredentials(options);
+  }
+
+  constructor(private options: TelegramCredentialsManagerInit) {
+    this.ensureStorageDirectory();
+    this.loadCredentials();
+    this.loadProxyList();
+  }
+
+  /**
+   * Ensure storage directory exists
+   */
+  private ensureStorageDirectory(): void {
+    const storageDir = this.options.pathFileStorage.split("/").slice(0, -1).join("/");
+    if (!fs.existsSync(storageDir)) {
+      fs.mkdirSync(storageDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Load credentials from JSON file
+   */
+  private loadCredentials(): void {
+    try {
+      if (fs.existsSync(this.options.pathFileStorage)) {
+        const data = fs.readFileSync(this.options.pathFileStorage, "utf8");
+        this.credentials = JSON.parse(data) || [];
+      } else {
+        this.credentials = [];
+        this.saveCredentials();
+      }
+    } catch (error) {
+      console.error("Error loading credentials:", error);
+      this.credentials = [];
+    }
+  }
+
+  /**
+   * Загрузить список прокси из файла
+   */
+  private loadProxyList(): void {
+    try {
+      if (fs.existsSync(this.options.pathFileProxyList)) {
+        const data = fs.readFileSync(this.options.pathFileProxyList, "utf8");
+        this.proxyList = data.split('\n').filter(line => line.trim() !== '');
+      } else {
+        this.proxyList = [];
+      }
+    } catch (error) {
+      console.error("Ошибка загрузки списка прокси:", error);
+      this.proxyList = [];
+    }
+  }
+
+  /**
+   * Получить текущий offset из файла счетчика
+   */
+  private getCurrentOffset(): number {
+    try {
+      if (fs.existsSync(this.options.pathFileCounterOffset)) {
+        const data = fs.readFileSync(this.options.pathFileCounterOffset, "utf8");
+        return parseInt(data.trim()) || 0;
+      }
+      return 0;
+    } catch (error) {
+      console.error("Ошибка чтения offset:", error);
+      return 0;
+    }
+  }
+
+  /**
+   * Сохранить новый offset в файл счетчика
+   */
+  private saveOffset(offset: number): void {
+    try {
+      fs.writeFileSync(this.options.pathFileCounterOffset, offset.toString(), "utf8");
+    } catch (error) {
+      console.error("Ошибка сохранения offset:", error);
+      throw new Error("Не удалось сохранить offset");
+    }
+  }
+
+  /**
+   * Парсинг строки прокси в формат TelegramClientProxy
+   * Поддерживаемые форматы: 
+   * - socks4://username:password@host:port
+   * - socks5://username:password@host:port
+   * - http://username:password@host:port (будет использоваться как SOCKS5)
+   */
+  private parseProxyString(proxyString: string): TelegramClientProxy {
+    // Проверяем SOCKS4 формат
+    let match = proxyString.match(/^socks4:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
+    if (match) {
+      const [, username, password, ip, port] = match;
+      return {
+        ip,
+        port: parseInt(port),
+        username,
+        password,
+        socksType: 4
+      };
+    }
+
+    // Проверяем SOCKS5 формат
+    match = proxyString.match(/^socks5:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
+    if (match) {
+      const [, username, password, ip, port] = match;
+      return {
+        ip,
+        port: parseInt(port),
+        username,
+        password,
+        socksType: 5
+      };
+    }
+
+    // Проверяем HTTP формат (используем как SOCKS5)
+    match = proxyString.match(/^http:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/);
+    if (match) {
+      const [, username, password, ip, port] = match;
+      return {
+        ip,
+        port: parseInt(port),
+        username,
+        password,
+        socksType: 5  // HTTP прокси используем как SOCKS5
+      };
+    }
+
+    throw new Error(`Неверный формат прокси: ${proxyString}. Поддерживаемые форматы: socks4://, socks5://, http://`);
+  }
+
+  /**
+   * Получить следующий прокси из списка
+   */
+  private getNextProxy(): TelegramClientProxy {
+    if (this.proxyList.length === 0) {
+      throw new Error("Список прокси пуст");
+    }
+
+    const currentOffset = this.getCurrentOffset();
+    
+    if (currentOffset >= this.proxyList.length) {
+      throw new Error("Прокси закончились");
+    }
+
+    const proxyString = this.proxyList[currentOffset];
+    const proxy = this.parseProxyString(proxyString);
+    
+    // Увеличиваем offset для следующего использования
+    this.saveOffset(currentOffset + 1);
+    
+    return proxy;
+  }
+
+  /**
+   * Save credentials to JSON file
+   */
+  private saveCredentials(): void {
+    try {
+      fs.writeFileSync(
+        this.options.pathFileStorage,
+        JSON.stringify(this.credentials, null, 2),
+        "utf8"
+      );
+    } catch (error) {
+      console.error("Error saving credentials:", error);
+      throw new Error("Failed to save credentials");
+    }
+  }
+
+  /**
+   * Add or update credential
+   */
+  addCredential(credential: TelegramCredentials): void {
+    // replace +
+    if (credential.phone.includes('+')) {
+      credential.phone = credential.phone.replace('+', '');
+    }
+
+    // Attach proxy to credential
+    if (this.requiredProxyForCredentials && !credential.proxy) {
+      try {
+        credential.proxy = this.getNextProxy();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Не удалось назначить прокси: ${errorMessage}`);
+      }
+    }
+
+    const existingIndex =  this.credentials.findIndex((c) => c != null && c.phone === credential.phone);
+
+    if (existingIndex !== -1) {
+      // Update existing credential
+      this.credentials[existingIndex] = { ...this.credentials[existingIndex], ...credential };
+    } else {
+      // Add new credential
+      this.credentials.push(credential);
+    }
+
+    this.credentials = this.credentials.filter((c) => c != null);
+
+    this.saveCredentials();
+  }
+
+  /**
+   * Get credential by phone number
+   */
+  getCredential(phone: string): TelegramCredentials | null {
+    return this.credentials.find((c) => c != null && c.phone === phone) || null;
+  }
+
+  /**
+   * Delete credential by phone number
+   */
+  deleteCredential(phone: string): boolean {
+    const initialLength = this.credentials.length;
+    this.credentials = this.credentials.filter((c) => c.phone !== phone);
+
+    if (this.credentials.length < initialLength) {
+      this.saveCredentials();
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get all credentials
+   */
+  getAllCredentials(): TelegramCredentials[] {
+    return [...this.credentials];
+  }
+
+  /**
+   * Check if credential exists
+   */
+  hasCredential(phone: string): boolean {
+    return this.credentials.some((c) => c.phone === phone);
+  }
+
+  /**
+   * Update session for existing credential
+   */
+  updateSession(phone: string, session: string): boolean {
+    const credential = this.credentials.find((c) => c.phone === phone);
+    if (credential) {
+      credential.session = session;
+      this.saveCredentials();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get credentials count
+   */
+  getCredentialsCount(): number {
+    return this.credentials.length;
+  }
+
+  /**
+   * Clear all credentials
+   */
+  clearAllCredentials(): void {
+    this.credentials = [];
+    this.saveCredentials();
+  }
+
+  /**
+   * Get credentials by proxy configuration
+   */
+  getCredentialsByProxy(proxyHost: string, proxyPort: number): TelegramCredentials[] {
+    return this.credentials.filter(
+      (c) => c.proxy && c.proxy.ip === proxyHost && c.proxy.port === proxyPort
+    );
+  }
+
+  /**
+   * Get credentials without proxy
+   */
+  getCredentialsWithoutProxy(): TelegramCredentials[] {
+    return this.credentials.filter((c) => !c.proxy);
+  }
+}
+
+export class TelegramAccountRemote {
+  private initOptions: TelegramAccountRemoteInit;
+  private tgClient!: TelegramClient; // Используем definite assignment assertion
+  private credentialsManager: TelegramManagerCredentialsDriver;
+
+  static init(initOptions: TelegramAccountRemoteInit) {
+    return new TelegramAccountRemote(initOptions);
+  }
+
+  constructor(initOptions: TelegramAccountRemoteInit) {
+    this.initOptions = initOptions;
+    this.credentialsManager = initOptions.credetialsManager;
+  }
+
+  async attemptRestoreSession(credentials: TelegramCredentials): Promise<boolean> {
+    const { phone, proxy, session, password } = credentials;
+    const { appId, appHash } = this.initOptions;
+    
+    if (session) {
+      const clientParams: TelegramClientParams = {connectionRetries: 5};
+
+      if (credentials.proxy) {
+        clientParams.proxy = credentials.proxy;
+      }
+
+      this.tgClient = new TelegramClient(new StringSession(session), Number(appId), appHash, clientParams);
+
+      return await this.tgClient.connect();
+    }
+
+    return false;
+  }
+
+  async login(
+    credentials: TelegramCredentials,
+    cbRequestCode: CallableFunction,
+    cbRequestPassword: CallableFunction,
+    cbError: CallableFunction,
+  ): Promise<void> {
+    const { phone, proxy, session, password } = credentials;
+    const { appId, appHash } = this.initOptions;
+
+    if (session) {
+      throw new Error("Account is already registered");
+    }
+
+    try {
+      this.tgClient = new TelegramClient(new StringSession(""), Number(appId), appHash, {
+        connectionRetries: 5,
+        proxy: credentials.proxy,
+        timeout: 10000 * 60 * 10,
+      });
+      console.log('Login cresentials:', credentials)
+      // @ts-ignore
+      await this.tgClient.start({
+        phoneNumber: async () => phone,
+        password: async () => {
+          if (!password) {
+            return await cbRequestPassword();
+          }
+          return password;
+        },
+        phoneCode: async () => {
+          return await cbRequestCode();
+        },
+        onError: (err: Error) => {
+            cbError('Error for wait authentiction', err);
+        },
+      });
+
+      const session = this.tgClient.session.save() as unknown as string;
+
+      this.credentialsManager.addCredential({
+        phone,
+        proxy,
+        session,
+        password,
+      });
+
+      console.log("Регистрация успешна!");
+      console.log("Сессия:\n", session);
+
+    } catch (err) {
+      throw new Error("Failed to register account", { cause: err });
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    await this.tgClient.disconnect();
+  }
+
+  async disconnectWhenConnect() {
+    await this.tgClient.disconnect();
+  }
+
+  /**
+   * Отправляет команду /start боту
+   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
+   * @returns true если команда успешно отправлена
+   */
+  async sendStartCommand(botUsername: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Убираем @ из username если он есть
+      const normalizedUsername = botUsername.startsWith('@') ? botUsername.substring(1) : botUsername;
+      
+      // Ищем бота по username
+      const result = await this.tgClient.sendMessage(normalizedUsername, {
+        message: '/start'
+      });
+      
+      return result ? true : false;
+    } catch (error) {
+      console.error('Error sending /start command:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to send /start command to @${botUsername}: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Получает ID чата с ботом
+   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
+   * @returns ID чата с ботом
+   */
+  async getBotChatId(botUsername: string): Promise<number> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Убираем @ из username если он есть
+      const normalizedUsername = botUsername.startsWith('@') ? botUsername.substring(1) : botUsername;
+      
+      // Получаем информацию о диалоге с ботом
+      const dialog = await this.tgClient.getDialogs({
+        limit: 1
+      });
+
+      if (!dialog || dialog.length === 0 || !dialog[0] || !dialog[0].id) {
+        throw new Error(`Chat with bot @${normalizedUsername} not found`);
+      }
+
+      return dialog[0].id!.toJSNumber();
+    } catch (error) {
+      console.error('Error getting bot chat ID:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to get chat ID for @${botUsername}: ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Отправляет жалобу на бота
+   * @param botUsername username бота (например: 'my_bot' или '@my_bot')
+   * @param reason причина жалобы: 'spam' | 'violence' | 'pornography' | 'custompromoting' | 'other'
+   * @returns true если жалоба успешно отправлена
+   */
+  async reportBot(
+    botUsername: string, 
+    reason: 'spam' | 'violence' | 'pornography' | 'custompromoting' | 'other' = 'spam'
+  ): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      const chatId = await this.getBotChatId(botUsername);
+      
+      // Получаем сообщения от бота для репорта
+      const messages = await this.tgClient.getMessages(chatId, { limit: 1 });
+      if (!messages || messages.length === 0) {
+        throw new Error('No messages found to report');
+      }
+
+      // Формируем причину жалобы
+      let reportReason = reason;
+      if (reason === 'custompromoting') {
+        reportReason = 'spam';
+      }
+
+      // Отправляем жалобу на последнее сообщение
+      await this.tgClient.sendMessage(chatId, {
+        message: `/report ${reportReason}`,
+        replyTo: messages[0].id
+      });
+
+      return true;
+    } catch (error) {
+      console.error('Error reporting bot:', error);
+      if (error instanceof Error) {
+        throw new Error(`Failed to report @${botUsername}: ${error.message}`);
+      }
+      throw new Error(`Failed to report @${botUsername}: Unknown error`);
+    }
+  }
+
+  /**
+   * Проверяет, зарегистрирован ли номер телефона в Telegram
+   * @param phoneNumber номер телефона в международном формате (например: '+380123456789')
+   * @returns true если номер зарегистрирован в Telegram, false если нет
+   */
+  async isPhoneRegistered(phoneNumber: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Попытаемся найти пользователя, отправив сообщение самому себе с информацией о номере
+      // Это безопасный способ проверки без отправки реальных сообщений
+      const me = await this.tgClient.getMe();
+      
+      // Используем поиск по username если номер содержит буквы, иначе считаем что это номер
+      if (phoneNumber.includes('@')) {
+        try {
+          const entity = await this.tgClient.getEntity(phoneNumber);
+          return entity ? true : false;
+        } catch {
+          return false;
+        }
+      }
+
+      // Для номеров телефонов возвращаем true по умолчанию
+      // В реальном приложении здесь должен быть более сложный API вызов
+      console.log(`Проверка номера ${phoneNumber} - предполагаем что зарегистрирован`);
+      return true;
+    } catch (error) {
+      console.error('Error checking phone registration:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Добавляет контакт в адресную книгу Telegram
+   * @param phoneNumber номер телефона в международном формате
+   * @param firstName имя контакта
+   * @param lastName фамилия контакта (необязательно)
+   * @returns true если контакт успешно добавлен
+   */
+  async addContact(phoneNumber: string, firstName: string, lastName?: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Импортируем API для работы с контактами
+      const bigInteger = (await import('big-integer')).default;
+      
+      // Нормализуем номер телефона (убираем все символы кроме цифр и +)
+      const normalizedPhone = phoneNumber.replace(/[^\d+]/g, '');
+      
+      // Создаем контакт для импорта
+      const contact = new Api.InputPhoneContact({
+        clientId: bigInteger(Math.floor(Math.random() * 1000000000)), // Генерируем случайный ID
+        phone: normalizedPhone.replace(/^\+/, ''), // Убираем + для API
+        firstName: firstName,
+        lastName: lastName || ''
+      });
+
+      console.log(`🔍 Попытка добавить контакт: ${firstName} ${lastName || ''} (${phoneNumber})`);
+
+      // Импортируем контакт через API
+      const result = await this.tgClient.invoke(
+        new Api.contacts.ImportContacts({
+          contacts: [contact]
+        })
+      );
+
+      // Проверяем результат импорта
+      if (result.imported && result.imported.length > 0) {
+        console.log(`✅ Контакт ${firstName} ${lastName || ''} (${phoneNumber}) успешно добавлен`);
+        
+        // Если есть информация о пользователе
+        if (result.users && result.users.length > 0) {
+          const user = result.users[0];
+          const username = (user as any).username;
+          console.log(`📱 Найден пользователь Telegram: @${username || 'без username'}`);
+          console.log(`🆔 ID пользователя: ${user.id}`);
+        }
+        
+        return true;
+      } else if (result.retryContacts && result.retryContacts.length > 0) {
+        console.log(`⚠️ Контакт ${phoneNumber} требует повторной попытки`);
+        throw new Error(`Contact ${phoneNumber} requires retry`);
+      } else {
+        // Проверяем, найден ли пользователь в результате (контакт уже существует)
+        if (result.users && result.users.length > 0) {
+          const user = result.users[0];
+          const username = (user as any).username;
+          console.log(`� Пользователь уже существует в контактах: @${username || 'без username'}`);
+          return true;
+        }
+        
+        console.log(`ℹ️ Контакт ${phoneNumber} не найден в Telegram или не удалось добавить`);
+        throw new Error(`Contact ${phoneNumber} not found or could not be added`);
+      }
+    } catch (error) {
+      console.error('Error adding contact:', error);
+      
+      // Если пользователь не найден, это не критическая ошибка
+      if (error instanceof Error && (
+        error.message.includes('USER_NOT_FOUND') ||
+        error.message.includes('PHONE_NOT_OCCUPIED') ||
+        error.message.includes('USERNAME_NOT_OCCUPIED')
+      )) {
+        console.log(`ℹ️ Пользователь с номером ${phoneNumber} не зарегистрирован в Telegram`);
+        throw new Error(`User with phone ${phoneNumber} is not registered in Telegram`);
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Получает информацию о пользователе по номеру телефона или username
+   * @param identifier номер телефона или username
+   * @returns информация о пользователе или null если не найден
+   */
+  async getUserByPhone(identifier: string): Promise<any | null> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Пытаемся получить информацию о пользователе
+      let entity;
+      
+      if (identifier.startsWith('@') || !identifier.startsWith('+')) {
+        // Если это username, пытаемся найти по username
+        entity = await this.tgClient.getEntity(identifier);
+      } else {
+        // Если это номер телефона, логируем попытку поиска
+        console.log(`Поиск пользователя по номеру: ${identifier}`);
+        return null; // В упрощенной версии возвращаем null для номеров
+      }
+
+      if (entity) {
+        return {
+          id: entity.id?.toString() || '',
+          firstName: (entity as any).firstName || '',
+          lastName: (entity as any).lastName || '',
+          username: (entity as any).username || '',
+          phone: identifier.startsWith('+') ? identifier : '',
+          isBot: (entity as any).bot || false,
+          isVerified: (entity as any).verified || false,
+          isPremium: (entity as any).premium || false
+        };
+      }
+
+      return null;
+    } catch (error) {
+      console.error('Error getting user info:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Массовая проверка номеров телефонов на регистрацию в Telegram
+   * @param phoneNumbers массив номеров телефонов
+   * @returns объект с результатами проверки для каждого номера
+   */
+  async checkMultiplePhones(phoneNumbers: string[]): Promise<{[phone: string]: boolean}> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    const results: {[phone: string]: boolean} = {};
+
+    // Проверяем каждый номер по очереди
+    for (const phone of phoneNumbers) {
+      try {
+        results[phone] = await this.isPhoneRegistered(phone);
+        
+        // Небольшая задержка между запросами для избежания rate limit
+        await new Promise(resolve => setTimeout(resolve, 200));
+      } catch (error) {
+        console.error(`Error checking phone ${phone}:`, error);
+        results[phone] = false;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Отправляет сообщение пользователю по ID или username
+   * @param target ID пользователя или username
+   * @param message текст сообщения
+   * @returns true если сообщение отправлено успешно
+   */
+  async sendMessageToUser(target: string, message: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Отправляем сообщение
+      const result = await this.tgClient.sendMessage(target, {
+        message: message
+      });
+
+      console.log(`✅ Сообщение отправлено пользователю ${target}`);
+      return result ? true : false;
+    } catch (error) {
+      console.error('Error sending message:', error);
+      throw new Error(`Failed to send message to ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}
+
+/**
+ * Менеджер учетных данных Telegram с поддержкой базы данных SQLite
+ */
+export class TelegramManagerCredentialsDB {
+  private database: Database;
+  private requiredProxyForCredentials: boolean = false;
+
+  // Локальные импорты для избежания конфликтов путей
+  private TgAccount: any;
+  private Proxy: any;
+  private TgAccountStatus: any;
+  private ProxyStatus: any;
+
+  constructor(database: Database) {
+    this.database = database;
+    
+    // Динамический импорт моделей
+    this.initModels();
+  }
+
+  private async initModels() {
+    this.TgAccount = TgAccount;
+    this.Proxy = Proxy;
+    this.TgAccountStatus = TgAccountStatus;
+    this.ProxyStatus = ProxyStatus;
+
+    // Устанавливаем базу данных для моделей
+    this.TgAccount.setDatabase(this.database);
+    this.Proxy.setDatabase(this.database);
+  }
+
+  /**
+   * Включить/выключить обязательное использование прокси для учетных данных
+   */
+  setRequiredProxyForCredentials(required: boolean): void {
+    this.requiredProxyForCredentials = required;
+  }
+
+  /**
+   * Преобразовать данные прокси из БД в формат TelegramClientProxy
+   */
+  private convertProxyToTelegramFormat(proxyData: any): TelegramClientProxy {
+    return {
+      ip: proxyData.ip,
+      port: proxyData.port,
+      username: proxyData.username || undefined,
+      password: proxyData.password || undefined,
+      secret: proxyData.secret || undefined,
+      socksType: (proxyData.socksType === 4 || proxyData.socksType === 5) ? proxyData.socksType as 4 | 5 : 5,
+      MTProxy: proxyData.MTProxy === 1
+    };
+  }
+
+  /**
+   * Получить следующий доступный прокси из БД
+   */
+  private async getNextProxy(): Promise<TelegramClientProxy> {
+    const proxy = await this.Proxy.getRandomActive();
+    if (!proxy) {
+      throw new Error("Нет доступных прокси в базе данных");
+    }
+
+    return this.convertProxyToTelegramFormat(proxy);
+  }
+
+  /**
+   * Добавить или обновить учетные данные
+   */
+  async addCredential(credential: TelegramCredentials): Promise<void> {
+    let proxyId: number | null = null;
+
+    // Назначить прокси если требуется
+    if (this.requiredProxyForCredentials && !credential.proxy) {
+      try {
+        const proxy = await this.getNextProxy();
+        credential.proxy = proxy;
+        
+        // Найти ID прокси в БД
+        const proxyData = await this.Proxy.findByIpPort(proxy.ip, proxy.port);
+        if (proxyData) {
+          proxyId = proxyData.id!;
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Не удалось назначить прокси: ${errorMessage}`);
+      }
+    } else if (credential.proxy) {
+      // Найти существующий прокси или создать новый
+      let proxyData = await this.Proxy.findByIpPort(credential.proxy.ip, credential.proxy.port);
+      if (!proxyData) {
+        // Создать новый прокси в БД
+        proxyId = await this.Proxy.create({
+          ip: credential.proxy.ip,
+          port: credential.proxy.port,
+          username: credential.proxy.username || null,
+          password: credential.proxy.password || null,
+          secret: credential.proxy.secret || null,
+          socksType: credential.proxy.socksType || null,
+          MTProxy: credential.proxy.MTProxy ? 1 : 0,
+          status: this.ProxyStatus.ACTIVE
+        });
+      } else {
+        proxyId = proxyData.id!;
+      }
+    }
+
+    // Используем upsert для вставки или обновления
+    await this.TgAccount.upsert({
+      phone: credential.phone.replace('+', ''),
+      session: credential.session || null,
+      password: credential.password || null,
+      proxy_id: proxyId,
+      status: credential.session ? this.TgAccountStatus.ACTIVE : this.TgAccountStatus.INACTIVE
+    });
+  }
+
+  /**
+   * Получить учетные данные по номеру телефона
+   */
+  async getCredential(phone: string): Promise<TelegramCredentials | null> {
+    const accountData = await this.TgAccount.findWithProxy(phone);
+    if (!accountData) {
+      return null;
+    }
+
+    let proxy: TelegramClientProxy | undefined;
+    if (accountData.proxy_id && accountData.proxy_ip) {
+      proxy = {
+        ip: accountData.proxy_ip,
+        port: accountData.proxy_port,
+        username: accountData.proxy_username || undefined,
+        password: accountData.proxy_password || undefined,
+        secret: accountData.proxy_secret || undefined,
+        socksType: (accountData.proxy_socksType === 4 || accountData.proxy_socksType === 5) ? 
+          accountData.proxy_socksType as 4 | 5 : 5,
+        MTProxy: accountData.proxy_MTProxy === 1
+      };
+    }
+
+    return {
+      phone: accountData.phone,
+      session: accountData.session || undefined,
+      password: accountData.password || undefined,
+      proxy
+    };
+  }
+
+  /**
+   * Удалить учетные данные по номеру телефона
+   */
+  async deleteCredential(phone: string): Promise<boolean> {
+    const account = await this.TgAccount.findByPhone(phone);
+    if (account) {
+      await this.TgAccount.delete(phone);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Получить все учетные данные
+   */
+  async getAllCredentials(): Promise<TelegramCredentials[]> {
+    const accounts = await this.TgAccount.getAllWithProxy();
+    const credentials: TelegramCredentials[] = [];
+
+    for (const account of accounts) {
+      let proxy: TelegramClientProxy | undefined;
+      
+      if (account.proxy_id && account.proxy_ip) {
+        proxy = {
+          ip: account.proxy_ip,
+          port: account.proxy_port,
+          username: account.proxy_username || undefined,
+          password: account.proxy_password || undefined,
+          secret: account.proxy_secret || undefined,
+          socksType: (account.proxy_socksType === 4 || account.proxy_socksType === 5) ? 
+            account.proxy_socksType as 4 | 5 : 5,
+          MTProxy: account.proxy_MTProxy === 1
+        };
+      }
+
+      credentials.push({
+        phone: account.phone,
+        session: account.session || undefined,
+        password: account.password || undefined,
+        proxy
+      });
+    }
+
+    return credentials;
+  }
+
+  /**
+   * Проверить, существуют ли учетные данные
+   */
+  async hasCredential(phone: string): Promise<boolean> {
+    return await this.TgAccount.exists(phone);
+  }
+
+  /**
+   * Обновить сессию для существующего аккаунта
+   */
+  async updateSession(phone: string, session: string): Promise<boolean> {
+    const account = await this.TgAccount.findByPhone(phone);
+    if (account) {
+      await this.TgAccount.updateSession(phone, session);
+      await this.TgAccount.updateStatus(phone, this.TgAccountStatus.ACTIVE);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Получить количество учетных данных
+   */
+  async getCredentialsCount(): Promise<number> {
+    const stats = await this.TgAccount.getStats();
+    return stats.total;
+  }
+
+  /**
+   * Очистить все учетные данные
+   */
+  async clearAllCredentials(): Promise<void> {
+    const accounts = await this.TgAccount.getAll();
+    for (const account of accounts) {
+      await this.TgAccount.delete(account.id!);
+    }
+  }
+
+  /**
+   * Получить учетные данные по прокси
+   */
+  async getCredentialsByProxy(proxyHost: string, proxyPort: number): Promise<TelegramCredentials[]> {
+    const proxy = await this.Proxy.findByIpPort(proxyHost, proxyPort);
+    if (!proxy) {
+      return [];
+    }
+
+    const accounts = await this.TgAccount.getAll();
+    const credentials: TelegramCredentials[] = [];
+
+    for (const account of accounts) {
+      if (account.proxy_id === proxy.id) {
+        const proxyData = this.convertProxyToTelegramFormat(proxy);
+        credentials.push({
+          phone: account.phone,
+          session: account.session || undefined,
+          password: account.password || undefined,
+          proxy: proxyData
+        });
+      }
+    }
+
+    return credentials;
+  }
+
+  /**
+   * Получить учетные данные без прокси
+   */
+  async getCredentialsWithoutProxy(): Promise<TelegramCredentials[]> {
+    const accounts = await this.TgAccount.getWithoutProxy();
+    
+    return accounts.map(account => ({
+      phone: account.phone,
+      session: account.session || undefined,
+      password: account.password || undefined
+    }));
+  }
+
+  /**
+   * Получить активные учетные данные
+   */
+  async getActiveCredentials(): Promise<TelegramCredentials[]> {
+    const accounts = await this.TgAccount.getByStatus(this.TgAccountStatus.ACTIVE);
+    const credentials: TelegramCredentials[] = [];
+
+    for (const account of accounts) {
+      let proxy: TelegramClientProxy | undefined;
+      
+      if (account.proxy_id) {
+        const proxyData = await this.Proxy.findById(account.proxy_id);
+        if (proxyData && proxyData.status === this.ProxyStatus.ACTIVE) {
+          proxy = this.convertProxyToTelegramFormat(proxyData);
+        }
+      }
+
+      credentials.push({
+        phone: account.phone,
+        session: account.session || undefined,
+        password: account.password || undefined,
+        proxy
+      });
+    }
+
+    return credentials;
+  }
+
+  /**
+   * Получить случайные активные учетные данные
+   */
+  async getRandomActiveCredential(): Promise<TelegramCredentials | null> {
+    const account = await this.TgAccount.getRandomAvailable();
+    if (!account) {
+      return null;
+    }
+
+    let proxy: TelegramClientProxy | undefined;
+    if (account.proxy_id) {
+      const proxyData = await this.Proxy.findById(account.proxy_id);
+      if (proxyData && proxyData.status === this.ProxyStatus.ACTIVE) {
+        proxy = this.convertProxyToTelegramFormat(proxyData);
+      }
+    }
+
+    return {
+      phone: account.phone,
+      session: account.session || undefined,
+      password: account.password || undefined,
+      proxy
+    };
+  }
+
+  /**
+   * Обновить информацию о пользователе
+   */
+  async updateUserInfo(phone: string, userInfo: {
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    user_id?: number;
+  }): Promise<void> {
+    await this.TgAccount.updateUserInfo(phone, userInfo);
+  }
+
+  /**
+   * Обновить статус аккаунта
+   */
+  async updateAccountStatus(phone: string, status: any): Promise<void> {
+    const account = await this.TgAccount.findByPhone(phone);
+    if (account) {
+      await this.TgAccount.updateStatus(account.id!, status);
+    }
+  }
+
+  /**
+   * Отметить активность аккаунта
+   */
+  async markActivity(phone: string): Promise<void> {
+    const account = await this.TgAccount.findByPhone(phone);
+    if (account) {
+      await this.TgAccount.updateLastActivity(account.id!);
+    }
+  }
+
+  /**
+   * Получить статистику
+   */
+  async getStats(): Promise<{
+    accounts: any;
+    proxies: any;
+  }> {
+    const accountStats = await this.TgAccount.getStats();
+    const proxyStats = await this.Proxy.getStats();
+
+    return {
+      accounts: accountStats,
+      proxies: proxyStats
+    };
+  }
+
+  /**
+   * Добавить прокси в БД
+   */
+  async addProxy(proxyData: any): Promise<number> {
+    return await this.Proxy.create(proxyData);
+  }
+
+  /**
+   * Получить все прокси
+   */
+  async getAllProxies(): Promise<any[]> {
+    return await this.Proxy.getAll();
+  }
+
+  /**
+   * Получить активные прокси
+   */
+  async getActiveProxies(): Promise<any[]> {
+    return await this.Proxy.getActive();
+  }
+}