Update Dockerfile

Update docker-registry.yml
Update docker-hub.yml
2025-11-28 03:21:48 +03:00 · 2025-11-28 03:21:34 +03:00 · 2025-11-28 03:21:20 +03:00 · 2025-11-28 03:03:03 +03:00 · 2025-11-28 03:00:24 +03:00 · 2025-11-28 03:00:09 +03:00
330 changed files with 122183 additions and 15477 deletions
@@ -67,6 +67,14 @@ REMNAWAVE_SECRET_KEY=
 #   {telegram_id}       — ID Telegram
 REMNAWAVE_USER_DESCRIPTION_TEMPLATE="Bot user: {full_name} {username}"

+# Шаблон имени пользователя в панели Remnawave
+# Доступные плейсхолдеры аналогичны описанию выше
+#   {full_name}         — Имя, Фамилия из Telegram
+#   {username}          — @логин из Telegram (c @)
+#   {username_clean}    — логин из Telegram (без @)
+#   {telegram_id}       — ID Telegram
+REMNAWAVE_USER_USERNAME_TEMPLATE="user_{telegram_id}"
+
 # Режим удаления пользователей из панели RemnaWave
 # delete - полностью удалить пользователя из панели
 # disable - только деактивировать пользователя
@@ -77,7 +85,8 @@ REMNAWAVE_USER_DELETE_MODE=delete
 TRIAL_DURATION_DAYS=3
 TRIAL_TRAFFIC_LIMIT_GB=10
 TRIAL_DEVICE_LIMIT=1
-TRIAL_SQUAD_UUID=
+TRIAL_PAYMENT_ENABLED=false
+TRIAL_ACTIVATION_PRICE=0

 # ===== ПЛАТНАЯ ПОДПИСКА =====
 # Сколько устройств доступно по дефолту при покупке платной подписки
@@ -89,8 +98,13 @@ MAX_DEVICES_LIMIT=15
 # Дефолт параметры для подписок выданных через админку
 DEFAULT_TRAFFIC_LIMIT_GB=100

+# Плюсовать дни триала при покупке платной подписке 
+TRIAL_ADD_REMAINING_DAYS_TO_PAID=false
+
 # ===== ГЛОБАЛЬНЫЙ ПАРАМЕТР ДЛЯ ВСЕХ ПОДПИСОК =====
 DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
+# Сбрасывать трафик при каждой оплате подписки
+RESET_TRAFFIC_ON_PAYMENT=false

 # ===== НАСТРОЙКИ ТРАФИКА =====
 # Режим выбора трафика:
@@ -108,12 +122,24 @@ FIXED_TRAFFIC_LIMIT_GB=100
 AVAILABLE_SUBSCRIPTION_PERIODS=30,90,180
 AVAILABLE_RENEWAL_PERIODS=30,90,180

+# ===== НАСТРОЙКИ ПРОСТОЙ ПОКУПКИ =====
+# Включить упрощённую покупку из меню
+SIMPLE_SUBSCRIPTION_ENABLED=false
+# Стандартный период (должен совпадать с одним из AVAILABLE_SUBSCRIPTION_PERIODS)
+SIMPLE_SUBSCRIPTION_PERIOD_DAYS=30
+# Сколько устройств выдаётся в рамках простой подписки
+SIMPLE_SUBSCRIPTION_DEVICE_LIMIT=1
+# Лимит трафика в ГБ (0 — безлимит)
+SIMPLE_SUBSCRIPTION_TRAFFIC_GB=0
+# UUID сквада (оставьте пустым, чтобы использовать сквады по умолчанию)
+# SIMPLE_SUBSCRIPTION_SQUAD_UUID=
+
 # ===== ЦЕНЫ (в копейках) =====
 BASE_SUBSCRIPTION_PRICE=0

 # Цены за периоды
 PRICE_14_DAYS=7000
-PRICE_30_DAYS=9900
+PRICE_30_DAYS=1000
 PRICE_60_DAYS=25900
 PRICE_90_DAYS=36900
 PRICE_180_DAYS=69900
@@ -125,12 +151,17 @@ BASE_PROMO_GROUP_PERIOD_DISCOUNTS_ENABLED=false
 BASE_PROMO_GROUP_PERIOD_DISCOUNTS=60:10,90:20,180:40,360:70

 # Выводимые пакеты трафика и их цены в копейках
-TRAFFIC_PACKAGES_CONFIG="5:2000:false,10:3500:false,25:7000:false,50:11000:true,100:15000:true,250:17000:false,500:19000:false,1000:19500:true,0:20000:true"
+TRAFFIC_PACKAGES_CONFIG="5:2000:false,10:3500:false,25:7000:false,50:11000:true,100:15000:true,250:17000:false,500:19000:false,1000:19500:true,0:0:true"

 # Цена за дополнительное устройство (DEFAULT_DEVICE_LIMIT идет бесплатно!)
-PRICE_PER_DEVICE=5000
+PRICE_PER_DEVICE=10000
+# Включить выбор количества устройств при покупке и продлении
+DEVICES_SELECTION_ENABLED=true
+# Единое количество устройств для режима без выбора (0 — не назначать устройства)
+DEVICES_SELECTION_DISABLED_AMOUNT=0

 # ===== РЕФЕРАЛЬНАЯ СИСТЕМА =====
+REFERRAL_PROGRAM_ENABLED=true
 REFERRAL_MINIMUM_TOPUP_KOPEKS=10000
 REFERRAL_FIRST_TOPUP_BONUS_KOPEKS=10000
 REFERRAL_INVITER_BONUS_KOPEKS=10000
@@ -142,20 +173,24 @@ REFERRAL_NOTIFICATION_RETRY_ATTEMPTS=3

 # ===== АВТОПРОДЛЕНИЕ =====
 AUTOPAY_WARNING_DAYS=3,1
+DEFAULT_AUTOPAY_ENABLED=true
 DEFAULT_AUTOPAY_DAYS_BEFORE=3
 MIN_BALANCE_FOR_AUTOPAY_KOPEKS=10000

 # ===== ПЛАТЕЖНЫЕ СИСТЕМЫ =====

 # Telegram Stars (работает автоматически)
-TELEGRAM_STARS_ENABLED=true
-TELEGRAM_STARS_RATE_RUB=1.3
+TELEGRAM_STARS_ENABLED=false
+TELEGRAM_STARS_RATE_RUB=1.79

 # Tribute (https://tribute.app)
 TRIBUTE_ENABLED=false
 TRIBUTE_API_KEY=
 TRIBUTE_DONATE_LINK=
 TRIBUTE_WEBHOOK_PATH=/tribute-webhook
+TRIBUTE_WEBHOOK_HOST=0.0.0.0
+# Примечание: индивидуальные *_WEBHOOK_PORT используются только для старой схемы запуска.
+# В режиме единого FastAPI сервера оставьте эти значения по умолчанию.
 TRIBUTE_WEBHOOK_PORT=8081

 # YooKassa (https://yookassa.ru)
@@ -206,8 +241,8 @@ YOOKASSA_PAYMENT_SUBJECT=service

 # Webhook настройки
 YOOKASSA_WEBHOOK_PATH=/yookassa-webhook
+YOOKASSA_WEBHOOK_HOST=0.0.0.0
 YOOKASSA_WEBHOOK_PORT=8082
-YOOKASSA_WEBHOOK_SECRET=your_webhook_secret

 # Лимиты сумм пополнения через YooKassa (в копейках)
 YOOKASSA_MIN_AMOUNT_KOPEKS=5000
@@ -216,8 +251,18 @@ YOOKASSA_MAX_AMOUNT_KOPEKS=1000000
 # Быстрый выбор суммы пополнения через YooKassa
 YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED=true

+# Отключить отображение кнопок выбора суммы пополнения (оставить только ввод вручную)
+DISABLE_TOPUP_BUTTONS=false
+# Отключить пополнение баланса через поддержку
+SUPPORT_TOPUP_ENABLED=true
+
+# Автоматическая проверка зависших пополнений и повторные обращения к провайдерам
+PAYMENT_VERIFICATION_AUTO_CHECK_ENABLED=false
+# Интервал (в минутах) между автоматическими проверками пополнений
+PAYMENT_VERIFICATION_AUTO_CHECK_INTERVAL_MINUTES=10
+
 # ===== НАСТРОЙКИ ОПИСАНИЙ ПЛАТЕЖЕЙ =====
-# Эти настройки позволяют изменить описания платежей, 
+# Эти настройки позволяют изменить описания платежей,
 # чтобы избежать блокировок платежных систем
 PAYMENT_SERVICE_NAME=Интернет-сервис
 PAYMENT_BALANCE_DESCRIPTION=Пополнение баланса
@@ -232,11 +277,29 @@ CRYPTOBOT_WEBHOOK_SECRET=your_webhook_secret_here
 CRYPTOBOT_BASE_URL=https://pay.crypt.bot
 CRYPTOBOT_TESTNET=false
 CRYPTOBOT_WEBHOOK_PATH=/cryptobot-webhook
+# Эти порты используются только при ручном запуске старого aiohttp сервера.
+# В новой конфигурации все вебхуки обрабатываются через порт 8080.
 CRYPTOBOT_WEBHOOK_PORT=8081
 CRYPTOBOT_DEFAULT_ASSET=USDT
 CRYPTOBOT_ASSETS=USDT,TON,BTC,ETH,LTC,BNB,TRX,USDC
 CRYPTOBOT_INVOICE_EXPIRES_HOURS=24

+# HELEKET
+HELEKET_ENABLED=false
+HELEKET_MERCHANT_ID=
+HELEKET_API_KEY=
+HELEKET_BASE_URL=https://api.heleket.com/v1
+HELEKET_DEFAULT_CURRENCY=USDT
+HELEKET_DEFAULT_NETWORK=
+HELEKET_INVOICE_LIFETIME=3600
+HELEKET_MARKUP_PERCENT=0
+HELEKET_WEBHOOK_PATH=/heleket-webhook
+HELEKET_WEBHOOK_HOST=0.0.0.0
+HELEKET_WEBHOOK_PORT=8086
+HELEKET_CALLBACK_URL=
+HELEKET_RETURN_URL=
+HELEKET_SUCCESS_URL=
+
 # MULENPAY
 MULENPAY_ENABLED=false
 MULENPAY_API_KEY=
@@ -265,6 +328,26 @@ PAL24_PAYMENT_DESCRIPTION="Пополнение баланса"
 PAL24_MIN_AMOUNT_KOPEKS=10000
 PAL24_MAX_AMOUNT_KOPEKS=100000000
 PAL24_REQUEST_TIMEOUT=30
+# Отображать кнопку СБП в PayPalych (true - отображать, false - скрывать)
+PAL24_SBP_BUTTON_VISIBLE=true
+# Отображать кнопку оплаты картой в PayPalych (true - отображать, false - скрывать)
+PAL24_CARD_BUTTON_VISIBLE=true
+
+# PLATEGA
+PLATEGA_ENABLED=false
+PLATEGA_MERCHANT_ID=
+PLATEGA_SECRET=
+PLATEGA_BASE_URL=https://app.platega.io
+PLATEGA_RETURN_URL=
+PLATEGA_FAILED_URL=
+PLATEGA_CURRENCY=RUB
+# Список ID активных методов из кабинета Platega (через запятую)
+PLATEGA_ACTIVE_METHODS=2,10,11,12,13
+PLATEGA_MIN_AMOUNT_KOPEKS=10000
+PLATEGA_MAX_AMOUNT_KOPEKS=100000000
+PLATEGA_WEBHOOK_PATH=/platega-webhook
+PLATEGA_WEBHOOK_HOST=0.0.0.0
+PLATEGA_WEBHOOK_PORT=8086

 # ===== ИНТЕРФЕЙС И UX =====

@@ -272,6 +355,9 @@ PAL24_REQUEST_TIMEOUT=30
 ENABLE_LOGO_MODE=true
 LOGO_FILE=vpn_logo.png

+# Режим главного меню (default - классический режим работы бота, text - режим работы с активным ЛК MiniApp, отключает покупку/управление подпиской в меню, заменяет все кнопками открытия в MiniApp ЛК)
+MAIN_MENU_MODE=default
+
 # Скрыть блок с ссылкой подключения в разделе с информацией о подписке
 HIDE_SUBSCRIPTION_LINK=false

@@ -285,6 +371,11 @@ CONNECT_BUTTON_MODE=guide

 # URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
 MINIAPP_CUSTOM_URL=
+MINIAPP_STATIC_PATH=miniapp
+MINIAPP_SERVICE_NAME_EN=Bedolaga VPN
+MINIAPP_SERVICE_NAME_RU=Bedolaga VPN
+MINIAPP_SERVICE_DESCRIPTION_EN=Secure & Fast Connection
+MINIAPP_SERVICE_DESCRIPTION_RU=Безопасное и быстрое подключение

 # Параметры режима happ_cryptolink
 CONNECT_BUTTON_HAPP_DOWNLOAD_ENABLED=false
@@ -332,12 +423,18 @@ SERVER_STATUS_ITEMS_PER_PAGE=10
 MAINTENANCE_MODE=false
 MAINTENANCE_CHECK_INTERVAL=30
 MAINTENANCE_AUTO_ENABLE=true
+MAINTENANCE_MONITORING_ENABLED=true
+MAINTENANCE_RETRY_ATTEMPTS=1
 MAINTENANCE_MESSAGE=Ведутся технические работы. Сервис временно недоступен. Попробуйте позже.

 # ===== ЛОКАЛИЗАЦИЯ =====
 # Укажите язык из AVAILABLE_LANGUAGES. При некорректном значении используется ru.
 DEFAULT_LANGUAGE=ru
-AVAILABLE_LANGUAGES=ru,en
+AVAILABLE_LANGUAGES=ru,en,ua,zh
+# Включить выбор языка при старте и отображение кнопки в меню
+LANGUAGE_SELECTION_ENABLED=true
+# Часовой пояс
+TZ=Europe/Moscow # или UTC, America/New_York и т.д.

 # ===== ДОПОЛНИТЕЛЬНЫЕ НАСТРОЙКИ =====
 # Конфигурация приложений для гайда подключения
@@ -375,3 +472,20 @@ LOG_FILE=logs/bot.log
 DEBUG=false
 WEBHOOK_URL=
 WEBHOOK_PATH=/webhook
+WEBHOOK_SECRET_TOKEN=
+WEBHOOK_DROP_PENDING_UPDATES=true
+WEBHOOK_MAX_QUEUE_SIZE=1024
+WEBHOOK_WORKERS=4
+WEBHOOK_ENQUEUE_TIMEOUT=0.1
+WEBHOOK_WORKER_SHUTDOWN_TIMEOUT=30.0
+BOT_RUN_MODE=polling  # polling, webhook или both
+
+# ===== ЕДИНЫЙ ВЕБ-СЕРВЕР =====
+WEB_API_ENABLED=false
+WEB_API_HOST=0.0.0.0
+WEB_API_PORT=8080
+WEB_API_ALLOWED_ORIGINS=*
+WEB_API_DOCS_ENABLED=false
+WEB_API_DEFAULT_TOKEN=
+WEB_API_DEFAULT_TOKEN_NAME=Bootstrap Token
+MINIAPP_STATIC_PATH=miniapp
@@ -0,0 +1,42 @@
+---
+name: Bug Bedolage
+about: Создать баг-репорт «Бедолаге»
+title: "[BUG] Заголовок"
+labels: ''
+assignees: ''
+
+---
+
+## Описание / Конфигурация
+
+Кратко описываем текущую проблему.
+
+Указываем настройки из `.env` конфига (если таковые имеются):
+
+```yml
+
+```
+
+## Шаги для воспроизведения
+
+1. 
+2. 
+3. 
+
+### Фактический результат
+
+* 
+* 
+* 
+
+### Скрины поведения
+
+Копируем изображение и вставляем прям сюда, если есть. Если нет — удаляем секцию.
+
+## Ожидаемое поведение
+
+Опишите, как должно работать.
+
+## Дополнительная информация
+
+Добавляем сюда дополнительную инфу, если есть. Если нет — удаляем секцию.
@@ -0,0 +1,32 @@
+---
+name: Feat Bedolage
+about: Создать запрос на фичу «Бедолаге»
+title: "[FEAT] Заголовок"
+labels: ''
+assignees: ''
+
+---
+
+## Описание / Конфигурация
+
+Кратко описываем что хотим.
+
+Указываем настройки из `.env` конфига (если таковые к месту):
+
+```yml
+
+```
+
+## Текущее поведение
+
+### Скрины поведения
+
+Копируем изображение и вставляем прям сюда, если есть. Если нет — удаляем секцию.
+
+## Желаемое поведение
+
+Опишите, как хотелось бы, чтобы было.
+
+## Дополнительная информация
+
+Добавляем сюда дополнительную инфу, если есть. Если нет — удаляем секцию.
@@ -36,15 +36,15 @@ jobs:
          TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:latest,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
          echo "🏷️ Собираем релизную версию: $VERSION"
        elif [[ $GITHUB_REF == refs/heads/main ]]; then
-          VERSION="v2.4.0-$(git rev-parse --short HEAD)"
+          VERSION="v2.8.0-$(git rev-parse --short HEAD)"
          TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:latest,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
          echo "🚀 Собираем версию из main: $VERSION"
        elif [[ $GITHUB_REF == refs/heads/dev ]]; then
-          VERSION="v2.4.0-dev-$(git rev-parse --short HEAD)"
+          VERSION="v2.8.0-dev-$(git rev-parse --short HEAD)"
          TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:dev,fr1ngg/remnawave-bedolaga-telegram-bot:${VERSION}"
          echo "🧪 Собираем dev версию: $VERSION"
        else
-          VERSION="v2.4.0-pr-$(git rev-parse --short HEAD)"
+          VERSION="v2.8.0-pr-$(git rev-parse --short HEAD)"
          TAGS="fr1ngg/remnawave-bedolaga-telegram-bot:pr-$(git rev-parse --short HEAD)"
          echo "🔀 Собираем PR версию: $VERSION"
        fi
@@ -49,13 +49,13 @@ jobs:
            VERSION=${GITHUB_REF#refs/tags/}
            echo "🏷️ Building release version: $VERSION"
          elif [[ $GITHUB_REF == refs/heads/main ]]; then
-            VERSION="v2.4.0-$(git rev-parse --short HEAD)"
+            VERSION="v2.8.0-$(git rev-parse --short HEAD)"
            echo "🚀 Building main version: $VERSION"
          elif [[ $GITHUB_REF == refs/heads/dev ]]; then
-            VERSION="v2.4.0-dev-$(git rev-parse --short HEAD)"
+            VERSION="v2.8.0-dev-$(git rev-parse --short HEAD)"
            echo "🧪 Building dev version: $VERSION"
          else
-            VERSION="v2.4.0-pr-$(git rev-parse --short HEAD)"
+            VERSION="v2.8.0-pr-$(git rev-parse --short HEAD)"
            echo "🔀 Building PR version: $VERSION"
          fi
          echo "version=$VERSION" >> $GITHUB_OUTPUT
@@ -1,19 +1,25 @@
 # Игнорируем все файлы и папки по умолчанию
 *
+docker-compose.override.yml

 # Исключения: разрешаем только нужные файлы
 !.dockerignore
 !.env.example
+!install_bot.sh
 !Dockerfile
 !app-config.json
 !main.py
 !requirements.txt
+!docs/
+!docs/**
+!migrations/
+!migrations/**

 # Разрешаем папку app/ и все её содержимое рекурсивно
 !app/
 !app/**
-!locales/
-!locales/**
+!tests/
+!tests/**

 # Дополнительно разрешаем README и лицензию (опционально)
 !README.md
@@ -14,7 +14,7 @@ RUN pip install --no-cache-dir --upgrade pip && \

 FROM python:3.13-slim

-ARG VERSION="v2.4.0"
+ARG VERSION="v2.8.0"
 ARG BUILD_DATE
 ARG VCS_REF

@@ -45,7 +45,7 @@ ENV PYTHONPATH=/app \
    BUILD_DATE=${BUILD_DATE} \
    VCS_REF=${VCS_REF}

-EXPOSE 8081 8082 8083
+EXPOSE 8080

 LABEL org.opencontainers.image.title="Bedolaga RemnaWave Bot" \
      org.opencontainers.image.description="Telegram bot for RemnaWave VPN service" \
@@ -57,6 +57,6 @@ LABEL org.opencontainers.image.title="Bedolaga RemnaWave Bot" \
      org.opencontainers.image.vendor="fr1ngg"

 HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
-    CMD wget --no-verbose --tries=1 --spider http://localhost:8081/health || exit 1
+    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1

 CMD ["python", "main.py"]
@@ -0,0 +1,39 @@
+.PHONY: up
+up: ## Поднять контейнеры (detached)
+	@echo "🚀 Поднимаем контейнеры (detached)..."
+	docker compose up -d --build
+
+.PHONY: up-follow
+up-follow: ## Поднять контейнеры с логами
+	@echo "📡 Поднимаем контейнеры (в консоли)..."
+	docker compose up --build
+
+.PHONY: down
+down: ## Остановить и удалить контейнеры
+	@echo "🛑 Останавливаем и удаляем контейнеры..."
+	docker compose down
+
+.PHONY: reload
+reload: ## Перезапустить контейнеры (detached)
+	@$(MAKE) down
+	@$(MAKE) up
+
+.PHONY: reload-follow
+reload-follow: ## Перезапустить контейнеры с логами
+	@$(MAKE) down
+	@$(MAKE) up-follow
+
+.PHONY: test
+test: ## Запустить тесты
+	@echo "🧪 Запускаем тесты..."
+	pytest -v
+
+.PHONY: help
+help: ## Показать список доступных команд
+	@echo ""
+	@echo "📘 Команды Makefile:"
+	@echo ""
+	@grep -E '^[a-zA-Z0-9_-]+:.*?##' $(MAKEFILE_LIST) | \
+		sed -E 's/:.*?## /| /' | \
+		awk -F'|' '{printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2}'
+	@echo ""
@@ -136,8 +136,7 @@ logger.debug(f"Webhook payload: {webhook_data}")
 # Открыть только необходимые порты
 ufw allow 80/tcp   # HTTP (redirect to HTTPS)
 ufw allow 443/tcp  # HTTPS
-ufw deny 8081/tcp  # Webhook порты (только через reverse proxy)
-ufw deny 8082/tcp
+ufw deny 8080/tcp  # Unified FastAPI сервер доступен только из внутренней сети
 ```

 ### 📊 Мониторинг безопасности
@@ -239,7 +238,6 @@ REMNAWAVE_API_KEY=your_api_key
 ADMIN_IDS=123456789,987654321

 # Webhook секреты - генерируйте случайные значения
-YOOKASSA_WEBHOOK_SECRET=random_secret_here
 TRIBUTE_WEBHOOK_SECRET=another_random_secret
 CRYPTOBOT_WEBHOOK_SECRET=yet_another_secret
 ```
@@ -283,7 +281,7 @@ services:
    
    # Не пробрасывайте порты наружу без необходимости
    ports:
-      - "127.0.0.1:8081:8081"  # Только localhost
+      - "127.0.0.1:8080:8080"  # Только localhost
    
    # Read-only root filesystem
    read_only: true
@@ -1,163 +1,658 @@
 {
-  "ios": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": true,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
-            "buttonText": {
-              "en": "App Store [EU]",
-              "ru": "App Store [EU]"
+  "config": {
+    "additionalLocales": [
+      "ru",
+      "zh",
+      "fa"
+    ],
+    "branding": {
+      "name": "Subscription",
+      "logoUrl": "https://raw.githubusercontent.com/Fr1ngg/remnawave-bedolaga-telegram-bot/bf0c1ce711a26fa2f24559e7e4443820e68d758b/assets/bedolaga_app3.svg",
+      "supportUrl": "https://t.me"
+    }
+  },
+  "platforms": {
+    "ios": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
+              "buttonText": {
+                "en": "Open in App Store [EU]",
+                "fa": "باز کردن در App Store [EU]",
+                "ru": "Открыть в App Store [EU]",
+                "zh": "在 App Store 中打开 [EU]"
+              }
+            },
+            {
+              "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
+              "buttonText": {
+                "en": "Open in App Store [RU]",
+                "fa": "باز کردن در App Store [RU]",
+                "ru": "Открыть в App Store [RU]",
+                "zh": "在 App Store 中打开 [RU]"
+              }
            }
+          ],
+          "description": {
+            "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+            "fa": "صفحه را در App Store باز کنید و برنامه را نصب کنید. آن را اجرا کنید، در پنجره مجوز پیکربندی VPN روی Allow کلیک کنید و رمز عبور خود را وارد کنید.",
+            "ru": "Откройте страницу в App Store и установите приложение. Запустите его, в окне разрешения VPN-конфигурации нажмите Allow и введите свой пароль.",
+            "zh": "在 App Store 中打开页面并安装应用。启动应用后，在 VPN 配置权限窗口中点击\"允许\"并输入您的密码。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below — the app will open and the subscription will be added automatically",
+            "fa": "برای افزودن خودکار اشتراک روی دکمه زیر کلیک کنید - برنامه باز خواهد شد",
+            "ru": "Нажмите кнопку ниже — приложение откроется, и подписка добавится автоматически.",
+            "zh": "点击下方按钮 — 应用将打开并自动添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
+          }
+        }
+      },
+      {
+        "id": "streisand",
+        "name": "Streisand",
+        "isFeatured": false,
+        "urlScheme": "streisand://import/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://apps.apple.com/ru/app/streisand/id6450534064",
+              "buttonText": {
+                "en": "Open in App Store",
+                "fa": "باز کردن در App Store",
+                "ru": "Открыть в App Store",
+                "zh": "在 App Store 中打开"
+              }
+            }
+          ],
+          "description": {
+            "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+            "fa": "صفحه را در App Store باز کنید و برنامه را نصب کنید. آن را اجرا کنید، در پنجره مجوز پیکربندی VPN روی Allow کلیک کنید و رمز عبور خود را وارد کنید.",
+            "ru": "Откройте страницу в App Store и установите приложение. Запустите его, в окне разрешения VPN-конфигурации нажмите Allow и введите свой пароль.",
+            "zh": "在 App Store 中打开页面并安装应用。启动应用后，在 VPN 配置权限窗口中点击\"允许\"并输入您的密码。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below — the app will open and the subscription will be added automatically",
+            "fa": "برای افزودن خودکار اشتراک روی دکمه زیر کلیک کنید - برنامه باز خواهد شد",
+            "ru": "Нажмите кнопку ниже — приложение откроется, и подписка добавится автоматически.",
+            "zh": "点击下方按钮 — 应用将打开并自动添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
+          }
+        }
+      },
+      {
+        "id": "shadowrocket",
+        "name": "Shadowrocket",
+        "isFeatured": false,
+        "urlScheme": "sub://",
+        "isNeedBase64Encoding": true,
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://apps.apple.com/ru/app/shadowrocket/id932747118",
+              "buttonText": {
+                "en": "Open in App Store",
+                "fa": "باز کردن در App Store",
+                "ru": "Открыть в App Store",
+                "zh": "在 App Store 中打开"
+              }
+            }
+          ],
+          "description": {
+            "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+            "fa": "صفحه را در App Store باز کنید و برنامه را نصب کنید. آن را اجرا کنید، در پنجره مجوز پیکربندی VPN روی Allow کلیک کنید و رمز عبور خود را وارد کنید.",
+            "ru": "Откройте страницу в App Store и установите приложение. Запустите его, в окне разрешения VPN-конфигурации нажмите Allow и введите свой пароль.",
+            "zh": "在 App Store 中打开页面并安装应用。启动应用后，在 VPN 配置权限窗口中点击\"允许\"并输入您的密码。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below — the app will open and the subscription will be added automatically",
+            "fa": "برای افزودن خودکار اشتراک روی دکمه زیر کلیک کنید - برنامه باز خواهد شد",
+            "ru": "Нажмите кнопку ниже — приложение откроется, и подписка добавится автоматически.",
+            "zh": "点击下方按钮 — 应用将打开并自动添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
+          }
+        }
+      }
+    ],
+    "android": [
+      {
+        "id": "happ",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://play.google.com/store/apps/details?id=com.happproxy",
+              "buttonText": {
+                "en": "Open in Google Play",
+                "fa": "باز کردن در Google Play",
+                "ru": "Открыть в Google Play",
+                "zh": "在 Google Play 中打开"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/Happ-proxy/happ-android/releases/latest/download/Happ.apk",
+              "buttonText": {
+                "en": "Download APK",
+                "fa": "دانلود APK",
+                "ru": "Скачать APK",
+                "zh": "下载 APK"
+              }
+            }
+          ],
+          "description": {
+            "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+            "fa": "صفحه را در Google Play باز کنید و برنامه را نصب کنید. یا برنامه را مستقیماً از فایل APK نصب کنید، اگر Google Play کار نمی کند.",
+            "ru": "Откройте страницу в Google Play и установите приложение. Или установите приложение из APK файла напрямую, если Google Play не работает.",
+            "zh": "在 Google Play 中打开页面并安装应用。如果 Google Play 无法使用，也可以直接从 APK 文件安装应用。"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open the app and connect to the server",
+            "fa": "برنامه را باز کنید و به سرور متصل شوید",
+            "ru": "Откройте приложение и подключитесь к серверу",
+            "zh": "打开应用并连接到服务器"
+          }
+        }
+      },
+      {
+        "id": "clash-meta",
+        "name": "Clash Meta",
+        "isFeatured": false,
+        "urlScheme": "clash://install-config?url=",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/MetaCubeX/ClashMetaForAndroid/releases/download/v2.11.7/cmfa-2.11.7-meta-universal-release.apk",
+              "buttonText": {
+                "en": "Download APK",
+                "fa": "دانلود APK",
+                "ru": "Скачать APK",
+                "zh": "下载 APK"
+              }
+            },
+            {
+              "buttonLink": "https://f-droid.org/packages/com.github.metacubex.clash.meta/",
+              "buttonText": {
+                "en": "Open in F-Droid",
+                "fa": "در F-Droid باز کنید",
+                "ru": "Открыть в F-Droid",
+                "zh": "在 F-Droid 中打开"
+              }
+            }
+          ],
+          "description": {
+            "en": "Download and install Clash Meta APK",
+            "fa": "دانلود و نصب Clash Meta APK",
+            "ru": "Скачайте и установите Clash Meta APK",
+            "zh": "下载并安装 Clash Meta APK"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Tap the button to import configuration",
+            "fa": "برای وارد کردن پیکربندی روی دکمه ضربه بزنید",
+            "ru": "Нажмите кнопку, чтобы импортировать конфигурацию",
+            "zh": "点击按钮导入配置"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open Clash Meta and tap on Connect",
+            "fa": "Clash Meta را باز کنید و روی اتصال ضربه بزنید",
+            "ru": "Откройте Clash Meta и нажмите Подключиться",
+            "zh": "打开 Clash Meta 并点击连接"
+          }
+        }
+      }
+    ],
+    "macos": [
+      {
+        "id": "clash-verge",
+        "name": "Clash Verge",
+        "isFeatured": true,
+        "urlScheme": "clash://install-config?url=",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_x64-setup.exe",
+              "buttonText": {
+                "en": "Windows",
+                "fa": "ویندوز",
+                "ru": "Windows",
+                "zh": "Windows"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_x64.dmg",
+              "buttonText": {
+                "en": "macOS (Intel)",
+                "fa": "مک (اینتل)",
+                "ru": "macOS (Intel)",
+                "zh": "macOS (Intel)"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_aarch64.dmg",
+              "buttonText": {
+                "en": "macOS (Apple Silicon)",
+                "fa": "مک (Apple Silicon)",
+                "ru": "macOS (Apple Silicon)",
+                "zh": "macOS (Apple Silicon)"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases",
+              "buttonText": {
+                "en": "Linux",
+                "fa": "لینوکس",
+                "ru": "Linux",
+                "zh": "Linux"
+              }
+            }
+          ],
+          "description": {
+            "en": "Choose the version for your device, click the button below and install the app.",
+            "fa": "نسخه مناسب برای دستگاه خود را انتخاب کنید، دکمه زیر را فشار دهید و برنامه را نصب کنید",
+            "ru": "Выберите подходящую версию для вашего устройства, нажмите на кнопку ниже и установите приложение.",
+            "zh": "选择适合您设备的版本，点击下方按钮并安装应用。"
+          }
+        },
+        "additionalBeforeAddSubscriptionStep": {
+          "buttons": [],
+          "description": {
+            "en": "After launching the app, you can change the language in settings. In the left panel, find the gear icon, then navigate to Verge 设置 and select 语言设置.",
+            "fa": "پس از راه‌اندازی برنامه، می‌توانید زبان را در تنظیمات تغییر دهید. در پنل سمت چپ، نماد چرخ دنده را پیدا کنید، سپس به Verge 设置 بروید و 语言设置 را انتخاب کنید.",
+            "ru": "После запуска приложения вы можете сменить язык в настройках. В левой панели найдите иконку шестеренки, далее ориентируйтесь на Verge 设置 и выберите пункт 语言设置.",
+            "zh": "启动应用后，您可以在设置中更改语言。在左侧面板找到齿轮图标，然后导航到 Verge 设置并选择语言设置。"
          },
-          {
-            "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
-            "buttonText": {
-              "en": "App Store [RU]",
-              "ru": "App Store [RU]"
-            }
+          "title": {
+            "en": "Change language",
+            "fa": "تغییر زبان",
+            "ru": "Смена языка",
+            "zh": "更改语言"
          }
-        ],
-        "description": {
-          "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
-          "ru": "Откройте страницу в App Store и установите приложение. Вернись на страницу с подпиской"
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below — the app will open and the subscription will be added automatically",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
-          "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов."
-        }
-      }
-    }
-  ],
-  "android": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": true,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://play.google.com/store/apps/details?id=com.happproxy",
-            "buttonText": {
-              "en": "Google Play",
-              "ru": "Google Play"
-            }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "additionalAfterAddSubscriptionStep": {
+          "buttons": [],
+          "title": {
+            "en": "If the subscription is not added",
+            "fa": "اگر اشتراک در برنامه نصب نشده است",
+            "ru": "Если подписка не добавилась",
+            "zh": "如果订阅未添加"
          },
-          {
-            "buttonLink": "https://github.com/Happ-proxy/happ-android/releases/latest/download/Happ.apk",
-            "buttonText": {
-              "en": "Download APK",
-              "ru": "Скачать APK"
-            }
+          "description": {
+            "en": "If nothing happens after clicking the button, add the subscription manually. Click the Get Link button in the top right corner of this page, copy the link. In Clash Verge, go to the Profiles section and paste the link in the text field, then click the Import button.",
+            "fa": "اگر پس از کلیک روی دکمه اتفاقی نیفتاد، اشتراک را به صورت دستی اضافه کنید. در گوشه بالا سمت راست این صفحه روی دکمه دریافت لینک کلیک کنید، لینک را کپی کنید. در Clash Verge به بخش پروفایل‌ها بروید و لینک را در فیلد متنی وارد کنید، سپس روی دکمه وارد کردن کلیک کنید.",
+            "ru": "Если после нажатия на кнопку ничего не произошло, добавьте подписку вручную. Нажмите на этой страницу кнопку Получить ссылку в правом верхнем углу, скопируйте ссылку. В Clash Verge перейдите в раздел Профили и вставьте ссылку в текстовое поле, затем нажмите на кнопку Импорт.",
+            "zh": "如果点击按钮后没有反应，请手动添加订阅。点击此页面右上角的获取链接按钮，复制链接。在 Clash Verge 中，转到配置文件部分，将链接粘贴到文本字段中，然后点击导入按钮。"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "You can select a server in the Proxy section, and enable VPN in the Settings section. Set the TUN Mode switch to ON.",
+            "fa": "می‌توانید در بخش پروکسی سرور را انتخاب کنید و در بخش تنظیمات VPN را فعال کنید. کلید TUN Mode را در حالت روشن قرار دهید.",
+            "ru": "Выбрать сервер можно в разделе Прокси, включить VPN можно в разделе Настройки. Установите переключатель TUN Mode в положение ВКЛ.",
+            "zh": "您可以在代理部分选择服务器，在设置部分启用 VPN。将 TUN 模式开关设置为开启。"
          }
-        ],
-        "description": {
-          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
-          "ru": "Откройте страницу в Google Play и установите приложение. Или установите приложение из APK файла напрямую, если Google Play не работает."
        }
      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "Open the app and connect to the server",
-          "ru": "Откройте приложение и подключитесь к серверу"
+      {
+        "id": "hiddify",
+        "name": "Hiddify",
+        "isFeatured": false,
+        "urlScheme": "hiddify://import/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-Windows-Setup-x64.exe",
+              "buttonText": {
+                "en": "Windows",
+                "fa": "ویندوز",
+                "ru": "Windows",
+                "zh": "Windows"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-MacOS.dmg",
+              "buttonText": {
+                "en": "macOS",
+                "fa": "مک",
+                "ru": "macOS",
+                "zh": "macOS"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-Linux-x64.AppImage",
+              "buttonText": {
+                "en": "Linux",
+                "fa": "لینوکس",
+                "ru": "Linux",
+                "zh": "Linux"
+              }
+            }
+          ],
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. If needed, select a different server in the Proxy section",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. در صورت نیاز، سرور دیگری را در بخش پروکسی انتخاب کنید",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. При необходимости выберите другой сервер в разделе Прокси.",
+            "zh": "在主界面中，点击中央的大电源按钮连接 VPN。如有需要，可在代理部分选择不同的服务器"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, select a different server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
+          }
        }
      }
-    }
-  ],
-  "pc": [
-    {
-      "id": "happ",
-      "name": "Happ",
-      "isFeatured": false,
-      "urlScheme": "happ://add/",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215?l=ru",
-            "buttonText": {
-              "en": "Mac Os",
-              "ru": "Mac Os"
+    ],
+    "windows": [
+      {
+        "id": "clash-verge",
+        "name": "Clash Verge",
+        "isFeatured": true,
+        "urlScheme": "clash://install-config?url=",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_x64-setup.exe",
+              "buttonText": {
+                "en": "Windows",
+                "fa": "ویندوز",
+                "ru": "Windows",
+                "zh": "Windows"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_x64.dmg",
+              "buttonText": {
+                "en": "macOS (Intel)",
+                "fa": "مک (اینتل)",
+                "ru": "macOS (Intel)",
+                "zh": "macOS (Intel)"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases/download/v2.2.2/Clash.Verge_2.2.2_aarch64.dmg",
+              "buttonText": {
+                "en": "macOS (Apple Silicon)",
+                "fa": "مک (Apple Silicon)",
+                "ru": "macOS (Apple Silicon)",
+                "zh": "macOS (Apple Silicon)"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/clash-verge-rev/clash-verge-rev/releases",
+              "buttonText": {
+                "en": "Linux",
+                "fa": "لینوکس",
+                "ru": "Linux",
+                "zh": "Linux"
+              }
            }
+          ],
+          "description": {
+            "en": "Choose the version for your device, click the button below and install the app.",
+            "fa": "نسخه مناسب برای دستگاه خود را انتخاب کنید، دکمه زیر را فشار دهید و برنامه را نصب کنید",
+            "ru": "Выберите подходящую версию для вашего устройства, нажмите на кнопку ниже и установите приложение.",
+            "zh": "选择适合您设备的版本，点击下方按钮并安装应用。"
+          }
+        },
+        "additionalBeforeAddSubscriptionStep": {
+          "buttons": [],
+          "description": {
+            "en": "After launching the app, you can change the language in settings. In the left panel, find the gear icon, then navigate to Verge 设置 and select 语言设置.",
+            "fa": "پس از راه‌اندازی برنامه، می‌توانید زبان را در تنظیمات تغییر دهید. در پنل سمت چپ، نماد چرخ دنده را پیدا کنید، سپس به Verge 设置 بروید و 语言设置 را انتخاب کنید.",
+            "ru": "После запуска приложения вы можете сменить язык в настройках. В левой панели найдите иконку шестеренки, далее ориентируйтесь на Verge 设置 и выберите пункт 语言设置.",
+            "zh": "启动应用后，您可以在设置中更改语言。在左侧面板找到齿轮图标，然后导航到 Verge 设置并选择语言设置。"
          },
-          {
-            "buttonLink": "https://github.com/Happ-proxy/happ-desktop/releases/latest/download/setup-Happ.x86.exe",
-            "buttonText": {
-              "en": "Windows",
-              "ru": "Windows"
-            }
+          "title": {
+            "en": "Change language",
+            "fa": "تغییر زبان",
+            "ru": "Смена языка",
+            "zh": "更改语言"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "additionalAfterAddSubscriptionStep": {
+          "buttons": [],
+          "title": {
+            "en": "If the subscription is not added",
+            "fa": "اگر اشتراک در برنامه نصب نشده است",
+            "ru": "Если подписка не добавилась",
+            "zh": "如果订阅未添加"
+          },
+          "description": {
+            "en": "If nothing happens after clicking the button, add the subscription manually. Click the Get Link button in the top right corner of this page, copy the link. In Clash Verge, go to the Profiles section and paste the link in the text field, then click the Import button.",
+            "fa": "اگر پس از کلیک روی دکمه اتفاقی نیفتاد، اشتراک را به صورت دستی اضافه کنید. در گوشه بالا سمت راست این صفحه روی دکمه دریافت لینک کلیک کنید، لینک را کپی کنید. در Clash Verge به بخش پروفایل‌ها بروید و لینک را در فیلد متنی وارد کنید، سپس روی دکمه وارد کردن کلیک کنید.",
+            "ru": "Если после нажатия на кнопку ничего не произошло, добавьте подписку вручную. Нажмите на этой страницу кнопку Получить ссылку в правом верхнем углу, скопируйте ссылку. В Clash Verge перейдите в раздел Профили и вставьте ссылку в текстовое поле, затем нажмите на кнопку Импорт.",
+            "zh": "如果点击按钮后没有反应，请手动添加订阅。点击此页面右上角的获取链接按钮，复制链接。在 Clash Verge 中，转到配置文件部分，将链接粘贴到文本字段中，然后点击导入按钮。"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "You can select a server in the Proxy section, and enable VPN in the Settings section. Set the TUN Mode switch to ON.",
+            "fa": "می‌توانید در بخش پروکسی سرور را انتخاب کنید و در بخش تنظیمات VPN را فعال کنید. کلید TUN Mode را در حالت روشن قرار دهید.",
+            "ru": "Выبрать сервер можно в разделе Прокси, включить VPN можно в разделе Настройки. Установите переключатель TUN Mode в положение ВКЛ.",
+            "zh": "您可以在代理部分选择服务器，在设置部分启用 VPN。将 TUN 模式开关设置为开启。"
          }
-        ],
-        "description": {
-          "en": "Choose the version for your device, click the button below and install the app.",
-          "ru": "Выберите подходящую версию для вашего устройства, нажмите на кнопку ниже и установите приложение"
        }
      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "You can select a server",
-          "ru": "Выберете локацию, включить VPN"
+      {
+        "id": "hiddify",
+        "name": "Hiddify",
+        "isFeatured": false,
+        "urlScheme": "hiddify://import/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-Windows-Setup-x64.exe",
+              "buttonText": {
+                "en": "Windows",
+                "fa": "ویندوز",
+                "ru": "Windows",
+                "zh": "Windows"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-MacOS.dmg",
+              "buttonText": {
+                "en": "macOS",
+                "fa": "مک",
+                "ru": "macOS",
+                "zh": "macOS"
+              }
+            },
+            {
+              "buttonLink": "https://github.com/hiddify/hiddify-app/releases/download/v2.5.7/Hiddify-Linux-x64.AppImage",
+              "buttonText": {
+                "en": "Linux",
+                "fa": "لینوکس",
+                "ru": "Linux",
+                "zh": "Linux"
+              }
+            }
+          ],
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. If needed, select a different server in the Proxy section",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. در صورت نیاز، سرور دیگری را در بخش پروکسی انتخاب کنید",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. При необходимости выберите другой сервер в разделе Прокси.",
+            "zh": "在主界面中，点击中央的大电源按钮连接 VPN。如有需要，可在代理部分选择不同的服务器"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "fa": "برای افزودن اشتراک روی دکمه زیر کلیک کنید",
+            "ru": "Нажмите кнопку ниже, чтобы добавить подписку",
+            "zh": "点击下方按钮添加订阅"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, select a different server from the server list.",
+            "fa": "در بخش اصلی، دکمه بزرگ روشن/خاموش در مرکز را برای اتصال به VPN کلیک کنید. فراموش نکنید که یک سرور را از لیست سرورها انتخاب کنید. در صورت نیاز، سرور دیگری را از لیست سرورها انتخاب کنید.",
+            "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов.",
+            "zh": "在主界面中，点击中央的大电源按钮连接到 VPN。别忘了从服务器列表中选择一个服务器。如有需要，可从服务器列表中选择其他服务器。"
+          }
        }
      }
-    }
-  ],
-  "tv": [
-    {
-      "id": "vpn4tv",
-      "name": "VPN4TV",
-      "isFeatured": true,
-      "urlScheme": "",
-      "installationStep": {
-        "buttons": [
-          {
-            "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
-            "buttonText": {
-              "en": "Google Play",
-              "ru": "Google Play"
+    ],
+    "linux": [],
+    "androidTV": [
+      {
+        "id": "new-app-androidtv-1760203310792",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
+              "buttonText": {
+                "en": "Google Play",
+                "ru": "Button TextGoogle Play",
+                "zh": "Button Text",
+                "fa": "Button Text"
+              }
            }
+          ],
+          "description": {
+            "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+            "ru": "Откройте страницу в Google Play и установите приложение",
+            "zh": "-",
+            "fa": "-"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал",
+            "zh": "-",
+            "fa": "-"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open the app and connect to the server",
+            "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN",
+            "zh": "-",
+            "fa": "-"
          }
-        ],
-        "description": {
-          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
-          "ru": "Откройте страницу в Google Play и установите приложение"
-        }
-      },
-      "addSubscriptionStep": {
-        "description": {
-          "en": "Click the button below to add subscription",
-          "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал"
-        }
-      },
-      "connectAndUseStep": {
-        "description": {
-          "en": "Open the app and connect to the server",
-          "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN"
        }
      }
-    }
-  ]
+    ],
+    "appleTV": [
+      {
+        "id": "new-app-appletv-1760203488851",
+        "name": "Happ",
+        "isFeatured": true,
+        "urlScheme": "happ://add/",
+        "installationStep": {
+          "buttons": [
+            {
+              "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
+              "buttonText": {
+                "en": "Google Play",
+                "ru": "Google Play",
+                "zh": "Button Text",
+                "fa": "Button Text"
+              }
+            }
+          ],
+          "description": {
+            "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+            "ru": "Откройте страницу в Google Play и установите приложение",
+            "zh": "-",
+            "fa": "-"
+          }
+        },
+        "addSubscriptionStep": {
+          "description": {
+            "en": "Click the button below to add subscription",
+            "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал",
+            "zh": "-",
+            "fa": "-"
+          }
+        },
+        "connectAndUseStep": {
+          "description": {
+            "en": "Open the app and connect to the server",
+            "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN",
+            "zh": "-",
+            "fa": "-"
+          }
+        }
+      }
+    ]
+  }
 }
@@ -10,14 +10,25 @@ from app.middlewares.auth import AuthMiddleware
 from app.middlewares.logging import LoggingMiddleware
 from app.middlewares.throttling import ThrottlingMiddleware
 from app.middlewares.subscription_checker import SubscriptionStatusMiddleware
-from app.middlewares.maintenance import MaintenanceMiddleware  
+from app.middlewares.maintenance import MaintenanceMiddleware
+from app.middlewares.display_name_restriction import DisplayNameRestrictionMiddleware
 from app.services.maintenance_service import maintenance_service
 from app.utils.cache import cache 

 from app.handlers import (
-    start, menu, subscription, balance, promocode,
-    referral, support, server_status, common, tickets
+    start,
+    menu,
+    subscription,
+    balance,
+    promocode,
+    referral,
+    support,
+    server_status,
+    common,
+    tickets,
 )
+from app.handlers import polls as user_polls
+from app.handlers import simple_subscription
 from app.handlers.admin import (
    main as admin_main,
    users as admin_users,
@@ -29,17 +40,26 @@ from app.handlers.admin import (
    rules as admin_rules,
    remnawave as admin_remnawave,
    statistics as admin_statistics,
+    polls as admin_polls,
    servers as admin_servers,
    maintenance as admin_maintenance,
    promo_groups as admin_promo_groups,
    campaigns as admin_campaigns,
+    promo_offers as admin_promo_offers,
    user_messages as admin_user_messages,
    updates as admin_updates,
    backup as admin_backup,
+    system_logs as admin_system_logs,
    welcome_text as admin_welcome_text,
    tickets as admin_tickets,
    reports as admin_reports,
    bot_configuration as admin_bot_configuration,
+    pricing as admin_pricing,
+    privacy_policy as admin_privacy_policy,
+    public_offer as admin_public_offer,
+    faq as admin_faq,
+    payments as admin_payments,
+    trials as admin_trials,
 )
 from app.handlers.stars_payments import register_stars_handlers

@@ -96,6 +116,10 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    dp.callback_query.middleware(LoggingMiddleware())
    dp.message.middleware(MaintenanceMiddleware())
    dp.callback_query.middleware(MaintenanceMiddleware())
+    display_name_middleware = DisplayNameRestrictionMiddleware()
+    dp.message.middleware(display_name_middleware)
+    dp.callback_query.middleware(display_name_middleware)
+    dp.pre_checkout_query.middleware(display_name_middleware)
    dp.message.middleware(ThrottlingMiddleware())
    dp.callback_query.middleware(ThrottlingMiddleware())

@@ -116,7 +140,7 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    start.register_handlers(dp)
    menu.register_handlers(dp)
    subscription.register_handlers(dp)
-    balance.register_handlers(dp)
+    balance.register_balance_handlers(dp)
    promocode.register_handlers(dp)
    referral.register_handlers(dp)
    support.register_handlers(dp)
@@ -133,25 +157,41 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    admin_rules.register_handlers(dp)
    admin_remnawave.register_handlers(dp)
    admin_statistics.register_handlers(dp)
+    admin_polls.register_handlers(dp)
    admin_promo_groups.register_handlers(dp)
    admin_campaigns.register_handlers(dp)
+    admin_promo_offers.register_handlers(dp)
    admin_maintenance.register_handlers(dp)
    admin_user_messages.register_handlers(dp)
    admin_updates.register_handlers(dp)
    admin_backup.register_handlers(dp)
+    admin_system_logs.register_handlers(dp)
    admin_welcome_text.register_welcome_text_handlers(dp)
    admin_tickets.register_handlers(dp)
    admin_reports.register_handlers(dp)
    admin_bot_configuration.register_handlers(dp)
+    admin_pricing.register_handlers(dp)
+    admin_privacy_policy.register_handlers(dp)
+    admin_public_offer.register_handlers(dp)
+    admin_faq.register_handlers(dp)
+    admin_payments.register_handlers(dp)
+    admin_trials.register_handlers(dp)
    common.register_handlers(dp)
    register_stars_handlers(dp)
+    user_polls.register_handlers(dp)
+    simple_subscription.register_simple_subscription_handlers(dp)
    logger.info("⭐ Зарегистрированы обработчики Telegram Stars платежей")
+    logger.info("⚡ Зарегистрированы обработчики простой покупки")
+    logger.info("⚡ Зарегистрированы обработчики простой подписки")
    
-    try:
-        await maintenance_service.start_monitoring()
-        logger.info("Мониторинг техработ запущен")
-    except Exception as e:
-        logger.error(f"Ошибка запуска мониторинга техработ: {e}")
+    if settings.is_maintenance_monitoring_enabled():
+        try:
+            await maintenance_service.start_monitoring()
+            logger.info("Мониторинг техработ запущен")
+        except Exception as e:
+            logger.error(f"Ошибка запуска мониторинга техработ: {e}")
+    else:
+        logger.info("Мониторинг техработ отключен настройками")
    
    logger.info("🛡️ GlobalErrorMiddleware активирован - бот защищен от устаревших callback queries")
    logger.info("Бот успешно настроен")
@@ -0,0 +1,23 @@
+"""Database package exports."""
+
+from .database import (
+    DatabaseManager,
+    batch_ops,
+    close_db,
+    db_manager,
+    get_db,
+    get_db_read_only,
+    get_pool_metrics,
+    init_db,
+)
+
+__all__ = [
+    "DatabaseManager",
+    "batch_ops",
+    "close_db",
+    "db_manager",
+    "get_db",
+    "get_db_read_only",
+    "get_pool_metrics",
+    "init_db",
+]
@@ -32,6 +32,7 @@ async def create_campaign(
    subscription_traffic_gb: Optional[int] = None,
    subscription_device_limit: Optional[int] = None,
    subscription_squads: Optional[List[str]] = None,
+    is_active: bool = True,
 ) -> AdvertisingCampaign:
    campaign = AdvertisingCampaign(
        name=name,
@@ -43,7 +44,7 @@ async def create_campaign(
        subscription_device_limit=subscription_device_limit,
        subscription_squads=subscription_squads or [],
        created_by=created_by,
-        is_active=True,
+        is_active=is_active,
    )

    db.add(campaign)
@@ -135,7 +136,10 @@ async def update_campaign(
        "is_active",
    }

-    update_data = {key: value for key, value in kwargs.items() if key in allowed_fields}
+    update_data = {}
+    for key, value in kwargs.items():
+        if key in allowed_fields and value is not None:
+            update_data[key] = value

    if not update_data:
        return campaign
@@ -1,11 +1,18 @@
+from __future__ import annotations
+
+import logging
 from datetime import datetime, timedelta
-from typing import Optional
+from typing import List, Optional

-from sqlalchemy import select
+from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload

+from app.database.crud.promo_offer_log import log_promo_offer_action
 from app.database.models import DiscountOffer

+logger = logging.getLogger(__name__)
+

 async def upsert_discount_offer(
    db: AsyncSession,
@@ -16,6 +23,8 @@ async def upsert_discount_offer(
    discount_percent: int,
    bonus_amount_kopeks: int,
    valid_hours: int,
+    effect_type: str = "percent_discount",
+    extra_data: Optional[dict] = None,
 ) -> DiscountOffer:
    """Create or refresh a discount offer for a user."""

@@ -37,6 +46,8 @@ async def upsert_discount_offer(
        offer.bonus_amount_kopeks = bonus_amount_kopeks
        offer.expires_at = expires_at
        offer.subscription_id = subscription_id
+        offer.effect_type = effect_type
+        offer.extra_data = extra_data
    else:
        offer = DiscountOffer(
            user_id=user_id,
@@ -46,6 +57,8 @@ async def upsert_discount_offer(
            bonus_amount_kopeks=bonus_amount_kopeks,
            expires_at=expires_at,
            is_active=True,
+            effect_type=effect_type,
+            extra_data=extra_data,
        )
        db.add(offer)

@@ -56,16 +69,128 @@ async def upsert_discount_offer(

 async def get_offer_by_id(db: AsyncSession, offer_id: int) -> Optional[DiscountOffer]:
    result = await db.execute(
-        select(DiscountOffer).where(DiscountOffer.id == offer_id)
+        select(DiscountOffer)
+        .options(
+            selectinload(DiscountOffer.user),
+            selectinload(DiscountOffer.subscription),
+        )
+        .where(DiscountOffer.id == offer_id)
    )
    return result.scalar_one_or_none()


-async def mark_offer_claimed(db: AsyncSession, offer: DiscountOffer) -> DiscountOffer:
+async def list_discount_offers(
+    db: AsyncSession,
+    *,
+    offset: int = 0,
+    limit: int = 50,
+    user_id: Optional[int] = None,
+    notification_type: Optional[str] = None,
+    is_active: Optional[bool] = None,
+) -> List[DiscountOffer]:
+    stmt = (
+        select(DiscountOffer)
+        .options(
+            selectinload(DiscountOffer.user),
+            selectinload(DiscountOffer.subscription),
+        )
+        .order_by(DiscountOffer.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+
+    if user_id is not None:
+        stmt = stmt.where(DiscountOffer.user_id == user_id)
+    if notification_type:
+        stmt = stmt.where(DiscountOffer.notification_type == notification_type)
+    if is_active is not None:
+        stmt = stmt.where(DiscountOffer.is_active == is_active)
+
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+
+async def list_active_discount_offers_for_user(
+    db: AsyncSession,
+    user_id: int,
+) -> List[DiscountOffer]:
+    """Return active (not yet claimed) offers for a user."""
+
+    now = datetime.utcnow()
+    stmt = (
+        select(DiscountOffer)
+        .options(
+            selectinload(DiscountOffer.user),
+            selectinload(DiscountOffer.subscription),
+        )
+        .where(
+            DiscountOffer.user_id == user_id,
+            DiscountOffer.is_active == True,  # noqa: E712
+            DiscountOffer.expires_at > now,
+        )
+        .order_by(DiscountOffer.expires_at.asc())
+    )
+
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+
+async def count_discount_offers(
+    db: AsyncSession,
+    *,
+    user_id: Optional[int] = None,
+    notification_type: Optional[str] = None,
+    is_active: Optional[bool] = None,
+) -> int:
+    stmt = select(func.count(DiscountOffer.id))
+
+    if user_id is not None:
+        stmt = stmt.where(DiscountOffer.user_id == user_id)
+    if notification_type:
+        stmt = stmt.where(DiscountOffer.notification_type == notification_type)
+    if is_active is not None:
+        stmt = stmt.where(DiscountOffer.is_active == is_active)
+
+    result = await db.execute(stmt)
+    return int(result.scalar() or 0)
+
+
+async def mark_offer_claimed(
+    db: AsyncSession,
+    offer: DiscountOffer,
+    *,
+    details: Optional[dict] = None,
+) -> DiscountOffer:
    offer.claimed_at = datetime.utcnow()
    offer.is_active = False
    await db.commit()
    await db.refresh(offer)
+
+    try:
+        await log_promo_offer_action(
+            db,
+            user_id=offer.user_id,
+            offer_id=offer.id,
+            action="claimed",
+            source=offer.notification_type,
+            percent=offer.discount_percent,
+            effect_type=offer.effect_type,
+            details=details,
+        )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.warning(
+            "Failed to record promo offer claim log for offer %s: %s",
+            offer.id,
+            exc,
+        )
+        try:
+            await db.rollback()
+        except Exception as rollback_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to rollback session after promo offer claim log failure: %s",
+                rollback_error,
+            )
+
    return offer


@@ -82,9 +207,69 @@ async def deactivate_expired_offers(db: AsyncSession) -> int:
        return 0

    count = 0
+    log_payloads = []
    for offer in offers:
        offer.is_active = False
        count += 1
+        log_payloads.append(
+            {
+                "user_id": offer.user_id,
+                "offer_id": offer.id,
+                "source": offer.notification_type,
+                "percent": offer.discount_percent,
+                "effect_type": offer.effect_type,
+            }
+        )

    await db.commit()
+
+    for payload in log_payloads:
+        if not payload.get("user_id"):
+            continue
+        try:
+            await log_promo_offer_action(
+                db,
+                user_id=payload["user_id"],
+                offer_id=payload["offer_id"],
+                action="disabled",
+                source=payload.get("source"),
+                percent=payload.get("percent"),
+                effect_type=payload.get("effect_type"),
+                details={"reason": "offer_expired"},
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to record promo offer disable log for offer %s: %s",
+                payload.get("offer_id"),
+                exc,
+            )
+            try:
+                await db.rollback()
+            except Exception as rollback_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to rollback session after promo offer disable log failure: %s",
+                    rollback_error,
+                )
+
    return count
+
+
+async def get_latest_claimed_offer_for_user(
+    db: AsyncSession,
+    user_id: int,
+    source: Optional[str] = None,
+) -> Optional[DiscountOffer]:
+    stmt = (
+        select(DiscountOffer)
+        .where(
+            DiscountOffer.user_id == user_id,
+            DiscountOffer.claimed_at.isnot(None),
+        )
+        .order_by(DiscountOffer.claimed_at.desc())
+    )
+
+    if source:
+        stmt = stmt.where(DiscountOffer.notification_type == source)
+
+    result = await db.execute(stmt)
+    return result.scalars().first()
@@ -0,0 +1,150 @@
+import logging
+from datetime import datetime
+from typing import Iterable, Optional
+
+from sqlalchemy import delete, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import FaqPage, FaqSetting
+
+logger = logging.getLogger(__name__)
+
+
+async def get_faq_setting(db: AsyncSession, language: str) -> Optional[FaqSetting]:
+    result = await db.execute(
+        select(FaqSetting).where(FaqSetting.language == language)
+    )
+    return result.scalar_one_or_none()
+
+
+async def set_faq_enabled(db: AsyncSession, language: str, enabled: bool) -> FaqSetting:
+    setting = await get_faq_setting(db, language)
+
+    if setting:
+        setting.is_enabled = bool(enabled)
+        setting.updated_at = datetime.utcnow()
+    else:
+        setting = FaqSetting(
+            language=language,
+            is_enabled=bool(enabled),
+        )
+        db.add(setting)
+
+    await db.commit()
+    await db.refresh(setting)
+
+    logger.info(
+        "✅ Статус FAQ для языка %s обновлен: %s",
+        language,
+        "enabled" if setting.is_enabled else "disabled",
+    )
+
+    return setting
+
+
+async def upsert_faq_setting(db: AsyncSession, language: str, enabled: bool) -> FaqSetting:
+    return await set_faq_enabled(db, language, enabled)
+
+
+async def get_faq_pages(
+    db: AsyncSession,
+    language: str,
+    *,
+    include_inactive: bool = False,
+) -> list[FaqPage]:
+    query = select(FaqPage).where(FaqPage.language == language)
+
+    if not include_inactive:
+        query = query.where(FaqPage.is_active.is_(True))
+
+    query = query.order_by(FaqPage.display_order.asc(), FaqPage.id.asc())
+
+    result = await db.execute(query)
+    pages = list(result.scalars().all())
+    return pages
+
+
+async def get_faq_page_by_id(db: AsyncSession, page_id: int) -> Optional[FaqPage]:
+    result = await db.execute(select(FaqPage).where(FaqPage.id == page_id))
+    return result.scalar_one_or_none()
+
+
+async def create_faq_page(
+    db: AsyncSession,
+    *,
+    language: str,
+    title: str,
+    content: str,
+    display_order: Optional[int] = None,
+    is_active: bool = True,
+) -> FaqPage:
+    if display_order is None:
+        result = await db.execute(
+            select(func.max(FaqPage.display_order)).where(FaqPage.language == language)
+        )
+        max_order = result.scalar() or 0
+        display_order = max_order + 1
+
+    page = FaqPage(
+        language=language,
+        title=title,
+        content=content,
+        display_order=display_order,
+        is_active=is_active,
+    )
+
+    db.add(page)
+    await db.commit()
+    await db.refresh(page)
+
+    logger.info("✅ Создана страница FAQ %s для языка %s", page.id, language)
+
+    return page
+
+
+async def update_faq_page(
+    db: AsyncSession,
+    page: FaqPage,
+    *,
+    title: Optional[str] = None,
+    content: Optional[str] = None,
+    display_order: Optional[int] = None,
+    is_active: Optional[bool] = None,
+) -> FaqPage:
+    if title is not None:
+        page.title = title
+    if content is not None:
+        page.content = content
+    if display_order is not None:
+        page.display_order = display_order
+    if is_active is not None:
+        page.is_active = bool(is_active)
+
+    page.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(page)
+
+    logger.info("✅ Страница FAQ %s обновлена", page.id)
+
+    return page
+
+
+async def delete_faq_page(db: AsyncSession, page_id: int) -> None:
+    await db.execute(delete(FaqPage).where(FaqPage.id == page_id))
+    await db.commit()
+    logger.info("🗑️ Страница FAQ %s удалена", page_id)
+
+
+async def bulk_update_order(
+    db: AsyncSession,
+    pages: Iterable[tuple[int, int]],
+) -> None:
+    for page_id, order in pages:
+        await db.execute(
+            update(FaqPage)
+            .where(FaqPage.id == page_id)
+            .values(display_order=order, updated_at=datetime.utcnow())
+        )
+    await db.commit()
+
@@ -0,0 +1,176 @@
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import HeleketPayment
+
+logger = logging.getLogger(__name__)
+
+
+async def create_heleket_payment(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    uuid: str,
+    order_id: str,
+    amount: str,
+    currency: str,
+    status: str,
+    payer_amount: Optional[str] = None,
+    payer_currency: Optional[str] = None,
+    exchange_rate: Optional[float] = None,
+    discount_percent: Optional[int] = None,
+    payment_url: Optional[str] = None,
+    expires_at: Optional[datetime] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> HeleketPayment:
+    payment = HeleketPayment(
+        user_id=user_id,
+        uuid=uuid,
+        order_id=order_id,
+        amount=amount,
+        currency=currency,
+        status=status,
+        payer_amount=payer_amount,
+        payer_currency=payer_currency,
+        exchange_rate=exchange_rate,
+        discount_percent=discount_percent,
+        payment_url=payment_url,
+        expires_at=expires_at,
+        metadata_json=metadata or {},
+    )
+
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Создан Heleket платеж: uuid=%s order_id=%s amount=%s %s для пользователя %s",
+        uuid,
+        order_id,
+        amount,
+        currency,
+        user_id,
+    )
+
+    return payment
+
+
+async def get_heleket_payment_by_uuid(
+    db: AsyncSession,
+    uuid: str,
+) -> Optional[HeleketPayment]:
+    result = await db.execute(
+        select(HeleketPayment)
+        .options(selectinload(HeleketPayment.user))
+        .where(HeleketPayment.uuid == uuid)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_heleket_payment_by_order_id(
+    db: AsyncSession,
+    order_id: str,
+) -> Optional[HeleketPayment]:
+    result = await db.execute(
+        select(HeleketPayment)
+        .options(selectinload(HeleketPayment.user))
+        .where(HeleketPayment.order_id == order_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_heleket_payment_by_id(
+    db: AsyncSession,
+    payment_id: int,
+) -> Optional[HeleketPayment]:
+    result = await db.execute(
+        select(HeleketPayment)
+        .options(selectinload(HeleketPayment.user))
+        .where(HeleketPayment.id == payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_heleket_payment(
+    db: AsyncSession,
+    uuid: str,
+    *,
+    status: Optional[str] = None,
+    payer_amount: Optional[str] = None,
+    payer_currency: Optional[str] = None,
+    exchange_rate: Optional[float] = None,
+    discount_percent: Optional[int] = None,
+    paid_at: Optional[datetime] = None,
+    payment_url: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> Optional[HeleketPayment]:
+    payment = await get_heleket_payment_by_uuid(db, uuid)
+
+    if not payment:
+        logger.error("Heleket платеж с uuid=%s не найден", uuid)
+        return None
+
+    if status is not None:
+        payment.status = status
+    if payer_amount is not None:
+        payment.payer_amount = payer_amount
+    if payer_currency is not None:
+        payment.payer_currency = payer_currency
+    if exchange_rate is not None:
+        payment.exchange_rate = exchange_rate
+    if discount_percent is not None:
+        payment.discount_percent = discount_percent
+    if payment_url is not None:
+        payment.payment_url = payment_url
+    if metadata is not None:
+        existing = dict(payment.metadata_json or {})
+        existing.update(metadata)
+        payment.metadata_json = existing
+    if paid_at is not None:
+        payment.paid_at = paid_at
+
+    payment.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Обновлен Heleket платеж %s: статус=%s payer_amount=%s %s",
+        uuid,
+        payment.status,
+        payment.payer_amount,
+        payment.payer_currency,
+    )
+
+    return payment
+
+
+async def link_heleket_payment_to_transaction(
+    db: AsyncSession,
+    uuid: str,
+    transaction_id: int,
+) -> Optional[HeleketPayment]:
+    payment = await get_heleket_payment_by_uuid(db, uuid)
+
+    if not payment:
+        logger.error("Не найден Heleket платеж для связи с транзакцией: %s", uuid)
+        return None
+
+    payment.transaction_id = transaction_id
+    payment.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Heleket платеж %s связан с транзакцией %s",
+        uuid,
+        transaction_id,
+    )
+
+    return payment
@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import (
+    MainMenuButton,
+    MainMenuButtonActionType,
+    MainMenuButtonVisibility,
+)
+
+
+async def count_main_menu_buttons(db: AsyncSession) -> int:
+    result = await db.execute(select(func.count()).select_from(MainMenuButton))
+    return int(result.scalar() or 0)
+
+
+async def get_main_menu_buttons(
+    db: AsyncSession,
+    *,
+    limit: Optional[int] = None,
+    offset: Optional[int] = None,
+) -> list[MainMenuButton]:
+    stmt = select(MainMenuButton).order_by(
+        MainMenuButton.display_order.asc(),
+        MainMenuButton.id.asc(),
+    )
+
+    if offset is not None:
+        stmt = stmt.offset(offset)
+    if limit is not None:
+        stmt = stmt.limit(limit)
+
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_main_menu_button_by_id(
+    db: AsyncSession, button_id: int
+) -> MainMenuButton | None:
+    result = await db.execute(
+        select(MainMenuButton).where(MainMenuButton.id == button_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_next_display_order(db: AsyncSession) -> int:
+    result = await db.execute(select(func.max(MainMenuButton.display_order)))
+    current_max = result.scalar()
+    return (int(current_max) if current_max is not None else 0) + 1
+
+
+def _enum_value(value, enum_cls):
+    if value is None:
+        return None
+    if isinstance(value, enum_cls):
+        return value.value
+    return str(value)
+
+
+async def create_main_menu_button(
+    db: AsyncSession,
+    *,
+    text: str,
+    action_type: MainMenuButtonActionType | str,
+    action_value: str,
+    visibility: MainMenuButtonVisibility | str = MainMenuButtonVisibility.ALL,
+    is_active: bool = True,
+    display_order: Optional[int] = None,
+) -> MainMenuButton:
+    if display_order is None:
+        display_order = await get_next_display_order(db)
+
+    button = MainMenuButton(
+        text=text,
+        action_type=_enum_value(action_type, MainMenuButtonActionType),
+        action_value=action_value,
+        visibility=_enum_value(visibility, MainMenuButtonVisibility)
+        or MainMenuButtonVisibility.ALL.value,
+        is_active=bool(is_active),
+        display_order=int(display_order),
+    )
+
+    db.add(button)
+    await db.commit()
+    await db.refresh(button)
+    return button
+
+
+async def update_main_menu_button(
+    db: AsyncSession,
+    button: MainMenuButton,
+    *,
+    text: Optional[str] = None,
+    action_type: MainMenuButtonActionType | str | None = None,
+    action_value: Optional[str] = None,
+    visibility: MainMenuButtonVisibility | str | None = None,
+    is_active: Optional[bool] = None,
+    display_order: Optional[int] = None,
+) -> MainMenuButton:
+    if text is not None:
+        button.text = text
+    if action_type is not None:
+        button.action_type = _enum_value(action_type, MainMenuButtonActionType)
+    if action_value is not None:
+        button.action_value = action_value
+    if visibility is not None:
+        button.visibility = _enum_value(visibility, MainMenuButtonVisibility)
+    if is_active is not None:
+        button.is_active = bool(is_active)
+    if display_order is not None:
+        button.display_order = int(display_order)
+
+    await db.commit()
+    await db.refresh(button)
+    return button
+
+
+async def delete_main_menu_button(db: AsyncSession, button: MainMenuButton) -> None:
+    await db.delete(button)
+    await db.commit()
+
+
+async def reorder_main_menu_buttons(
+    db: AsyncSession,
+    ordered_ids: Sequence[int],
+) -> None:
+    if not ordered_ids:
+        return
+
+    order_map = {int(button_id): index for index, button_id in enumerate(ordered_ids)}
+
+    result = await db.execute(
+        select(MainMenuButton).where(MainMenuButton.id.in_(order_map.keys()))
+    )
+    buttons = result.scalars().all()
+
+    for button in buttons:
+        desired_order = order_map.get(button.id)
+        if desired_order is not None:
+            button.display_order = desired_order
+
+    await db.commit()
@@ -3,8 +3,10 @@ from datetime import datetime
 from typing import Optional

 from sqlalchemy import select
+from datetime import datetime
 from sqlalchemy.ext.asyncio import AsyncSession

+from app.config import settings
 from app.database.models import MulenPayPayment

 logger = logging.getLogger(__name__)
@@ -40,7 +42,8 @@ async def create_mulenpay_payment(
    await db.refresh(payment)

    logger.info(
-        "Создан MulenPay платеж #%s (uuid=%s) на сумму %s копеек для пользователя %s",
+        "Создан %s платеж #%s (uuid=%s) на сумму %s копеек для пользователя %s",
+        settings.get_mulenpay_display_name(),
        payment.mulen_payment_id,
        uuid,
        amount_kopeks,
@@ -88,6 +91,7 @@ async def update_mulenpay_payment_status(
    paid_at: Optional[datetime] = None,
    callback_payload: Optional[dict] = None,
    mulen_payment_id: Optional[int] = None,
+    metadata: Optional[dict] = None,
 ) -> MulenPayPayment:
    payment.status = status
    if is_paid is not None:
@@ -98,6 +102,8 @@ async def update_mulenpay_payment_status(
        payment.callback_payload = callback_payload
    if mulen_payment_id is not None and not payment.mulen_payment_id:
        payment.mulen_payment_id = mulen_payment_id
+    if metadata is not None:
+        payment.metadata_json = metadata

    payment.updated_at = datetime.utcnow()
    await db.commit()
@@ -105,6 +111,19 @@ async def update_mulenpay_payment_status(
    return payment


+async def update_mulenpay_payment_metadata(
+    db: AsyncSession,
+    *,
+    payment: MulenPayPayment,
+    metadata: dict,
+) -> MulenPayPayment:
+    payment.metadata_json = metadata
+    payment.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(payment)
+    return payment
+
+
 async def link_mulenpay_payment_to_transaction(
    db: AsyncSession,
    *,
@@ -50,3 +50,17 @@ async def clear_notifications(db: AsyncSession, subscription_id: int) -> None:
        )
    )
    await db.commit()
+
+
+async def clear_notification_by_type(
+    db: AsyncSession,
+    subscription_id: int,
+    notification_type: str,
+) -> None:
+    await db.execute(
+        delete(SentNotification).where(
+            SentNotification.subscription_id == subscription_id,
+            SentNotification.notification_type == notification_type,
+        )
+    )
+    await db.commit()
@@ -3,6 +3,7 @@
 from __future__ import annotations

 import logging
+from datetime import datetime
 from typing import Any, Dict, Optional

 from sqlalchemy import select, update
@@ -87,6 +88,7 @@ async def update_pal24_payment_status(
    status: str,
    is_active: Optional[bool] = None,
    is_paid: Optional[bool] = None,
+    paid_at: Optional[datetime] = None,
    payment_id: Optional[str] = None,
    payment_status: Optional[str] = None,
    payment_method: Optional[str] = None,
@@ -94,6 +96,7 @@ async def update_pal24_payment_status(
    balance_currency: Optional[str] = None,
    payer_account: Optional[str] = None,
    callback_payload: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
 ) -> Pal24Payment:
    update_values: Dict[str, Any] = {
        "status": status,
@@ -103,6 +106,8 @@ async def update_pal24_payment_status(
        update_values["is_active"] = is_active
    if is_paid is not None:
        update_values["is_paid"] = is_paid
+    if paid_at is not None:
+        update_values["paid_at"] = paid_at
    if payment_id is not None:
        update_values["payment_id"] = payment_id
    if payment_status is not None:
@@ -117,6 +122,8 @@ async def update_pal24_payment_status(
        update_values["payer_account"] = payer_account
    if callback_payload is not None:
        update_values["callback_payload"] = callback_payload
+    if metadata is not None:
+        update_values["metadata_json"] = metadata

    update_values["last_status"] = status

@@ -0,0 +1,156 @@
+"""CRUD-операции для платежей Platega."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Any, Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import PlategaPayment
+
+logger = logging.getLogger(__name__)
+
+
+async def create_platega_payment(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    amount_kopeks: int,
+    currency: str,
+    description: Optional[str],
+    status: str,
+    payment_method_code: int,
+    correlation_id: str,
+    platega_transaction_id: Optional[str],
+    redirect_url: Optional[str],
+    return_url: Optional[str],
+    failed_url: Optional[str],
+    payload: Optional[str],
+    metadata: Optional[dict[str, Any]] = None,
+    expires_at: Optional[datetime] = None,
+) -> PlategaPayment:
+    payment = PlategaPayment(
+        user_id=user_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        description=description,
+        status=status,
+        payment_method_code=payment_method_code,
+        correlation_id=correlation_id,
+        platega_transaction_id=platega_transaction_id,
+        redirect_url=redirect_url,
+        return_url=return_url,
+        failed_url=failed_url,
+        payload=payload,
+        metadata_json=metadata or {},
+        expires_at=expires_at,
+    )
+
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Создан Platega платеж #%s (tx=%s) на сумму %s копеек для пользователя %s",
+        payment.id,
+        platega_transaction_id,
+        amount_kopeks,
+        user_id,
+    )
+
+    return payment
+
+
+async def get_platega_payment_by_id(
+    db: AsyncSession, payment_id: int
+) -> Optional[PlategaPayment]:
+    result = await db.execute(
+        select(PlategaPayment).where(PlategaPayment.id == payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_platega_payment_by_id_for_update(
+    db: AsyncSession, payment_id: int
+) -> Optional[PlategaPayment]:
+    result = await db.execute(
+        select(PlategaPayment)
+        .where(PlategaPayment.id == payment_id)
+        .with_for_update()
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_platega_payment_by_transaction_id(
+    db: AsyncSession, transaction_id: str
+) -> Optional[PlategaPayment]:
+    result = await db.execute(
+        select(PlategaPayment).where(
+            PlategaPayment.platega_transaction_id == transaction_id
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_platega_payment_by_correlation_id(
+    db: AsyncSession, correlation_id: str
+) -> Optional[PlategaPayment]:
+    result = await db.execute(
+        select(PlategaPayment).where(
+            PlategaPayment.correlation_id == correlation_id
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_platega_payment(
+    db: AsyncSession,
+    *,
+    payment: PlategaPayment,
+    status: Optional[str] = None,
+    is_paid: Optional[bool] = None,
+    paid_at: Optional[datetime] = None,
+    platega_transaction_id: Optional[str] = None,
+    redirect_url: Optional[str] = None,
+    callback_payload: Optional[dict[str, Any]] = None,
+    metadata: Optional[dict[str, Any]] = None,
+    expires_at: Optional[datetime] = None,
+) -> PlategaPayment:
+    if status is not None:
+        payment.status = status
+    if is_paid is not None:
+        payment.is_paid = is_paid
+    if paid_at is not None:
+        payment.paid_at = paid_at
+    if platega_transaction_id and not payment.platega_transaction_id:
+        payment.platega_transaction_id = platega_transaction_id
+    if redirect_url is not None:
+        payment.redirect_url = redirect_url
+    if callback_payload is not None:
+        payment.callback_payload = callback_payload
+    if metadata is not None:
+        payment.metadata_json = metadata
+    if expires_at is not None:
+        payment.expires_at = expires_at
+
+    payment.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(payment)
+    return payment
+
+
+async def link_platega_payment_to_transaction(
+    db: AsyncSession,
+    *,
+    payment: PlategaPayment,
+    transaction_id: int,
+) -> PlategaPayment:
+    payment.transaction_id = transaction_id
+    payment.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(payment)
+    return payment
@@ -0,0 +1,297 @@
+import logging
+from typing import Iterable, Sequence
+
+from sqlalchemy import and_, delete, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import (
+    Poll,
+    PollAnswer,
+    PollOption,
+    PollQuestion,
+    PollResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def create_poll(
+    db: AsyncSession,
+    *,
+    title: str,
+    description: str | None,
+    reward_enabled: bool,
+    reward_amount_kopeks: int,
+    created_by: int | None,
+    questions: Sequence[dict[str, Iterable[str]]],
+) -> Poll:
+    poll = Poll(
+        title=title,
+        description=description,
+        reward_enabled=reward_enabled,
+        reward_amount_kopeks=reward_amount_kopeks if reward_enabled else 0,
+        created_by=created_by,
+    )
+    db.add(poll)
+    await db.flush()
+
+    for order, question_data in enumerate(questions, start=1):
+        question_text = question_data.get("text", "").strip()
+        if not question_text:
+            continue
+
+        question = PollQuestion(
+            poll_id=poll.id,
+            text=question_text,
+            order=order,
+        )
+        db.add(question)
+        await db.flush()
+
+        for option_order, option_text in enumerate(question_data.get("options", []), start=1):
+            option_text = option_text.strip()
+            if not option_text:
+                continue
+            option = PollOption(
+                question_id=question.id,
+                text=option_text,
+                order=option_order,
+            )
+            db.add(option)
+
+    await db.commit()
+    await db.refresh(
+        poll,
+        attribute_names=["questions"],
+    )
+    return poll
+
+
+async def list_polls(db: AsyncSession) -> list[Poll]:
+    result = await db.execute(
+        select(Poll)
+        .options(
+            selectinload(Poll.questions).options(selectinload(PollQuestion.options))
+        )
+        .order_by(Poll.created_at.desc())
+    )
+    return result.scalars().all()
+
+
+async def get_poll_by_id(db: AsyncSession, poll_id: int) -> Poll | None:
+    result = await db.execute(
+        select(Poll)
+        .options(
+            selectinload(Poll.questions).options(selectinload(PollQuestion.options)),
+            selectinload(Poll.responses),
+        )
+        .where(Poll.id == poll_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def delete_poll(db: AsyncSession, poll_id: int) -> bool:
+    poll = await db.get(Poll, poll_id)
+    if not poll:
+        return False
+
+    await db.delete(poll)
+    await db.commit()
+    logger.info("🗑️ Удалён опрос %s", poll_id)
+    return True
+
+
+async def create_poll_response(
+    db: AsyncSession,
+    poll_id: int,
+    user_id: int,
+) -> PollResponse:
+    result = await db.execute(
+        select(PollResponse)
+        .where(
+            and_(
+                PollResponse.poll_id == poll_id,
+                PollResponse.user_id == user_id,
+            )
+        )
+    )
+    response = result.scalar_one_or_none()
+    if response:
+        return response
+
+    response = PollResponse(
+        poll_id=poll_id,
+        user_id=user_id,
+    )
+    db.add(response)
+    await db.commit()
+    await db.refresh(response)
+    return response
+
+
+async def get_poll_response_by_id(
+    db: AsyncSession,
+    response_id: int,
+) -> PollResponse | None:
+    result = await db.execute(
+        select(PollResponse)
+        .options(
+            selectinload(PollResponse.poll)
+            .options(selectinload(Poll.questions).options(selectinload(PollQuestion.options))),
+            selectinload(PollResponse.answers),
+            selectinload(PollResponse.user),
+        )
+        .where(PollResponse.id == response_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def record_poll_answer(
+    db: AsyncSession,
+    *,
+    response_id: int,
+    question_id: int,
+    option_id: int,
+) -> PollAnswer:
+    result = await db.execute(
+        select(PollAnswer)
+        .where(
+            and_(
+                PollAnswer.response_id == response_id,
+                PollAnswer.question_id == question_id,
+            )
+        )
+    )
+    answer = result.scalar_one_or_none()
+    if answer:
+        answer.option_id = option_id
+        await db.commit()
+        await db.refresh(answer)
+        return answer
+
+    answer = PollAnswer(
+        response_id=response_id,
+        question_id=question_id,
+        option_id=option_id,
+    )
+    db.add(answer)
+    await db.commit()
+    await db.refresh(answer)
+    return answer
+
+
+async def reset_poll_answers(db: AsyncSession, response_id: int) -> None:
+    await db.execute(
+        delete(PollAnswer).where(PollAnswer.response_id == response_id)
+    )
+    await db.commit()
+
+
+async def get_poll_statistics(db: AsyncSession, poll_id: int) -> dict:
+    totals_result = await db.execute(
+        select(
+            func.count(PollResponse.id),
+            func.count(PollResponse.completed_at),
+            func.coalesce(func.sum(PollResponse.reward_amount_kopeks), 0),
+        ).where(PollResponse.poll_id == poll_id)
+    )
+    total_responses, completed_responses, reward_sum = totals_result.one()
+
+    option_counts_result = await db.execute(
+        select(
+            PollQuestion.id,
+            PollQuestion.text,
+            PollQuestion.order,
+            PollOption.id,
+            PollOption.text,
+            PollOption.order,
+            func.count(PollAnswer.id),
+        )
+        .join(PollOption, PollOption.question_id == PollQuestion.id)
+        .outerjoin(
+            PollAnswer,
+            and_(
+                PollAnswer.question_id == PollQuestion.id,
+                PollAnswer.option_id == PollOption.id,
+            ),
+        )
+        .where(PollQuestion.poll_id == poll_id)
+        .group_by(
+            PollQuestion.id,
+            PollQuestion.text,
+            PollQuestion.order,
+            PollOption.id,
+            PollOption.text,
+            PollOption.order,
+        )
+        .order_by(PollQuestion.order.asc(), PollOption.order.asc())
+    )
+
+    questions_map: dict[int, dict] = {}
+    for (
+        question_id,
+        question_text,
+        question_order,
+        option_id,
+        option_text,
+        option_order,
+        answer_count,
+    ) in option_counts_result:
+        question_entry = questions_map.setdefault(
+            question_id,
+            {
+                "id": question_id,
+                "text": question_text,
+                "order": question_order,
+                "options": [],
+            },
+        )
+        question_entry["options"].append(
+            {
+                "id": option_id,
+                "text": option_text,
+                "count": answer_count,
+            }
+        )
+
+    questions = sorted(questions_map.values(), key=lambda item: item["order"])
+
+    return {
+        "total_responses": total_responses,
+        "completed_responses": completed_responses,
+        "reward_sum_kopeks": reward_sum,
+        "questions": questions,
+    }
+
+
+async def get_poll_responses_with_answers(
+    db: AsyncSession,
+    poll_id: int,
+    *,
+    limit: int,
+    offset: int,
+) -> tuple[list[PollResponse], int]:
+    total_result = await db.execute(
+        select(func.count()).select_from(PollResponse).where(PollResponse.poll_id == poll_id)
+    )
+    total = int(total_result.scalar_one() or 0)
+
+    if total == 0:
+        return [], 0
+
+    result = await db.execute(
+        select(PollResponse)
+        .options(
+            selectinload(PollResponse.user),
+            selectinload(PollResponse.answers).selectinload(PollAnswer.question),
+            selectinload(PollResponse.answers).selectinload(PollAnswer.option),
+        )
+        .where(PollResponse.poll_id == poll_id)
+        .order_by(PollResponse.sent_at.asc())
+        .offset(offset)
+        .limit(limit)
+    )
+
+    responses = result.scalars().unique().all()
+    return responses, total
@@ -0,0 +1,79 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import PrivacyPolicy
+
+logger = logging.getLogger(__name__)
+
+
+async def get_privacy_policy(db: AsyncSession, language: str) -> Optional[PrivacyPolicy]:
+    result = await db.execute(
+        select(PrivacyPolicy).where(PrivacyPolicy.language == language)
+    )
+    return result.scalar_one_or_none()
+
+
+async def upsert_privacy_policy(
+    db: AsyncSession,
+    language: str,
+    content: str,
+    *,
+    enable_if_new: bool = True,
+) -> PrivacyPolicy:
+    policy = await get_privacy_policy(db, language)
+
+    if policy:
+        policy.content = content or ""
+        policy.updated_at = datetime.utcnow()
+    else:
+        policy = PrivacyPolicy(
+            language=language,
+            content=content or "",
+            is_enabled=True if enable_if_new else False,
+        )
+        db.add(policy)
+
+    await db.commit()
+    await db.refresh(policy)
+
+    logger.info(
+        "✅ Политика конфиденциальности для языка %s обновлена (ID: %s)",
+        language,
+        policy.id,
+    )
+
+    return policy
+
+
+async def set_privacy_policy_enabled(
+    db: AsyncSession,
+    language: str,
+    enabled: bool,
+) -> PrivacyPolicy:
+    policy = await get_privacy_policy(db, language)
+
+    if policy:
+        policy.is_enabled = bool(enabled)
+        policy.updated_at = datetime.utcnow()
+    else:
+        policy = PrivacyPolicy(
+            language=language,
+            content="",
+            is_enabled=bool(enabled),
+        )
+        db.add(policy)
+
+    await db.commit()
+    await db.refresh(policy)
+
+    logger.info(
+        "✅ Статус политики конфиденциальности для языка %s обновлен: %s",
+        language,
+        "enabled" if policy.is_enabled else "disabled",
+    )
+
+    return policy
@@ -1,11 +1,11 @@
 import logging
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Set, Tuple

 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.database.models import PromoGroup, User
+from app.database.models import PromoGroup, User, UserPromoGroup


 def _normalize_period_discounts(period_discounts: Optional[Dict[int, int]]) -> Dict[int, int]:
@@ -30,20 +30,54 @@ logger = logging.getLogger(__name__)

 async def get_promo_groups_with_counts(
    db: AsyncSession,
+    *,
+    offset: int = 0,
+    limit: Optional[int] = None,
 ) -> List[Tuple[PromoGroup, int]]:
-    result = await db.execute(
+    query = (
        select(PromoGroup, func.count(User.id))
        .outerjoin(User, User.promo_group_id == PromoGroup.id)
        .group_by(PromoGroup.id)
-        .order_by(PromoGroup.is_default.desc(), PromoGroup.name)
+        .order_by(PromoGroup.priority.desc(), PromoGroup.name)
    )
+
+    if offset:
+        query = query.offset(offset)
+    if limit is not None:
+        query = query.limit(limit)
+
+    result = await db.execute(query)
    return result.all()


+async def get_auto_assign_promo_groups(db: AsyncSession) -> List[PromoGroup]:
+    result = await db.execute(
+        select(PromoGroup)
+        .where(PromoGroup.auto_assign_total_spent_kopeks.is_not(None))
+        .where(PromoGroup.auto_assign_total_spent_kopeks > 0)
+        .order_by(PromoGroup.auto_assign_total_spent_kopeks, PromoGroup.id)
+    )
+    return result.scalars().all()
+
+
+async def has_auto_assign_promo_groups(db: AsyncSession) -> bool:
+    result = await db.execute(
+        select(func.count(PromoGroup.id))
+        .where(PromoGroup.auto_assign_total_spent_kopeks.is_not(None))
+        .where(PromoGroup.auto_assign_total_spent_kopeks > 0)
+    )
+    return bool(result.scalar_one())
+
+
 async def get_promo_group_by_id(db: AsyncSession, group_id: int) -> Optional[PromoGroup]:
    return await db.get(PromoGroup, group_id)


+async def count_promo_groups(db: AsyncSession) -> int:
+    result = await db.execute(select(func.count(PromoGroup.id)))
+    return int(result.scalar_one())
+
+
 async def get_default_promo_group(db: AsyncSession) -> Optional[PromoGroup]:
    result = await db.execute(
        select(PromoGroup).where(PromoGroup.is_default.is_(True))
@@ -55,12 +89,14 @@ async def create_promo_group(
    db: AsyncSession,
    name: str,
    *,
+    priority: int = 0,
    server_discount_percent: int,
    traffic_discount_percent: int,
    device_discount_percent: int,
    period_discounts: Optional[Dict[int, int]] = None,
    auto_assign_total_spent_kopeks: Optional[int] = None,
    apply_discounts_to_addons: bool = True,
+    is_default: bool = False,
 ) -> PromoGroup:
    normalized_period_discounts = _normalize_period_discounts(period_discounts)

@@ -70,24 +106,38 @@ async def create_promo_group(
        else None
    )

+    existing_default = await get_default_promo_group(db)
+    should_be_default = existing_default is None or is_default
+
    promo_group = PromoGroup(
        name=name.strip(),
+        priority=max(0, priority),
        server_discount_percent=max(0, min(100, server_discount_percent)),
        traffic_discount_percent=max(0, min(100, traffic_discount_percent)),
        device_discount_percent=max(0, min(100, device_discount_percent)),
        period_discounts=normalized_period_discounts or None,
        auto_assign_total_spent_kopeks=auto_assign_total_spent_kopeks,
        apply_discounts_to_addons=bool(apply_discounts_to_addons),
-        is_default=False,
+        is_default=should_be_default,
    )

    db.add(promo_group)
+    await db.flush()
+
+    if should_be_default and existing_default and existing_default.id != promo_group.id:
+        await db.execute(
+            update(PromoGroup)
+            .where(PromoGroup.id != promo_group.id)
+            .values(is_default=False)
+        )
+
    await db.commit()
    await db.refresh(promo_group)

    logger.info(
-        "Создана промогруппа '%s' с скидками (servers=%s%%, traffic=%s%%, devices=%s%%, periods=%s) и порогом автоприсвоения %s₽, скидки на доп. услуги: %s",
+        "Создана промогруппа '%s' (default=%s) с скидками (servers=%s%%, traffic=%s%%, devices=%s%%, periods=%s) и порогом автоприсвоения %s₽, скидки на доп. услуги: %s",
        promo_group.name,
+        promo_group.is_default,
        promo_group.server_discount_percent,
        promo_group.traffic_discount_percent,
        promo_group.device_discount_percent,
@@ -104,15 +154,19 @@ async def update_promo_group(
    group: PromoGroup,
    *,
    name: Optional[str] = None,
+    priority: Optional[int] = None,
    server_discount_percent: Optional[int] = None,
    traffic_discount_percent: Optional[int] = None,
    device_discount_percent: Optional[int] = None,
    period_discounts: Optional[Dict[int, int]] = None,
    auto_assign_total_spent_kopeks: Optional[int] = None,
    apply_discounts_to_addons: Optional[bool] = None,
+    is_default: Optional[bool] = None,
 ) -> PromoGroup:
    if name is not None:
        group.name = name.strip()
+    if priority is not None:
+        group.priority = max(0, priority)
    if server_discount_percent is not None:
        group.server_discount_percent = max(0, min(100, server_discount_percent))
    if traffic_discount_percent is not None:
@@ -127,6 +181,36 @@ async def update_promo_group(
    if apply_discounts_to_addons is not None:
        group.apply_discounts_to_addons = bool(apply_discounts_to_addons)

+    if is_default is not None:
+        if is_default:
+            group.is_default = True
+            await db.flush()
+            await db.execute(
+                update(PromoGroup)
+                .where(PromoGroup.id != group.id)
+                .values(is_default=False)
+            )
+        else:
+            if group.is_default:
+                group.is_default = False
+                await db.flush()
+                replacement = await db.execute(
+                    select(PromoGroup)
+                    .where(PromoGroup.id != group.id)
+                    .order_by(PromoGroup.id)
+                    .limit(1)
+                )
+                new_default = replacement.scalars().first()
+                if new_default:
+                    await db.execute(
+                        update(PromoGroup)
+                        .where(PromoGroup.id == new_default.id)
+                        .values(is_default=True)
+                    )
+                else:
+                    # Не допускаем состояния без базовой промогруппы
+                    group.is_default = True
+
    await db.commit()
    await db.refresh(group)

@@ -148,11 +232,43 @@ async def delete_promo_group(db: AsyncSession, group: PromoGroup) -> bool:
        logger.error("Не найдена базовая промогруппа для reassignment")
        return False

+
+    # Получаем список пользователей, связанных с удаляемой промогруппой
+    affected_user_ids: Set[int] = set()
+
+    user_ids_result = await db.execute(
+        select(User.id).where(User.promo_group_id == group.id)
+    )
+    affected_user_ids.update(user_ids_result.scalars().all())
+
+    promo_group_links_result = await db.execute(
+        select(UserPromoGroup.user_id).where(UserPromoGroup.promo_group_id == group.id)
+    )
+    affected_user_ids.update(promo_group_links_result.scalars().all())
+
    await db.execute(
        update(User)
        .where(User.promo_group_id == group.id)
        .values(promo_group_id=default_group.id)
    )
+
+    if affected_user_ids:
+        existing_defaults_result = await db.execute(
+            select(UserPromoGroup.user_id)
+            .where(UserPromoGroup.promo_group_id == default_group.id)
+            .where(UserPromoGroup.user_id.in_(affected_user_ids))
+        )
+        existing_default_user_ids = set(existing_defaults_result.scalars().all())
+
+        for user_id in affected_user_ids - existing_default_user_ids:
+            db.add(
+                UserPromoGroup(
+                    user_id=user_id,
+                    promo_group_id=default_group.id,
+                    assigned_by="system",
+                )
+            )
+
    await db.delete(group)
    await db.commit()

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict, List, Optional, Tuple
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import PromoOfferLog
+
+logger = logging.getLogger(__name__)
+
+
+async def log_promo_offer_action(
+    db: AsyncSession,
+    *,
+    user_id: Optional[int],
+    offer_id: Optional[int],
+    action: str,
+    source: Optional[str] = None,
+    percent: Optional[int] = None,
+    effect_type: Optional[str] = None,
+    details: Optional[Dict[str, object]] = None,
+    commit: bool = True,
+) -> PromoOfferLog:
+    """Persist a promo offer log entry."""
+
+    entry = PromoOfferLog(
+        user_id=user_id,
+        offer_id=offer_id,
+        action=action,
+        source=source,
+        percent=percent,
+        effect_type=effect_type,
+        details=(details or {}).copy(),
+    )
+    db.add(entry)
+
+    if commit:
+        try:
+            await db.commit()
+            await db.refresh(entry)
+        except Exception:
+            logger.exception("Failed to commit promo offer log entry")
+            raise
+
+    return entry
+
+
+async def list_promo_offer_logs(
+    db: AsyncSession,
+    offset: int = 0,
+    limit: int = 20,
+    *,
+    user_id: Optional[int] = None,
+    offer_id: Optional[int] = None,
+    action: Optional[str] = None,
+    source: Optional[str] = None,
+) -> Tuple[List[PromoOfferLog], int]:
+    stmt = (
+        select(PromoOfferLog)
+        .options(
+            selectinload(PromoOfferLog.user),
+            selectinload(PromoOfferLog.offer),
+        )
+        .order_by(PromoOfferLog.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+
+    if user_id is not None:
+        stmt = stmt.where(PromoOfferLog.user_id == user_id)
+    if offer_id is not None:
+        stmt = stmt.where(PromoOfferLog.offer_id == offer_id)
+    if action:
+        stmt = stmt.where(PromoOfferLog.action == action)
+    if source:
+        stmt = stmt.where(PromoOfferLog.source == source)
+
+    result = await db.execute(stmt)
+    logs = result.scalars().all()
+
+    count_stmt = select(func.count(PromoOfferLog.id))
+    if user_id is not None:
+        count_stmt = count_stmt.where(PromoOfferLog.user_id == user_id)
+    if offer_id is not None:
+        count_stmt = count_stmt.where(PromoOfferLog.offer_id == offer_id)
+    if action:
+        count_stmt = count_stmt.where(PromoOfferLog.action == action)
+    if source:
+        count_stmt = count_stmt.where(PromoOfferLog.source == source)
+
+    total = (await db.execute(count_stmt)).scalar() or 0
+
+    return logs, total
@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, List, Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import PromoOfferTemplate
+
+
+UPDATED_TEMPLATE_MESSAGES = {
+    "extend_discount": (
+        "💎 Экономия {discount_percent}% при продлении\n\n"
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Срок действия предложения — {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+    "purchase_discount": (
+        "🎯 Вернитесь со скидкой {discount_percent}%\n\n"
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Предложение действует {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+}
+
+
+LEGACY_TEMPLATE_MESSAGES = {
+    "extend_discount": (
+        "💎 <b>Экономия {discount_percent}% при продлении</b>\n\n"
+        "Активируйте предложение и получите дополнительную скидку на оплату продления. "
+        "Она суммируется с вашими промогрупповыми скидками и действует один раз.\n"
+        "Срок действия предложения — {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+    "purchase_discount": (
+        "🎯 <b>Вернитесь со скидкой {discount_percent}%</b>\n\n"
+        "После активации мы применим дополнительную скидку к вашей следующей оплате подписки. "
+        "Скидка суммируется с промогруппой и действует один раз.\n"
+        "Предложение действует {valid_hours} ч.\n"
+        "После активации скидка действует {active_discount_hours} ч."
+    ),
+}
+
+
+DEFAULT_TEMPLATES: tuple[dict, ...] = (
+    {
+        "offer_type": "test_access",
+        "name": "Тестовые сервера",
+        "message_text": (
+            "🔥 <b>Испытайте новые сервера</b>\n\n"
+            "Активируйте предложение и получите временный доступ к дополнительным сквадам на {test_duration_hours} ч.\n"
+            "Предложение действительно {valid_hours} ч."
+        ),
+        "button_text": "🚀 Попробовать серверы",
+        "valid_hours": 24,
+        "discount_percent": 0,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": None,
+        "test_duration_hours": 24,
+        "test_squad_uuids": [],
+    },
+    {
+        "offer_type": "extend_discount",
+        "name": "Скидка на продление",
+        "message_text": UPDATED_TEMPLATE_MESSAGES["extend_discount"],
+        "button_text": "🎁 Получить скидку",
+        "valid_hours": 24,
+        "discount_percent": 20,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": 24,
+        "test_duration_hours": None,
+        "test_squad_uuids": [],
+    },
+    {
+        "offer_type": "purchase_discount",
+        "name": "Скидка на покупку",
+        "message_text": UPDATED_TEMPLATE_MESSAGES["purchase_discount"],
+        "button_text": "🎁 Забрать скидку",
+        "valid_hours": 48,
+        "discount_percent": 25,
+        "bonus_amount_kopeks": 0,
+        "active_discount_hours": 48,
+        "test_duration_hours": None,
+        "test_squad_uuids": [],
+    },
+)
+
+
+def _format_template_fields(payload: dict) -> dict:
+    data = dict(payload)
+    data.setdefault("valid_hours", 24)
+    data.setdefault("discount_percent", 0)
+    data.setdefault("bonus_amount_kopeks", 0)
+    data.setdefault("active_discount_hours", None)
+    data.setdefault("test_duration_hours", None)
+    data.setdefault("test_squad_uuids", [])
+    return data
+
+
+async def ensure_default_templates(db: AsyncSession, *, created_by: Optional[int] = None) -> List[PromoOfferTemplate]:
+    templates: List[PromoOfferTemplate] = []
+
+    for template_data in DEFAULT_TEMPLATES:
+        result = await db.execute(
+            select(PromoOfferTemplate).where(PromoOfferTemplate.offer_type == template_data["offer_type"])
+        )
+        existing = result.scalars().first()
+        if existing:
+            new_message = UPDATED_TEMPLATE_MESSAGES.get(template_data["offer_type"])
+            legacy_message = LEGACY_TEMPLATE_MESSAGES.get(template_data["offer_type"])
+            should_update = False
+
+            if new_message and legacy_message and existing.message_text == legacy_message:
+                should_update = True
+            elif new_message and (
+                "{bonus_amount" in existing.message_text or "Мы начислим" in existing.message_text
+            ):
+                should_update = True
+
+            if should_update and new_message:
+                existing.message_text = new_message
+                existing.updated_at = datetime.utcnow()
+                await db.flush()
+
+            target_active_hours = template_data.get("active_discount_hours")
+            if (
+                target_active_hours is not None
+                and target_active_hours > 0
+                and not existing.active_discount_hours
+            ):
+                existing.active_discount_hours = target_active_hours
+                existing.updated_at = datetime.utcnow()
+                await db.flush()
+            templates.append(existing)
+            continue
+
+        payload = _format_template_fields(template_data)
+        template = PromoOfferTemplate(
+            name=payload["name"],
+            offer_type=payload["offer_type"],
+            message_text=payload["message_text"],
+            button_text=payload["button_text"],
+            valid_hours=payload["valid_hours"],
+            discount_percent=payload["discount_percent"],
+            bonus_amount_kopeks=payload["bonus_amount_kopeks"],
+            active_discount_hours=payload["active_discount_hours"],
+            test_duration_hours=payload["test_duration_hours"],
+            test_squad_uuids=payload["test_squad_uuids"],
+            is_active=True,
+            created_by=created_by,
+        )
+        db.add(template)
+        await db.flush()
+        templates.append(template)
+
+    await db.commit()
+
+    return templates
+
+
+async def list_promo_offer_templates(db: AsyncSession) -> List[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).order_by(PromoOfferTemplate.offer_type, PromoOfferTemplate.id)
+    )
+    return result.scalars().all()
+
+
+async def get_promo_offer_template_by_id(db: AsyncSession, template_id: int) -> Optional[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).where(PromoOfferTemplate.id == template_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_promo_offer_template_by_type(db: AsyncSession, offer_type: str) -> Optional[PromoOfferTemplate]:
+    result = await db.execute(
+        select(PromoOfferTemplate).where(PromoOfferTemplate.offer_type == offer_type)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_promo_offer_template(
+    db: AsyncSession,
+    template: PromoOfferTemplate,
+    *,
+    name: Optional[str] = None,
+    message_text: Optional[str] = None,
+    button_text: Optional[str] = None,
+    valid_hours: Optional[int] = None,
+    discount_percent: Optional[int] = None,
+    bonus_amount_kopeks: Optional[int] = None,
+    active_discount_hours: Optional[int] = None,
+    test_duration_hours: Optional[int] = None,
+    test_squad_uuids: Optional[Iterable[str]] = None,
+    is_active: Optional[bool] = None,
+) -> PromoOfferTemplate:
+    if name is not None:
+        template.name = name
+    if message_text is not None:
+        template.message_text = message_text
+    if button_text is not None:
+        template.button_text = button_text
+    if valid_hours is not None:
+        template.valid_hours = valid_hours
+    if discount_percent is not None:
+        template.discount_percent = discount_percent
+    if bonus_amount_kopeks is not None:
+        template.bonus_amount_kopeks = bonus_amount_kopeks
+    if active_discount_hours is not None:
+        template.active_discount_hours = active_discount_hours
+    if test_duration_hours is not None:
+        template.test_duration_hours = test_duration_hours
+    if test_squad_uuids is not None:
+        template.test_squad_uuids = list(test_squad_uuids)
+    if is_active is not None:
+        template.is_active = is_active
+
+    template.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(template)
+    return template
@@ -13,12 +13,50 @@ logger = logging.getLogger(__name__)
 async def get_promocode_by_code(db: AsyncSession, code: str) -> Optional[PromoCode]:
    result = await db.execute(
        select(PromoCode)
-        .options(selectinload(PromoCode.uses))
+        .options(
+            selectinload(PromoCode.uses),
+            selectinload(PromoCode.promo_group)
+        )
        .where(PromoCode.code == code.upper())
    )
    return result.scalar_one_or_none()


+async def get_promocode_by_id(db: AsyncSession, promo_id: int) -> Optional[PromoCode]:
+    """
+    Получает промокод по ID с eager loading всех связанных данных.
+    Используется для избежания lazy loading в async контексте.
+    """
+    result = await db.execute(
+        select(PromoCode)
+        .options(
+            selectinload(PromoCode.uses),
+            selectinload(PromoCode.promo_group)
+        )
+        .where(PromoCode.id == promo_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def check_promocode_validity(db: AsyncSession, code: str) -> dict:
+    """
+    Проверяет существование и валидность промокода без активации.
+    Возвращает словарь с информацией о промокоде.
+    """
+    promocode = await get_promocode_by_code(db, code)
+
+    if not promocode:
+        return {"valid": False, "error": "not_found", "promocode": None}
+
+    if not promocode.is_valid:
+        if promocode.current_uses >= promocode.max_uses:
+            return {"valid": False, "error": "used", "promocode": None}
+        else:
+            return {"valid": False, "error": "expired", "promocode": None}
+
+    return {"valid": True, "error": None, "promocode": promocode}
+
+
 async def create_promocode(
    db: AsyncSession,
    code: str,
@@ -27,7 +65,8 @@ async def create_promocode(
    subscription_days: int = 0,
    max_uses: int = 1,
    valid_until: Optional[datetime] = None,
-    created_by: Optional[int] = None
+    created_by: Optional[int] = None,
+    promo_group_id: Optional[int] = None
 ) -> PromoCode:
    
    promocode = PromoCode(
@@ -37,14 +76,18 @@ async def create_promocode(
        subscription_days=subscription_days,
        max_uses=max_uses,
        valid_until=valid_until,
-        created_by=created_by
+        created_by=created_by,
+        promo_group_id=promo_group_id
    )
    
    db.add(promocode)
    await db.commit()
    await db.refresh(promocode)
-    
-    logger.info(f"✅ Создан промокод: {code}")
+
+    if promo_group_id:
+        logger.info(f"✅ Создан промокод: {code} с промогруппой ID {promo_group_id}")
+    else:
+        logger.info(f"✅ Создан промокод: {code}")
    return promocode


@@ -53,9 +96,9 @@ async def use_promocode(
    promocode_id: int,
    user_id: int
 ) -> bool:
-    
+
    try:
-        promocode = await db.get(PromoCode, promocode_id)
+        promocode = await get_promocode_by_id(db, promocode_id)
        if not promocode:
            return False
        
@@ -143,14 +186,17 @@ async def get_promocodes_list(
    limit: int = 50,
    is_active: Optional[bool] = None
 ) -> List[PromoCode]:
-    
-    query = select(PromoCode).options(selectinload(PromoCode.uses))
-    
+
+    query = select(PromoCode).options(
+        selectinload(PromoCode.uses),
+        selectinload(PromoCode.promo_group)
+    )
+
    if is_active is not None:
        query = query.where(PromoCode.is_active == is_active)
-    
+
    query = query.order_by(PromoCode.created_at.desc()).offset(offset).limit(limit)
-    
+
    result = await db.execute(query)
    return result.scalars().all()

@@ -0,0 +1,79 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import PublicOffer
+
+logger = logging.getLogger(__name__)
+
+
+async def get_public_offer(db: AsyncSession, language: str) -> Optional[PublicOffer]:
+    result = await db.execute(
+        select(PublicOffer).where(PublicOffer.language == language)
+    )
+    return result.scalar_one_or_none()
+
+
+async def upsert_public_offer(
+    db: AsyncSession,
+    language: str,
+    content: str,
+    *,
+    enable_if_new: bool = True,
+) -> PublicOffer:
+    offer = await get_public_offer(db, language)
+
+    if offer:
+        offer.content = content or ""
+        offer.updated_at = datetime.utcnow()
+    else:
+        offer = PublicOffer(
+            language=language,
+            content=content or "",
+            is_enabled=True if enable_if_new else False,
+        )
+        db.add(offer)
+
+    await db.commit()
+    await db.refresh(offer)
+
+    logger.info(
+        "✅ Публичная оферта для языка %s обновлена (ID: %s)",
+        language,
+        offer.id,
+    )
+
+    return offer
+
+
+async def set_public_offer_enabled(
+    db: AsyncSession,
+    language: str,
+    enabled: bool,
+) -> PublicOffer:
+    offer = await get_public_offer(db, language)
+
+    if offer:
+        offer.is_enabled = bool(enabled)
+        offer.updated_at = datetime.utcnow()
+    else:
+        offer = PublicOffer(
+            language=language,
+            content="",
+            is_enabled=bool(enabled),
+        )
+        db.add(offer)
+
+    await db.commit()
+    await db.refresh(offer)
+
+    logger.info(
+        "✅ Статус публичной оферты для языка %s обновлен: %s",
+        language,
+        "enabled" if offer.is_enabled else "disabled",
+    )
+
+    return offer
@@ -1,11 +1,30 @@
 import logging
+import random
+from datetime import datetime
 from typing import Iterable, List, Optional, Sequence, Tuple

-from sqlalchemy import select, and_, func, update, delete, text
+from sqlalchemy import (
+    select,
+    and_,
+    func,
+    update,
+    delete,
+    text,
+    or_,
+    cast,
+    String,
+)
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.database.models import PromoGroup, ServerSquad, SubscriptionServer, Subscription
+from app.database.models import (
+    PromoGroup,
+    ServerSquad,
+    SubscriptionServer,
+    Subscription,
+    SubscriptionStatus,
+    User,
+)

 logger = logging.getLogger(__name__)

@@ -27,6 +46,8 @@ async def create_server_squad(
    description: str = None,
    max_users: int = None,
    is_available: bool = True,
+    is_trial_eligible: bool = False,
+    sort_order: int = 0,
    promo_group_ids: Optional[Iterable[int]] = None,
 ) -> ServerSquad:

@@ -59,6 +80,8 @@ async def create_server_squad(
        description=description,
        max_users=max_users,
        is_available=is_available,
+        is_trial_eligible=is_trial_eligible,
+        sort_order=sort_order,
        allowed_promo_groups=promo_groups,
    )

@@ -146,6 +169,58 @@ async def get_available_server_squads(
    return result.scalars().unique().all()


+async def get_active_server_squads(db: AsyncSession) -> List[ServerSquad]:
+    """Возвращает список активных серверов, доступных для подключения."""
+
+    squads = await get_available_server_squads(db)
+
+    if not squads:
+        return []
+
+    eligible: List[ServerSquad] = []
+
+    for squad in squads:
+        max_users = squad.max_users
+        current_users = squad.current_users or 0
+
+        if max_users is not None and current_users >= max_users:
+            continue
+
+        eligible.append(squad)
+
+    if eligible:
+        return eligible
+
+    return squads
+
+
+async def choose_random_active_server_squad(
+    db: AsyncSession,
+) -> Optional[ServerSquad]:
+    """Возвращает случайный активный сервер."""
+
+    squads = await get_active_server_squads(db)
+
+    if not squads:
+        return None
+
+    return random.choice(squads)
+
+
+async def get_random_active_squad_uuid(
+    db: AsyncSession,
+    fallback_uuid: Optional[str] = None,
+) -> Optional[str]:
+    """Возвращает UUID случайного активного сервера или запасной UUID."""
+
+    squad = await choose_random_active_server_squad(db)
+
+    if squad:
+        return squad.squad_uuid
+
+    return fallback_uuid
+
+
 async def update_server_squad_promo_groups(
    db: AsyncSession, server_id: int, promo_group_ids: Iterable[int]
 ) -> Optional[ServerSquad]:
@@ -187,8 +262,15 @@ async def update_server_squad(
 ) -> Optional[ServerSquad]:
    
    valid_fields = {
-        'display_name', 'country_code', 'price_kopeks', 'description',
-        'max_users', 'is_available', 'sort_order'
+        "display_name",
+        "original_name",
+        "country_code",
+        "price_kopeks",
+        "description",
+        "max_users",
+        "is_available",
+        "sort_order",
+        "is_trial_eligible",
    }
    
    filtered_updates = {k: v for k, v in updates.items() if k in valid_fields}
@@ -232,10 +314,10 @@ async def sync_with_remnawave(
    db: AsyncSession,
    remnawave_squads: List[dict]
 ) -> Tuple[int, int, int]:
-    
+
    created = 0
    updated = 0
-    disabled = 0
+    removed = 0
    
    existing_servers = {}
    result = await db.execute(select(ServerSquad))
@@ -265,19 +347,186 @@ async def sync_with_remnawave(
            )
            created += 1
    
-    for uuid, server in existing_servers.items():
-        if uuid not in remnawave_uuids and server.is_available:
-            server.is_available = False
-            disabled += 1
-    
+    removed_servers = [
+        server for uuid, server in existing_servers.items()
+        if uuid not in remnawave_uuids
+    ]
+
+    if removed_servers:
+        removed_ids = [server.id for server in removed_servers]
+        removed_uuids = {server.squad_uuid for server in removed_servers}
+
+        subscription_ids_result = await db.execute(
+            select(SubscriptionServer.subscription_id)
+            .where(SubscriptionServer.server_squad_id.in_(removed_ids))
+        )
+        subscription_ids = {row[0] for row in subscription_ids_result.fetchall()}
+
+        for server in removed_servers:
+            logger.info(
+                "🗑️ Удаляется сервер %s (UUID: %s)",
+                server.display_name,
+                server.squad_uuid,
+            )
+
+        await db.execute(
+            delete(SubscriptionServer).where(SubscriptionServer.server_squad_id.in_(removed_ids))
+        )
+
+        subscriptions_to_update: dict[int, Subscription] = {}
+
+        if subscription_ids:
+            subscriptions_result = await db.execute(
+                select(Subscription).where(Subscription.id.in_(subscription_ids))
+            )
+            for subscription in subscriptions_result.scalars().unique().all():
+                subscriptions_to_update[subscription.id] = subscription
+
+        for squad_uuid in removed_uuids:
+            if not squad_uuid:
+                continue
+
+            extra_result = await db.execute(
+                select(Subscription).where(
+                    text("connected_squads::text LIKE :uuid_pattern")
+                ),
+                {"uuid_pattern": f'%"{squad_uuid}"%'}
+            )
+
+            for subscription in extra_result.scalars().unique().all():
+                subscriptions_to_update[subscription.id] = subscription
+
+        cleaned_subscriptions = 0
+
+        for subscription in subscriptions_to_update.values():
+            current_squads = list(subscription.connected_squads or [])
+            if not current_squads:
+                continue
+
+            filtered_squads = [
+                squad_uuid for squad_uuid in current_squads if squad_uuid not in removed_uuids
+            ]
+
+            if len(filtered_squads) != len(current_squads):
+                subscription.connected_squads = filtered_squads
+                subscription.updated_at = datetime.utcnow()
+                cleaned_subscriptions += 1
+
+        await db.execute(delete(ServerSquad).where(ServerSquad.id.in_(removed_ids)))
+        removed = len(removed_servers)
+
+        if cleaned_subscriptions:
+            logger.info(
+                "🧹 Обновлены подписки после удаления серверов: %s",
+                cleaned_subscriptions,
+            )
+
    await db.commit()
-    
-    logger.info(f"🔄 Синхронизация завершена: +{created} ~{updated} -{disabled}")
-    return created, updated, disabled
+
+    logger.info(f"🔄 Синхронизация завершена: +{created} ~{updated} -{removed}")
+    return created, updated, removed
+
+
+async def get_server_connected_users(
+    db: AsyncSession,
+    server_id: int
+) -> List[User]:
+
+    server_uuid_result = await db.execute(
+        select(ServerSquad.squad_uuid).where(ServerSquad.id == server_id)
+    )
+    server_uuid = server_uuid_result.scalar_one_or_none()
+
+    connection_filters = [SubscriptionServer.id.isnot(None)]
+
+    if server_uuid:
+        connection_filters.append(
+            cast(Subscription.connected_squads, String).like(
+                f'%"{server_uuid}"%'
+            )
+        )
+
+    result = await db.execute(
+        select(User)
+        .join(Subscription, Subscription.user_id == User.id)
+        .outerjoin(
+            SubscriptionServer,
+            and_(
+                SubscriptionServer.subscription_id == Subscription.id,
+                SubscriptionServer.server_squad_id == server_id,
+            ),
+        )
+        .where(or_(*connection_filters))
+        .options(selectinload(User.subscription))
+        .order_by(User.id)
+    )
+
+    return result.scalars().unique().all()
+
+
+async def get_trial_eligible_server_squads(
+    db: AsyncSession,
+    include_unavailable: bool = False,
+) -> List[ServerSquad]:
+
+    query = select(ServerSquad).where(ServerSquad.is_trial_eligible.is_(True))
+
+    result = await db.execute(query)
+    squads = result.scalars().unique().all()
+
+    if include_unavailable:
+        return squads
+
+    preferred_squads: List[ServerSquad] = []
+    fallback_squads: List[ServerSquad] = []
+
+    for squad in squads:
+        current_users = squad.current_users or 0
+        is_full = squad.max_users is not None and current_users >= squad.max_users
+
+        if is_full:
+            continue
+
+        if squad.is_available:
+            preferred_squads.append(squad)
+        else:
+            fallback_squads.append(squad)
+
+    if preferred_squads:
+        return preferred_squads
+
+    if fallback_squads:
+        return fallback_squads
+
+    return squads
+
+
+async def choose_random_trial_server_squad(
+    db: AsyncSession,
+) -> Optional[ServerSquad]:
+
+    squads = await get_trial_eligible_server_squads(db)
+
+    if not squads:
+        return None
+
+    return random.choice(squads)
+
+
+async def get_random_trial_squad_uuid(
+    db: AsyncSession,
+) -> Optional[str]:
+
+    squad = await choose_random_trial_server_squad(db)
+
+    if squad:
+        return squad.squad_uuid
+
+    return None


 def _generate_display_name(original_name: str) -> str:
-    
+
    country_names = {
        'NL': '🇳🇱 Нидерланды',
        'DE': '🇩🇪 Германия', 
@@ -313,10 +562,10 @@ def _extract_country_code(original_name: str) -> Optional[str]:


 async def get_server_statistics(db: AsyncSession) -> dict:
-    
+
    total_result = await db.execute(select(func.count(ServerSquad.id)))
    total_servers = total_result.scalar()
-    
+
    available_result = await db.execute(
        select(func.count(ServerSquad.id))
        .where(ServerSquad.is_available == True)
@@ -355,6 +604,25 @@ async def get_server_statistics(db: AsyncSession) -> dict:
        'total_revenue_rubles': total_revenue_kopeks / 100
    }

+
+async def count_active_users_for_squad(db: AsyncSession, squad_uuid: str) -> int:
+    """Возвращает количество активных подписок, подключенных к указанному скваду."""
+
+    result = await db.execute(
+        select(func.count(Subscription.id)).where(
+            Subscription.status.in_(
+                [
+                    SubscriptionStatus.ACTIVE.value,
+                    SubscriptionStatus.TRIAL.value,
+                ]
+            ),
+            cast(Subscription.connected_squads, String).like(f'%"{squad_uuid}"%'),
+        )
+    )
+
+    return result.scalar() or 0
+
+
 async def add_user_to_servers(
    db: AsyncSession,
    server_squad_ids: List[int]
@@ -1,7 +1,7 @@
 import logging
 from datetime import datetime, timedelta
-from typing import Optional, List, Tuple
-from sqlalchemy import select, and_, func
+from typing import Iterable, Optional, List, Tuple
+from sqlalchemy import select, and_, func, delete
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

@@ -11,10 +11,12 @@ from app.database.models import (
    User,
    SubscriptionServer,
    PromoGroup,
+    UserPromoGroup,
 )
 from app.database.crud.notification import clear_notifications
 from app.utils.pricing_utils import calculate_months_from_days, get_remaining_months
 from app.config import settings
+from app.utils.timezone import format_local_datetime

 logger = logging.getLogger(__name__)

@@ -30,6 +32,7 @@ async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Optiona
    subscription = result.scalar_one_or_none()
    
    if subscription:
+        logger.info(f"🔍 Загружена подписка {subscription.id} для пользователя {user_id}, статус: {subscription.status}")
        subscription = await check_and_update_subscription_status(db, subscription)
    
    return subscription
@@ -40,17 +43,35 @@ async def create_trial_subscription(
    user_id: int,
    duration_days: int = None,
    traffic_limit_gb: int = None,
-    device_limit: int = None,
+    device_limit: Optional[int] = None,
    squad_uuid: str = None
 ) -> Subscription:
    
    duration_days = duration_days or settings.TRIAL_DURATION_DAYS
    traffic_limit_gb = traffic_limit_gb or settings.TRIAL_TRAFFIC_LIMIT_GB
-    device_limit = device_limit or settings.TRIAL_DEVICE_LIMIT
-    squad_uuid = squad_uuid or settings.TRIAL_SQUAD_UUID
-    
+    if device_limit is None:
+        device_limit = settings.TRIAL_DEVICE_LIMIT
+    if not squad_uuid:
+        try:
+            from app.database.crud.server_squad import get_random_trial_squad_uuid
+
+            squad_uuid = await get_random_trial_squad_uuid(db)
+
+            if squad_uuid:
+                logger.debug(
+                    "Выбран сквад %s для триальной подписки пользователя %s",
+                    squad_uuid,
+                    user_id,
+                )
+        except Exception as error:
+            logger.error(
+                "Не удалось получить сквад для триальной подписки пользователя %s: %s",
+                user_id,
+                error,
+            )
+
    end_date = datetime.utcnow() + timedelta(days=duration_days)
-    
+
    subscription = Subscription(
        user_id=user_id,
        status=SubscriptionStatus.ACTIVE.value,
@@ -59,14 +80,43 @@ async def create_trial_subscription(
        end_date=end_date,
        traffic_limit_gb=traffic_limit_gb,
        device_limit=device_limit,
-        connected_squads=[squad_uuid] if squad_uuid else []
+        connected_squads=[squad_uuid] if squad_uuid else [],
+        autopay_enabled=settings.is_autopay_enabled_by_default(),
+        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
    )
    
    db.add(subscription)
    await db.commit()
    await db.refresh(subscription)
-    
+
    logger.info(f"🎁 Создана триальная подписка для пользователя {user_id}")
+
+    if squad_uuid:
+        try:
+            from app.database.crud.server_squad import (
+                get_server_ids_by_uuids,
+                add_user_to_servers,
+            )
+
+            server_ids = await get_server_ids_by_uuids(db, [squad_uuid])
+            if server_ids:
+                await add_user_to_servers(db, server_ids)
+                logger.info(
+                    "📈 Обновлен счетчик пользователей для триального сквада %s",
+                    squad_uuid,
+                )
+            else:
+                logger.warning(
+                    "⚠️ Не удалось найти серверы для обновления счетчика (сквад %s)",
+                    squad_uuid,
+                )
+        except Exception as error:
+            logger.error(
+                "⚠️ Ошибка обновления счетчика пользователей для триального сквада %s: %s",
+                squad_uuid,
+                error,
+            )
+
    return subscription


@@ -74,13 +124,17 @@ async def create_paid_subscription(
    db: AsyncSession,
    user_id: int,
    duration_days: int,
-    traffic_limit_gb: int = 0, 
-    device_limit: int = 1,
-    connected_squads: List[str] = None
+    traffic_limit_gb: int = 0,
+    device_limit: Optional[int] = None,
+    connected_squads: List[str] = None,
+    update_server_counters: bool = False,
 ) -> Subscription:
-    
+
    end_date = datetime.utcnow() + timedelta(days=duration_days)
    
+    if device_limit is None:
+        device_limit = settings.DEFAULT_DEVICE_LIMIT
+
    subscription = Subscription(
        user_id=user_id,
        status=SubscriptionStatus.ACTIVE.value,
@@ -89,14 +143,131 @@ async def create_paid_subscription(
        end_date=end_date,
        traffic_limit_gb=traffic_limit_gb,
        device_limit=device_limit,
-        connected_squads=connected_squads or []
+        connected_squads=connected_squads or [],
+        autopay_enabled=settings.is_autopay_enabled_by_default(),
+        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
    )
    
    db.add(subscription)
    await db.commit()
    await db.refresh(subscription)
    
-    logger.info(f"💎 Создана платная подписка для пользователя {user_id}")
+    logger.info(f"💎 Создана платная подписка для пользователя {user_id}, ID: {subscription.id}, статус: {subscription.status}")
+
+    squad_uuids = list(connected_squads or [])
+    if update_server_counters and squad_uuids:
+        try:
+            from app.database.crud.server_squad import (
+                get_server_ids_by_uuids,
+                add_user_to_servers,
+            )
+
+            server_ids = await get_server_ids_by_uuids(db, squad_uuids)
+            if server_ids:
+                await add_user_to_servers(db, server_ids)
+                logger.info(
+                    "📈 Обновлен счетчик пользователей для платной подписки пользователя %s (сквады: %s)",
+                    user_id,
+                    squad_uuids,
+                )
+            else:
+                logger.warning(
+                    "⚠️ Не удалось найти серверы для обновления счетчика платной подписки пользователя %s (сквады: %s)",
+                    user_id,
+                    squad_uuids,
+                )
+        except Exception as error:
+            logger.error(
+                "⚠️ Ошибка обновления счетчика пользователей серверов для платной подписки пользователя %s: %s",
+                user_id,
+                error,
+            )
+
+    return subscription
+
+
+async def replace_subscription(
+    db: AsyncSession,
+    subscription: Subscription,
+    *,
+    duration_days: int,
+    traffic_limit_gb: int,
+    device_limit: int,
+    connected_squads: List[str],
+    is_trial: bool,
+    autopay_enabled: Optional[bool] = None,
+    autopay_days_before: Optional[int] = None,
+    update_server_counters: bool = False,
+) -> Subscription:
+    """Перезаписывает параметры существующей подписки пользователя."""
+
+    current_time = datetime.utcnow()
+    old_squads = set(subscription.connected_squads or [])
+    new_squads = set(connected_squads or [])
+
+    new_autopay_enabled = (
+        subscription.autopay_enabled
+        if autopay_enabled is None
+        else autopay_enabled
+    )
+    new_autopay_days_before = (
+        subscription.autopay_days_before
+        if autopay_days_before is None
+        else autopay_days_before
+    )
+
+    subscription.status = SubscriptionStatus.ACTIVE.value
+    subscription.is_trial = is_trial
+    subscription.start_date = current_time
+    subscription.end_date = current_time + timedelta(days=duration_days)
+    subscription.traffic_limit_gb = traffic_limit_gb
+    subscription.traffic_used_gb = 0.0
+    subscription.device_limit = device_limit
+    subscription.connected_squads = list(new_squads)
+    subscription.subscription_url = None
+    subscription.subscription_crypto_link = None
+    subscription.remnawave_short_uuid = None
+    subscription.autopay_enabled = new_autopay_enabled
+    subscription.autopay_days_before = new_autopay_days_before
+    subscription.updated_at = current_time
+
+    await db.commit()
+    await db.refresh(subscription)
+
+    if update_server_counters:
+        try:
+            from app.database.crud.server_squad import (
+                add_user_to_servers,
+                get_server_ids_by_uuids,
+                remove_user_from_servers,
+            )
+
+            squads_to_remove = old_squads - new_squads
+            squads_to_add = new_squads - old_squads
+
+            if squads_to_remove:
+                server_ids = await get_server_ids_by_uuids(db, list(squads_to_remove))
+                if server_ids:
+                    await remove_user_from_servers(db, sorted(server_ids))
+
+            if squads_to_add:
+                server_ids = await get_server_ids_by_uuids(db, list(squads_to_add))
+                if server_ids:
+                    await add_user_to_servers(db, sorted(server_ids))
+
+            logger.info(
+                "♻️ Обновлены параметры подписки %s: удалено сквадов %s, добавлено %s",
+                subscription.id,
+                len(squads_to_remove),
+                len(squads_to_add),
+            )
+        except Exception as error:
+            logger.error(
+                "⚠️ Ошибка обновления счетчиков серверов при замене подписки %s: %s",
+                subscription.id,
+                error,
+            )
+
    return subscription


@@ -106,23 +277,72 @@ async def extend_subscription(
    days: int
 ) -> Subscription:
    current_time = datetime.utcnow()
-    
+
    logger.info(f"🔄 Продление подписки {subscription.id} на {days} дней")
    logger.info(f"📊 Текущие параметры: статус={subscription.status}, окончание={subscription.end_date}")
-    
-    if subscription.end_date > current_time:
+
+    # НОВОЕ: Вычисляем бонусные дни от триала ДО изменения end_date
+    bonus_days = 0
+    if subscription.is_trial and settings.TRIAL_ADD_REMAINING_DAYS_TO_PAID:
+        # Вычисляем остаток триала
+        if subscription.end_date and subscription.end_date > current_time:
+            remaining = subscription.end_date - current_time
+            if remaining.total_seconds() > 0:
+                bonus_days = max(0, remaining.days)
+                logger.info(
+                    "🎁 Обнаружен остаток триала: %s дней для подписки %s",
+                    bonus_days,
+                    subscription.id,
+                )
+
+    # Применяем продление с учетом бонусных дней
+    total_days = days + bonus_days
+
+    if days < 0:
        subscription.end_date = subscription.end_date + timedelta(days=days)
-        logger.info(f"📅 Подписка активна, добавляем {days} дней к текущей дате окончания")
+        logger.info(
+            "📅 Срок подписки уменьшен на %s дней, новая дата окончания: %s",
+            abs(days),
+            subscription.end_date,
+        )
+    elif subscription.end_date > current_time:
+        subscription.end_date = subscription.end_date + timedelta(days=total_days)
+        logger.info(f"📅 Подписка активна, добавляем {total_days} дней ({days} + {bonus_days} бонус) к текущей дате окончания")
    else:
-        subscription.end_date = current_time + timedelta(days=days)
-        logger.info(f"📅 Подписка истекла, устанавливаем новую дату окончания")
+        subscription.end_date = current_time + timedelta(days=total_days)
+        logger.info(f"📅 Подписка истекла, устанавливаем новую дату окончания на {total_days} дней ({days} + {bonus_days} бонус)")
+
+    # УДАЛЕНО: Автоматическая конвертация триала по длительности
+    # Теперь триал конвертируется ТОЛЬКО после успешного коммита продления
+    # и ТОЛЬКО вызывающей функцией (например, _auto_extend_subscription)
+
+    # Логируем статус подписки перед проверкой
+    logger.info(f"🔄 Продление подписки {subscription.id}, текущий статус: {subscription.status}, дни: {days}")
    
-    if subscription.status == SubscriptionStatus.EXPIRED.value:
+    if days > 0 and subscription.status in (
+        SubscriptionStatus.EXPIRED.value,
+        SubscriptionStatus.DISABLED.value,
+    ):
+        previous_status = subscription.status
        subscription.status = SubscriptionStatus.ACTIVE.value
-        logger.info(f"🔄 Статус изменён с EXPIRED на ACTIVE")
-    
+        logger.info(
+            "🔄 Статус подписки %s изменён с %s на ACTIVE",
+            subscription.id,
+            previous_status,
+        )
+    elif days > 0 and subscription.status == SubscriptionStatus.PENDING.value:
+        logger.warning(
+            "⚠️ Попытка продлить PENDING подписку %s, дни: %s",
+            subscription.id,
+            days
+        )
+
+    if settings.RESET_TRAFFIC_ON_PAYMENT:
+        subscription.traffic_used_gb = 0.0
+        logger.info("🔄 Сбрасываем использованный трафик согласно настройке RESET_TRAFFIC_ON_PAYMENT")
+
    subscription.updated_at = current_time
-    
+
    await db.commit()
    await db.refresh(subscription)
    await clear_notifications(db, subscription.id)
@@ -203,6 +423,64 @@ async def remove_subscription_squad(
    return subscription


+async def decrement_subscription_server_counts(
+    db: AsyncSession,
+    subscription: Optional[Subscription],
+    *,
+    subscription_servers: Optional[Iterable[SubscriptionServer]] = None,
+) -> None:
+    """Decrease server counters linked to the provided subscription."""
+
+    if not subscription:
+        return
+
+    server_ids: set[int] = set()
+
+    if subscription_servers is not None:
+        for sub_server in subscription_servers:
+            if sub_server and sub_server.server_squad_id is not None:
+                server_ids.add(sub_server.server_squad_id)
+    else:
+        try:
+            ids_from_links = await get_subscription_server_ids(db, subscription.id)
+            server_ids.update(ids_from_links)
+        except Exception as error:
+            logger.error(
+                "⚠️ Не удалось получить серверы подписки %s для уменьшения счетчика: %s",
+                subscription.id,
+                error,
+            )
+
+    connected_squads = list(subscription.connected_squads or [])
+    if connected_squads:
+        try:
+            from app.database.crud.server_squad import get_server_ids_by_uuids
+
+            squad_server_ids = await get_server_ids_by_uuids(db, connected_squads)
+            server_ids.update(squad_server_ids)
+        except Exception as error:
+            logger.error(
+                "⚠️ Не удалось сопоставить сквады подписки %s с серверами: %s",
+                subscription.id,
+                error,
+            )
+
+    if not server_ids:
+        return
+
+    try:
+        from app.database.crud.server_squad import remove_user_from_servers
+
+        await remove_user_from_servers(db, sorted(server_ids))
+    except Exception as error:
+        logger.error(
+            "⚠️ Ошибка уменьшения счетчика пользователей серверов %s для подписки %s: %s",
+            list(server_ids),
+            subscription.id,
+            error,
+        )
+
+
 async def update_subscription_autopay(
    db: AsyncSession,
    subscription: Subscription,
@@ -398,10 +676,113 @@ async def get_subscriptions_statistics(db: AsyncSession) -> dict:
        "purchased_today": purchased_today,
        "purchased_week": purchased_week,
        "purchased_month": purchased_month,
-        "trial_to_paid_conversion": trial_to_paid_conversion, 
-        "renewals_count": renewals_count 
+        "trial_to_paid_conversion": trial_to_paid_conversion,
+        "renewals_count": renewals_count
    }

+
+async def get_trial_statistics(db: AsyncSession) -> dict:
+    now = datetime.utcnow()
+
+    total_trials_result = await db.execute(
+        select(func.count(Subscription.id)).where(Subscription.is_trial.is_(True))
+    )
+    total_trials = total_trials_result.scalar() or 0
+
+    active_trials_result = await db.execute(
+        select(func.count(Subscription.id)).where(
+            Subscription.is_trial.is_(True),
+            Subscription.end_date > now,
+            Subscription.status.in_(
+                [SubscriptionStatus.TRIAL.value, SubscriptionStatus.ACTIVE.value]
+            ),
+        )
+    )
+    active_trials = active_trials_result.scalar() or 0
+
+    resettable_trials_result = await db.execute(
+        select(func.count(Subscription.id))
+        .join(User, Subscription.user_id == User.id)
+        .where(
+            Subscription.is_trial.is_(True),
+            Subscription.end_date <= now,
+            User.has_had_paid_subscription.is_(False),
+        )
+    )
+    resettable_trials = resettable_trials_result.scalar() or 0
+
+    return {
+        "used_trials": total_trials,
+        "active_trials": active_trials,
+        "resettable_trials": resettable_trials,
+    }
+
+
+async def reset_trials_for_users_without_paid_subscription(db: AsyncSession) -> int:
+    now = datetime.utcnow()
+
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.subscription_servers),
+        )
+        .join(User, Subscription.user_id == User.id)
+        .where(
+            Subscription.is_trial.is_(True),
+            Subscription.end_date <= now,
+            User.has_had_paid_subscription.is_(False),
+        )
+    )
+
+    subscriptions = result.scalars().unique().all()
+    if not subscriptions:
+        return 0
+
+    reset_count = len(subscriptions)
+    for subscription in subscriptions:
+        try:
+            await decrement_subscription_server_counts(
+                db,
+                subscription,
+                subscription_servers=subscription.subscription_servers,
+            )
+        except Exception as error:  # pragma: no cover - defensive logging
+            logger.error(
+                "Не удалось обновить счётчики серверов при сбросе триала %s: %s",
+                subscription.id,
+                error,
+            )
+
+    subscription_ids = [subscription.id for subscription in subscriptions]
+
+    if subscription_ids:
+        try:
+            await db.execute(
+                delete(SubscriptionServer).where(
+                    SubscriptionServer.subscription_id.in_(subscription_ids)
+                )
+            )
+        except Exception as error:  # pragma: no cover - defensive logging
+            logger.error(
+                "Ошибка удаления серверных связей триалов %s: %s",
+                subscription_ids,
+                error,
+            )
+            raise
+
+        await db.execute(delete(Subscription).where(Subscription.id.in_(subscription_ids)))
+
+    try:
+        await db.commit()
+    except Exception as error:  # pragma: no cover - defensive logging
+        await db.rollback()
+        logger.error("Ошибка сохранения сброса триалов: %s", error)
+        raise
+
+    logger.info("♻️ Сброшено триальных подписок: %s", reset_count)
+    return reset_count
+
 async def update_subscription_usage(
    db: AsyncSession,
    subscription: Subscription,
@@ -607,8 +988,8 @@ async def calculate_subscription_total_cost(
        ]
    }

-    logger.info(f"📊 Расчет стоимости подписки на {period_days} дней ({months_in_period} мес):")
-    logger.info(f"   Базовый период: {base_price/100}₽")
+    logger.debug(f"📊 Расчет стоимости подписки на {period_days} дней ({months_in_period} мес):")
+    logger.debug(f"   Базовый период: {base_price/100}₽")
    if total_traffic_price > 0:
        message = (
            f"   Трафик: {traffic_price_per_month/100}₽/мес × {months_in_period} = {total_traffic_price/100}₽"
@@ -617,7 +998,7 @@ async def calculate_subscription_total_cost(
            message += (
                f" (скидка {traffic_discount_percent}%: -{total_traffic_discount/100}₽)"
            )
-        logger.info(message)
+        logger.debug(message)
    if total_servers_price > 0:
        message = (
            f"   Серверы: {servers_price_per_month/100}₽/мес × {months_in_period} = {total_servers_price/100}₽"
@@ -626,7 +1007,7 @@ async def calculate_subscription_total_cost(
            message += (
                f" (скидка {servers_discount_percent}%: -{total_servers_discount/100}₽)"
            )
-        logger.info(message)
+        logger.debug(message)
    if total_devices_price > 0:
        message = (
            f"   Устройства: {devices_price_per_month/100}₽/мес × {months_in_period} = {total_devices_price/100}₽"
@@ -635,8 +1016,8 @@ async def calculate_subscription_total_cost(
            message += (
                f" (скидка {devices_discount_percent}%: -{total_devices_discount/100}₽)"
            )
-        logger.info(message)
-    logger.info(f"   ИТОГО: {total_cost/100}₽")
+        logger.debug(message)
+    logger.debug(f"   ИТОГО: {total_cost/100}₽")
    
    return total_cost, details
    
@@ -724,7 +1105,7 @@ async def get_subscription_renewal_cost(
        result = await db.execute(
            select(Subscription)
            .options(
-                selectinload(Subscription.user).selectinload(User.promo_group),
+                selectinload(Subscription.user).selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
            )
            .where(Subscription.id == subscription_id)
        )
@@ -941,6 +1322,14 @@ async def check_and_update_subscription_status(
    
    current_time = datetime.utcnow()
    
+    logger.info(
+        "🔍 Проверка статуса подписки %s, текущий статус: %s, дата окончания: %s, текущее время: %s",
+        subscription.id,
+        subscription.status,
+        format_local_datetime(subscription.end_date),
+        format_local_datetime(current_time),
+    )
+    
    if (subscription.status == SubscriptionStatus.ACTIVE.value and 
        subscription.end_date <= current_time):
        
@@ -951,9 +1340,68 @@ async def check_and_update_subscription_status(
        await db.refresh(subscription)
        
        logger.info(f"⏰ Статус подписки пользователя {subscription.user_id} изменен на 'expired'")
+    elif subscription.status == SubscriptionStatus.PENDING.value:
+        logger.info(f"ℹ️ Проверка PENDING подписки {subscription.id}, статус остается без изменений")
    
    return subscription

+async def create_subscription_no_commit(
+    db: AsyncSession,
+    user_id: int,
+    status: str = "trial",
+    is_trial: bool = True,
+    end_date: datetime = None,
+    traffic_limit_gb: int = 10,
+    traffic_used_gb: float = 0.0,
+    device_limit: int = 1,
+    connected_squads: list = None,
+    remnawave_short_uuid: str = None,
+    subscription_url: str = "",
+    subscription_crypto_link: str = "",
+    autopay_enabled: Optional[bool] = None,
+    autopay_days_before: Optional[int] = None,
+) -> Subscription:
+    """
+    Создает подписку без немедленного коммита для пакетной обработки
+    """
+    
+    if end_date is None:
+        end_date = datetime.utcnow() + timedelta(days=3)
+    
+    if connected_squads is None:
+        connected_squads = []
+    
+    subscription = Subscription(
+        user_id=user_id,
+        status=status,
+        is_trial=is_trial,
+        end_date=end_date,
+        traffic_limit_gb=traffic_limit_gb,
+        traffic_used_gb=traffic_used_gb,
+        device_limit=device_limit,
+        connected_squads=connected_squads,
+        remnawave_short_uuid=remnawave_short_uuid,
+        subscription_url=subscription_url,
+        subscription_crypto_link=subscription_crypto_link,
+        autopay_enabled=(
+            settings.is_autopay_enabled_by_default()
+            if autopay_enabled is None
+            else autopay_enabled
+        ),
+        autopay_days_before=(
+            settings.DEFAULT_AUTOPAY_DAYS_BEFORE
+            if autopay_days_before is None
+            else autopay_days_before
+        ),
+    )
+    
+    db.add(subscription)
+    # Не коммитим сразу, оставляем для пакетной обработки
+    
+    logger.info(f"✅ Подготовлена подписка для пользователя {user_id} (ожидает коммита)")
+    return subscription
+
+
 async def create_subscription(
    db: AsyncSession,
    user_id: int,
@@ -966,7 +1414,9 @@ async def create_subscription(
    connected_squads: list = None,
    remnawave_short_uuid: str = None,
    subscription_url: str = "",
-    subscription_crypto_link: str = ""
+    subscription_crypto_link: str = "",
+    autopay_enabled: Optional[bool] = None,
+    autopay_days_before: Optional[int] = None,
 ) -> Subscription:
    
    if end_date is None:
@@ -986,7 +1436,17 @@ async def create_subscription(
        connected_squads=connected_squads,
        remnawave_short_uuid=remnawave_short_uuid,
        subscription_url=subscription_url,
-        subscription_crypto_link=subscription_crypto_link
+        subscription_crypto_link=subscription_crypto_link,
+        autopay_enabled=(
+            settings.is_autopay_enabled_by_default()
+            if autopay_enabled is None
+            else autopay_enabled
+        ),
+        autopay_days_before=(
+            settings.DEFAULT_AUTOPAY_DAYS_BEFORE
+            if autopay_days_before is None
+            else autopay_days_before
+        ),
    )
    
    db.add(subscription)
@@ -995,3 +1455,130 @@ async def create_subscription(
    
    logger.info(f"✅ Создана подписка для пользователя {user_id}")
    return subscription
+
+
+async def create_pending_subscription(
+    db: AsyncSession,
+    user_id: int,
+    duration_days: int,
+    traffic_limit_gb: int = 0,
+    device_limit: int = 1,
+    connected_squads: List[str] = None,
+    payment_method: str = "pending",
+    total_price_kopeks: int = 0
+) -> Subscription:
+    """Creates a pending subscription that will be activated after payment."""
+    
+    current_time = datetime.utcnow()
+    end_date = current_time + timedelta(days=duration_days)
+
+    existing_subscription = await get_subscription_by_user_id(db, user_id)
+
+    if existing_subscription:
+        if (
+            existing_subscription.status == SubscriptionStatus.ACTIVE.value
+            and existing_subscription.end_date > current_time
+        ):
+            logger.warning(
+                "⚠️ Попытка создать pending подписку для активного пользователя %s. Возвращаем существующую запись.",
+                user_id,
+            )
+            return existing_subscription
+
+        existing_subscription.status = SubscriptionStatus.PENDING.value
+        existing_subscription.is_trial = False
+        existing_subscription.start_date = current_time
+        existing_subscription.end_date = end_date
+        existing_subscription.traffic_limit_gb = traffic_limit_gb
+        existing_subscription.device_limit = device_limit
+        existing_subscription.connected_squads = connected_squads or []
+        existing_subscription.traffic_used_gb = 0.0
+        existing_subscription.updated_at = current_time
+
+        await db.commit()
+        await db.refresh(existing_subscription)
+
+        logger.info(
+            "♻️ Обновлена ожидающая подписка пользователя %s, ID: %s, метод оплаты: %s",
+            user_id,
+            existing_subscription.id,
+            payment_method,
+        )
+        return existing_subscription
+
+    subscription = Subscription(
+        user_id=user_id,
+        status=SubscriptionStatus.PENDING.value,
+        is_trial=False,
+        start_date=current_time,
+        end_date=end_date,
+        traffic_limit_gb=traffic_limit_gb,
+        device_limit=device_limit,
+        connected_squads=connected_squads or [],
+        autopay_enabled=settings.is_autopay_enabled_by_default(),
+        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
+    )
+    
+    db.add(subscription)
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(
+        "💳 Создана ожидающая подписка для пользователя %s, ID: %s, метод оплаты: %s",
+        user_id,
+        subscription.id,
+        payment_method,
+    )
+    
+    return subscription
+
+
+async def activate_pending_subscription(
+    db: AsyncSession,
+    user_id: int,
+    period_days: int = None
+) -> Optional[Subscription]:
+    """Активирует pending подписку пользователя, меняя её статус на ACTIVE."""
+    from sqlalchemy import and_
+    
+    logger.info(f"Активация pending подписки: пользователь {user_id}, период {period_days} дней")
+    
+    # Находим pending подписку пользователя
+    result = await db.execute(
+        select(Subscription)
+        .where(
+            and_(
+                Subscription.user_id == user_id,
+                Subscription.status == SubscriptionStatus.PENDING.value
+            )
+        )
+    )
+    pending_subscription = result.scalar_one_or_none()
+    
+    if not pending_subscription:
+        logger.warning(f"Не найдена pending подписка для пользователя {user_id}")
+        return None
+    
+    logger.info(f"Найдена pending подписка {pending_subscription.id} для пользователя {user_id}, статус: {pending_subscription.status}")
+    
+    # Обновляем статус подписки на ACTIVE
+    current_time = datetime.utcnow()
+    pending_subscription.status = SubscriptionStatus.ACTIVE.value
+    
+    # Если указан период, обновляем дату окончания
+    if period_days is not None:
+        effective_start = pending_subscription.start_date or current_time
+        if effective_start < current_time:
+            effective_start = current_time
+        pending_subscription.end_date = effective_start + timedelta(days=period_days)
+    
+    # Обновляем дату начала, если она не установлена или в прошлом
+    if not pending_subscription.start_date or pending_subscription.start_date < current_time:
+        pending_subscription.start_date = current_time
+    
+    await db.commit()
+    await db.refresh(pending_subscription)
+    
+    logger.info(f"Подписка пользователя {user_id} активирована, ID: {pending_subscription.id}")
+    
+    return pending_subscription
@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, Iterable, Optional, Tuple
+
+from sqlalchemy import and_, func, select
+from sqlalchemy.orm import selectinload
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import SubscriptionEvent
+
+
+async def create_subscription_event(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    event_type: str,
+    subscription_id: Optional[int] = None,
+    transaction_id: Optional[int] = None,
+    amount_kopeks: Optional[int] = None,
+    currency: Optional[str] = None,
+    message: Optional[str] = None,
+    occurred_at: Optional[datetime] = None,
+    extra: Optional[Dict[str, Any]] = None,
+) -> SubscriptionEvent:
+    event = SubscriptionEvent(
+        user_id=user_id,
+        event_type=event_type,
+        subscription_id=subscription_id,
+        transaction_id=transaction_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        message=message,
+        occurred_at=occurred_at or datetime.utcnow(),
+        extra=extra or None,
+    )
+    db.add(event)
+    await db.commit()
+    await db.refresh(event)
+    return event
+
+
+async def list_subscription_events(
+    db: AsyncSession,
+    *,
+    limit: int,
+    offset: int,
+    event_types: Optional[Iterable[str]] = None,
+    user_id: Optional[int] = None,
+) -> Tuple[list[SubscriptionEvent], int]:
+    base_query = select(SubscriptionEvent)
+    filters = []
+
+    if event_types:
+        filters.append(SubscriptionEvent.event_type.in_(set(event_types)))
+    if user_id:
+        filters.append(SubscriptionEvent.user_id == user_id)
+
+    if filters:
+        base_query = base_query.where(and_(*filters))
+
+    total_query = base_query.with_only_columns(func.count()).order_by(None)
+    total = await db.scalar(total_query) or 0
+
+    result = await db.execute(
+        base_query.options(selectinload(SubscriptionEvent.user))
+        .order_by(SubscriptionEvent.occurred_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+
+    return result.scalars().all(), int(total)
@@ -274,6 +274,30 @@ class TicketCRUD:
            db, ticket_id, TicketStatus.CLOSED.value, datetime.utcnow()
        )

+    @staticmethod
+    async def close_all_open_tickets(
+        db: AsyncSession,
+    ) -> List[int]:
+        """Закрыть все открытые тикеты. Возвращает список идентификаторов закрытых тикетов."""
+        open_statuses = [TicketStatus.OPEN.value, TicketStatus.ANSWERED.value]
+        result = await db.execute(
+            select(Ticket.id).where(Ticket.status.in_(open_statuses))
+        )
+        ticket_ids = result.scalars().all()
+
+        if not ticket_ids:
+            return []
+
+        now = datetime.utcnow()
+        await db.execute(
+            update(Ticket)
+            .where(Ticket.id.in_(ticket_ids))
+            .values(status=TicketStatus.CLOSED.value, closed_at=now, updated_at=now)
+        )
+        await db.commit()
+
+        return ticket_ids
+
    @staticmethod
    async def add_support_audit(
        db: AsyncSession,
@@ -309,18 +333,42 @@ class TicketCRUD:
        *,
        limit: int = 50,
        offset: int = 0,
+        action: Optional[str] = None,
    ) -> List[SupportAuditLog]:
        from sqlalchemy import select, desc
-        result = await db.execute(
-            select(SupportAuditLog).order_by(desc(SupportAuditLog.created_at)).offset(offset).limit(limit)
-        )
+
+        query = select(SupportAuditLog).order_by(desc(SupportAuditLog.created_at))
+
+        if action:
+            query = query.where(SupportAuditLog.action == action)
+
+        result = await db.execute(query.offset(offset).limit(limit))
        return result.scalars().all()

    @staticmethod
-    async def count_support_audit(db: AsyncSession) -> int:
+    async def count_support_audit(db: AsyncSession, action: Optional[str] = None) -> int:
        from sqlalchemy import select, func
-        result = await db.execute(select(func.count()).select_from(SupportAuditLog))
+
+        query = select(func.count()).select_from(SupportAuditLog)
+
+        if action:
+            query = query.where(SupportAuditLog.action == action)
+
+        result = await db.execute(query)
        return int(result.scalar() or 0)
+
+    @staticmethod
+    async def list_support_audit_actions(db: AsyncSession) -> List[str]:
+        from sqlalchemy import select
+
+        result = await db.execute(
+            select(SupportAuditLog.action)
+            .where(SupportAuditLog.action.isnot(None))
+            .distinct()
+            .order_by(SupportAuditLog.action)
+        )
+
+        return [row[0] for row in result.fetchall()]
    
    @staticmethod
    async def get_open_tickets_count(db: AsyncSession) -> int:
@@ -118,12 +118,7 @@ async def get_user_total_spent_kopeks(db: AsyncSession, user_id: int) -> int:
            and_(
                Transaction.user_id == user_id,
                Transaction.is_completed.is_(True),
-                Transaction.type.in_(
-                    [
-                        TransactionType.DEPOSIT.value,
-                        TransactionType.SUBSCRIPTION_PAYMENT.value,
-                    ]
-                ),
+                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
            )
        )
    )
@@ -2,14 +2,28 @@ import logging
 import secrets
 import string
 from datetime import datetime, timedelta
-from typing import Optional, List
-from sqlalchemy import select, and_, or_, func
+from typing import Optional, List, Dict
+from sqlalchemy import select, and_, or_, func, case, nullslast, text
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import selectinload
+from sqlalchemy.orm import selectinload, joinedload
+from sqlalchemy.exc import IntegrityError

-from app.database.models import User, UserStatus, Subscription, Transaction, PromoGroup
+from app.database.models import (
+    User,
+    UserStatus,
+    Subscription,
+    SubscriptionStatus,
+    Transaction,
+    PromoGroup,
+    UserPromoGroup,
+    PaymentMethod,
+    TransactionType,
+)
 from app.config import settings
 from app.database.crud.promo_group import get_default_promo_group
+from app.database.crud.discount_offer import get_latest_claimed_offer_for_user
+from app.database.crud.promo_offer_log import log_promo_offer_action
+from app.utils.validators import sanitize_telegram_name

 logger = logging.getLogger(__name__)

@@ -25,6 +39,8 @@ async def get_user_by_id(db: AsyncSession, user_id: int) -> Optional[User]:
        select(User)
        .options(
            selectinload(User.subscription),
+            selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
+            selectinload(User.referrer),
            selectinload(User.promo_group),
        )
        .where(User.id == user_id)
@@ -32,6 +48,7 @@ async def get_user_by_id(db: AsyncSession, user_id: int) -> Optional[User]:
    user = result.scalar_one_or_none()
    
    if user and user.subscription:
+        # Загружаем дополнительные зависимости для subscription
        _ = user.subscription.is_active
    
    return user
@@ -42,25 +59,64 @@ async def get_user_by_telegram_id(db: AsyncSession, telegram_id: int) -> Optiona
        select(User)
        .options(
            selectinload(User.subscription),
+            selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
+            selectinload(User.referrer),
            selectinload(User.promo_group),
        )
        .where(User.telegram_id == telegram_id)
    )
    user = result.scalar_one_or_none()
-    
+
    if user and user.subscription:
+        # Загружаем дополнительные зависимости для subscription
        _ = user.subscription.is_active
-    
+
+    return user
+
+
+async def get_user_by_username(db: AsyncSession, username: str) -> Optional[User]:
+    if not username:
+        return None
+
+    normalized = username.lower()
+
+    result = await db.execute(
+        select(User)
+        .options(
+            selectinload(User.subscription),
+            selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
+            selectinload(User.referrer),
+            selectinload(User.promo_group),
+        )
+        .where(func.lower(User.username) == normalized)
+    )
+
+    user = result.scalar_one_or_none()
+
+    if user and user.subscription:
+        # Загружаем дополнительные зависимости для subscription
+        _ = user.subscription.is_active
+
    return user


 async def get_user_by_referral_code(db: AsyncSession, referral_code: str) -> Optional[User]:
    result = await db.execute(
        select(User)
-        .options(selectinload(User.promo_group))
+        .options(
+            selectinload(User.subscription),
+            selectinload(User.promo_group),
+            selectinload(User.referrer),
+        )
        .where(User.referral_code == referral_code)
    )
-    return result.scalar_one_or_none()
+    user = result.scalar_one_or_none()
+    
+    if user and user.subscription:
+        # Загружаем дополнительные зависимости для subscription
+        _ = user.subscription.is_active
+    
+    return user


 async def create_unique_referral_code(db: AsyncSession) -> str:
@@ -76,6 +132,88 @@ async def create_unique_referral_code(db: AsyncSession) -> str:
    return f"ref{timestamp}"


+async def _sync_users_sequence(db: AsyncSession) -> None:
+    """Ensure the users.id sequence matches the current max ID."""
+    await db.execute(
+        text(
+            "SELECT setval('users_id_seq', "
+            "COALESCE((SELECT MAX(id) FROM users), 0) + 1, false)"
+        )
+    )
+    await db.commit()
+    logger.warning(
+        "🔄 Последовательность users_id_seq была синхронизирована с текущим максимумом id"
+    )
+
+
+async def _get_or_create_default_promo_group(db: AsyncSession) -> PromoGroup:
+    default_group = await get_default_promo_group(db)
+    if default_group:
+        return default_group
+
+    default_group = PromoGroup(
+        name="Базовый юзер",
+        server_discount_percent=0,
+        traffic_discount_percent=0,
+        device_discount_percent=0,
+        is_default=True,
+    )
+    db.add(default_group)
+    await db.flush()
+    return default_group
+
+
+async def create_user_no_commit(
+    db: AsyncSession,
+    telegram_id: int,
+    username: str = None,
+    first_name: str = None,
+    last_name: str = None,
+    language: str = "ru",
+    referred_by_id: int = None,
+    referral_code: str = None
+) -> User:
+    """
+    Создает пользователя без немедленного коммита для пакетной обработки
+    """
+    
+    if not referral_code:
+        referral_code = await create_unique_referral_code(db)
+    
+    default_group = await _get_or_create_default_promo_group(db)
+    promo_group_id = default_group.id
+
+    safe_first = sanitize_telegram_name(first_name)
+    safe_last = sanitize_telegram_name(last_name)
+    user = User(
+        telegram_id=telegram_id,
+        username=username,
+        first_name=safe_first,
+        last_name=safe_last,
+        language=language,
+        referred_by_id=referred_by_id,
+        referral_code=referral_code,
+        balance_kopeks=0,
+        has_had_paid_subscription=False,
+        has_made_first_topup=False,
+        promo_group_id=promo_group_id,
+    )
+
+    db.add(user)
+
+    # Обязательно выполняем flush, чтобы получить присвоенный первичный ключ
+    await db.flush()
+
+    # Сохраняем ссылку на группу, чтобы дальнейшие операции могли её использовать
+    user.promo_group = default_group
+
+    # Не коммитим сразу, оставляем для пакетной обработки
+    logger.info(
+        f"✅ Подготовлен пользователь {telegram_id} с реферальным кодом {referral_code} (ожидает коммита)"
+    )
+    return user
+
+
 async def create_user(
    db: AsyncSession,
    telegram_id: int,
@@ -90,44 +228,61 @@ async def create_user(
    if not referral_code:
        referral_code = await create_unique_referral_code(db)
    
-    default_group = await get_default_promo_group(db)
-    if not default_group:
-        default_group = PromoGroup(
-            name="Базовый юзер",
-            server_discount_percent=0,
-            traffic_discount_percent=0,
-            device_discount_percent=0,
-            is_default=True,
+    attempts = 3
+
+    for attempt in range(1, attempts + 1):
+        default_group = await _get_or_create_default_promo_group(db)
+        promo_group_id = default_group.id
+
+        safe_first = sanitize_telegram_name(first_name)
+        safe_last = sanitize_telegram_name(last_name)
+        user = User(
+            telegram_id=telegram_id,
+            username=username,
+            first_name=safe_first,
+            last_name=safe_last,
+            language=language,
+            referred_by_id=referred_by_id,
+            referral_code=referral_code,
+            balance_kopeks=0,
+            has_had_paid_subscription=False,
+            has_made_first_topup=False,
+            promo_group_id=promo_group_id,
        )
-        db.add(default_group)
-        await db.flush()

-    promo_group_id = default_group.id
+        db.add(user)

-    user = User(
-        telegram_id=telegram_id,
-        username=username,
-        first_name=first_name,
-        last_name=last_name,
-        language=language,
-        referred_by_id=referred_by_id,
-        referral_code=referral_code,
-        balance_kopeks=0,
-        has_had_paid_subscription=False,
-        has_made_first_topup=False,
-        promo_group_id=promo_group_id,
-    )
-    
-    db.add(user)
-    await db.commit()
-    await db.refresh(user)
-    
-    if default_group:
-        user.promo_group = default_group
+        try:
+            await db.commit()
+            await db.refresh(user)

-    logger.info(f"✅ Создан пользователь {telegram_id} с реферальным кодом {referral_code}")
+            user.promo_group = default_group
+            logger.info(
+                f"✅ Создан пользователь {telegram_id} с реферальным кодом {referral_code}"
+            )
+            return user

-    return user
+        except IntegrityError as exc:
+            await db.rollback()
+
+            if (
+                isinstance(getattr(exc, "orig", None), Exception)
+                and "users_pkey" in str(exc.orig)
+                and attempt < attempts
+            ):
+                logger.warning(
+                    "⚠️ Обнаружено несоответствие последовательности users_id_seq при создании пользователя %s. "
+                    "Выполняем повторную синхронизацию (попытка %s/%s)",
+                    telegram_id,
+                    attempt,
+                    attempts,
+                )
+                await _sync_users_sequence(db)
+                continue
+
+            raise
+
+    raise RuntimeError("Не удалось создать пользователя после синхронизации последовательности")


 async def update_user(
@@ -136,7 +291,10 @@ async def update_user(
    **kwargs
 ) -> User:
    
+    from app.utils.validators import sanitize_telegram_name
    for field, value in kwargs.items():
+        if field in ("first_name", "last_name"):
+            value = sanitize_telegram_name(value)
        if hasattr(user, field):
            setattr(user, field, value)
    
@@ -153,7 +311,8 @@ async def add_user_balance(
    amount_kopeks: int,
    description: str = "Пополнение баланса",
    create_transaction: bool = True,
-    bot = None 
+    transaction_type: TransactionType = TransactionType.DEPOSIT,
+    bot = None
 ) -> bool:
    try:
        old_balance = user.balance_kopeks
@@ -162,12 +321,11 @@ async def add_user_balance(
        
        if create_transaction:
            from app.database.crud.transaction import create_transaction as create_trans
-            from app.database.models import TransactionType
-            
+
            await create_trans(
                db=db,
                user_id=user.id,
-                type=TransactionType.DEPOSIT,
+                type=transaction_type,
                amount_kopeks=amount_kopeks,
                description=description
            )
@@ -187,9 +345,10 @@ async def add_user_balance(

 async def add_user_balance_by_id(
    db: AsyncSession,
-    telegram_id: int, 
+    telegram_id: int,
    amount_kopeks: int,
-    description: str = "Пополнение баланса"
+    description: str = "Пополнение баланса",
+    transaction_type: TransactionType = TransactionType.DEPOSIT,
 ) -> bool:
    try:
        user = await get_user_by_telegram_id(db, telegram_id)
@@ -197,7 +356,13 @@ async def add_user_balance_by_id(
            logger.error(f"Пользователь с telegram_id {telegram_id} не найден")
            return False
        
-        return await add_user_balance(db, user, amount_kopeks, description)
+        return await add_user_balance(
+            db,
+            user,
+            amount_kopeks,
+            description,
+            transaction_type=transaction_type,
+        )
        
    except Exception as e:
        logger.error(f"Ошибка пополнения баланса пользователя {telegram_id}: {e}")
@@ -205,29 +370,115 @@ async def add_user_balance_by_id(


 async def subtract_user_balance(
-    db: AsyncSession, 
-    user: User, 
-    amount_kopeks: int, 
-    description: str
+    db: AsyncSession,
+    user: User,
+    amount_kopeks: int,
+    description: str,
+    create_transaction: bool = False,
+    payment_method: Optional[PaymentMethod] = None,
+    *,
+    consume_promo_offer: bool = False,
 ) -> bool:
-    logger.error(f"💸 ОТЛАДКА subtract_user_balance:")
-    logger.error(f"   👤 User ID: {user.id} (TG: {user.telegram_id})")
-    logger.error(f"   💰 Баланс до списания: {user.balance_kopeks} копеек")
-    logger.error(f"   💸 Сумма к списанию: {amount_kopeks} копеек")
-    logger.error(f"   📝 Описание: {description}")
+    logger.info(f"💸 ОТЛАДКА subtract_user_balance:")
+    logger.info(f"   👤 User ID: {user.id} (TG: {user.telegram_id})")
+    logger.info(f"   💰 Баланс до списания: {user.balance_kopeks} копеек")
+    logger.info(f"   💸 Сумма к списанию: {amount_kopeks} копеек")
+    logger.info(f"   📝 Описание: {description}")
    
+    log_context: Optional[Dict[str, object]] = None
+    if consume_promo_offer:
+        try:
+            current_percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+        except (TypeError, ValueError):
+            current_percent = 0
+
+        if current_percent > 0:
+            source = getattr(user, "promo_offer_discount_source", None)
+            log_context = {
+                "offer_id": None,
+                "percent": current_percent,
+                "source": source,
+                "effect_type": None,
+                "details": {
+                    "reason": "manual_charge",
+                    "description": description,
+                    "amount_kopeks": amount_kopeks,
+                },
+            }
+            try:
+                offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+            except Exception as lookup_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to fetch latest claimed promo offer for user %s: %s",
+                    user.id,
+                    lookup_error,
+                )
+                offer = None
+
+            if offer:
+                log_context["offer_id"] = offer.id
+                log_context["effect_type"] = offer.effect_type
+                if not log_context["percent"] and offer.discount_percent:
+                    log_context["percent"] = offer.discount_percent
+
    if user.balance_kopeks < amount_kopeks:
        logger.error(f"   ❌ НЕДОСТАТОЧНО СРЕДСТВ!")
        return False
-    
+
    try:
        old_balance = user.balance_kopeks
        user.balance_kopeks -= amount_kopeks
+
+        if consume_promo_offer and getattr(user, "promo_offer_discount_percent", 0):
+            user.promo_offer_discount_percent = 0
+            user.promo_offer_discount_source = None
+            user.promo_offer_discount_expires_at = None
+
        user.updated_at = datetime.utcnow()
-        
+
        await db.commit()
        await db.refresh(user)
-        
+
+        if create_transaction:
+            from app.database.crud.transaction import (
+                create_transaction as create_trans,
+            )
+
+            await create_trans(
+                db=db,
+                user_id=user.id,
+                type=TransactionType.WITHDRAWAL,
+                amount_kopeks=amount_kopeks,
+                description=description,
+                payment_method=payment_method,
+            )
+
+        if consume_promo_offer and log_context:
+            try:
+                await log_promo_offer_action(
+                    db,
+                    user_id=user.id,
+                    offer_id=log_context.get("offer_id"),
+                    action="consumed",
+                    source=log_context.get("source"),
+                    percent=log_context.get("percent"),
+                    effect_type=log_context.get("effect_type"),
+                    details=log_context.get("details"),
+                )
+            except Exception as log_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to record promo offer consumption log for user %s: %s",
+                    user.id,
+                    log_error,
+                )
+                try:
+                    await db.rollback()
+                except Exception as rollback_error:  # pragma: no cover - defensive logging
+                    logger.warning(
+                        "Failed to rollback session after promo offer consumption log failure: %s",
+                        rollback_error,
+                    )
+
        logger.error(f"   ✅ Средства списаны: {old_balance} → {user.balance_kopeks}")
        return True
        
@@ -237,16 +488,115 @@ async def subtract_user_balance(
        return False


+async def cleanup_expired_promo_offer_discounts(db: AsyncSession) -> int:
+    now = datetime.utcnow()
+    result = await db.execute(
+        select(User).where(
+            User.promo_offer_discount_percent > 0,
+            User.promo_offer_discount_expires_at.isnot(None),
+            User.promo_offer_discount_expires_at <= now,
+        )
+    )
+    users = result.scalars().all()
+    if not users:
+        return 0
+
+    log_payloads: List[Dict[str, object]] = []
+
+    for user in users:
+        try:
+            percent = int(getattr(user, "promo_offer_discount_percent", 0) or 0)
+        except (TypeError, ValueError):
+            percent = 0
+
+        source = getattr(user, "promo_offer_discount_source", None)
+        offer_id = None
+        effect_type = None
+
+        if source:
+            try:
+                offer = await get_latest_claimed_offer_for_user(db, user.id, source)
+            except Exception as lookup_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to fetch latest claimed promo offer for user %s during expiration cleanup: %s",
+                    user.id,
+                    lookup_error,
+                )
+                offer = None
+
+            if offer:
+                offer_id = offer.id
+                effect_type = offer.effect_type
+                if not percent and offer.discount_percent:
+                    percent = offer.discount_percent
+
+        log_payloads.append(
+            {
+                "user_id": user.id,
+                "offer_id": offer_id,
+                "source": source,
+                "percent": percent,
+                "effect_type": effect_type,
+            }
+        )
+
+        user.promo_offer_discount_percent = 0
+        user.promo_offer_discount_source = None
+        user.promo_offer_discount_expires_at = None
+        user.updated_at = now
+
+    await db.commit()
+
+    for payload in log_payloads:
+        user_id = payload.get("user_id")
+        if not user_id:
+            continue
+        try:
+            await log_promo_offer_action(
+                db,
+                user_id=user_id,
+                offer_id=payload.get("offer_id"),
+                action="disabled",
+                source=payload.get("source"),
+                percent=payload.get("percent"),
+                effect_type=payload.get("effect_type"),
+                details={"reason": "offer_expired"},
+            )
+        except Exception as log_error:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to log promo offer expiration for user %s: %s",
+                user_id,
+                log_error,
+            )
+            try:
+                await db.rollback()
+            except Exception as rollback_error:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "Failed to rollback session after promo offer expiration log failure: %s",
+                    rollback_error,
+                )
+
+    return len(users)
+
+
 async def get_users_list(
    db: AsyncSession,
    offset: int = 0,
    limit: int = 50,
    search: Optional[str] = None,
    status: Optional[UserStatus] = None,
-    order_by_balance: bool = False
+    order_by_balance: bool = False,
+    order_by_traffic: bool = False,
+    order_by_last_activity: bool = False,
+    order_by_total_spent: bool = False,
+    order_by_purchase_count: bool = False
 ) -> List[User]:
    
-    query = select(User).options(selectinload(User.subscription))
+    query = select(User).options(
+        selectinload(User.subscription),
+        selectinload(User.promo_group),
+        selectinload(User.referrer),
+    )
    
    if status:
        query = query.where(User.status == status.value)
@@ -260,20 +610,96 @@ async def get_users_list(
        ]
        
        if search.isdigit():
-            conditions.append(User.telegram_id == int(search))
+            try:
+                search_int = int(search)
+                # Добавляем условие поиска по telegram_id, который является BigInteger
+                # и может содержать большие значения, в отличие от User.id (INTEGER)
+                conditions.append(User.telegram_id == search_int)
+            except ValueError:
+                # Если не удалось преобразовать в int, просто ищем по текстовым полям
+                pass
        
        query = query.where(or_(*conditions))
-    
-    # Сортировка по балансу в порядке убывания, если order_by_balance=True
-    if order_by_balance:
-        query = query.order_by(User.balance_kopeks.desc())
+
+    sort_flags = [
+        order_by_balance,
+        order_by_traffic,
+        order_by_last_activity,
+        order_by_total_spent,
+        order_by_purchase_count,
+    ]
+    if sum(int(flag) for flag in sort_flags) > 1:
+        logger.debug(
+            "Выбрано несколько сортировок пользователей — применяется приоритет: трафик > траты > покупки > баланс > активность"
+        )
+
+    transactions_stats = None
+    if order_by_total_spent or order_by_purchase_count:
+        from app.database.models import Transaction
+
+        transactions_stats = (
+            select(
+                Transaction.user_id.label("user_id"),
+                func.coalesce(
+                    func.sum(
+                        case(
+                            (
+                                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                                Transaction.amount_kopeks,
+                            ),
+                            else_=0,
+                        )
+                    ),
+                    0,
+                ).label("total_spent"),
+                func.coalesce(
+                    func.sum(
+                        case(
+                            (
+                                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                                1,
+                            ),
+                            else_=0,
+                        )
+                    ),
+                    0,
+                ).label("purchase_count"),
+            )
+            .where(Transaction.is_completed.is_(True))
+            .group_by(Transaction.user_id)
+            .subquery()
+        )
+        query = query.outerjoin(transactions_stats, transactions_stats.c.user_id == User.id)
+
+    if order_by_traffic:
+        traffic_sort = func.coalesce(Subscription.traffic_used_gb, 0.0)
+        query = query.outerjoin(Subscription, Subscription.user_id == User.id)
+        query = query.order_by(traffic_sort.desc(), User.created_at.desc())
+    elif order_by_total_spent:
+        order_column = func.coalesce(transactions_stats.c.total_spent, 0)
+        query = query.order_by(order_column.desc(), User.created_at.desc())
+    elif order_by_purchase_count:
+        order_column = func.coalesce(transactions_stats.c.purchase_count, 0)
+        query = query.order_by(order_column.desc(), User.created_at.desc())
+    elif order_by_balance:
+        query = query.order_by(User.balance_kopeks.desc(), User.created_at.desc())
+    elif order_by_last_activity:
+        query = query.order_by(nullslast(User.last_activity.desc()), User.created_at.desc())
    else:
        query = query.order_by(User.created_at.desc())
    
    query = query.offset(offset).limit(limit)
    
    result = await db.execute(query)
-    return result.scalars().all()
+    users = result.scalars().all()
+    
+    # Загружаем дополнительные зависимости для всех пользователей
+    for user in users:
+        if user and user.subscription:
+            # Загружаем дополнительные зависимости для subscription
+            _ = user.subscription.is_active
+    
+    return users


 async def get_users_count(
@@ -296,7 +722,14 @@ async def get_users_count(
        ]
        
        if search.isdigit():
-            conditions.append(User.telegram_id == int(search))
+            try:
+                search_int = int(search)
+                # Добавляем условие поиска по telegram_id, который является BigInteger
+                # и может содержать большие значения, в отличие от User.id (INTEGER)
+                conditions.append(User.telegram_id == search_int)
+            except ValueError:
+                # Если не удалось преобразовать в int, просто ищем по текстовым полям
+                pass
        
        query = query.where(or_(*conditions))
    
@@ -304,17 +737,148 @@ async def get_users_count(
    return result.scalar()


+async def get_users_spending_stats(
+    db: AsyncSession,
+    user_ids: List[int]
+) -> Dict[int, Dict[str, int]]:
+    if not user_ids:
+        return {}
+
+    from app.database.models import Transaction
+
+    stats_query = (
+        select(
+            Transaction.user_id,
+            func.coalesce(
+                func.sum(
+                    case(
+                        (
+                            Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                            Transaction.amount_kopeks,
+                        ),
+                        else_=0,
+                    )
+                ),
+                0,
+            ).label("total_spent"),
+            func.coalesce(
+                func.sum(
+                    case(
+                        (
+                            Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                            1,
+                        ),
+                        else_=0,
+                    )
+                ),
+                0,
+            ).label("purchase_count"),
+        )
+        .where(
+            Transaction.user_id.in_(user_ids),
+            Transaction.is_completed.is_(True),
+        )
+        .group_by(Transaction.user_id)
+    )
+
+    result = await db.execute(stats_query)
+    rows = result.all()
+
+    return {
+        row.user_id: {
+            "total_spent": int(row.total_spent or 0),
+            "purchase_count": int(row.purchase_count or 0),
+        }
+        for row in rows
+    }
+
+
 async def get_referrals(db: AsyncSession, user_id: int) -> List[User]:
    result = await db.execute(
        select(User)
        .options(
            selectinload(User.subscription),
+            selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
+            selectinload(User.referrer),
            selectinload(User.promo_group),
        )
        .where(User.referred_by_id == user_id)
        .order_by(User.created_at.desc())
    )
-    return result.scalars().all()
+    users = result.scalars().all()
+    
+    # Загружаем дополнительные зависимости для всех пользователей
+    for user in users:
+        if user and user.subscription:
+            # Загружаем дополнительные зависимости для subscription
+            _ = user.subscription.is_active
+    
+    return users
+
+
+async def get_users_for_promo_segment(db: AsyncSession, segment: str) -> List[User]:
+    now = datetime.utcnow()
+
+    base_query = (
+        select(User)
+        .options(
+            selectinload(User.subscription),
+            selectinload(User.promo_group),
+            selectinload(User.referrer),
+        )
+        .where(User.status == UserStatus.ACTIVE.value)
+    )
+
+    if segment == "no_subscription":
+        query = (
+            base_query.outerjoin(Subscription, Subscription.user_id == User.id)
+            .where(Subscription.id.is_(None))
+        )
+    else:
+        query = base_query.join(Subscription)
+
+        if segment == "paid_active":
+            query = query.where(
+                Subscription.is_trial == False,  # noqa: E712
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date > now,
+            )
+        elif segment == "paid_expired":
+            query = query.where(
+                Subscription.is_trial == False,  # noqa: E712
+                or_(
+                    Subscription.status == SubscriptionStatus.EXPIRED.value,
+                    Subscription.end_date <= now,
+                ),
+            )
+        elif segment == "trial_active":
+            query = query.where(
+                Subscription.is_trial == True,  # noqa: E712
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date > now,
+            )
+        elif segment == "trial_expired":
+            query = query.where(
+                Subscription.is_trial == True,  # noqa: E712
+                or_(
+                    Subscription.status == SubscriptionStatus.EXPIRED.value,
+                    Subscription.end_date <= now,
+                ),
+            )
+        else:
+            logger.warning("Неизвестный сегмент для промо: %s", segment)
+            return []
+
+    result = await db.execute(query.order_by(User.id))
+    users = result.scalars().unique().all()
+    
+    # Загружаем дополнительные зависимости для всех пользователей
+    for user in users:
+        if user and user.subscription:
+            # Загружаем дополнительные зависимости для subscription
+            _ = user.subscription.is_active
+    
+    return users


 async def get_inactive_users(db: AsyncSession, months: int = 3) -> List[User]:
@@ -324,6 +888,8 @@ async def get_inactive_users(db: AsyncSession, months: int = 3) -> List[User]:
        select(User)
        .options(
            selectinload(User.subscription),
+            selectinload(User.user_promo_groups).selectinload(UserPromoGroup.promo_group),
+            selectinload(User.referrer),
            selectinload(User.promo_group),
        )
        .where(
@@ -333,7 +899,15 @@ async def get_inactive_users(db: AsyncSession, months: int = 3) -> List[User]:
            )
        )
    )
-    return result.scalars().all()
+    users = result.scalars().all()
+    
+    # Загружаем дополнительные зависимости для всех пользователей
+    for user in users:
+        if user and user.subscription:
+            # Загружаем дополнительные зависимости для subscription
+            _ = user.subscription.is_active
+    
+    return users


 async def delete_user(db: AsyncSession, user: User) -> bool:
@@ -5,7 +5,8 @@ from typing import Optional, List
 from sqlalchemy import select, func, and_
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.database.models import UserMessage
+from app.database.models import User, UserMessage
+from app.utils.validators import sanitize_html, validate_html_tags

 logger = logging.getLogger(__name__)

@@ -13,15 +14,25 @@ logger = logging.getLogger(__name__)
 async def create_user_message(
    db: AsyncSession,
    message_text: str,
-    created_by: int,
+    created_by: Optional[int] = None,
    is_active: bool = True,
    sort_order: int = 0
 ) -> UserMessage:
+    is_valid, error_message = validate_html_tags(message_text)
+    if not is_valid:
+        raise ValueError(error_message)
+
+    resolved_creator = created_by
+
+    if created_by is not None:
+        result = await db.execute(select(User.id).where(User.id == created_by))
+        resolved_creator = result.scalar_one_or_none()
+
    message = UserMessage(
        message_text=message_text,
        is_active=is_active,
        sort_order=sort_order,
-        created_by=created_by
+        created_by=resolved_creator,
    )
    
    db.add(message)
@@ -55,25 +66,33 @@ async def get_random_active_message(db: AsyncSession) -> Optional[str]:
        return None
    
    random_message = random.choice(active_messages)
-    return random_message.message_text
+    return sanitize_html(random_message.message_text)


 async def get_all_user_messages(
    db: AsyncSession,
    offset: int = 0,
-    limit: int = 50
+    limit: int = 50,
+    include_inactive: bool = True,
 ) -> List[UserMessage]:
+    query = select(UserMessage).order_by(UserMessage.created_at.desc())
+    if not include_inactive:
+        query = query.where(UserMessage.is_active == True)
+
    result = await db.execute(
-        select(UserMessage)
-        .order_by(UserMessage.created_at.desc())
+        query
        .offset(offset)
        .limit(limit)
    )
    return result.scalars().all()


-async def get_user_messages_count(db: AsyncSession) -> int:
-    result = await db.execute(select(func.count(UserMessage.id)))
+async def get_user_messages_count(db: AsyncSession, include_inactive: bool = True) -> int:
+    query = select(func.count(UserMessage.id))
+    if not include_inactive:
+        query = query.where(UserMessage.is_active == True)
+
+    result = await db.execute(query)
    return result.scalar()


@@ -88,8 +107,11 @@ async def update_user_message(
    
    if not message:
        return None
-    
+
    if message_text is not None:
+        is_valid, error_message = validate_html_tags(message_text)
+        if not is_valid:
+            raise ValueError(error_message)
        message.message_text = message_text
    
    if is_active is not None:
@@ -0,0 +1,311 @@
+"""CRUD операции для связи пользователей с промогруппами (Many-to-Many)."""
+import logging
+from datetime import datetime
+from typing import List, Optional
+
+from sqlalchemy import select, and_, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import UserPromoGroup, PromoGroup, User
+
+logger = logging.getLogger(__name__)
+
+
+async def _sync_user_primary_promo_group(
+    db: AsyncSession,
+    user_id: int,
+) -> None:
+    """Синхронизирует колонку users.promo_group_id с primary промогруппой."""
+
+    try:
+        result = await db.execute(
+            select(UserPromoGroup.promo_group_id)
+            .join(PromoGroup, UserPromoGroup.promo_group_id == PromoGroup.id)
+            .where(UserPromoGroup.user_id == user_id)
+            .order_by(desc(PromoGroup.priority), PromoGroup.id)
+        )
+
+        first = result.first()
+        new_primary_id = first[0] if first else None
+
+        user = await db.get(User, user_id)
+        if not user:
+            return
+
+        if user.promo_group_id != new_primary_id:
+            user.promo_group_id = new_primary_id
+            user.updated_at = datetime.utcnow()
+
+    except Exception as error:
+        logger.error(
+            "Ошибка синхронизации primary промогруппы пользователя %s: %s",
+            user_id,
+            error,
+        )
+
+
+async def sync_user_primary_promo_group(
+    db: AsyncSession,
+    user_id: int,
+) -> None:
+    """Публичная обертка для синхронизации primary промогруппы пользователя."""
+
+    await _sync_user_primary_promo_group(db, user_id)
+
+
+async def add_user_to_promo_group(
+    db: AsyncSession,
+    user_id: int,
+    promo_group_id: int,
+    assigned_by: str = "admin"
+) -> Optional[UserPromoGroup]:
+    """
+    Добавляет пользователю промогруппу.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+        promo_group_id: ID промогруппы
+        assigned_by: Кто назначил ('admin', 'system', 'auto', 'promocode')
+
+    Returns:
+        UserPromoGroup или None если уже существует
+    """
+    try:
+        # Проверяем существование связи
+        existing = await has_user_promo_group(db, user_id, promo_group_id)
+        if existing:
+            logger.info(f"Пользователь {user_id} уже имеет промогруппу {promo_group_id}")
+            return None
+
+        # Создаем новую связь
+        user_promo_group = UserPromoGroup(
+            user_id=user_id,
+            promo_group_id=promo_group_id,
+            assigned_by=assigned_by,
+        )
+        db.add(user_promo_group)
+        await db.flush()
+
+        await _sync_user_primary_promo_group(db, user_id)
+
+        await db.commit()
+        await db.refresh(user_promo_group)
+
+        logger.info(f"Пользователю {user_id} добавлена промогруппа {promo_group_id} ({assigned_by})")
+        return user_promo_group
+
+    except Exception as error:
+        logger.error(f"Ошибка добавления промогруппы пользователю: {error}")
+        await db.rollback()
+        return None
+
+
+async def remove_user_from_promo_group(
+    db: AsyncSession,
+    user_id: int,
+    promo_group_id: int
+) -> bool:
+    """
+    Удаляет промогруппу у пользователя.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+        promo_group_id: ID промогруппы
+
+    Returns:
+        True если удалено, False если связи не было
+    """
+    try:
+        result = await db.execute(
+            select(UserPromoGroup).where(
+                and_(
+                    UserPromoGroup.user_id == user_id,
+                    UserPromoGroup.promo_group_id == promo_group_id
+                )
+            )
+        )
+        user_promo_group = result.scalar_one_or_none()
+
+        if not user_promo_group:
+            logger.warning(f"Связь пользователя {user_id} с промогруппой {promo_group_id} не найдена")
+            return False
+
+        await db.delete(user_promo_group)
+        await db.flush()
+
+        await _sync_user_primary_promo_group(db, user_id)
+
+        await db.commit()
+
+        logger.info(f"У пользователя {user_id} удалена промогруппа {promo_group_id}")
+        return True
+
+    except Exception as error:
+        logger.error(f"Ошибка удаления промогруппы у пользователя: {error}")
+        await db.rollback()
+        return False
+
+
+async def get_user_promo_groups(
+    db: AsyncSession,
+    user_id: int
+) -> List[UserPromoGroup]:
+    """
+    Получает все промогруппы пользователя, отсортированные по приоритету.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+
+    Returns:
+        Список UserPromoGroup с загруженными PromoGroup, отсортированный по приоритету DESC
+    """
+    try:
+        result = await db.execute(
+            select(UserPromoGroup)
+            .options(selectinload(UserPromoGroup.promo_group))
+            .where(UserPromoGroup.user_id == user_id)
+            .join(PromoGroup, UserPromoGroup.promo_group_id == PromoGroup.id)
+            .order_by(desc(PromoGroup.priority), PromoGroup.id)
+        )
+        return list(result.scalars().all())
+
+    except Exception as error:
+        logger.error(f"Ошибка получения промогрупп пользователя {user_id}: {error}")
+        return []
+
+
+async def get_primary_user_promo_group(
+    db: AsyncSession,
+    user_id: int
+) -> Optional[PromoGroup]:
+    """
+    Получает промогруппу пользователя с максимальным приоритетом.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+
+    Returns:
+        PromoGroup с максимальным приоритетом или None
+    """
+    try:
+        user_promo_groups = await get_user_promo_groups(db, user_id)
+
+        if not user_promo_groups:
+            return None
+
+        # Первая в списке имеет максимальный приоритет (список уже отсортирован)
+        return user_promo_groups[0].promo_group if user_promo_groups[0].promo_group else None
+
+    except Exception as error:
+        logger.error(f"Ошибка получения primary промогруппы пользователя {user_id}: {error}")
+        return None
+
+
+async def has_user_promo_group(
+    db: AsyncSession,
+    user_id: int,
+    promo_group_id: int
+) -> bool:
+    """
+    Проверяет наличие промогруппы у пользователя.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+        promo_group_id: ID промогруппы
+
+    Returns:
+        True если пользователь уже имеет эту промогруппу
+    """
+    try:
+        result = await db.execute(
+            select(UserPromoGroup).where(
+                and_(
+                    UserPromoGroup.user_id == user_id,
+                    UserPromoGroup.promo_group_id == promo_group_id
+                )
+            )
+        )
+        return result.scalar_one_or_none() is not None
+
+    except Exception as error:
+        logger.error(f"Ошибка проверки промогруппы пользователя: {error}")
+        return False
+
+
+async def count_user_promo_groups(
+    db: AsyncSession,
+    user_id: int
+) -> int:
+    """
+    Подсчитывает количество промогрупп у пользователя.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+
+    Returns:
+        Количество промогрупп
+    """
+    try:
+        result = await db.execute(
+            select(UserPromoGroup).where(UserPromoGroup.user_id == user_id)
+        )
+        return len(list(result.scalars().all()))
+
+    except Exception as error:
+        logger.error(f"Ошибка подсчета промогрупп пользователя: {error}")
+        return 0
+
+
+async def replace_user_promo_groups(
+    db: AsyncSession,
+    user_id: int,
+    promo_group_ids: List[int],
+    assigned_by: str = "admin"
+) -> bool:
+    """
+    Заменяет все промогруппы пользователя на новый список.
+
+    Args:
+        db: Сессия БД
+        user_id: ID пользователя
+        promo_group_ids: Список ID промогрупп
+        assigned_by: Кто назначил
+
+    Returns:
+        True если успешно
+    """
+    try:
+        # Удаляем все текущие промогруппы
+        await db.execute(
+            select(UserPromoGroup).where(UserPromoGroup.user_id == user_id)
+        )
+        result = await db.execute(
+            select(UserPromoGroup).where(UserPromoGroup.user_id == user_id)
+        )
+        for upg in result.scalars().all():
+            await db.delete(upg)
+
+        # Добавляем новые
+        for promo_group_id in promo_group_ids:
+            user_promo_group = UserPromoGroup(
+                user_id=user_id,
+                promo_group_id=promo_group_id,
+                assigned_by=assigned_by
+            )
+            db.add(user_promo_group)
+
+        await db.commit()
+        logger.info(f"Промогруппы пользователя {user_id} заменены на {promo_group_ids}")
+        return True
+
+    except Exception as error:
+        logger.error(f"Ошибка замены промогрупп пользователя: {error}")
+        await db.rollback()
+        return False
@@ -0,0 +1,168 @@
+"""CRUD helpers for WATA payment records."""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import WataPayment
+
+logger = logging.getLogger(__name__)
+
+
+async def create_wata_payment(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    payment_link_id: str,
+    amount_kopeks: int,
+    currency: str,
+    description: Optional[str],
+    status: str,
+    type_: Optional[str],
+    url: Optional[str],
+    order_id: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    expires_at: Optional[datetime] = None,
+    terminal_public_id: Optional[str] = None,
+    success_redirect_url: Optional[str] = None,
+    fail_redirect_url: Optional[str] = None,
+) -> WataPayment:
+    payment = WataPayment(
+        user_id=user_id,
+        payment_link_id=payment_link_id,
+        order_id=order_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        description=description,
+        status=status,
+        type=type_,
+        url=url,
+        metadata_json=metadata or {},
+        expires_at=expires_at,
+        terminal_public_id=terminal_public_id,
+        success_redirect_url=success_redirect_url,
+        fail_redirect_url=fail_redirect_url,
+    )
+
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Создан Wata платеж #%s для пользователя %s: %s копеек (статус %s)",
+        payment.id,
+        user_id,
+        amount_kopeks,
+        status,
+    )
+
+    return payment
+
+
+async def get_wata_payment_by_id(
+    db: AsyncSession,
+    payment_id: int,
+) -> Optional[WataPayment]:
+    result = await db.execute(
+        select(WataPayment).where(WataPayment.id == payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_wata_payment_by_link_id(
+    db: AsyncSession,
+    payment_link_id: str,
+) -> Optional[WataPayment]:
+    result = await db.execute(
+        select(WataPayment).where(WataPayment.payment_link_id == payment_link_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_wata_payment_by_order_id(
+    db: AsyncSession,
+    order_id: str,
+) -> Optional[WataPayment]:
+    result = await db.execute(
+        select(WataPayment).where(WataPayment.order_id == order_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_wata_payment_status(
+    db: AsyncSession,
+    payment: WataPayment,
+    *,
+    status: Optional[str] = None,
+    is_paid: Optional[bool] = None,
+    paid_at: Optional[datetime] = None,
+    last_status: Optional[str] = None,
+    url: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    callback_payload: Optional[Dict[str, Any]] = None,
+    terminal_public_id: Optional[str] = None,
+) -> WataPayment:
+    update_values: Dict[str, Any] = {}
+
+    if status is not None:
+        update_values["status"] = status
+    if is_paid is not None:
+        update_values["is_paid"] = is_paid
+    if paid_at is not None:
+        update_values["paid_at"] = paid_at
+    if last_status is not None:
+        update_values["last_status"] = last_status
+    if url is not None:
+        update_values["url"] = url
+    if metadata is not None:
+        update_values["metadata_json"] = metadata
+    if callback_payload is not None:
+        update_values["callback_payload"] = callback_payload
+    if terminal_public_id is not None:
+        update_values["terminal_public_id"] = terminal_public_id
+
+    if not update_values:
+        return payment
+
+    await db.execute(
+        update(WataPayment)
+        .where(WataPayment.id == payment.id)
+        .values(**update_values)
+    )
+
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Обновлен Wata платеж %s: статус=%s, is_paid=%s",
+        payment.payment_link_id,
+        payment.status,
+        payment.is_paid,
+    )
+
+    return payment
+
+
+async def link_wata_payment_to_transaction(
+    db: AsyncSession,
+    payment: WataPayment,
+    transaction_id: int,
+) -> WataPayment:
+    await db.execute(
+        update(WataPayment)
+        .where(WataPayment.id == payment.id)
+        .values(transaction_id=transaction_id)
+    )
+    await db.commit()
+    await db.refresh(payment)
+
+    logger.info(
+        "Wata платеж %s привязан к транзакции %s",
+        payment.payment_link_id,
+        transaction_id,
+    )
+
+    return payment
@@ -0,0 +1,106 @@
+"""CRUD операции для токенов административного веб-API."""
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, List, Optional
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import WebApiToken
+
+
+async def list_tokens(
+    db: AsyncSession,
+    *,
+    include_inactive: bool = False,
+) -> List[WebApiToken]:
+    query = select(WebApiToken)
+
+    if not include_inactive:
+        query = query.where(WebApiToken.is_active.is_(True))
+
+    query = query.order_by(WebApiToken.created_at.desc())
+
+    result = await db.execute(query)
+    return list(result.scalars().all())
+
+
+async def get_token_by_id(db: AsyncSession, token_id: int) -> Optional[WebApiToken]:
+    return await db.get(WebApiToken, token_id)
+
+
+async def get_token_by_hash(db: AsyncSession, token_hash: str) -> Optional[WebApiToken]:
+    query = select(WebApiToken).where(
+        WebApiToken.token_hash == token_hash
+    )
+    result = await db.execute(query)
+    return result.scalar_one_or_none()
+
+
+async def create_token(
+    db: AsyncSession,
+    *,
+    name: str,
+    token_hash: str,
+    token_prefix: str,
+    description: Optional[str] = None,
+    expires_at: Optional[datetime] = None,
+    created_by: Optional[str] = None,
+) -> WebApiToken:
+    token = WebApiToken(
+        name=name,
+        token_hash=token_hash,
+        token_prefix=token_prefix,
+        description=description,
+        expires_at=expires_at,
+        created_by=created_by,
+        is_active=True,
+    )
+
+    db.add(token)
+    await db.flush()
+    await db.refresh(token)
+    return token
+
+
+async def update_token(
+    db: AsyncSession,
+    token: WebApiToken,
+    **kwargs,
+) -> WebApiToken:
+    for key, value in kwargs.items():
+        if hasattr(token, key):
+            setattr(token, key, value)
+    token.updated_at = datetime.utcnow()
+    await db.flush()
+    await db.refresh(token)
+    return token
+
+
+async def set_tokens_active_status(
+    db: AsyncSession,
+    token_ids: Iterable[int],
+    *,
+    is_active: bool,
+) -> None:
+    await db.execute(
+        update(WebApiToken)
+        .where(WebApiToken.id.in_(list(token_ids)))
+        .values(is_active=is_active, updated_at=datetime.utcnow())
+    )
+
+
+async def delete_token(db: AsyncSession, token: WebApiToken) -> None:
+    await db.delete(token)
+
+
+__all__ = [
+    "list_tokens",
+    "get_token_by_id",
+    "get_token_by_hash",
+    "create_token",
+    "update_token",
+    "set_tokens_active_status",
+    "delete_token",
+]
@@ -1,10 +1,10 @@
 import logging
 from datetime import datetime
 from typing import Optional
-from sqlalchemy import select, update
+from sqlalchemy import select, update, func
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.database.models import WelcomeText
+from app.database.models import User, WelcomeText

 logger = logging.getLogger(__name__)

@@ -45,6 +45,37 @@ async def get_current_welcome_text_settings(db: AsyncSession) -> dict:
        'id': None
    }

+
+async def get_welcome_text_by_id(db: AsyncSession, welcome_text_id: int) -> Optional[WelcomeText]:
+    result = await db.execute(
+        select(WelcomeText).where(WelcomeText.id == welcome_text_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def list_welcome_texts(
+    db: AsyncSession,
+    *,
+    include_inactive: bool = True,
+    limit: int = 50,
+    offset: int = 0,
+):
+    query = select(WelcomeText).order_by(WelcomeText.updated_at.desc())
+    if not include_inactive:
+        query = query.where(WelcomeText.is_active == True)
+
+    result = await db.execute(query.limit(limit).offset(offset))
+    return result.scalars().all()
+
+
+async def count_welcome_texts(db: AsyncSession, *, include_inactive: bool = True) -> int:
+    query = select(func.count(WelcomeText.id))
+    if not include_inactive:
+        query = query.where(WelcomeText.is_active == True)
+
+    result = await db.execute(query)
+    return result.scalar()
+
 async def toggle_welcome_text_status(db: AsyncSession, admin_id: int) -> bool:
    try:
        result = await db.execute(
@@ -113,6 +144,87 @@ async def set_welcome_text(db: AsyncSession, text_content: str, admin_id: int) -
        await db.rollback()
        return False

+
+async def create_welcome_text(
+    db: AsyncSession,
+    *,
+    text_content: str,
+    created_by: Optional[int] = None,
+    is_enabled: bool = True,
+    is_active: bool = True,
+) -> WelcomeText:
+    resolved_creator = created_by
+
+    if created_by is not None:
+        result = await db.execute(select(User.id).where(User.id == created_by))
+        resolved_creator = result.scalar_one_or_none()
+
+    if is_active:
+        await db.execute(update(WelcomeText).values(is_active=False))
+
+    welcome_text = WelcomeText(
+        text_content=text_content,
+        is_active=is_active,
+        is_enabled=is_enabled,
+        created_by=resolved_creator,
+    )
+
+    db.add(welcome_text)
+    await db.commit()
+    await db.refresh(welcome_text)
+
+    logger.info(
+        "✅ Создан приветственный текст ID %s (активный=%s, включен=%s)",
+        welcome_text.id,
+        welcome_text.is_active,
+        welcome_text.is_enabled,
+    )
+    return welcome_text
+
+
+async def update_welcome_text(
+    db: AsyncSession,
+    welcome_text: WelcomeText,
+    *,
+    text_content: Optional[str] = None,
+    is_enabled: Optional[bool] = None,
+    is_active: Optional[bool] = None,
+) -> WelcomeText:
+    if is_active:
+        await db.execute(
+            update(WelcomeText)
+            .where(WelcomeText.id != welcome_text.id)
+            .values(is_active=False)
+        )
+
+    if text_content is not None:
+        welcome_text.text_content = text_content
+
+    if is_enabled is not None:
+        welcome_text.is_enabled = is_enabled
+
+    if is_active is not None:
+        welcome_text.is_active = is_active
+
+    welcome_text.updated_at = datetime.utcnow()
+
+    await db.commit()
+    await db.refresh(welcome_text)
+
+    logger.info(
+        "📝 Обновлен приветственный текст ID %s (активный=%s, включен=%s)",
+        welcome_text.id,
+        welcome_text.is_active,
+        welcome_text.is_enabled,
+    )
+    return welcome_text
+
+
+async def delete_welcome_text(db: AsyncSession, welcome_text: WelcomeText) -> None:
+    await db.delete(welcome_text)
+    await db.commit()
+    logger.info("🗑️ Удален приветственный текст ID %s", welcome_text.id)
+
 async def get_current_welcome_text_or_default() -> str:
    return (
        f"Привет, {{user_name}}! 🎁 3 дней VPN бесплатно! "
@@ -1,31 +1,167 @@
 import logging
-from typing import AsyncGenerator
-
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
-from sqlalchemy.pool import NullPool
-
+from typing import AsyncGenerator, Optional
+from contextlib import asynccontextmanager
+from sqlalchemy.ext.asyncio import (
+    AsyncSession, 
+    create_async_engine, 
+    async_sessionmaker,
+    AsyncEngine
+)
+from sqlalchemy.pool import NullPool, AsyncAdaptedQueuePool
+from sqlalchemy import event, text, bindparam, inspect
+from sqlalchemy.engine import Engine
+import time
 from app.config import settings
 from app.database.models import Base

 logger = logging.getLogger(__name__)

+# ============================================================================
+# PRODUCTION-GRADE CONNECTION POOLING
+# ============================================================================
+
+if settings.get_database_url().startswith("sqlite"):
+    poolclass = NullPool
+    pool_kwargs = {}
+else:
+    poolclass = AsyncAdaptedQueuePool
+    pool_kwargs = {
+        "pool_size": 20,
+        "max_overflow": 30,
+        "pool_timeout": 30,
+        "pool_recycle": 3600,
+        "pool_pre_ping": True,
+        # 🔥 Агрессивная очистка мертвых соединений
+        "pool_reset_on_return": "rollback",
+    }
+
+# ============================================================================
+# ENGINE WITH ADVANCED OPTIMIZATIONS
+# ============================================================================
+
 engine = create_async_engine(
-    settings.DATABASE_URL,
-    poolclass=NullPool,
+    settings.get_database_url(),
+    poolclass=poolclass,
    echo=settings.DEBUG,
-    future=True
+    future=True,
+    **pool_kwargs,
+    
+    connect_args={
+        "server_settings": {
+            "application_name": "remnawave_bot",
+            "jit": "on",
+            "statement_timeout": "60000",  # 60 секунд
+            "idle_in_transaction_session_timeout": "300000",  # 5 минут
+        },
+        "command_timeout": 60,
+        "timeout": 10,
+    } if not settings.get_database_url().startswith("sqlite") else {},
+    
+    execution_options={
+        "isolation_level": "READ COMMITTED",  # Оптимальный для большинства случаев
+        "compiled_cache_size": 500,  # Кеш скомпилированных запросов
+    }
 )

+# ============================================================================
+# SESSION FACTORY WITH OPTIMIZATIONS
+# ============================================================================
+
 AsyncSessionLocal = async_sessionmaker(
    bind=engine,
    class_=AsyncSession,
    expire_on_commit=False,
-    autoflush=True,
-    autocommit=False
+    autoflush=False,  # 🔥 Критично для производительности
+    autocommit=False,
 )

+# ============================================================================
+# QUERY PERFORMANCE MONITORING
+# ============================================================================
+
+if settings.DEBUG:
+    @event.listens_for(Engine, "before_cursor_execute")
+    def before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        conn.info.setdefault("query_start_time", []).append(time.time())
+        logger.debug(f"🔍 Executing query: {statement[:100]}...")
+
+    @event.listens_for(Engine, "after_cursor_execute")
+    def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        total = time.time() - conn.info["query_start_time"].pop(-1)
+        if total > 0.1:  # Логируем медленные запросы > 100ms
+            logger.warning(f"🐌 Slow query ({total:.3f}s): {statement[:100]}...")
+        else:
+            logger.debug(f"⚡ Query executed in {total:.3f}s")
+
+# ============================================================================
+# ADVANCED SESSION MANAGER WITH READ REPLICAS
+# ============================================================================
+
+class DatabaseManager:
+    """Продвинутый менеджер БД с поддержкой реплик и кеширования"""
+    
+    def __init__(self):
+        self.engine = engine
+        self.read_replica_engine: Optional[AsyncEngine] = None
+        
+        if hasattr(settings, 'DATABASE_READ_REPLICA_URL') and settings.DATABASE_READ_REPLICA_URL:
+            self.read_replica_engine = create_async_engine(
+                settings.DATABASE_READ_REPLICA_URL,
+                poolclass=poolclass,
+                pool_size=30,  # Больше для read операций
+                max_overflow=50,
+                pool_pre_ping=True,
+                echo=False,
+            )
+    
+    @asynccontextmanager
+    async def session(self, read_only: bool = False):
+        target_engine = self.read_replica_engine if (read_only and self.read_replica_engine) else self.engine
+        
+        async_session = async_sessionmaker(
+            bind=target_engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autoflush=False,
+        )
+        
+        async with async_session() as session:
+            try:
+                yield session
+                if not read_only:
+                    await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+    
+    async def health_check(self) -> dict:
+        pool = self.engine.pool
+
+        try:
+            async with AsyncSessionLocal() as session:
+                start = time.time()
+                await session.execute(text("SELECT 1"))
+                latency = (time.time() - start) * 1000
+            status = "healthy"
+        except Exception as e:
+            logger.error(f"❌ Database health check failed: {e}")
+            status = "unhealthy"
+            latency = None
+
+        return {
+            "status": status,
+            "latency_ms": round(latency, 2) if latency else None,
+            "pool": _collect_health_pool_metrics(pool),
+        }
+
+db_manager = DatabaseManager()
+
+# ============================================================================
+# SESSION DEPENDENCY FOR FASTAPI/AIOGRAM
+# ============================================================================

 async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Стандартная dependency для FastAPI"""
    async with AsyncSessionLocal() as session:
        try:
            yield session
@@ -33,19 +169,229 @@ async def get_db() -> AsyncGenerator[AsyncSession, None]:
        except Exception:
            await session.rollback()
            raise
-        finally:
-            await session.close()

+async def get_db_read_only() -> AsyncGenerator[AsyncSession, None]:
+    """Read-only dependency для тяжелых SELECT запросов"""
+    async with db_manager.session(read_only=True) as session:
+        yield session
+
+# ============================================================================
+# BATCH OPERATIONS FOR PERFORMANCE
+# ============================================================================
+
+class BatchOperations:
+    """Утилиты для массовых операций"""
+    
+    @staticmethod
+    async def bulk_insert(session: AsyncSession, model, data: list[dict], chunk_size: int = 1000):
+        """Массовая вставка с чанками"""
+        for i in range(0, len(data), chunk_size):
+            chunk = data[i:i + chunk_size]
+            session.add_all([model(**item) for item in chunk])
+            await session.flush()
+        await session.commit()
+    
+    @staticmethod
+    async def bulk_update(session: AsyncSession, model, data: list[dict], chunk_size: int = 1000):
+        """Массовое обновление с чанками"""
+        if not data:
+            return
+
+        primary_keys = [column.name for column in model.__table__.primary_key.columns]
+        if not primary_keys:
+            raise ValueError("Model must have a primary key for bulk_update")
+
+        updatable_columns = [
+            column.name
+            for column in model.__table__.columns
+            if column.name not in primary_keys
+        ]
+
+        if not updatable_columns:
+            raise ValueError("No columns available for update in bulk_update")
+
+        stmt = (
+            model.__table__.update()
+            .where(
+                *[
+                    getattr(model.__table__.c, pk) == bindparam(pk)
+                    for pk in primary_keys
+                ]
+            )
+            .values(
+                **{
+                    column: bindparam(column, required=False)
+                    for column in updatable_columns
+                }
+            )
+        )
+
+        for i in range(0, len(data), chunk_size):
+            chunk = data[i:i + chunk_size]
+            filtered_chunk = []
+            for item in chunk:
+                missing_keys = [pk for pk in primary_keys if pk not in item]
+                if missing_keys:
+                    raise ValueError(
+                        f"Missing primary key values {missing_keys} for bulk_update"
+                    )
+
+                filtered_item = {
+                    key: value
+                    for key, value in item.items()
+                    if key in primary_keys or key in updatable_columns
+                }
+                filtered_chunk.append(filtered_item)
+
+            await session.execute(stmt, filtered_chunk)
+        await session.commit()
+
+batch_ops = BatchOperations()
+
+# ============================================================================
+# INITIALIZATION AND CLEANUP
+# ============================================================================

 async def init_db():
-    logger.info("Создание таблиц базы данных...")
+    """Инициализация БД с оптимизациями"""
+    logger.info("🚀 Создание таблиц базы данных...")
    
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
+
+    if not settings.get_database_url().startswith("sqlite"):
+        logger.info("📊 Создание индексов для оптимизации...")
+
+        async with engine.begin() as conn:
+            indexes = [
+                ("users", "CREATE INDEX IF NOT EXISTS idx_users_telegram_id ON users(telegram_id)"),
+                (
+                    "subscriptions",
+                    "CREATE INDEX IF NOT EXISTS idx_subscriptions_user_id ON subscriptions(user_id)",
+                ),
+                (
+                    "subscriptions",
+                    "CREATE INDEX IF NOT EXISTS idx_subscriptions_status ON subscriptions(status) WHERE status = 'active'",
+                ),
+                (
+                    "payments",
+                    "CREATE INDEX IF NOT EXISTS idx_payments_created_at ON payments(created_at DESC)",
+                ),
+            ]
+
+            for table_name, index_sql in indexes:
+                table_exists = await conn.run_sync(lambda sync_conn: inspect(sync_conn).has_table(table_name))
+
+                if not table_exists:
+                    logger.debug(
+                        "Пропускаем создание индекса %s: таблица %s отсутствует",
+                        index_sql,
+                        table_name,
+                    )
+                    continue
+
+                try:
+                    await conn.execute(text(index_sql))
+                except Exception as e:
+                    logger.debug("Index creation skipped for %s: %s", table_name, e)
    
    logger.info("✅ База данных успешно инициализирована")
-
+    
+    health = await db_manager.health_check()
+    logger.info(f"📊 Database health: {health}")

 async def close_db():
+    """Корректное закрытие всех соединений"""
+    logger.info("🔄 Закрытие соединений с БД...")
+    
    await engine.dispose()
-    logger.info("✅ Подключение к базе данных закрыто")
+    
+    if db_manager.read_replica_engine:
+        await db_manager.read_replica_engine.dispose()
+    
+    logger.info("✅ Все подключения к базе данных закрыты")
+
+# ============================================================================
+# CONNECTION POOL METRICS (для мониторинга)
+# ============================================================================
+
+def _pool_counters(pool):
+    """Return basic pool counters or ``None`` when unsupported."""
+
+    required_methods = ("size", "checkedin", "checkedout", "overflow")
+
+    for method_name in required_methods:
+        method = getattr(pool, method_name, None)
+        if method is None or not callable(method):
+            return None
+
+    size = pool.size()
+    checked_in = pool.checkedin()
+    checked_out = pool.checkedout()
+    overflow = pool.overflow()
+
+    total_connections = size + overflow
+
+    return {
+        "size": size,
+        "checked_in": checked_in,
+        "checked_out": checked_out,
+        "overflow": overflow,
+        "total_connections": total_connections,
+        "utilization_percent": (checked_out / total_connections * 100) if total_connections else 0.0,
+    }
+
+
+def _collect_health_pool_metrics(pool) -> dict:
+    counters = _pool_counters(pool)
+
+    if counters is None:
+        return {
+            "metrics_available": False,
+            "size": 0,
+            "checked_in": 0,
+            "checked_out": 0,
+            "overflow": 0,
+            "total_connections": 0,
+            "utilization": "0.0%",
+        }
+
+    return {
+        "metrics_available": True,
+        "size": counters["size"],
+        "checked_in": counters["checked_in"],
+        "checked_out": counters["checked_out"],
+        "overflow": counters["overflow"],
+        "total_connections": counters["total_connections"],
+        "utilization": f"{counters['utilization_percent']:.1f}%",
+    }
+
+
+async def get_pool_metrics() -> dict:
+    """Детальные метрики пула для Prometheus/Grafana"""
+    pool = engine.pool
+
+    counters = _pool_counters(pool)
+
+    if counters is None:
+        return {
+            "metrics_available": False,
+            "pool_size": 0,
+            "checked_in_connections": 0,
+            "checked_out_connections": 0,
+            "overflow_connections": 0,
+            "total_connections": 0,
+            "max_possible_connections": 0,
+            "pool_utilization_percent": 0.0,
+        }
+
+    return {
+        "metrics_available": True,
+        "pool_size": counters["size"],
+        "checked_in_connections": counters["checked_in"],
+        "checked_out_connections": counters["checked_out"],
+        "overflow_connections": counters["overflow"],
+        "total_connections": counters["total_connections"],
+        "max_possible_connections": counters["total_connections"] + (getattr(pool, "_max_overflow", 0) or 0),
+        "pool_utilization_percent": round(counters["utilization_percent"], 2),
+    }
@@ -1,5 +1,5 @@
 from datetime import datetime, timedelta
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Any
 from enum import Enum

 from sqlalchemy import (
@@ -54,20 +54,23 @@ class SubscriptionStatus(Enum):
    ACTIVE = "active"
    EXPIRED = "expired"
    DISABLED = "disabled"
+    PENDING = "pending"


 class TransactionType(Enum):
-    DEPOSIT = "deposit"  
-    WITHDRAWAL = "withdrawal"  
-    SUBSCRIPTION_PAYMENT = "subscription_payment"  
-    REFUND = "refund" 
-    REFERRAL_REWARD = "referral_reward"  
+    DEPOSIT = "deposit"
+    WITHDRAWAL = "withdrawal"
+    SUBSCRIPTION_PAYMENT = "subscription_payment"
+    REFUND = "refund"
+    REFERRAL_REWARD = "referral_reward"
+    POLL_REWARD = "poll_reward"


 class PromoCodeType(Enum):
-    BALANCE = "balance" 
-    SUBSCRIPTION_DAYS = "subscription_days"  
-    TRIAL_SUBSCRIPTION = "trial_subscription"  
+    BALANCE = "balance"
+    SUBSCRIPTION_DAYS = "subscription_days"
+    TRIAL_SUBSCRIPTION = "trial_subscription"
+    PROMO_GROUP = "promo_group"


 class PaymentMethod(Enum):
@@ -75,10 +78,24 @@ class PaymentMethod(Enum):
    TRIBUTE = "tribute"
    YOOKASSA = "yookassa"
    CRYPTOBOT = "cryptobot"
+    HELEKET = "heleket"
    MULENPAY = "mulenpay"
    PAL24 = "pal24"
+    WATA = "wata"
+    PLATEGA = "platega"
    MANUAL = "manual"

+
+class MainMenuButtonActionType(Enum):
+    URL = "url"
+    MINI_APP = "mini_app"
+
+
+class MainMenuButtonVisibility(Enum):
+    ALL = "all"
+    ADMINS = "admins"
+    SUBSCRIBERS = "subscribers"
+
 class YooKassaPayment(Base):
    __tablename__ = "yookassa_payments"
    
@@ -177,6 +194,72 @@ class CryptoBotPayment(Base):
        return f"<CryptoBotPayment(id={self.id}, invoice_id={self.invoice_id}, amount={self.amount} {self.asset}, status={self.status})>"


+class HeleketPayment(Base):
+    __tablename__ = "heleket_payments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    uuid = Column(String(255), unique=True, nullable=False, index=True)
+    order_id = Column(String(128), unique=True, nullable=False, index=True)
+
+    amount = Column(String(50), nullable=False)
+    currency = Column(String(10), nullable=False)
+    payer_amount = Column(String(50), nullable=True)
+    payer_currency = Column(String(10), nullable=True)
+    exchange_rate = Column(Float, nullable=True)
+    discount_percent = Column(Integer, nullable=True)
+
+    status = Column(String(50), nullable=False)
+    payment_url = Column(Text, nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+
+    paid_at = Column(DateTime, nullable=True)
+    expires_at = Column(DateTime, nullable=True)
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    user = relationship("User", backref="heleket_payments")
+    transaction = relationship("Transaction", backref="heleket_payment")
+
+    @property
+    def amount_float(self) -> float:
+        try:
+            return float(self.amount)
+        except (TypeError, ValueError):
+            return 0.0
+
+    @property
+    def amount_kopeks(self) -> int:
+        return int(round(self.amount_float * 100))
+
+    @property
+    def payer_amount_float(self) -> float:
+        try:
+            return float(self.payer_amount) if self.payer_amount is not None else 0.0
+        except (TypeError, ValueError):
+            return 0.0
+
+    @property
+    def is_paid(self) -> bool:
+        return self.status in {"paid", "paid_over"}
+
+    def __repr__(self):
+        return (
+            "<HeleketPayment(id={id}, uuid={uuid}, order_id={order_id}, amount={amount}"
+            " {currency}, status={status})>"
+        ).format(
+            id=self.id,
+            uuid=self.uuid,
+            order_id=self.order_id,
+            amount=self.amount,
+            currency=self.currency,
+            status=self.status,
+        )
+
+
 class MulenPayPayment(Base):
    __tablename__ = "mulenpay_payments"

@@ -282,11 +365,112 @@ class Pal24Payment(Base):
        )


+class WataPayment(Base):
+    __tablename__ = "wata_payments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    payment_link_id = Column(String(64), unique=True, nullable=False, index=True)
+    order_id = Column(String(255), nullable=True, index=True)
+    amount_kopeks = Column(Integer, nullable=False)
+    currency = Column(String(10), nullable=False, default="RUB")
+    description = Column(Text, nullable=True)
+    type = Column(String(50), nullable=True)
+
+    status = Column(String(50), nullable=False, default="Opened")
+    is_paid = Column(Boolean, default=False)
+    paid_at = Column(DateTime, nullable=True)
+    last_status = Column(String(50), nullable=True)
+    terminal_public_id = Column(String(64), nullable=True)
+
+    url = Column(Text, nullable=True)
+    success_redirect_url = Column(Text, nullable=True)
+    fail_redirect_url = Column(Text, nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+    callback_payload = Column(JSON, nullable=True)
+
+    expires_at = Column(DateTime, nullable=True)
+
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    user = relationship("User", backref="wata_payments")
+    transaction = relationship("Transaction", backref="wata_payment")
+
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return (
+            "<WataPayment(id={0}, link_id={1}, amount={2}₽, status={3})>".format(
+                self.id,
+                self.payment_link_id,
+                self.amount_rubles,
+                self.status,
+            )
+        )
+
+
+class PlategaPayment(Base):
+    __tablename__ = "platega_payments"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    platega_transaction_id = Column(String(255), unique=True, nullable=True, index=True)
+    correlation_id = Column(String(64), unique=True, nullable=False, index=True)
+    amount_kopeks = Column(Integer, nullable=False)
+    currency = Column(String(10), nullable=False, default="RUB")
+    description = Column(Text, nullable=True)
+
+    payment_method_code = Column(Integer, nullable=False)
+    status = Column(String(50), nullable=False, default="PENDING")
+    is_paid = Column(Boolean, default=False)
+    paid_at = Column(DateTime, nullable=True)
+
+    redirect_url = Column(Text, nullable=True)
+    return_url = Column(Text, nullable=True)
+    failed_url = Column(Text, nullable=True)
+    payload = Column(String(255), nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+    callback_payload = Column(JSON, nullable=True)
+
+    expires_at = Column(DateTime, nullable=True)
+
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    user = relationship("User", backref="platega_payments")
+    transaction = relationship("Transaction", backref="platega_payment")
+
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+    def __repr__(self) -> str:  # pragma: no cover - debug helper
+        return (
+            "<PlategaPayment(id={0}, transaction_id={1}, amount={2}₽, status={3}, method={4})>".format(
+                self.id,
+                self.platega_transaction_id,
+                self.amount_rubles,
+                self.status,
+                self.payment_method_code,
+            )
+        )
+
+
 class PromoGroup(Base):
    __tablename__ = "promo_groups"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(255), unique=True, nullable=False)
+    priority = Column(Integer, nullable=False, default=0, index=True)
    server_discount_percent = Column(Integer, nullable=False, default=0)
    traffic_discount_percent = Column(Integer, nullable=False, default=0)
    device_discount_percent = Column(Integer, nullable=False, default=0)
@@ -298,6 +482,7 @@ class PromoGroup(Base):
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())

    users = relationship("User", back_populates="promo_group")
+    user_promo_groups = relationship("UserPromoGroup", back_populates="promo_group", cascade="all, delete-orphan")
    server_squads = relationship(
        "ServerSquad",
        secondary=server_squad_promo_groups,
@@ -356,11 +541,31 @@ class PromoGroup(Base):
            "traffic": self.traffic_discount_percent,
            "devices": self.device_discount_percent,
        }
-        percent = mapping.get(category, 0)
+        percent = mapping.get(category) or 0
+
+        if percent == 0 and self.is_default:
+            base_period_discount = self._get_period_discount(period_days)
+            percent = max(percent, base_period_discount)

        return max(0, min(100, percent))


+class UserPromoGroup(Base):
+    """Таблица связи Many-to-Many между пользователями и промогруппами."""
+    __tablename__ = "user_promo_groups"
+
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
+    promo_group_id = Column(Integer, ForeignKey("promo_groups.id", ondelete="CASCADE"), primary_key=True)
+    assigned_at = Column(DateTime, default=func.now())
+    assigned_by = Column(String(50), default="system")
+
+    user = relationship("User", back_populates="user_promo_groups")
+    promo_group = relationship("PromoGroup", back_populates="user_promo_groups")
+
+    def __repr__(self):
+        return f"<UserPromoGroup(user_id={self.user_id}, promo_group_id={self.promo_group_id}, assigned_by='{self.assigned_by}')>"
+
+
 class User(Base):
    __tablename__ = "users"

@@ -386,30 +591,64 @@ class User(Base):
    transactions = relationship("Transaction", back_populates="user")
    referral_earnings = relationship("ReferralEarning", foreign_keys="ReferralEarning.user_id", back_populates="user")
    discount_offers = relationship("DiscountOffer", back_populates="user")
+    promo_offer_logs = relationship("PromoOfferLog", back_populates="user")
    lifetime_used_traffic_bytes = Column(BigInteger, default=0)
    auto_promo_group_assigned = Column(Boolean, nullable=False, default=False)
    auto_promo_group_threshold_kopeks = Column(BigInteger, nullable=False, default=0)
+    referral_commission_percent = Column(Integer, nullable=True)
+    promo_offer_discount_percent = Column(Integer, nullable=False, default=0)
+    promo_offer_discount_source = Column(String(100), nullable=True)
+    promo_offer_discount_expires_at = Column(DateTime, nullable=True)
    last_remnawave_sync = Column(DateTime, nullable=True)
    trojan_password = Column(String(255), nullable=True)
    vless_uuid = Column(String(255), nullable=True)
    ss_password = Column(String(255), nullable=True)
    has_made_first_topup: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
-    promo_group_id = Column(Integer, ForeignKey("promo_groups.id", ondelete="RESTRICT"), nullable=False, index=True)
+    promo_group_id = Column(Integer, ForeignKey("promo_groups.id", ondelete="RESTRICT"), nullable=True, index=True)
    promo_group = relationship("PromoGroup", back_populates="users")
-    
+    user_promo_groups = relationship("UserPromoGroup", back_populates="user", cascade="all, delete-orphan")
+    poll_responses = relationship("PollResponse", back_populates="user")
+
    @property
    def balance_rubles(self) -> float:
        return self.balance_kopeks / 100
-    
+
    @property
    def full_name(self) -> str:
        parts = [self.first_name, self.last_name]
        return " ".join(filter(None, parts)) or self.username or f"ID{self.telegram_id}"

+    def get_primary_promo_group(self):
+        """Возвращает промогруппу с максимальным приоритетом."""
+        if not self.user_promo_groups:
+            return getattr(self, "promo_group", None)
+
+        try:
+            # Сортируем по приоритету группы (убывание), затем по ID группы
+            # Используем getattr для защиты от ленивой загрузки
+            sorted_groups = sorted(
+                self.user_promo_groups,
+                key=lambda upg: (
+                    getattr(upg.promo_group, 'priority', 0) if upg.promo_group else 0,
+                    upg.promo_group_id
+                ),
+                reverse=True
+            )
+
+            if sorted_groups and sorted_groups[0].promo_group:
+                return sorted_groups[0].promo_group
+        except Exception:
+            # Если возникла ошибка (например, ленивая загрузка), fallback на старую связь
+            pass
+
+        # Fallback на старую связь если новая пустая или возникла ошибка
+        return getattr(self, "promo_group", None)
+
    def get_promo_discount(self, category: str, period_days: Optional[int] = None) -> int:
-        if not self.promo_group:
+        primary_group = self.get_primary_promo_group()
+        if not primary_group:
            return 0
-        return self.promo_group.get_discount_percent(category, period_days)
+        return primary_group.get_discount_percent(category, period_days)
    
    def add_balance(self, kopeks: int) -> None:
        self.balance_kopeks += kopeks
@@ -453,6 +692,7 @@ class Subscription(Base):

    user = relationship("User", back_populates="subscription")
    discount_offers = relationship("DiscountOffer", back_populates="subscription")
+    temporary_accesses = relationship("SubscriptionTemporaryAccess", back_populates="subscription")
    
    @property
    def is_active(self) -> bool:
@@ -571,8 +811,7 @@ class Subscription(Base):
        return 0.0
    
    def extend_subscription(self, days: int):
-        from datetime import timedelta, datetime
-    
+
        if self.end_date > datetime.utcnow():
            self.end_date = self.end_date + timedelta(days=days)
        else:
@@ -657,13 +896,15 @@ class PromoCode(Base):
    valid_until = Column(DateTime, nullable=True)
    
    is_active = Column(Boolean, default=True)
-    
+
    created_by = Column(Integer, ForeignKey("users.id"), nullable=True)
-    
+    promo_group_id = Column(Integer, ForeignKey("promo_groups.id", ondelete="SET NULL"), nullable=True, index=True)
+
    created_at = Column(DateTime, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
-    
+
    uses = relationship("PromoCodeUse", back_populates="promocode")
+    promo_group = relationship("PromoGroup")
    
    @property
    def is_valid(self) -> bool:
@@ -740,9 +981,9 @@ class Squad(Base):

 class ServiceRule(Base):
    __tablename__ = "service_rules"
-    
+
    id = Column(Integer, primary_key=True, index=True)
-    
+
    order = Column(Integer, default=0)
    title = Column(String(255), nullable=False)
    
@@ -756,9 +997,54 @@ class ServiceRule(Base):
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())


+class PrivacyPolicy(Base):
+    __tablename__ = "privacy_policies"
+
+    id = Column(Integer, primary_key=True, index=True)
+    language = Column(String(10), nullable=False, unique=True)
+    content = Column(Text, nullable=False)
+    is_enabled = Column(Boolean, default=True, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class PublicOffer(Base):
+    __tablename__ = "public_offers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    language = Column(String(10), nullable=False, unique=True)
+    content = Column(Text, nullable=False)
+    is_enabled = Column(Boolean, default=True, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class FaqSetting(Base):
+    __tablename__ = "faq_settings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    language = Column(String(10), nullable=False, unique=True)
+    is_enabled = Column(Boolean, default=True, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class FaqPage(Base):
+    __tablename__ = "faq_pages"
+
+    id = Column(Integer, primary_key=True, index=True)
+    language = Column(String(10), nullable=False, index=True)
+    title = Column(String(255), nullable=False)
+    content = Column(Text, nullable=False)
+    display_order = Column(Integer, default=0, nullable=False)
+    is_active = Column(Boolean, default=True, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
 class SystemSetting(Base):
    __tablename__ = "system_settings"
-    
+
    id = Column(Integer, primary_key=True, index=True)
    key = Column(String(255), unique=True, nullable=False)
    value = Column(Text, nullable=True)
@@ -797,6 +1083,30 @@ class SentNotification(Base):
    subscription = relationship("Subscription", backref="sent_notifications")


+class SubscriptionEvent(Base):
+    __tablename__ = "subscription_events"
+
+    id = Column(Integer, primary_key=True, index=True)
+    event_type = Column(String(50), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+    subscription_id = Column(
+        Integer, ForeignKey("subscriptions.id", ondelete="SET NULL"), nullable=True
+    )
+    transaction_id = Column(
+        Integer, ForeignKey("transactions.id", ondelete="SET NULL"), nullable=True
+    )
+    amount_kopeks = Column(Integer, nullable=True)
+    currency = Column(String(16), nullable=True)
+    message = Column(Text, nullable=True)
+    occurred_at = Column(DateTime, nullable=False, default=func.now())
+    extra = Column(JSON, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+    user = relationship("User", backref="subscription_events")
+    subscription = relationship("Subscription", backref="subscription_events")
+    transaction = relationship("Transaction", backref="subscription_events")
+
+
 class DiscountOffer(Base):
    __tablename__ = "discount_offers"
    __table_args__ = (
@@ -812,17 +1122,79 @@ class DiscountOffer(Base):
    expires_at = Column(DateTime, nullable=False)
    claimed_at = Column(DateTime, nullable=True)
    is_active = Column(Boolean, default=True, nullable=False)
+    effect_type = Column(String(50), nullable=False, default="percent_discount")
+    extra_data = Column(JSON, nullable=True)
    created_at = Column(DateTime, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())

    user = relationship("User", back_populates="discount_offers")
    subscription = relationship("Subscription", back_populates="discount_offers")
+    logs = relationship("PromoOfferLog", back_populates="offer")
+
+
+class PromoOfferTemplate(Base):
+    __tablename__ = "promo_offer_templates"
+    __table_args__ = (
+        Index("ix_promo_offer_templates_type", "offer_type"),
+    )
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False)
+    offer_type = Column(String(50), nullable=False)
+    message_text = Column(Text, nullable=False)
+    button_text = Column(String(255), nullable=False)
+    valid_hours = Column(Integer, nullable=False, default=24)
+    discount_percent = Column(Integer, nullable=False, default=0)
+    bonus_amount_kopeks = Column(Integer, nullable=False, default=0)
+    active_discount_hours = Column(Integer, nullable=True)
+    test_duration_hours = Column(Integer, nullable=True)
+    test_squad_uuids = Column(JSON, default=list)
+    is_active = Column(Boolean, default=True, nullable=False)
+    created_by = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    creator = relationship("User")
+
+
+class SubscriptionTemporaryAccess(Base):
+    __tablename__ = "subscription_temporary_access"
+
+    id = Column(Integer, primary_key=True, index=True)
+    subscription_id = Column(Integer, ForeignKey("subscriptions.id", ondelete="CASCADE"), nullable=False)
+    offer_id = Column(Integer, ForeignKey("discount_offers.id", ondelete="CASCADE"), nullable=False)
+    squad_uuid = Column(String(255), nullable=False)
+    expires_at = Column(DateTime, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    deactivated_at = Column(DateTime, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    was_already_connected = Column(Boolean, default=False, nullable=False)
+
+    subscription = relationship("Subscription", back_populates="temporary_accesses")
+    offer = relationship("DiscountOffer")
+
+
+class PromoOfferLog(Base):
+    __tablename__ = "promo_offer_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True, index=True)
+    offer_id = Column(Integer, ForeignKey("discount_offers.id", ondelete="SET NULL"), nullable=True, index=True)
+    action = Column(String(50), nullable=False)
+    source = Column(String(100), nullable=True)
+    percent = Column(Integer, nullable=True)
+    effect_type = Column(String(50), nullable=True)
+    details = Column(JSON, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+    user = relationship("User", back_populates="promo_offer_logs")
+    offer = relationship("DiscountOffer", back_populates="logs")

 class BroadcastHistory(Base):
    __tablename__ = "broadcast_history"
-    
+
    id = Column(Integer, primary_key=True, index=True)
-    target_type = Column(String(100), nullable=False)  
+    target_type = Column(String(100), nullable=False)
    message_text = Column(Text, nullable=False)  
    has_media = Column(Boolean, default=False)
    media_type = Column(String(20), nullable=True) 
@@ -838,6 +1210,106 @@ class BroadcastHistory(Base):
    completed_at = Column(DateTime(timezone=True), nullable=True)
    admin = relationship("User", back_populates="broadcasts")

+
+class Poll(Base):
+    __tablename__ = "polls"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(255), nullable=False)
+    description = Column(Text, nullable=True)
+    reward_enabled = Column(Boolean, nullable=False, default=False)
+    reward_amount_kopeks = Column(Integer, nullable=False, default=0)
+    created_by = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)
+
+    creator = relationship("User", backref="created_polls", foreign_keys=[created_by])
+    questions = relationship(
+        "PollQuestion",
+        back_populates="poll",
+        cascade="all, delete-orphan",
+        order_by="PollQuestion.order",
+    )
+    responses = relationship(
+        "PollResponse",
+        back_populates="poll",
+        cascade="all, delete-orphan",
+    )
+
+
+class PollQuestion(Base):
+    __tablename__ = "poll_questions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    poll_id = Column(Integer, ForeignKey("polls.id", ondelete="CASCADE"), nullable=False, index=True)
+    text = Column(Text, nullable=False)
+    order = Column(Integer, nullable=False, default=0)
+
+    poll = relationship("Poll", back_populates="questions")
+    options = relationship(
+        "PollOption",
+        back_populates="question",
+        cascade="all, delete-orphan",
+        order_by="PollOption.order",
+    )
+    answers = relationship("PollAnswer", back_populates="question")
+
+
+class PollOption(Base):
+    __tablename__ = "poll_options"
+
+    id = Column(Integer, primary_key=True, index=True)
+    question_id = Column(Integer, ForeignKey("poll_questions.id", ondelete="CASCADE"), nullable=False, index=True)
+    text = Column(Text, nullable=False)
+    order = Column(Integer, nullable=False, default=0)
+
+    question = relationship("PollQuestion", back_populates="options")
+    answers = relationship("PollAnswer", back_populates="option")
+
+
+class PollResponse(Base):
+    __tablename__ = "poll_responses"
+
+    id = Column(Integer, primary_key=True, index=True)
+    poll_id = Column(Integer, ForeignKey("polls.id", ondelete="CASCADE"), nullable=False, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    sent_at = Column(DateTime, default=func.now(), nullable=False)
+    started_at = Column(DateTime, nullable=True)
+    completed_at = Column(DateTime, nullable=True)
+    reward_given = Column(Boolean, nullable=False, default=False)
+    reward_amount_kopeks = Column(Integer, nullable=False, default=0)
+
+    poll = relationship("Poll", back_populates="responses")
+    user = relationship("User", back_populates="poll_responses")
+    answers = relationship(
+        "PollAnswer",
+        back_populates="response",
+        cascade="all, delete-orphan",
+    )
+
+    __table_args__ = (
+        UniqueConstraint("poll_id", "user_id", name="uq_poll_user"),
+    )
+
+
+class PollAnswer(Base):
+    __tablename__ = "poll_answers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    response_id = Column(Integer, ForeignKey("poll_responses.id", ondelete="CASCADE"), nullable=False, index=True)
+    question_id = Column(Integer, ForeignKey("poll_questions.id", ondelete="CASCADE"), nullable=False, index=True)
+    option_id = Column(Integer, ForeignKey("poll_options.id", ondelete="CASCADE"), nullable=False, index=True)
+    created_at = Column(DateTime, default=func.now(), nullable=False)
+
+    response = relationship("PollResponse", back_populates="answers")
+    question = relationship("PollQuestion", back_populates="answers")
+    option = relationship("PollOption", back_populates="answers")
+
+    __table_args__ = (
+        UniqueConstraint("response_id", "question_id", name="uq_poll_answer_unique"),
+    )
+
+
 class ServerSquad(Base):
    __tablename__ = "server_squads"

@@ -852,6 +1324,7 @@ class ServerSquad(Base):
    country_code = Column(String(5), nullable=True)
    
    is_available = Column(Boolean, default=True)
+    is_trial_eligible = Column(Boolean, default=False, nullable=False)
    
    price_kopeks = Column(Integer, default=0)
    
@@ -1091,7 +1564,7 @@ class Ticket(Base):

 class TicketMessage(Base):
    __tablename__ = "ticket_messages"
-    
+
    id = Column(Integer, primary_key=True, index=True)
    ticket_id = Column(Integer, ForeignKey("tickets.id", ondelete="CASCADE"), nullable=False)
    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
@@ -1118,6 +1591,65 @@ class TicketMessage(Base):
    @property
    def is_admin_message(self) -> bool:
        return self.is_from_admin
-    
+
    def __repr__(self):
-        return f"<TicketMessage(id={self.id}, ticket_id={self.ticket_id}, is_admin={self.is_from_admin}, text='{self.message_text[:30]}...')>"
+        return f"<TicketMessage(id={self.id}, ticket_id={self.ticket_id}, is_admin={self.is_from_admin}, text='{self.message_text[:30]}...')>"
+
+
+class WebApiToken(Base):
+    __tablename__ = "web_api_tokens"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False)
+    token_hash = Column(String(128), nullable=False, unique=True, index=True)
+    token_prefix = Column(String(32), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    expires_at = Column(DateTime, nullable=True)
+    last_used_at = Column(DateTime, nullable=True)
+    last_used_ip = Column(String(64), nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    created_by = Column(String(255), nullable=True)
+
+    def __repr__(self) -> str:
+        status = "active" if self.is_active else "revoked"
+        return f"<WebApiToken id={self.id} name='{self.name}' status={status}>"
+
+
+class MainMenuButton(Base):
+    __tablename__ = "main_menu_buttons"
+
+    id = Column(Integer, primary_key=True, index=True)
+    text = Column(String(64), nullable=False)
+    action_type = Column(String(20), nullable=False)
+    action_value = Column(Text, nullable=False)
+    visibility = Column(String(20), nullable=False, default=MainMenuButtonVisibility.ALL.value)
+    is_active = Column(Boolean, nullable=False, default=True)
+    display_order = Column(Integer, nullable=False, default=0)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    __table_args__ = (
+        Index("ix_main_menu_buttons_order", "display_order", "id"),
+    )
+
+    @property
+    def action_type_enum(self) -> MainMenuButtonActionType:
+        try:
+            return MainMenuButtonActionType(self.action_type)
+        except ValueError:
+            return MainMenuButtonActionType.URL
+
+    @property
+    def visibility_enum(self) -> MainMenuButtonVisibility:
+        try:
+            return MainMenuButtonVisibility(self.visibility)
+        except ValueError:
+            return MainMenuButtonVisibility.ALL
+
+    def __repr__(self) -> str:
+        return (
+            f"<MainMenuButton id={self.id} text='{self.text}' "
+            f"action={self.action_type} visibility={self.visibility} active={self.is_active}>"
+        )
@@ -19,10 +19,10 @@ class CryptoBotService:
        self.webhook_secret = settings.CRYPTOBOT_WEBHOOK_SECRET
    
    async def _make_request(
-        self, 
-        method: str, 
-        endpoint: str, 
-        data: Optional[Dict] = None
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
    ) -> Optional[Dict[str, Any]]:
        
        if not self.api_token:
@@ -37,11 +37,18 @@ class CryptoBotService:
        
        try:
            async with aiohttp.ClientSession() as session:
+                request_kwargs: Dict[str, Any] = {"headers": headers}
+
+                if method.upper() == "GET":
+                    if data:
+                        request_kwargs["params"] = data
+                elif data:
+                    request_kwargs["json"] = data
+
                async with session.request(
-                    method, 
-                    url, 
-                    headers=headers,
-                    json=data if data else None
+                    method,
+                    url,
+                    **request_kwargs,
                ) as response:
                    
                    response_data = await response.json()
@@ -95,21 +102,34 @@ class CryptoBotService:
        asset: Optional[str] = None,
        status: Optional[str] = None,
        offset: int = 0,
-        count: int = 100
+        count: int = 100,
+        invoice_ids: Optional[list] = None,
    ) -> Optional[list]:
-        
+
        data = {
            'offset': offset,
            'count': count
        }
-        
+
        if asset:
            data['asset'] = asset
-        
+
        if status:
            data['status'] = status
-        
-        return await self._make_request('GET', 'getInvoices', data)
+
+        if invoice_ids:
+            data['invoice_ids'] = invoice_ids
+
+        result = await self._make_request('GET', 'getInvoices', data)
+
+        if isinstance(result, dict):
+            items = result.get('items')
+            return items if isinstance(items, list) else []
+
+        if isinstance(result, list):
+            return result
+
+        return []
    
    async def get_balance(self) -> Optional[list]:
        return await self._make_request('GET', 'getBalance')
@@ -0,0 +1,174 @@
+"""HTTP client for Heleket payment API."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import logging
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class HeleketService:
+    """Minimal wrapper around Heleket API endpoints."""
+
+    def __init__(self) -> None:
+        self.base_url = settings.HELEKET_BASE_URL.rstrip("/")
+        self.merchant_id = settings.HELEKET_MERCHANT_ID
+        self.api_key = settings.HELEKET_API_KEY
+
+    @property
+    def is_configured(self) -> bool:
+        return bool(self.merchant_id and self.api_key)
+
+    def _prepare_body(
+        self,
+        payload: Dict[str, Any],
+        *,
+        ignore_none: bool,
+        sort_keys: bool,
+    ) -> str:
+        if ignore_none:
+            cleaned = {key: value for key, value in payload.items() if value is not None}
+        else:
+            cleaned = dict(payload)
+
+        serialized = json.dumps(
+            cleaned,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            sort_keys=sort_keys,
+        )
+
+        if "/" in serialized:
+            serialized = serialized.replace("/", "\\/")
+
+        return serialized
+
+    def _generate_signature(self, body: str) -> str:
+        api_key = self.api_key or ""
+        encoded = base64.b64encode(body.encode("utf-8")).decode("utf-8")
+        raw = f"{encoded}{api_key}"
+        return hashlib.md5(raw.encode("utf-8")).hexdigest()
+
+    async def _request(
+        self,
+        endpoint: str,
+        payload: Dict[str, Any],
+        *,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        if not self.is_configured:
+            logger.error("Heleket сервис не настроен: merchant или api_key отсутствуют")
+            return None
+
+        body = self._prepare_body(payload, ignore_none=True, sort_keys=True)
+        signature = self._generate_signature(body)
+
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        headers = {
+            "merchant": self.merchant_id or "",
+            "sign": signature,
+            "Content-Type": "application/json",
+        }
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=30)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    url,
+                    data=body.encode("utf-8"),
+                    headers=headers,
+                    params=params,
+                ) as response:
+                    text = await response.text()
+                    if response.content_type != "application/json":
+                        logger.error("Ответ Heleket не JSON (%s): %s", response.content_type, text)
+                        return None
+
+                    try:
+                        data = json.loads(text)
+                    except json.JSONDecodeError:
+                        logger.error("Ошибка парсинга Heleket JSON: %s", text)
+                        return None
+
+                    if response.status >= 400:
+                        logger.error("Heleket API %s вернул статус %s: %s", endpoint, response.status, data)
+                        return None
+
+                    if isinstance(data, dict) and data.get("state") == 0:
+                        return data
+
+                    logger.error("Heleket API вернул ошибку: %s", data)
+                    return None
+        except Exception as error:  # pragma: no cover - defensive
+            logger.error("Ошибка запроса к Heleket API: %s", error)
+            return None
+
+    async def create_payment(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        return await self._request("payment", payload)
+
+    async def get_payment_info(
+        self,
+        *,
+        uuid: Optional[str] = None,
+        order_id: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        if not uuid and not order_id:
+            raise ValueError("Нужно указать uuid или order_id для Heleket payment/info")
+
+        payload: Dict[str, Any] = {}
+        if uuid:
+            payload["uuid"] = uuid
+        if order_id:
+            payload["order_id"] = order_id
+
+        return await self._request("payment/info", payload)
+
+    async def list_payments(
+        self,
+        *,
+        date_from: Optional[str] = None,
+        date_to: Optional[str] = None,
+        cursor: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        payload: Dict[str, Any] = {}
+        if date_from:
+            payload["date_from"] = date_from
+        if date_to:
+            payload["date_to"] = date_to
+
+        params = {"cursor": cursor} if cursor else None
+        return await self._request("payment/list", payload, params=params)
+
+    def verify_webhook_signature(self, payload: Dict[str, Any]) -> bool:
+        if not self.is_configured:
+            logger.warning("Heleket сервис не настроен, подпись пропускается")
+            return True
+
+        if not isinstance(payload, dict):
+            logger.error("Heleket webhook payload не dict: %s", payload)
+            return False
+
+        signature = payload.get("sign")
+        if not signature:
+            logger.error("Heleket webhook без подписи")
+            return False
+
+        data = dict(payload)
+        data.pop("sign", None)
+        body = self._prepare_body(data, ignore_none=False, sort_keys=False)
+        expected = self._generate_signature(body)
+
+        is_valid = hmac.compare_digest(expected, str(signature))
+
+        if not is_valid:
+            logger.error("Неверная подпись Heleket webhook: ожидается %s, получено %s", expected, signature)
+        return is_valid
@@ -0,0 +1,111 @@
+import asyncio
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from aiohttp import web
+
+from app.config import settings
+from app.database.database import get_db
+from app.external.heleket import HeleketService
+from app.services.payment_service import PaymentService
+
+logger = logging.getLogger(__name__)
+
+
+class HeleketWebhookHandler:
+    def __init__(self, payment_service: PaymentService) -> None:
+        self.payment_service = payment_service
+        self.service = HeleketService()
+
+    async def handle(self, request: web.Request) -> web.Response:
+        if not settings.is_heleket_enabled():
+            logger.warning("Получен Heleket webhook, но сервис отключен")
+            return web.json_response({"status": "error", "reason": "disabled"}, status=503)
+
+        try:
+            payload: Dict[str, Any] = await request.json()
+        except json.JSONDecodeError:
+            logger.error("Некорректный JSON Heleket webhook")
+            return web.json_response({"status": "error", "reason": "invalid_json"}, status=400)
+
+        if not self.service.verify_webhook_signature(payload):
+            return web.json_response({"status": "error", "reason": "invalid_signature"}, status=401)
+
+        processed: Optional[bool] = None
+        async for db in get_db():
+            processed = await self.payment_service.process_heleket_webhook(db, payload)
+
+        if processed:
+            return web.json_response({"status": "ok"}, status=200)
+
+        return web.json_response({"status": "error", "reason": "not_processed"}, status=400)
+
+    async def health_check(self, _: web.Request) -> web.Response:
+        return web.json_response(
+            {
+                "status": "ok",
+                "service": "heleket_webhook",
+                "enabled": settings.is_heleket_enabled(),
+                "path": settings.HELEKET_WEBHOOK_PATH,
+            }
+        )
+
+    async def options_handler(self, _: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type, Authorization",
+            },
+        )
+
+
+def create_heleket_app(payment_service: PaymentService) -> web.Application:
+    handler = HeleketWebhookHandler(payment_service)
+    app = web.Application()
+    app.router.add_post(settings.HELEKET_WEBHOOK_PATH, handler.handle)
+    app.router.add_get("/heleket/health", handler.health_check)
+    app.router.add_get("/health", handler.health_check)
+    app.router.add_options(settings.HELEKET_WEBHOOK_PATH, handler.options_handler)
+    return app
+
+
+async def start_heleket_webhook_server(payment_service: PaymentService) -> None:
+    if not settings.is_heleket_enabled():
+        logger.info("Heleket отключен, webhook сервер не запускается")
+        return
+
+    app = create_heleket_app(payment_service)
+    runner = web.AppRunner(app)
+    await runner.setup()
+
+    site = web.TCPSite(
+        runner,
+        host=settings.HELEKET_WEBHOOK_HOST,
+        port=settings.HELEKET_WEBHOOK_PORT,
+    )
+
+    try:
+        await site.start()
+        logger.info(
+            "Heleket webhook сервер запущен на %s:%s",
+            settings.HELEKET_WEBHOOK_HOST,
+            settings.HELEKET_WEBHOOK_PORT,
+        )
+        logger.info(
+            "Heleket webhook URL: http://%s:%s%s",
+            settings.HELEKET_WEBHOOK_HOST,
+            settings.HELEKET_WEBHOOK_PORT,
+            settings.HELEKET_WEBHOOK_PATH,
+        )
+
+        while True:
+            await asyncio.sleep(1)
+    except asyncio.CancelledError:
+        logger.info("Heleket webhook сервер остановлен по запросу")
+    finally:
+        await site.stop()
+        await runner.cleanup()
+        logger.info("Heleket webhook сервер корректно остановлен")
@@ -1,8 +1,9 @@
-"""Flask webhook server for PayPalych postbacks."""
+"""Flask webhook server for PayPalych callbacks."""

 from __future__ import annotations

 import asyncio
+from concurrent.futures import TimeoutError as FuturesTimeoutError
 import json
 import logging
 import threading
@@ -13,7 +14,7 @@ from flask import Flask, jsonify, request
 from werkzeug.serving import make_server

 from app.config import settings
-from app.database.database import get_db
+from app.database.database import AsyncSessionLocal
 from app.services.pal24_service import Pal24Service, Pal24APIError
 from app.services.payment_service import PaymentService

@@ -56,27 +57,33 @@ def create_pal24_flask_app(
            logger.error("Pal24 webhook получен, но сервис не настроен")
            return jsonify({"status": "error", "reason": "service_not_configured"}), 503

+        logger.debug("Получен Pal24 webhook: headers=%s", dict(request.headers))
+
        payload = _normalize_payload()
        if not payload:
            logger.warning("Пустой Pal24 webhook")
            return jsonify({"status": "error", "reason": "empty_payload"}), 400

        try:
-            parsed_payload = pal24_service.parse_postback(payload)
+            parsed_payload = pal24_service.parse_callback(payload)
        except Pal24APIError as error:
            logger.error("Ошибка валидации Pal24 webhook: %s", error)
            return jsonify({"status": "error", "reason": str(error)}), 400

        async def process() -> bool:
-            async for db in get_db():
+            async with AsyncSessionLocal() as db:
                try:
-                    return await payment_service.process_pal24_postback(db, parsed_payload)
-                finally:
-                    await db.close()
+                    return await payment_service.process_pal24_callback(db, parsed_payload)
+                except Exception:
+                    await db.rollback()
+                    raise

        try:
            future = asyncio.run_coroutine_threadsafe(process(), loop)
-            processed = future.result()
+            processed = future.result(timeout=settings.PAL24_REQUEST_TIMEOUT)
+        except FuturesTimeoutError:
+            logger.error("Обработка Pal24 webhook превысила таймаут %sс", settings.PAL24_REQUEST_TIMEOUT)
+            return jsonify({"status": "error", "reason": "timeout"}), 504
        except Exception as error:  # pragma: no cover - defensive
            logger.exception("Критическая ошибка обработки Pal24 webhook: %s", error)
            return jsonify({"status": "error", "reason": "internal_error"}), 500
@@ -105,7 +112,7 @@ def create_pal24_flask_app(


 class Pal24WebhookServer:
-    """Threaded Flask server for Pal24 postbacks."""
+    """Threaded Flask server for Pal24 callbacks."""

    def __init__(self, payment_service: PaymentService, loop: AbstractEventLoop) -> None:
        self.app = create_pal24_flask_app(payment_service, loop)
@@ -4,7 +4,6 @@ import ssl
 import base64 
 from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Union, Any
-from urllib.parse import urlparse
 import aiohttp
 import logging
 from dataclasses import dataclass
@@ -164,7 +163,7 @@ class RemnaWaveAPI:
    async def __aenter__(self):
        conn_type = self._detect_connection_type()
        
-        logger.info(f"Подключение к Remnawave: {self.base_url} (тип: {conn_type})")
+        logger.debug(f"Подключение к Remnawave: {self.base_url} (тип: {conn_type})")
            
        headers = self._prepare_auth_headers() 
        
@@ -1,4 +1,5 @@
 import logging
+from decimal import Decimal, ROUND_HALF_UP
 from typing import Optional, Dict, Any
 from aiogram import Bot
 from aiogram.types import LabeledPrice, InlineKeyboardMarkup, InlineKeyboardButton
@@ -18,8 +19,9 @@ class TelegramStarsService:
        return settings.rubles_to_stars(rubles)
    
    @staticmethod
-    def calculate_rubles_from_stars(stars: int) -> float:
-        return settings.stars_to_rubles(stars)
+    def calculate_rubles_from_stars(stars: int) -> Decimal:
+        rate = Decimal(str(settings.get_stars_rate()))
+        return (Decimal(stars) * rate).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
    
    async def create_invoice(
        self,
@@ -31,10 +33,10 @@ class TelegramStarsService:
        start_parameter: Optional[str] = None
    ) -> Optional[str]:
        try:
-            amount_rubles = amount_kopeks / 100
-            stars_amount = self.calculate_stars_from_rubles(amount_rubles)
+            amount_rubles = Decimal(amount_kopeks) / Decimal(100)
+            stars_amount = self.calculate_stars_from_rubles(float(amount_rubles))
            stars_rate = settings.get_stars_rate()
-            
+
            invoice_link = await self.bot.create_invoice_link(
                title=title,
                description=description,
@@ -46,7 +48,7 @@ class TelegramStarsService:
            )
            
            logger.info(
-                f"Создан Stars invoice на {stars_amount} звезд (~{int(amount_rubles)}₽) "
+                f"Создан Stars invoice на {stars_amount} звезд (~{settings.format_price(amount_kopeks)}) "
                f"для {chat_id}, курс: {stars_rate}₽/⭐"
            )
            return invoice_link
@@ -65,8 +67,8 @@ class TelegramStarsService:
        keyboard: Optional[InlineKeyboardMarkup] = None
    ) -> Optional[Dict[str, Any]]:
        try:
-            amount_rubles = amount_kopeks / 100
-            stars_amount = self.calculate_stars_from_rubles(amount_rubles)
+            amount_rubles = Decimal(amount_kopeks) / Decimal(100)
+            stars_amount = self.calculate_stars_from_rubles(float(amount_rubles))
            stars_rate = settings.get_stars_rate()
            
            message = await self.bot.send_invoice(
@@ -82,12 +84,12 @@ class TelegramStarsService:
            
            logger.info(
                f"Отправлен Stars invoice {message.message_id} на {stars_amount} звезд "
-                f"(~{int(amount_rubles)}₽), курс: {stars_rate}₽/⭐"
+                f"(~{settings.format_price(amount_kopeks)}), курс: {stars_rate}₽/⭐"
            )
            return {
                "message_id": message.message_id,
                "stars_amount": stars_amount,
-                "rubles_amount": amount_rubles,
+                "rubles_amount": float(amount_rubles),
                "payload": payload
            }
            
@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional
+
+import aiohttp
+from aiohttp import web
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+
+from app.config import settings
+from app.database.database import get_db
+from app.services.payment_service import PaymentService
+
+logger = logging.getLogger(__name__)
+
+
+class WataPublicKeyProvider:
+    """Loads and caches the WATA public key used for webhook signature validation."""
+
+    def __init__(self, *, cache_seconds: Optional[int] = None) -> None:
+        self._cache_seconds = cache_seconds or int(settings.WATA_PUBLIC_KEY_CACHE_SECONDS)
+        self._cached_key: Optional[str] = None
+        self._expires_at: Optional[datetime] = None
+        self._lock = asyncio.Lock()
+
+    async def get_public_key(self) -> Optional[str]:
+        """Returns a cached public key or fetches a new one from WATA."""
+
+        now = datetime.utcnow()
+        if self._cached_key and self._expires_at and now < self._expires_at:
+            return self._cached_key
+
+        async with self._lock:
+            now = datetime.utcnow()
+            if self._cached_key and self._expires_at and now < self._expires_at:
+                return self._cached_key
+
+            key = await self._fetch_public_key()
+            if key:
+                self._cached_key = key
+                if self._cache_seconds > 0:
+                    self._expires_at = datetime.utcnow() + timedelta(seconds=self._cache_seconds)
+                else:
+                    self._expires_at = None
+                logger.debug("Получен и закеширован публичный ключ WATA")
+                return self._cached_key
+
+            if self._cached_key:
+                logger.warning("Используем ранее закешированный публичный ключ WATA")
+                return self._cached_key
+
+            logger.error("Публичный ключ WATA недоступен")
+            return None
+
+    async def _fetch_public_key(self) -> Optional[str]:
+        url = settings.WATA_PUBLIC_KEY_URL or f"{settings.WATA_BASE_URL.rstrip('/')}/public-key"
+        timeout = aiohttp.ClientTimeout(total=settings.WATA_REQUEST_TIMEOUT)
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(url) as response:
+                    text = await response.text()
+                    if response.status >= 400:
+                        logger.error(
+                            "Ошибка получения публичного ключа WATA %s: %s",
+                            response.status,
+                            text,
+                        )
+                        return None
+
+                    try:
+                        payload = await response.json()
+                    except aiohttp.ContentTypeError:
+                        logger.error("Ответ WATA public-key не является JSON: %s", text)
+                        return None
+
+            if isinstance(payload, dict):
+                value = payload.get("value")
+                if value:
+                    return value
+                logger.error("Ответ WATA public-key не содержит ключ: %s", payload)
+            else:
+                logger.error("Неожиданный формат ответа WATA public-key: %s", payload)
+        except Exception as error:
+            logger.error("Ошибка запроса публичного ключа WATA: %s", error)
+
+        return None
+
+
+class WataWebhookHandler:
+    """Processes webhook callbacks coming from WATA."""
+
+    def __init__(
+        self,
+        payment_service: PaymentService,
+        *,
+        public_key_provider: Optional[WataPublicKeyProvider] = None,
+    ) -> None:
+        self.payment_service = payment_service
+        self.public_key_provider = public_key_provider or WataPublicKeyProvider()
+
+    async def _verify_signature(self, raw_body: str, signature: str) -> bool:
+        signature = (signature or "").strip()
+        if not signature:
+            logger.error("WATA webhook без подписи")
+            return False
+
+        public_key_pem = await self.public_key_provider.get_public_key()
+        if not public_key_pem:
+            logger.error("Публичный ключ WATA отсутствует, проверка подписи невозможна")
+            return False
+
+        try:
+            signature_bytes = base64.b64decode(signature)
+        except (ValueError, TypeError):
+            logger.error("Некорректная подпись WATA (не Base64)")
+            return False
+
+        try:
+            public_key = serialization.load_pem_public_key(public_key_pem.encode("utf-8"))
+        except ValueError as error:
+            logger.error("Ошибка загрузки публичного ключа WATA: %s", error)
+            return False
+
+        try:
+            public_key.verify(
+                signature_bytes,
+                raw_body.encode("utf-8"),
+                padding.PKCS1v15(),
+                hashes.SHA512(),
+            )
+            return True
+        except InvalidSignature:
+            logger.warning("Подпись WATA webhook не прошла проверку")
+            return False
+        except Exception as error:
+            logger.error("Ошибка проверки подписи WATA: %s", error)
+            return False
+
+    async def handle_webhook(self, request: web.Request) -> web.Response:
+        if not settings.is_wata_enabled():
+            logger.warning("Получен WATA webhook, но сервис отключен")
+            return web.json_response({"status": "error", "reason": "wata_disabled"}, status=503)
+
+        raw_body = await request.text()
+        if not raw_body:
+            logger.warning("Получен пустой WATA webhook")
+            return web.json_response({"status": "error", "reason": "empty_body"}, status=400)
+
+        signature = request.headers.get("X-Signature")
+        if not await self._verify_signature(raw_body, signature or ""):
+            return web.json_response({"status": "error", "reason": "invalid_signature"}, status=401)
+
+        try:
+            payload: Dict[str, Any] = json.loads(raw_body)
+        except json.JSONDecodeError:
+            logger.error("Некорректный JSON WATA webhook")
+            return web.json_response({"status": "error", "reason": "invalid_json"}, status=400)
+
+        logger.info(
+            "Получен WATA webhook: order_id=%s, status=%s",
+            payload.get("orderId"),
+            payload.get("transactionStatus"),
+        )
+
+        processed: Optional[bool] = None
+        async for db in get_db():
+            processed = await self.payment_service.process_wata_webhook(db, payload)
+            # Allow the generator to finish naturally so it can commit/rollback.
+            # get_db() yields only once, so exiting the loop body without breaking
+            # triggers the generator cleanup logic on the next iteration attempt.
+
+        if processed is None:
+            logger.error("Не удалось обработать WATA webhook: нет сессии БД")
+            return web.json_response({"status": "error", "reason": "db_session_unavailable"}, status=500)
+
+        if processed:
+            return web.json_response({"status": "ok"}, status=200)
+
+        return web.json_response({"status": "error", "reason": "not_processed"}, status=400)
+
+    async def health_check(self, request: web.Request) -> web.Response:
+        return web.json_response(
+            {
+                "status": "ok",
+                "service": "wata_webhook",
+                "enabled": settings.is_wata_enabled(),
+                "path": settings.WATA_WEBHOOK_PATH,
+            }
+        )
+
+    async def options_handler(self, _: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type, X-Signature",
+            },
+        )
+
+
+def create_wata_webhook_app(payment_service: PaymentService) -> web.Application:
+    app = web.Application()
+    handler = WataWebhookHandler(payment_service)
+
+    app.router.add_post(settings.WATA_WEBHOOK_PATH, handler.handle_webhook)
+    app.router.add_get(settings.WATA_WEBHOOK_PATH, handler.health_check)
+    app.router.add_options(settings.WATA_WEBHOOK_PATH, handler.options_handler)
+    app.router.add_get("/health", handler.health_check)
+
+    logger.info(
+        "Настроен WATA webhook endpoint на %s",
+        settings.WATA_WEBHOOK_PATH,
+    )
+
+    return app
+
+
+async def start_wata_webhook_server(payment_service: PaymentService) -> None:
+    if not settings.is_wata_enabled():
+        logger.info("WATA отключен, webhook сервер не запускается")
+        return
+
+    app = create_wata_webhook_app(payment_service)
+    runner = web.AppRunner(app)
+    await runner.setup()
+
+    site = web.TCPSite(
+        runner,
+        host=settings.WATA_WEBHOOK_HOST,
+        port=settings.WATA_WEBHOOK_PORT,
+    )
+
+    try:
+        await site.start()
+        logger.info(
+            "WATA webhook сервер запущен на %s:%s",
+            settings.WATA_WEBHOOK_HOST,
+            settings.WATA_WEBHOOK_PORT,
+        )
+        logger.info(
+            "WATA webhook URL: http://%s:%s%s",
+            settings.WATA_WEBHOOK_HOST,
+            settings.WATA_WEBHOOK_PORT,
+            settings.WATA_WEBHOOK_PATH,
+        )
+
+        while True:
+            await asyncio.sleep(1)
+    except asyncio.CancelledError:
+        logger.info("WATA webhook сервер остановлен по запросу")
+    finally:
+        await site.stop()
+        await runner.cleanup()
+        logger.info("WATA webhook сервер корректно остановлен")
@@ -1,8 +1,9 @@
+import base64
 import hashlib
 import hmac
 import logging
 import json
-from typing import Optional
+from typing import Optional, Iterable

 from aiohttp import web
 from aiogram import Bot
@@ -47,7 +48,12 @@ class WebhookServer:
        logger.info(f"Webhook сервер настроен:")
        logger.info(f"  - Tribute webhook: POST {settings.TRIBUTE_WEBHOOK_PATH}")
        if settings.is_mulenpay_enabled():
-            logger.info(f"  - Mulen Pay webhook: POST {settings.MULENPAY_WEBHOOK_PATH}")
+            mulenpay_name = settings.get_mulenpay_display_name()
+            logger.info(
+                "  - %s webhook: POST %s",
+                mulenpay_name,
+                settings.MULENPAY_WEBHOOK_PATH,
+            )
        if settings.is_cryptobot_enabled():
            logger.info(f"  - CryptoBot webhook: POST {settings.CRYPTOBOT_WEBHOOK_PATH}")
        logger.info(f"  - Health check: GET /health")
@@ -65,20 +71,39 @@ class WebhookServer:
            
            self.site = web.TCPSite(
                self.runner,
-                host='0.0.0.0',
+                host=settings.TRIBUTE_WEBHOOK_HOST,
                port=settings.TRIBUTE_WEBHOOK_PORT
            )
-            
+
            await self.site.start()
-            
-            logger.info(f"Webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
-            logger.info(f"Tribute webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+
+            logger.info(
+                "Webhook сервер запущен на %s:%s",
+                settings.TRIBUTE_WEBHOOK_HOST,
+                settings.TRIBUTE_WEBHOOK_PORT,
+            )
+            logger.info(
+                "Tribute webhook URL: http://%s:%s%s",
+                settings.TRIBUTE_WEBHOOK_HOST,
+                settings.TRIBUTE_WEBHOOK_PORT,
+                settings.TRIBUTE_WEBHOOK_PATH,
+            )
            if settings.is_mulenpay_enabled():
+                mulenpay_name = settings.get_mulenpay_display_name()
                logger.info(
-                    f"Mulen Pay webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.MULENPAY_WEBHOOK_PATH}"
+                    "%s webhook URL: http://%s:%s%s",
+                    mulenpay_name,
+                    settings.TRIBUTE_WEBHOOK_HOST,
+                    settings.TRIBUTE_WEBHOOK_PORT,
+                    settings.MULENPAY_WEBHOOK_PATH,
                )
            if settings.is_cryptobot_enabled():
-                logger.info(f"CryptoBot webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.CRYPTOBOT_WEBHOOK_PATH}")
+                logger.info(
+                    "CryptoBot webhook URL: http://%s:%s%s",
+                    settings.TRIBUTE_WEBHOOK_HOST,
+                    settings.TRIBUTE_WEBHOOK_PORT,
+                    settings.CRYPTOBOT_WEBHOOK_PATH,
+                )
            
        except Exception as e:
            logger.error(f"Ошибка запуска webhook сервера: {e}")
@@ -110,71 +135,175 @@ class WebhookServer:

    async def _mulenpay_webhook_handler(self, request: web.Request) -> web.Response:
        try:
-            logger.info(f"Получен Mulen Pay webhook: {request.method} {request.path}")
+            mulenpay_name = settings.get_mulenpay_display_name()
+            logger.info(
+                "%s webhook: %s %s",
+                mulenpay_name,
+                request.method,
+                request.path,
+            )
+            logger.info(
+                "%s webhook headers: %s",
+                mulenpay_name,
+                dict(request.headers),
+            )
            raw_body = await request.read()

            if not raw_body:
-                logger.warning("Пустой Mulen Pay webhook")
+                logger.warning("Пустой %s webhook", mulenpay_name)
                return web.json_response({"status": "error", "reason": "empty_body"}, status=400)

+            # Временно отключаем проверку подписи для отладки
+            # TODO: Включить обратно после настройки MulenPay
            if not self._verify_mulenpay_signature(request, raw_body):
-                return web.json_response({"status": "error", "reason": "invalid_signature"}, status=401)
+                logger.warning(
+                    "%s webhook signature verification failed, but processing anyway for debugging",
+                    mulenpay_name,
+                )
+                # return web.json_response({"status": "error", "reason": "invalid_signature"}, status=401)

            try:
                payload = json.loads(raw_body.decode('utf-8'))
            except json.JSONDecodeError as error:
-                logger.error(f"Ошибка парсинга Mulen Pay webhook: {error}")
+                logger.error(f"Ошибка парсинга {mulenpay_name} webhook: {error}")
                return web.json_response({"status": "error", "reason": "invalid_json"}, status=400)

            payment_service = PaymentService(self.bot)

-            async for db in get_db():
+            # Получаем соединение с БД
+            db_generator = get_db()
+            db = await db_generator.__anext__()
+            
+            try:
+                success = await payment_service.process_mulenpay_callback(db, payload)
+                if success:
+                    return web.json_response({"status": "ok"}, status=200)
+                return web.json_response({"status": "error", "reason": "processing_failed"}, status=400)
+            except Exception as error:
+                logger.error(
+                    f"Ошибка обработки {mulenpay_name} webhook: {error}",
+                    exc_info=True,
+                )
+                return web.json_response({"status": "error", "reason": "internal_error"}, status=500)
+            finally:
                try:
-                    success = await payment_service.process_mulenpay_callback(db, payload)
-                    if success:
-                        return web.json_response({"status": "ok"}, status=200)
-                    return web.json_response({"status": "error", "reason": "processing_failed"}, status=400)
-                except Exception as error:
-                    logger.error(f"Ошибка обработки Mulen Pay webhook: {error}", exc_info=True)
-                    return web.json_response({"status": "error", "reason": "internal_error"}, status=500)
-                finally:
-                    break
+                    await db_generator.__anext__()
+                except StopAsyncIteration:
+                    pass

        except Exception as error:
-            logger.error(f"Критическая ошибка Mulen Pay webhook: {error}", exc_info=True)
+            mulenpay_name = settings.get_mulenpay_display_name()
+            logger.error(
+                f"Критическая ошибка {mulenpay_name} webhook: {error}",
+                exc_info=True,
+            )
            return web.json_response({"status": "error", "reason": "internal_error", "message": str(error)}, status=500)

+    @staticmethod
+    def _extract_mulenpay_header(request: web.Request, header_names: Iterable[str]) -> Optional[str]:
+        for header_name in header_names:
+            value = request.headers.get(header_name)
+            if value:
+                return value.strip()
+        return None
+
    @staticmethod
    def _verify_mulenpay_signature(request: web.Request, raw_body: bytes) -> bool:
        secret_key = settings.MULENPAY_SECRET_KEY
+        display_name = settings.get_mulenpay_display_name()
        if not secret_key:
-            logger.error("Mulen Pay secret key is not configured")
+            logger.error("%s secret key is not configured", display_name)
            return False

-        signature = request.headers.get('X-MulenPay-Signature')
+        # Логируем все заголовки для отладки
+        logger.info("%s webhook headers for signature verification:", display_name)
+        for header_name, header_value in request.headers.items():
+            if any(keyword in header_name.lower() for keyword in ['signature', 'sign', 'token', 'auth']):
+                logger.info(f"  {header_name}: {header_value}")
+
+        signature = WebhookServer._extract_mulenpay_header(
+            request,
+            (
+                'X-MulenPay-Signature',
+                'X-Mulenpay-Signature',
+                'X-MULENPAY-SIGNATURE',
+                'X-MulenPay-Webhook-Signature',
+                'X-Mulenpay-Webhook-Signature',
+                'X-MULENPAY-WEBHOOK-SIGNATURE',
+                'X-Signature',
+                'Signature',
+                'X-MulenPay-Sign',
+                'X-Mulenpay-Sign',
+                'X-MULENPAY-SIGN',
+                'MulenPay-Signature',
+                'Mulenpay-Signature',
+                'MULENPAY-SIGNATURE',
+                'signature',
+                'sign',
+            )
+        )
        if signature:
-            expected_signature = hmac.new(
+            normalized_signature = signature
+            if normalized_signature.lower().startswith('sha256='):
+                normalized_signature = normalized_signature.split('=', 1)[1].strip()
+
+            hmac_digest = hmac.new(
                secret_key.encode('utf-8'),
                raw_body,
                hashlib.sha256,
-            ).hexdigest()
+            ).digest()
+            expected_hex_signature = hmac_digest.hex()
+            expected_base64_signature = base64.b64encode(hmac_digest).decode('utf-8').strip()
+            expected_urlsafe_base64_signature = base64.urlsafe_b64encode(hmac_digest).decode('utf-8').strip()

-            if hmac.compare_digest(signature.strip().lower(), expected_signature.lower()):
+            normalized_signature_lower = normalized_signature.lower()
+            if hmac.compare_digest(normalized_signature_lower, expected_hex_signature.lower()):
                return True

-            logger.error("Неверная подпись Mulen Pay webhook")
+            normalized_signature_no_padding = normalized_signature.rstrip('=')
+            if hmac.compare_digest(normalized_signature_no_padding, expected_base64_signature.rstrip('=')):
+                return True
+
+            if hmac.compare_digest(normalized_signature_no_padding, expected_urlsafe_base64_signature.rstrip('=')):
+                return True
+
+            logger.error("Неверная подпись %s webhook", display_name)
            return False

        authorization_header = request.headers.get('Authorization')
-        if authorization_header and authorization_header.startswith('Bearer '):
-            token = authorization_header.split(' ', 1)[1].strip()
-            if hmac.compare_digest(token, secret_key):
+        if authorization_header:
+            scheme, _, value = authorization_header.partition(' ')
+            scheme_lower = scheme.lower()
+            token = value.strip() if value else scheme.strip()
+
+            if scheme_lower in ('bearer', 'token'):
+                if hmac.compare_digest(token, secret_key):
+                    return True
+
+                logger.error("Неверный %s токен %s webhook", scheme, display_name)
+                return False
+
+            if not value and hmac.compare_digest(token, secret_key):
                return True

-            logger.error("Неверный Bearer токен Mulen Pay webhook")
-            return False
+        fallback_token = WebhookServer._extract_mulenpay_header(
+            request,
+            (
+                'X-MulenPay-Token',
+                'X-Mulenpay-Token',
+                'X-Webhook-Token',
+            )
+        )
+        if fallback_token and hmac.compare_digest(fallback_token, secret_key):
+            return True

-        logger.error("Отсутствует подпись Mulen Pay webhook")
+        logger.info(
+            "%s webhook headers received: %s",
+            display_name,
+            {key: value for key, value in request.headers.items() if 'authorization' not in key.lower()}
+        )
+
+        logger.error("Отсутствует подпись %s webhook", display_name)
        return False

    async def _tribute_webhook_handler(self, request: web.Request) -> web.Response:
@@ -1,12 +1,16 @@
 import asyncio
 import logging
 import json
-import hashlib
-import hmac
-import base64
-from typing import Optional, Dict, Any
+from ipaddress import (
+    IPv4Address,
+    IPv4Network,
+    IPv6Address,
+    IPv6Network,
+    ip_address,
+    ip_network,
+)
+from typing import Iterable, Optional, Dict, Any, List, Union, Tuple
 from aiohttp import web
-from sqlalchemy.ext.asyncio import AsyncSession

 from app.config import settings
 from app.services.payment_service import PaymentService
@@ -15,155 +19,294 @@ from app.database.database import get_db
 logger = logging.getLogger(__name__)


+IPAddress = Union[IPv4Address, IPv6Address]
+IPNetwork = Union[IPv4Network, IPv6Network]
+
+YOOKASSA_ALLOWED_IP_NETWORKS: tuple[IPNetwork, ...] = (
+    ip_network("185.71.76.0/27"),
+    ip_network("185.71.77.0/27"),
+    ip_network("77.75.153.0/25"),
+    ip_network("77.75.154.128/25"),
+    ip_network("77.75.156.11/32"),
+    ip_network("77.75.156.35/32"),
+    ip_network("2a02:5180::/32"),
+)
+
+
+CLOUDFLARE_TRUSTED_NETWORKS: tuple[IPNetwork, ...] = (
+    ip_network("173.245.48.0/20"),
+    ip_network("103.21.244.0/22"),
+    ip_network("103.22.200.0/22"),
+    ip_network("103.31.4.0/22"),
+    ip_network("141.101.64.0/18"),
+    ip_network("108.162.192.0/18"),
+    ip_network("190.93.240.0/20"),
+    ip_network("188.114.96.0/20"),
+    ip_network("197.234.240.0/22"),
+    ip_network("198.41.128.0/17"),
+    ip_network("162.158.0.0/15"),
+    ip_network("104.16.0.0/13"),
+    ip_network("104.24.0.0/14"),
+    ip_network("172.64.0.0/13"),
+    ip_network("131.0.72.0/22"),
+    ip_network("2400:cb00::/32"),
+    ip_network("2606:4700::/32"),
+    ip_network("2803:f800::/32"),
+    ip_network("2405:b500::/32"),
+    ip_network("2405:8100::/32"),
+    ip_network("2a06:98c0::/29"),
+    ip_network("2c0f:f248::/32"),
+)
+
+
+YOOKASSA_ALLOWED_EVENTS: tuple[str, ...] = (
+    "payment.succeeded",
+    "payment.waiting_for_capture",
+    "payment.canceled",
+)
+
+
+def collect_yookassa_ip_candidates(*values: Optional[str]) -> List[str]:
+    candidates: List[str] = []
+    for value in values:
+        if not value:
+            continue
+        for part in value.split(","):
+            normalized = part.strip()
+            if normalized:
+                candidates.append(normalized)
+    return candidates
+
+
+def _parse_candidate_ip(candidate: str) -> Optional[IPAddress]:
+    value = candidate.strip()
+    if not value:
+        return None
+
+    if value.startswith("[") and "]" in value:
+        value = value[1:value.index("]")]
+
+    if "%" in value:
+        value = value.split("%", 1)[0]
+
+    if value.count(":") == 1 and "." in value:
+        host, _, port = value.rpartition(":")
+        if port.isdigit():
+            value = host
+
+    try:
+        return ip_address(value)
+    except ValueError:
+        return None
+
+
+def _should_trust_forwarded_headers(remote_ip: Optional[IPAddress]) -> bool:
+    if remote_ip is None:
+        return True
+
+    if _is_trusted_proxy_ip(remote_ip):
+        return True
+
+    return any(
+        getattr(remote_ip, attribute)
+        for attribute in ("is_private", "is_loopback", "is_link_local", "is_reserved")
+    )
+
+
+_TRUSTED_PROXY_NETWORKS_CACHE: Tuple[str, Tuple[IPNetwork, ...]] = ("", ())
+
+
+def _get_trusted_proxy_networks() -> Tuple[IPNetwork, ...]:
+    global _TRUSTED_PROXY_NETWORKS_CACHE
+
+    raw_value = getattr(settings, "YOOKASSA_TRUSTED_PROXY_NETWORKS", "") or ""
+    cached_raw, cached_networks = _TRUSTED_PROXY_NETWORKS_CACHE
+
+    if raw_value == cached_raw:
+        return cached_networks
+
+    networks: List[IPNetwork] = []
+    for part in raw_value.split(","):
+        candidate = part.strip()
+        if not candidate:
+            continue
+
+        try:
+            networks.append(ip_network(candidate, strict=False))
+        except ValueError:
+            logger.warning("Неверная сеть доверенного прокси YooKassa: %s", candidate)
+
+    cached_networks = tuple(networks)
+    _TRUSTED_PROXY_NETWORKS_CACHE = (raw_value, cached_networks)
+    return cached_networks
+
+
+def _is_trusted_proxy_ip(ip_object: IPAddress) -> bool:
+    if any(
+        getattr(ip_object, attribute)
+        for attribute in ("is_private", "is_loopback", "is_link_local", "is_reserved")
+    ):
+        return True
+
+    if any(ip_object in network for network in CLOUDFLARE_TRUSTED_NETWORKS):
+        return True
+
+    return any(ip_object in network for network in _get_trusted_proxy_networks())
+
+
+def resolve_yookassa_ip(
+    candidates: Iterable[str],
+    *,
+    remote: Optional[str] = None,
+) -> Optional[IPAddress]:
+    remote_ip = _parse_candidate_ip(remote) if remote else None
+
+    if (
+        remote_ip is not None
+        and remote_ip.is_global
+        and not _is_trusted_proxy_ip(remote_ip)
+    ):
+        return remote_ip
+
+    candidate_list = list(candidates)
+
+    if _should_trust_forwarded_headers(remote_ip):
+        last_hop = remote_ip
+        for candidate in reversed(candidate_list):
+            ip_object = _parse_candidate_ip(candidate)
+            if ip_object is not None:
+                if last_hop is None or _is_trusted_proxy_ip(last_hop):
+                    if _is_trusted_proxy_ip(ip_object):
+                        last_hop = ip_object
+                        continue
+                    return ip_object
+                break
+
+        if last_hop is not None and not _is_trusted_proxy_ip(last_hop):
+            return last_hop
+
+    return remote_ip if remote_ip is not None else next(
+        (ip for ip in (_parse_candidate_ip(value) for value in candidate_list) if ip is not None),
+        None,
+    )
+
+
+def is_yookassa_ip_allowed(ip_object: IPAddress) -> bool:
+    return any(ip_object in network for network in YOOKASSA_ALLOWED_IP_NETWORKS)
+
+
 class YooKassaWebhookHandler:

-    @staticmethod
-    def verify_webhook_signature(body: str, signature: str, secret: str) -> bool:
-        try:
-            signature_parts = signature.strip().split(' ')
-            
-            if len(signature_parts) < 4:
-                logger.error(f"Неверный формат подписи YooKassa: {signature}")
-                return False
-            
-            version = signature_parts[0] 
-            payment_id = signature_parts[1] 
-            timestamp = signature_parts[2]  
-            received_signature = signature_parts[3]
-            
-            if version != "v1":
-                logger.error(f"Неподдерживаемая версия подписи: {version}")
-                return False
-            
-            logger.info(f"Проверка подписи v1 для платежа {payment_id}, timestamp: {timestamp}")
-            
-            
-            expected_signature_1 = hmac.new(
-                secret.encode('utf-8'),
-                body.encode('utf-8'),
-                hashlib.sha256
-            ).digest()
-            expected_signature_1_b64 = base64.b64encode(expected_signature_1).decode('utf-8')
-            
-            signed_payload_2 = f"{payment_id}.{timestamp}.{body}"
-            expected_signature_2 = hmac.new(
-                secret.encode('utf-8'),
-                signed_payload_2.encode('utf-8'),
-                hashlib.sha256
-            ).digest()
-            expected_signature_2_b64 = base64.b64encode(expected_signature_2).decode('utf-8')
-            
-            signed_payload_3 = f"{timestamp}.{body}"
-            expected_signature_3 = hmac.new(
-                secret.encode('utf-8'),
-                signed_payload_3.encode('utf-8'),
-                hashlib.sha256
-            ).digest()
-            expected_signature_3_b64 = base64.b64encode(expected_signature_3).decode('utf-8')
-            
-            logger.debug(f"Получена подпись: {received_signature}")
-            logger.debug(f"Ожидаемая подпись (вариант 1): {expected_signature_1_b64}")
-            logger.debug(f"Ожидаемая подпись (вариант 2): {expected_signature_2_b64}")
-            logger.debug(f"Ожидаемая подпись (вариант 3): {expected_signature_3_b64}")
-            
-            is_valid = (
-                hmac.compare_digest(received_signature, expected_signature_1_b64) or
-                hmac.compare_digest(received_signature, expected_signature_2_b64) or  
-                hmac.compare_digest(received_signature, expected_signature_3_b64)
-            )
-            
-            if is_valid:
-                logger.info("✅ Подпись YooKassa webhook проверена успешно")
-            else:
-                logger.warning("⚠️ Подпись YooKassa webhook не совпадает ни с одним вариантом")
-            
-            return is_valid
-            
-        except Exception as e:
-            logger.error(f"Ошибка проверки подписи YooKassa: {e}")
-            return False
-    
    def __init__(self, payment_service: PaymentService):
        self.payment_service = payment_service
-    
+
    async def handle_webhook(self, request: web.Request) -> web.Response:
-        
+
        try:
            logger.info(f"📥 Получен YooKassa webhook: {request.method} {request.path}")
            logger.info(f"📋 Headers: {dict(request.headers)}")
-            
+
+            header_ip_candidates = collect_yookassa_ip_candidates(
+                request.headers.get("X-Forwarded-For"),
+                request.headers.get("X-Real-IP"),
+                request.headers.get("Cf-Connecting-Ip"),
+            )
+            client_ip = resolve_yookassa_ip(
+                header_ip_candidates,
+                remote=request.remote,
+            )
+
+            if client_ip is None:
+                logger.warning(
+                    "🚫 Не удалось определить IP-адрес отправителя YooKassa webhook. Кандидаты: %s",
+                    header_ip_candidates + ([request.remote] if request.remote else []),
+                )
+                return web.Response(status=403, text="Forbidden")
+
+            if not is_yookassa_ip_allowed(client_ip):
+                logger.warning(
+                    "🚫 YooKassa webhook отклонён: IP %s не входит в доверенные диапазоны (%s)",
+                    client_ip,
+                    ", ".join(str(network) for network in YOOKASSA_ALLOWED_IP_NETWORKS),
+                )
+                return web.Response(status=403, text="Forbidden")
+
+            logger.info("🌐 IP-адрес YooKassa подтверждён: %s", client_ip)
+
            body = await request.text()
-            
+
            if not body:
                logger.warning("⚠️ Получен пустой webhook от YooKassa")
                return web.Response(status=400, text="Empty body")
-            
+
            logger.info(f"📄 Body: {body}")
-            
+
            signature = request.headers.get('Signature') or request.headers.get('X-YooKassa-Signature')
-            
-            if settings.YOOKASSA_WEBHOOK_SECRET and signature:
-                logger.info(f"🔐 Получена подпись: {signature}")
-                
-                if not YooKassaWebhookHandler.verify_webhook_signature(body, signature, settings.YOOKASSA_WEBHOOK_SECRET):
-                    logger.warning("❌ Подпись не совпала, но продолжаем обработку (режим отладки)")
-                else:
-                    logger.info("✅ Подпись webhook проверена успешно")
-                    
-            elif settings.YOOKASSA_WEBHOOK_SECRET and not signature:
-                logger.warning("⚠️ Webhook без подписи, но секрет настроен")
-                
-            elif signature and not settings.YOOKASSA_WEBHOOK_SECRET:
-                logger.info("ℹ️ Подпись получена, но проверка отключена (YOOKASSA_WEBHOOK_SECRET не настроен)")
-                
-            else:
-                logger.info("ℹ️ Проверка подписи отключена")
-            
+            if signature:
+                logger.info("ℹ️ Получена подпись YooKassa: %s", signature)
+
            try:
                webhook_data = json.loads(body)
            except json.JSONDecodeError as e:
                logger.error(f"❌ Ошибка парсинга JSON webhook YooKassa: {e}")
                return web.Response(status=400, text="Invalid JSON")
-            
+
            logger.info(f"📊 Обработка webhook YooKassa: {webhook_data.get('event', 'unknown_event')}")
            logger.debug(f"🔍 Полные данные webhook: {webhook_data}")
-            
+
            event_type = webhook_data.get("event")
            if not event_type:
                logger.warning("⚠️ Webhook YooKassa без типа события")
                return web.Response(status=400, text="No event type")
-            
-            if event_type not in ["payment.succeeded", "payment.waiting_for_capture"]:
+
+            # Извлекаем ID платежа из вебхука для предотвращения дублирования
+            yookassa_payment_id = webhook_data.get("object", {}).get("id")
+            if not yookassa_payment_id:
+                logger.warning("⚠️ Webhook YooKassa без ID платежа")
+                return web.Response(status=400, text="No payment id")
+
+            if event_type not in YOOKASSA_ALLOWED_EVENTS:
                logger.info(f"ℹ️ Игнорируем событие YooKassa: {event_type}")
                return web.Response(status=200, text="OK")
-            
+
            async for db in get_db():
                try:
-                    success = await self.payment_service.process_yookassa_webhook(db, webhook_data)
+                    # Проверяем, не обрабатывается ли этот платеж уже (защита от дублирования)
+                    from app.database.models import PaymentMethod
+                    from app.database.crud.transaction import get_transaction_by_external_id
+                    existing_transaction = None
+                    if yookassa_payment_id and hasattr(db, "execute"):
+                        existing_transaction = await get_transaction_by_external_id(db, yookassa_payment_id, PaymentMethod.YOOKASSA)
+
+                    if existing_transaction and event_type == "payment.succeeded":
+                        logger.info(f"ℹ️ Платеж YooKassa {yookassa_payment_id} уже был обработан. Пропускаем дублирующий вебхук.")
+                        return web.Response(status=200, text="OK")
                    
+                    success = await self.payment_service.process_yookassa_webhook(db, webhook_data)
+
                    if success:
-                        logger.info(f"✅ Успешно обработан webhook YooKassa: {event_type}")
+                        logger.info(f"✅ Успешно обработан webhook YooKassa: {event_type} для платежа {yookassa_payment_id}")
                        return web.Response(status=200, text="OK")
                    else:
-                        logger.error(f"❌ Ошибка обработки webhook YooKassa: {event_type}")
+                        logger.error(f"❌ Ошибка обработки webhook YooKassa: {event_type} для платежа {yookassa_payment_id}")
                        return web.Response(status=500, text="Processing error")
-                        
+
                finally:
                    await db.close()
-        
+
        except Exception as e:
            logger.error(f"❌ Критическая ошибка обработки webhook YooKassa: {e}", exc_info=True)
            return web.Response(status=500, text="Internal server error")
-    
+
    def setup_routes(self, app: web.Application) -> None:
-        
+
        webhook_path = settings.YOOKASSA_WEBHOOK_PATH
        app.router.add_post(webhook_path, self.handle_webhook)
-        app.router.add_get(webhook_path, self._get_handler) 
-        app.router.add_options(webhook_path, self._options_handler) 
-        
+        app.router.add_get(webhook_path, self._get_handler)
+        app.router.add_options(webhook_path, self._options_handler)
+
        logger.info(f"✅ Настроен YooKassa webhook на пути: POST {webhook_path}")
-    
+
    async def _get_handler(self, request: web.Request) -> web.Response:
        return web.json_response({
            "status": "ok",
@@ -172,7 +315,7 @@ class YooKassaWebhookHandler:
            "path": request.path,
            "note": "Use POST method for actual webhooks"
        })
-    
+
    async def _options_handler(self, request: web.Request) -> web.Response:
        return web.Response(
            status=200,
@@ -185,49 +328,58 @@ class YooKassaWebhookHandler:


 def create_yookassa_webhook_app(payment_service: PaymentService) -> web.Application:
-    
+
    app = web.Application()
-    
+
    webhook_handler = YooKassaWebhookHandler(payment_service)
    webhook_handler.setup_routes(app)
-    
+
    async def health_check(request):
        return web.json_response({
-            "status": "ok", 
+            "status": "ok",
            "service": "yookassa_webhook",
            "port": settings.YOOKASSA_WEBHOOK_PORT,
            "path": settings.YOOKASSA_WEBHOOK_PATH,
            "enabled": settings.is_yookassa_enabled()
        })
-    
+
    app.router.add_get("/health", health_check)
-    
+
    return app


 async def start_yookassa_webhook_server(payment_service: PaymentService) -> None:
-    
+
    if not settings.is_yookassa_enabled():
        logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
        return
-    
+
    try:
        app = create_yookassa_webhook_app(payment_service)
-        
+
        runner = web.AppRunner(app)
        await runner.setup()
-        
+
        site = web.TCPSite(
-            runner, 
-            host='0.0.0.0',  
+            runner,
+            host=settings.YOOKASSA_WEBHOOK_HOST,
            port=settings.YOOKASSA_WEBHOOK_PORT
        )
-        
+
        await site.start()
-        
-        logger.info(f"✅ YooKassa webhook сервер запущен на порту {settings.YOOKASSA_WEBHOOK_PORT}")
-        logger.info(f"🎯 YooKassa webhook URL: http://0.0.0.0:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
-        
+
+        logger.info(
+            "✅ YooKassa webhook сервер запущен на %s:%s",
+            settings.YOOKASSA_WEBHOOK_HOST,
+            settings.YOOKASSA_WEBHOOK_PORT,
+        )
+        logger.info(
+            "🎯 YooKassa webhook URL: http://%s:%s%s",
+            settings.YOOKASSA_WEBHOOK_HOST,
+            settings.YOOKASSA_WEBHOOK_PORT,
+            settings.YOOKASSA_WEBHOOK_PATH,
+        )
+
        try:
            while True:
                await asyncio.sleep(1)
@@ -237,7 +389,7 @@ async def start_yookassa_webhook_server(payment_service: PaymentService) -> None
            await site.stop()
            await runner.cleanup()
            logger.info("✅ YooKassa webhook сервер остановлен")
-        
+
    except Exception as e:
        logger.error(f"❌ Ошибка запуска YooKassa webhook сервера: {e}", exc_info=True)
-        raise
+        raise
@@ -0,0 +1,3 @@
+from . import balance
+
+__all__ = ["balance"]
@@ -46,6 +46,9 @@ def _format_campaign_summary(campaign, texts) -> str:
        bonus_info = f"💰 Бонус на баланс: <b>{bonus_text}</b>"
    else:
        traffic_text = texts.format_traffic(campaign.subscription_traffic_gb or 0)
+        device_limit = campaign.subscription_device_limit
+        if device_limit is None:
+            device_limit = settings.DEFAULT_DEVICE_LIMIT
        bonus_info = (
            "📱 Подписка: <b>{days} д.</b>\n"
            "🌐 Трафик: <b>{traffic}</b>\n"
@@ -53,7 +56,7 @@ def _format_campaign_summary(campaign, texts) -> str:
        ).format(
            days=campaign.subscription_duration_days or 0,
            traffic=traffic_text,
-            devices=campaign.subscription_device_limit or settings.DEFAULT_DEVICE_LIMIT,
+            devices=device_limit,
        )

    return (
@@ -935,7 +938,9 @@ async def start_edit_campaign_subscription_devices(
        campaign_edit_message_is_caption=is_caption,
    )

-    current_devices = campaign.subscription_device_limit or settings.DEFAULT_DEVICE_LIMIT
+    current_devices = campaign.subscription_device_limit
+    if current_devices is None:
+        current_devices = settings.DEFAULT_DEVICE_LIMIT

    await callback.message.edit_text(
        (
@@ -71,10 +71,10 @@ async def show_users_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "👥 **Управление пользователями и подписками**\n\n"
-        "Выберите нужный раздел:",
+        texts.t("ADMIN_USERS_SUBMENU_TITLE", "👥 **Управление пользователями и подписками**\n\n") +
+        texts.t("ADMIN_SUBMENU_SELECT_SECTION", "Выберите нужный раздел:"),
        reply_markup=get_admin_users_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -89,10 +89,10 @@ async def show_promo_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "💰 **Промокоды и статистика**\n\n"
-        "Выберите нужный раздел:",
+        texts.t("ADMIN_PROMO_SUBMENU_TITLE", "💰 **Промокоды и статистика**\n\n") +
+        texts.t("ADMIN_SUBMENU_SELECT_SECTION", "Выберите нужный раздел:"),
        reply_markup=get_admin_promo_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -107,10 +107,10 @@ async def show_communications_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "📨 **Коммуникации**\n\n"
-        "Управление рассылками и текстами интерфейса:",
+        texts.t("ADMIN_COMMUNICATIONS_SUBMENU_TITLE", "📨 **Коммуникации**\n\n") +
+        texts.t("ADMIN_COMMUNICATIONS_SUBMENU_DESCRIPTION", "Управление рассылками и текстами интерфейса:"),
        reply_markup=get_admin_communications_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -128,16 +128,19 @@ async def show_support_submenu(
    # Moderators have access only to tickets and not to settings
    is_moderator_only = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
    
-    from app.keyboards.admin import get_admin_support_submenu_keyboard
    kb = get_admin_support_submenu_keyboard(db_user.language)
    if is_moderator_only:
        # Rebuild keyboard to include only tickets and back to main menu
        kb = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="🎫 Тикеты поддержки", callback_data="admin_tickets")],
-            [InlineKeyboardButton(text="⬅️ Назад", callback_data="back_to_menu")]
+            [InlineKeyboardButton(text=texts.t("ADMIN_SUPPORT_TICKETS", "🎫 Тикеты поддержки"), callback_data="admin_tickets")],
+            [InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")]
        ])
    await callback.message.edit_text(
-        "🛟 **Поддержка**\n\n" + ("Доступ к тикетам." if is_moderator_only else "Управление тикетами и настройками поддержки:"),
+        texts.t("ADMIN_SUPPORT_SUBMENU_TITLE", "🛟 **Поддержка**\n\n") + (
+            texts.t("ADMIN_SUPPORT_SUBMENU_DESCRIPTION_MODERATOR", "Доступ к тикетам.")
+            if is_moderator_only
+            else texts.t("ADMIN_SUPPORT_SUBMENU_DESCRIPTION", "Управление тикетами и настройками поддержки:")
+        ),
        reply_markup=kb,
        parse_mode="Markdown"
    )
@@ -150,12 +153,14 @@ async def show_moderator_panel(
    db_user: User,
    db: AsyncSession
 ):
+    texts = get_texts(db_user.language)
    kb = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🎫 Тикеты поддержки", callback_data="admin_tickets")],
-        [InlineKeyboardButton(text="⬅️ В главное меню", callback_data="back_to_menu")]
+        [InlineKeyboardButton(text=texts.t("ADMIN_SUPPORT_TICKETS", "🎫 Тикеты поддержки"), callback_data="admin_tickets")],
+        [InlineKeyboardButton(text=texts.t("BACK_TO_MAIN_MENU_BUTTON", "⬅️ В главное меню"), callback_data="back_to_menu")]
    ])
    await callback.message.edit_text(
-        "🧑‍⚖️ <b>Модерация поддержки</b>\n\nДоступ к тикетам поддержки.",
+        texts.t("ADMIN_SUPPORT_MODERATION_TITLE", "🧑‍⚖️ <b>Модерация поддержки</b>") + "\n\n" +
+        texts.t("ADMIN_SUPPORT_MODERATION_DESCRIPTION", "Доступ к тикетам поддержки."),
        parse_mode="HTML",
        reply_markup=kb
    )
@@ -169,6 +174,7 @@ async def show_support_audit(
    db_user: User,
    db: AsyncSession
 ):
+    texts = get_texts(db_user.language)
    # pagination
    page = 1
    if callback.data.startswith("admin_support_audit_page_"):
@@ -186,18 +192,23 @@ async def show_support_audit(
    offset = (page - 1) * per_page
    logs = await TicketCRUD.list_support_audit(db, limit=per_page, offset=offset)

-    lines = ["🧾 <b>Аудит модераторов</b>", ""]
+    lines = [texts.t("ADMIN_SUPPORT_AUDIT_TITLE", "🧾 <b>Аудит модераторов</b>"), ""]
    if not logs:
-        lines.append("Пока пусто")
+        lines.append(texts.t("ADMIN_SUPPORT_AUDIT_EMPTY", "Пока пусто"))
    else:
        for log in logs:
-            role = "Модератор" if getattr(log, 'is_moderator', False) else "Админ"
+            role = (
+                texts.t("ADMIN_SUPPORT_AUDIT_ROLE_MODERATOR", "Модератор")
+                if getattr(log, 'is_moderator', False)
+                else texts.t("ADMIN_SUPPORT_AUDIT_ROLE_ADMIN", "Админ")
+            )
            ts = log.created_at.strftime('%d.%m.%Y %H:%M') if getattr(log, 'created_at', None) else ''
            action_map = {
-                'close_ticket': 'Закрытие тикета',
-                'block_user_timed': 'Блокировка (время)',
-                'block_user_perm': 'Блокировка (навсегда)',
-                'unblock_user': 'Снятие блока',
+                'close_ticket': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_CLOSE_TICKET", "Закрытие тикета"),
+                'block_user_timed': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_TIMED", "Блокировка (время)"),
+                'block_user_perm': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_BLOCK_PERM", "Блокировка (навсегда)"),
+                'close_all_tickets': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_CLOSE_ALL_TICKETS", "Массовое закрытие тикетов"),
+                'unblock_user': texts.t("ADMIN_SUPPORT_AUDIT_ACTION_UNBLOCK", "Снятие блока"),
            }
            action_text = action_map.get(log.action, log.action)
            ticket_part = f" тикет #{log.ticket_id}" if log.ticket_id else ""
@@ -205,6 +216,8 @@ async def show_support_audit(
            extra = ""
            if log.action == 'block_user_timed' and 'minutes' in details:
                extra = f" ({details['minutes']} мин)"
+            elif log.action == 'close_all_tickets' and 'count' in details:
+                extra = f" ({details['count']})"
            lines.append(f"{ts} • {role} <code>{log.actor_telegram_id}</code> — {action_text}{ticket_part}{extra}")

    # keyboard with pagination
@@ -219,7 +232,7 @@ async def show_support_audit(
    kb_rows = []
    if nav_row:
        kb_rows.append(nav_row)
-    kb_rows.append([InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_submenu_support")])
+    kb_rows.append([InlineKeyboardButton(text=texts.BACK, callback_data="admin_submenu_support")])
    kb = InlineKeyboardMarkup(inline_keyboard=kb_rows)

    await callback.message.edit_text("\n".join(lines), parse_mode="HTML", reply_markup=kb)
@@ -234,10 +247,10 @@ async def show_settings_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "⚙️ **Настройки системы**\n\n"
-        "Управление Remnawave, мониторингом и другими настройками:",
+        texts.t("ADMIN_SETTINGS_SUBMENU_TITLE", "⚙️ **Настройки системы**\n\n") +
+        texts.t("ADMIN_SETTINGS_SUBMENU_DESCRIPTION", "Управление Remnawave, мониторингом и другими настройками:"),
        reply_markup=get_admin_settings_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -252,10 +265,10 @@ async def show_system_submenu(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    await callback.message.edit_text(
-        "🛠️ **Системные функции**\n\n"
-        "Отчеты, обновления, резервные копии и системные операции:",
+        texts.t("ADMIN_SYSTEM_SUBMENU_TITLE", "🛠️ **Системные функции**\n\n") +
+        texts.t("ADMIN_SYSTEM_SUBMENU_DESCRIPTION", "Отчеты, обновления, логи, резервные копии и системные операции:"),
        reply_markup=get_admin_system_submenu_keyboard(db_user.language),
        parse_mode="Markdown"
    )
@@ -436,4 +449,4 @@ def register_handlers(dp: Dispatcher):
    dp.message.register(
        admin_commands_help,
        Command("admin_help")
-    )
+    )
@@ -74,6 +74,7 @@ async def show_maintenance_panel(
 {status_emoji} <b>Режим техработ:</b> {status_text}
 {api_emoji} <b>API Remnawave:</b> {api_text}
 {monitoring_emoji} <b>Мониторинг:</b> {monitoring_text}
+🛠️ <b>Автозапуск мониторинга:</b> {'Включен' if status_info['monitoring_configured'] else 'Отключен'}
 ⏱️ <b>Интервал проверки:</b> {status_info['check_interval']}с
 🤖 <b>Автовключение:</b> {'Включено' if status_info['auto_enable_configured'] else 'Отключено'}
 {panel_info}
@@ -233,7 +234,11 @@ async def check_panel_status(
            f"👥 Пользователей онлайн: {status_data.get('users_online', 0)}",
            f"🖥️ Нод онлайн: {status_data.get('nodes_online', 0)}/{status_data.get('total_nodes', 0)}"
        ]
-        
+
+        attempts_used = status_data.get("attempts_used")
+        if attempts_used:
+            message_parts.append(f"🔁 Попыток проверки: {attempts_used}")
+
        if status_data.get("api_error"):
            message_parts.append(f"❌ Ошибка: {status_data['api_error'][:100]}")
        
@@ -3,8 +3,10 @@ import asyncio
 from datetime import datetime, timedelta
 from typing import Optional
 from aiogram import Dispatcher, types, F
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError, TelegramRetryAfter
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import InterfaceError
 from sqlalchemy import select, func, and_, or_

 from app.config import settings
@@ -16,25 +18,33 @@ from app.database.models import (
    SubscriptionStatus,
    BroadcastHistory,
 )
+from app.database.database import AsyncSessionLocal
 from app.keyboards.admin import (
    get_admin_messages_keyboard, get_broadcast_target_keyboard,
    get_custom_criteria_keyboard, get_broadcast_history_keyboard,
    get_admin_pagination_keyboard, get_broadcast_media_keyboard,
    get_media_confirm_keyboard, get_updated_message_buttons_selector_keyboard_with_media,
-    BROADCAST_BUTTONS, BROADCAST_BUTTON_ROWS, DEFAULT_BROADCAST_BUTTONS,
-    BROADCAST_BUTTON_LABELS
+    BROADCAST_BUTTON_ROWS, DEFAULT_BROADCAST_BUTTONS,
+    get_broadcast_button_config, get_broadcast_button_labels
 )
 from app.localization.texts import get_texts
 from app.database.crud.user import get_users_list
 from app.database.crud.subscription import get_expiring_subscriptions
 from app.utils.decorators import admin_required, error_handler
+from app.utils.miniapp_buttons import build_miniapp_or_callback_button

 logger = logging.getLogger(__name__)

-BUTTON_CONFIG = BROADCAST_BUTTONS
 BUTTON_ROWS = BROADCAST_BUTTON_ROWS
 DEFAULT_SELECTED_BUTTONS = DEFAULT_BROADCAST_BUTTONS
-BUTTON_LABELS = BROADCAST_BUTTON_LABELS
+
+TEXT_MENU_MINIAPP_BUTTON_KEYS = {
+    "balance",
+    "referrals",
+    "promocode",
+    "connect",
+    "subscription",
+}


 def get_message_buttons_selector_keyboard(language: str = "ru") -> types.InlineKeyboardMarkup:
@@ -45,22 +55,31 @@ def get_updated_message_buttons_selector_keyboard(selected_buttons: list, langua
    return get_updated_message_buttons_selector_keyboard_with_media(selected_buttons, False, language)


-def create_broadcast_keyboard(selected_buttons: list) -> Optional[types.InlineKeyboardMarkup]:
+def create_broadcast_keyboard(selected_buttons: list, language: str = "ru") -> Optional[types.InlineKeyboardMarkup]:
    selected_buttons = selected_buttons or []
    keyboard: list[list[types.InlineKeyboardButton]] = []
+    button_config_map = get_broadcast_button_config(language)

    for row in BUTTON_ROWS:
        row_buttons: list[types.InlineKeyboardButton] = []
        for button_key in row:
            if button_key not in selected_buttons:
                continue
-            button_config = BUTTON_CONFIG[button_key]
-            row_buttons.append(
-                types.InlineKeyboardButton(
-                    text=button_config["text"],
-                    callback_data=button_config["callback"]
+            button_config = button_config_map[button_key]
+            if settings.is_text_main_menu_mode() and button_key in TEXT_MENU_MINIAPP_BUTTON_KEYS:
+                row_buttons.append(
+                    build_miniapp_or_callback_button(
+                        text=button_config["text"],
+                        callback_data=button_config["callback"],
+                    )
+                )
+            else:
+                row_buttons.append(
+                    types.InlineKeyboardButton(
+                        text=button_config["text"],
+                        callback_data=button_config["callback"]
+                    )
                )
-            )
        if row_buttons:
            keyboard.append(row_buttons)

@@ -70,6 +89,56 @@ def create_broadcast_keyboard(selected_buttons: list) -> Optional[types.InlineKe
    return types.InlineKeyboardMarkup(inline_keyboard=keyboard)


+async def _persist_broadcast_result(
+    db: AsyncSession,
+    broadcast_history: BroadcastHistory,
+    sent_count: int,
+    failed_count: int,
+    status: str,
+) -> None:
+    """Сохраняет результаты рассылки с повторной попыткой при обрыве соединения."""
+
+    broadcast_history.sent_count = sent_count
+    broadcast_history.failed_count = failed_count
+    broadcast_history.status = status
+    broadcast_history.completed_at = datetime.utcnow()
+
+    try:
+        await db.commit()
+        return
+    except InterfaceError as error:
+        logger.warning(
+            "Соединение с БД потеряно при сохранении результатов рассылки, пробуем еще раз",
+            exc_info=error,
+        )
+        await db.rollback()
+
+    try:
+        async with AsyncSessionLocal() as retry_session:
+            retry_history = await retry_session.get(BroadcastHistory, broadcast_history.id)
+            if not retry_history:
+                logger.critical(
+                    "Не удалось найти запись BroadcastHistory #%s для повторной записи результатов",
+                    broadcast_history.id,
+                )
+                return
+
+            retry_history.sent_count = sent_count
+            retry_history.failed_count = failed_count
+            retry_history.status = status
+            retry_history.completed_at = broadcast_history.completed_at
+            await retry_session.commit()
+            logger.info(
+                "Результаты рассылки успешно сохранены после повторного подключения к БД (id=%s)",
+                broadcast_history.id,
+            )
+    except Exception as retry_error:
+        logger.critical(
+            "Не удалось сохранить результаты рассылки после восстановления подключения",
+            exc_info=retry_error,
+        )
+
+
@admin_required
@error_handler
 async def show_messages_menu(
@@ -628,7 +697,8 @@ async def confirm_button_selection(
        media_info = f"\n🖼️ <b>Медиафайл:</b> {media_type_names.get(media_type, media_type)}"
    
    ordered_keys = [button_key for row in BUTTON_ROWS for button_key in row]
-    selected_names = [BUTTON_LABELS[key] for key in ordered_keys if key in selected_buttons]
+    button_labels = get_broadcast_button_labels(db_user.language)
+    selected_names = [button_labels[key] for key in ordered_keys if key in selected_buttons]
    if selected_names:
        buttons_info = f"\n📘 <b>Кнопки:</b> {', '.join(selected_names)}"
    else:
@@ -745,56 +815,105 @@ async def confirm_broadcast(
    sent_count = 0
    failed_count = 0
    
-    broadcast_keyboard = create_broadcast_keyboard(selected_buttons)
+    broadcast_keyboard = create_broadcast_keyboard(selected_buttons, db_user.language)
    
-    for user in users:
-        try:
-            if has_media and media_file_id:
-                if media_type == "photo":
-                    await callback.bot.send_photo(
-                        chat_id=user.telegram_id,
-                        photo=media_file_id,
-                        caption=message_text,
-                        parse_mode="HTML",
-                        reply_markup=broadcast_keyboard
+    # Ограничение на количество одновременных отправок и базовая задержка между сообщениями,
+    # чтобы избежать перегрузки бота и лимитов Telegram при больших рассылках
+    max_concurrent_sends = 5
+    per_message_delay = 0.05
+    semaphore = asyncio.Semaphore(max_concurrent_sends)
+
+    async def send_single_broadcast(user):
+        """Отправляет одно сообщение рассылки с семафором ограничения"""
+        async with semaphore:
+            for attempt in range(3):
+                try:
+                    if has_media and media_file_id:
+                        if media_type == "photo":
+                            await callback.bot.send_photo(
+                                chat_id=user.telegram_id,
+                                photo=media_file_id,
+                                caption=message_text,
+                                parse_mode="HTML",
+                                reply_markup=broadcast_keyboard
+                            )
+                        elif media_type == "video":
+                            await callback.bot.send_video(
+                                chat_id=user.telegram_id,
+                                video=media_file_id,
+                                caption=message_text,
+                                parse_mode="HTML",
+                                reply_markup=broadcast_keyboard
+                            )
+                        elif media_type == "document":
+                            await callback.bot.send_document(
+                                chat_id=user.telegram_id,
+                                document=media_file_id,
+                                caption=message_text,
+                                parse_mode="HTML",
+                                reply_markup=broadcast_keyboard
+                            )
+                    else:
+                        await callback.bot.send_message(
+                            chat_id=user.telegram_id,
+                            text=message_text,
+                            parse_mode="HTML",
+                            reply_markup=broadcast_keyboard
+                        )
+
+                    await asyncio.sleep(per_message_delay)
+                    return True, user.telegram_id
+                except TelegramRetryAfter as e:
+                    retry_delay = min(e.retry_after + 1, 30)
+                    logger.warning(
+                        f"Превышен лимит Telegram для {user.telegram_id}, ожидание {retry_delay} сек."
                    )
-                elif media_type == "video":
-                    await callback.bot.send_video(
-                        chat_id=user.telegram_id,
-                        video=media_file_id,
-                        caption=message_text,
-                        parse_mode="HTML",
-                        reply_markup=broadcast_keyboard
+                    await asyncio.sleep(retry_delay)
+                except TelegramForbiddenError:
+                    # Пользователь мог удалить бота или запретить сообщения
+                    logger.info(f"Рассылка недоступна для пользователя {user.telegram_id}: Forbidden")
+                    return False, user.telegram_id
+                except TelegramBadRequest as e:
+                    logger.error(
+                        f"Некорректный запрос при рассылке пользователю {user.telegram_id}: {e}"
                    )
-                elif media_type == "document":
-                    await callback.bot.send_document(
-                        chat_id=user.telegram_id,
-                        document=media_file_id,
-                        caption=message_text,
-                        parse_mode="HTML",
-                        reply_markup=broadcast_keyboard
+                    return False, user.telegram_id
+                except Exception as e:
+                    logger.error(
+                        f"Ошибка отправки рассылки пользователю {user.telegram_id} (попытка {attempt + 1}/3): {e}"
                    )
-            else:
-                await callback.bot.send_message(
-                    chat_id=user.telegram_id,
-                    text=message_text,
-                    parse_mode="HTML",
-                    reply_markup=broadcast_keyboard
-                )
-            sent_count += 1
-            
-            if sent_count % 20 == 0:
-                await asyncio.sleep(1)
-                
-        except Exception as e:
-            failed_count += 1
-            logger.error(f"Ошибка отправки рассылки пользователю {user.telegram_id}: {e}")
+                    await asyncio.sleep(0.5 * (attempt + 1))
+
+            return False, user.telegram_id
+
+    # Отправляем сообщения пакетами для эффективности
+    batch_size = 50
+    for i in range(0, len(users), batch_size):
+        batch = users[i:i + batch_size]
+        tasks = [send_single_broadcast(user) for user in batch]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for result in results:
+            if isinstance(result, tuple):  # (success, telegram_id)
+                success, _ = result
+                if success:
+                    sent_count += 1
+                else:
+                    failed_count += 1
+            elif isinstance(result, Exception):
+                failed_count += 1
+
+        # Небольшая задержка между пакетами для снижения нагрузки на API
+        await asyncio.sleep(0.25)
    
-    broadcast_history.sent_count = sent_count
-    broadcast_history.failed_count = failed_count
-    broadcast_history.status = "completed" if failed_count == 0 else "partial"
-    broadcast_history.completed_at = datetime.utcnow()
-    await db.commit()
+    status = "completed" if failed_count == 0 else "partial"
+    await _persist_broadcast_result(
+        db=db,
+        broadcast_history=broadcast_history,
+        sent_count=sent_count,
+        failed_count=failed_count,
+        status=status,
+    )
    
    media_info = ""
    if has_media:
@@ -830,7 +949,24 @@ async def get_target_users_count(db: AsyncSession, target: str) -> int:


 async def get_target_users(db: AsyncSession, target: str) -> list:
-    users = await get_users_list(db, offset=0, limit=10000, status=UserStatus.ACTIVE)
+    # Загружаем всех активных пользователей батчами, чтобы не ограничиваться 10к
+    users: list[User] = []
+    offset = 0
+    batch_size = 5000
+
+    while True:
+        batch = await get_users_list(
+            db,
+            offset=offset,
+            limit=batch_size,
+            status=UserStatus.ACTIVE,
+        )
+
+        if not batch:
+            break
+
+        users.extend(batch)
+        offset += batch_size

    if target == "all":
        return users
@@ -37,6 +37,9 @@ def _build_notification_settings_view(language: str):

    trial_1h_status = _format_toggle(config["trial_inactive_1h"].get("enabled", True))
    trial_24h_status = _format_toggle(config["trial_inactive_24h"].get("enabled", True))
+    trial_channel_status = _format_toggle(
+        config["trial_channel_unsubscribed"].get("enabled", True)
+    )
    expired_1d_status = _format_toggle(config["expired_1d"].get("enabled", True))
    second_wave_status = _format_toggle(config["expired_second_wave"].get("enabled", True))
    third_wave_status = _format_toggle(config["expired_third_wave"].get("enabled", True))
@@ -45,6 +48,7 @@ def _build_notification_settings_view(language: str):
        "🔔 <b>Уведомления пользователям</b>\n\n"
        f"• 1 час после триала: {trial_1h_status}\n"
        f"• 24 часа после триала: {trial_24h_status}\n"
+        f"• Отписка от канала: {trial_channel_status}\n"
        f"• 1 день после истечения: {expired_1d_status}\n"
        f"• 2-3 дня (скидка {second_percent}% / {second_hours} ч): {second_wave_status}\n"
        f"• {third_days} дней (скидка {third_percent}% / {third_hours} ч): {third_wave_status}"
@@ -57,6 +61,8 @@ def _build_notification_settings_view(language: str):
        [InlineKeyboardButton(text="🧪 Тест: 1 час после триала", callback_data="admin_mon_notify_preview_trial_1h")],
        [InlineKeyboardButton(text=f"{trial_24h_status} • 24 часа после триала", callback_data="admin_mon_notify_toggle_trial_24h")],
        [InlineKeyboardButton(text="🧪 Тест: 24 часа после триала", callback_data="admin_mon_notify_preview_trial_24h")],
+        [InlineKeyboardButton(text=f"{trial_channel_status} • Отписка от канала", callback_data="admin_mon_notify_toggle_trial_channel")],
+        [InlineKeyboardButton(text="🧪 Тест: отписка от канала", callback_data="admin_mon_notify_preview_trial_channel")],
        [InlineKeyboardButton(text=f"{expired_1d_status} • 1 день после истечения", callback_data="admin_mon_notify_toggle_expired_1d")],
        [InlineKeyboardButton(text="🧪 Тест: 1 день после истечения", callback_data="admin_mon_notify_preview_expired_1d")],
        [InlineKeyboardButton(text=f"{second_wave_status} • 2-3 дня со скидкой", callback_data="admin_mon_notify_toggle_expired_2d")],
@@ -153,6 +159,36 @@ def _build_notification_preview_message(language: str, notification_type: str):
                ],
            ]
        )
+    elif notification_type == "trial_channel_unsubscribed":
+        template = texts.get(
+            "TRIAL_CHANNEL_UNSUBSCRIBED",
+            (
+                "🚫 <b>Доступ приостановлен</b>\n\n"
+                "Мы не нашли вашу подписку на наш канал, поэтому тестовая подписка отключена.\n\n"
+                "Подпишитесь на канал и нажмите «{check_button}», чтобы вернуть доступ."
+            ),
+        )
+        check_button = texts.t("CHANNEL_CHECK_BUTTON", "✅ Я подписался")
+        message = template.format(check_button=check_button)
+        buttons: list[list[InlineKeyboardButton]] = []
+        if settings.CHANNEL_LINK:
+            buttons.append(
+                [
+                    InlineKeyboardButton(
+                        text=texts.t("CHANNEL_SUBSCRIBE_BUTTON", "🔗 Подписаться"),
+                        url=settings.CHANNEL_LINK,
+                    )
+                ]
+            )
+        buttons.append(
+            [
+                InlineKeyboardButton(
+                    text=check_button,
+                    callback_data="sub_channel_check",
+                )
+            ]
+        )
+        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
    elif notification_type == "expired_1d":
        template = texts.get(
            "SUBSCRIPTION_EXPIRED_1D",
@@ -190,18 +226,16 @@ def _build_notification_preview_message(language: str, notification_type: str):
    elif notification_type == "expired_2d":
        percent = NotificationSettingsService.get_second_wave_discount_percent()
        valid_hours = NotificationSettingsService.get_second_wave_valid_hours()
-        bonus_amount = settings.PRICE_30_DAYS * percent // 100
        template = texts.get(
            "SUBSCRIPTION_EXPIRED_SECOND_WAVE",
            (
                "🔥 <b>Скидка {percent}% на продление</b>\n\n"
-                "Нажмите «Получить скидку», и мы начислим {bonus} на баланс. "
-                "Предложение действует до {expires_at}."
+                "Активируйте предложение, чтобы получить дополнительную скидку. "
+                "Она суммируется с вашей промогруппой и действует до {expires_at}."
            ),
        )
        message = template.format(
            percent=percent,
-            bonus=settings.format_price(bonus_amount),
            expires_at=(now + timedelta(hours=valid_hours)).strftime("%d.%m.%Y %H:%M"),
            trigger_days=3,
        )
@@ -237,18 +271,16 @@ def _build_notification_preview_message(language: str, notification_type: str):
        percent = NotificationSettingsService.get_third_wave_discount_percent()
        valid_hours = NotificationSettingsService.get_third_wave_valid_hours()
        trigger_days = NotificationSettingsService.get_third_wave_trigger_days()
-        bonus_amount = settings.PRICE_30_DAYS * percent // 100
        template = texts.get(
            "SUBSCRIPTION_EXPIRED_THIRD_WAVE",
            (
                "🎁 <b>Индивидуальная скидка {percent}%</b>\n\n"
-                "Прошло {trigger_days} дней без подписки — возвращайтесь, и мы добавим {bonus} на баланс. "
-                "Скидка действует до {expires_at}."
+                "Прошло {trigger_days} дней без подписки — возвращайтесь и активируйте дополнительную скидку. "
+                "Она суммируется с промогруппой и действует до {expires_at}."
            ),
        )
        message = template.format(
            percent=percent,
-            bonus=settings.format_price(bonus_amount),
            trigger_days=trigger_days,
            expires_at=(now + timedelta(hours=valid_hours)).strftime("%d.%m.%Y %H:%M"),
        )
@@ -368,7 +400,8 @@ async def admin_monitoring_menu(callback: CallbackQuery):
 🔧 Выберите действие:
 """
            
-            keyboard = get_monitoring_keyboard()
+            language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+            keyboard = get_monitoring_keyboard(language)
            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
            break
            
@@ -461,6 +494,27 @@ async def preview_trial_24h_notification(callback: CallbackQuery):
        await callback.answer("❌ Не удалось отправить тест", show_alert=True)


+@router.callback_query(F.data == "admin_mon_notify_toggle_trial_channel")
+@admin_required
+async def toggle_trial_channel_notification(callback: CallbackQuery):
+    enabled = NotificationSettingsService.is_trial_channel_unsubscribed_enabled()
+    NotificationSettingsService.set_trial_channel_unsubscribed_enabled(not enabled)
+    await callback.answer("✅ Включено" if not enabled else "⏸️ Отключено")
+    await _render_notification_settings(callback)
+
+
+@router.callback_query(F.data == "admin_mon_notify_preview_trial_channel")
+@admin_required
+async def preview_trial_channel_notification(callback: CallbackQuery):
+    try:
+        language = callback.from_user.language_code or settings.DEFAULT_LANGUAGE
+        await _send_notification_preview(callback.bot, callback.from_user.id, language, "trial_channel_unsubscribed")
+        await callback.answer("✅ Пример отправлен")
+    except Exception as exc:
+        logger.error("Failed to send trial channel preview: %s", exc)
+        await callback.answer("❌ Не удалось отправить тест", show_alert=True)
+
+
@router.callback_query(F.data == "admin_mon_notify_toggle_expired_1d")
@admin_required
 async def toggle_expired_1d_notification(callback: CallbackQuery):
@@ -533,6 +587,7 @@ async def preview_all_notifications(callback: CallbackQuery):
        for notification_type in [
            "trial_inactive_1h",
            "trial_inactive_24h",
+            "trial_channel_unsubscribed",
            "expired_1d",
            "expired_2d",
            "expired_nd",
@@ -972,6 +1027,20 @@ async def process_notification_value_input(message: Message, state: FSMContext):
    language = data.get("settings_language") or message.from_user.language_code or settings.DEFAULT_LANGUAGE
    texts = get_texts(language)

+    # Добавляем дополнительные проверки диапазона значений
+    if (key == "expired_second_wave" and field == "percent") or (key == "expired_third_wave" and field == "percent"):
+        if value < 0 or value > 100:
+            await message.answer("❌ Процент скидки должен быть от 0 до 100.")
+            return
+    elif (key == "expired_second_wave" and field == "hours") or (key == "expired_third_wave" and field == "hours"):
+        if value < 1 or value > 168:  # Максимум 168 часов (7 дней)
+            await message.answer("❌ Количество часов должно быть от 1 до 168.")
+            return
+    elif key == "expired_third_wave" and field == "trigger":
+        if value < 2:  # Минимум 2 дня
+            await message.answer("❌ Количество дней должно быть не менее 2.")
+            return
+
    success = False
    if key == "expired_second_wave" and field == "percent":
        success = NotificationSettingsService.set_second_wave_discount_percent(value)
@@ -1020,4 +1089,4 @@ async def process_notification_value_input(message: Message, state: FSMContext):


 def register_handlers(dp):
-    dp.include_router(router)
+    dp.include_router(router)
@@ -0,0 +1,612 @@
+from __future__ import annotations
+
+import html
+import math
+from typing import Optional
+
+from aiogram import Dispatcher, F, types
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import PaymentMethod, User
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.services.payment_verification_service import (
+    PendingPayment,
+    SUPPORTED_MANUAL_CHECK_METHODS,
+    get_payment_record,
+    list_recent_pending_payments,
+    run_manual_check,
+)
+from app.utils.decorators import admin_required, error_handler
+from app.utils.formatters import format_datetime, format_time_ago, format_username
+
+
+PAGE_SIZE = 6
+
+
+def _method_display(method: PaymentMethod) -> str:
+    if method == PaymentMethod.MULENPAY:
+        return settings.get_mulenpay_display_name()
+    if method == PaymentMethod.PAL24:
+        return "PayPalych"
+    if method == PaymentMethod.WATA:
+        return "WATA"
+    if method == PaymentMethod.HELEKET:
+        return "Heleket"
+    if method == PaymentMethod.YOOKASSA:
+        return "YooKassa"
+    if method == PaymentMethod.PLATEGA:
+        return "Platega"
+    if method == PaymentMethod.CRYPTOBOT:
+        return "CryptoBot"
+    if method == PaymentMethod.TELEGRAM_STARS:
+        return "Telegram Stars"
+    return method.value
+
+
+def _status_info(
+    record: PendingPayment,
+    *,
+    texts,
+) -> tuple[str, str]:
+    status = (record.status or "").lower()
+
+    if record.is_paid:
+        return "✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")
+
+    if record.method == PaymentMethod.PAL24:
+        mapping = {
+            "new": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "process": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_PROCESSING", "⌛ Processing")),
+            "success": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "fail": ("❌", texts.t("ADMIN_PAYMENT_STATUS_FAILED", "❌ Failed")),
+            "canceled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "cancel": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.MULENPAY:
+        mapping = {
+            "created": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "processing": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_PROCESSING", "⌛ Processing")),
+            "hold": ("🔒", texts.t("ADMIN_PAYMENT_STATUS_ON_HOLD", "🔒 Hold")),
+            "success": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "canceled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "cancel": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "error": ("⚠️", texts.t("ADMIN_PAYMENT_STATUS_FAILED", "❌ Failed")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.WATA:
+        mapping = {
+            "opened": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "pending": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "processing": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_PROCESSING", "⌛ Processing")),
+            "paid": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "closed": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "declined": ("❌", texts.t("ADMIN_PAYMENT_STATUS_FAILED", "❌ Failed")),
+            "canceled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "expired": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_EXPIRED", "⌛ Expired")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.PLATEGA:
+        mapping = {
+            "pending": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "inprogress": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_PROCESSING", "⌛ Processing")),
+            "confirmed": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "failed": ("❌", texts.t("ADMIN_PAYMENT_STATUS_FAILED", "❌ Failed")),
+            "canceled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "cancelled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+            "expired": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_EXPIRED", "⌛ Expired")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.HELEKET:
+        if status in {"pending", "created", "waiting", "check", "processing"}:
+            return "⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")
+        if status in {"paid", "paid_over"}:
+            return "✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")
+        if status in {"cancel", "canceled", "fail", "failed", "expired"}:
+            return "❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")
+        return "❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")
+
+    if record.method == PaymentMethod.YOOKASSA:
+        mapping = {
+            "pending": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "waiting_for_capture": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_PROCESSING", "⌛ Processing")),
+            "succeeded": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "canceled": ("❌", texts.t("ADMIN_PAYMENT_STATUS_CANCELED", "❌ Cancelled")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.CRYPTOBOT:
+        mapping = {
+            "active": ("⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")),
+            "paid": ("✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")),
+            "expired": ("⌛", texts.t("ADMIN_PAYMENT_STATUS_EXPIRED", "⌛ Expired")),
+        }
+        return mapping.get(status, ("❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")))
+
+    if record.method == PaymentMethod.TELEGRAM_STARS:
+        if record.is_paid:
+            return "✅", texts.t("ADMIN_PAYMENT_STATUS_PAID", "✅ Paid")
+        return "⏳", texts.t("ADMIN_PAYMENT_STATUS_PENDING", "⏳ Pending")
+
+    return "❓", texts.t("ADMIN_PAYMENT_STATUS_UNKNOWN", "❓ Unknown")
+
+
+def _is_checkable(record: PendingPayment) -> bool:
+    if record.method not in SUPPORTED_MANUAL_CHECK_METHODS:
+        return False
+    if not record.is_recent():
+        return False
+    status = (record.status or "").lower()
+    if record.method == PaymentMethod.PAL24:
+        return status in {"new", "process"}
+    if record.method == PaymentMethod.MULENPAY:
+        return status in {"created", "processing", "hold"}
+    if record.method == PaymentMethod.WATA:
+        return status in {"opened", "pending", "processing", "inprogress", "in_progress"}
+    if record.method == PaymentMethod.PLATEGA:
+        return status in {"pending", "inprogress", "in_progress"}
+    if record.method == PaymentMethod.HELEKET:
+        return status not in {"paid", "paid_over", "cancel", "canceled", "fail", "failed", "expired"}
+    if record.method == PaymentMethod.YOOKASSA:
+        return status in {"pending", "waiting_for_capture"}
+    if record.method == PaymentMethod.CRYPTOBOT:
+        return status in {"active"}
+    return False
+
+
+def _record_display_number(record: PendingPayment) -> str:
+    if record.identifier:
+        return str(record.identifier)
+    return str(record.local_id)
+
+
+def _build_list_keyboard(
+    records: list[PendingPayment],
+    *,
+    page: int,
+    total_pages: int,
+    language: str,
+) -> InlineKeyboardMarkup:
+    buttons: list[list[InlineKeyboardButton]] = []
+    texts = get_texts(language)
+
+    for record in records:
+        number = _record_display_number(record)
+        details_template = texts.t("ADMIN_PAYMENTS_ITEM_DETAILS", "📄 #{number}")
+        try:
+            button_text = details_template.format(number=number)
+        except Exception:  # pragma: no cover - fallback for broken localization
+            button_text = f"📄 {number}"
+        buttons.append(
+            [
+                InlineKeyboardButton(
+                    text=button_text,
+                    callback_data=f"admin_payment_{record.method.value}_{record.local_id}",
+                )
+            ]
+        )
+
+    if total_pages > 1:
+        navigation_row: list[InlineKeyboardButton] = []
+        if page > 1:
+            navigation_row.append(
+                InlineKeyboardButton(
+                    text="⬅️",
+                    callback_data=f"admin_payments_page_{page - 1}",
+                )
+            )
+
+        navigation_row.append(
+            InlineKeyboardButton(
+                text=f"{page}/{total_pages}",
+                callback_data="admin_payments_page_current",
+            )
+        )
+
+        if page < total_pages:
+            navigation_row.append(
+                InlineKeyboardButton(
+                    text="➡️",
+                    callback_data=f"admin_payments_page_{page + 1}",
+                )
+            )
+
+        buttons.append(navigation_row)
+
+    buttons.append([InlineKeyboardButton(text=texts.BACK, callback_data="admin_panel")])
+
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
+def _build_detail_keyboard(
+    record: PendingPayment,
+    *,
+    language: str,
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    rows: list[list[InlineKeyboardButton]] = []
+
+    payment = record.payment
+    payment_url = getattr(payment, "payment_url", None)
+    if record.method == PaymentMethod.PAL24:
+        payment_url = payment.link_url or payment.link_page_url or payment_url
+    elif record.method == PaymentMethod.WATA:
+        payment_url = payment.url or payment_url
+    elif record.method == PaymentMethod.YOOKASSA:
+        payment_url = getattr(payment, "confirmation_url", None) or payment_url
+    elif record.method == PaymentMethod.CRYPTOBOT:
+        payment_url = (
+            payment.bot_invoice_url
+            or payment.mini_app_invoice_url
+            or payment.web_app_invoice_url
+            or payment_url
+        )
+
+    if payment_url:
+        rows.append(
+            [
+                InlineKeyboardButton(
+                    text=texts.t("ADMIN_PAYMENT_OPEN_LINK", "🔗 Open link"),
+                    url=payment_url,
+                )
+            ]
+        )
+
+    if _is_checkable(record):
+        rows.append(
+            [
+                InlineKeyboardButton(
+                    text=texts.t("ADMIN_PAYMENT_CHECK_BUTTON", "🔁 Check status"),
+                    callback_data=f"admin_payment_check_{record.method.value}_{record.local_id}",
+                )
+            ]
+        )
+
+    rows.append([InlineKeyboardButton(text=texts.BACK, callback_data="admin_payments")])
+    return InlineKeyboardMarkup(inline_keyboard=rows)
+
+
+def _format_user_line(user: User) -> str:
+    username = format_username(user.username, user.telegram_id, user.full_name)
+    return f"👤 {html.escape(username)} (<code>{user.telegram_id}</code>)"
+
+
+def _build_record_lines(
+    record: PendingPayment,
+    *,
+    index: int,
+    texts,
+    language: str,
+) -> list[str]:
+    amount = settings.format_price(record.amount_kopeks)
+    if record.method == PaymentMethod.CRYPTOBOT:
+        crypto_amount = getattr(record.payment, "amount", None)
+        crypto_asset = getattr(record.payment, "asset", None)
+        if crypto_amount and crypto_asset:
+            amount = f"{crypto_amount} {crypto_asset}"
+    method_name = _method_display(record.method)
+    emoji, status_text = _status_info(record, texts=texts)
+    created = format_datetime(record.created_at)
+    age = format_time_ago(record.created_at, language)
+    identifier = (
+        html.escape(str(record.identifier)) if record.identifier else ""
+    )
+    display_number = html.escape(_record_display_number(record))
+
+    lines = [
+        f"{index}. <b>{html.escape(method_name)}</b> — {amount}",
+        f"   {emoji} {status_text}",
+        f"   🕒 {created} ({age})",
+        _format_user_line(record.user),
+    ]
+
+    if identifier:
+        lines.append(f"   🆔 ID: <code>{identifier}</code>")
+    else:
+        lines.append(f"   🆔 ID: <code>{display_number}</code>")
+
+    return lines
+
+
+def _build_payment_details_text(record: PendingPayment, *, texts, language: str) -> str:
+    method_name = _method_display(record.method)
+    emoji, status_text = _status_info(record, texts=texts)
+    amount = settings.format_price(record.amount_kopeks)
+    if record.method == PaymentMethod.CRYPTOBOT:
+        crypto_amount = getattr(record.payment, "amount", None)
+        crypto_asset = getattr(record.payment, "asset", None)
+        if crypto_amount and crypto_asset:
+            amount = f"{crypto_amount} {crypto_asset}"
+    created = format_datetime(record.created_at)
+    age = format_time_ago(record.created_at, language)
+    raw_identifier = record.identifier if record.identifier else record.local_id
+    identifier = html.escape(str(raw_identifier)) if raw_identifier is not None else "—"
+    lines = [
+        texts.t("ADMIN_PAYMENT_DETAILS_TITLE", "💳 <b>Payment details</b>"),
+        "",
+        f"<b>{html.escape(method_name)}</b>",
+        f"{emoji} {status_text}",
+        "",
+        f"💰 {texts.t('ADMIN_PAYMENT_AMOUNT', 'Amount')}: {amount}",
+        f"🕒 {texts.t('ADMIN_PAYMENT_CREATED', 'Created')}: {created} ({age})",
+        f"🆔 ID: <code>{identifier}</code>",
+        _format_user_line(record.user),
+    ]
+
+    if record.expires_at:
+        expires_at = format_datetime(record.expires_at)
+        lines.append(f"⏳ {texts.t('ADMIN_PAYMENT_EXPIRES', 'Expires')}: {expires_at}")
+
+    payment = record.payment
+
+    if record.method == PaymentMethod.PAL24:
+        if getattr(payment, "payment_status", None):
+            lines.append(
+                f"💳 {texts.t('ADMIN_PAYMENT_GATEWAY_STATUS', 'Gateway status')}: "
+                f"{html.escape(str(payment.payment_status))}"
+            )
+        if getattr(payment, "payment_method", None):
+            lines.append(
+                f"🏦 {texts.t('ADMIN_PAYMENT_GATEWAY_METHOD', 'Method')}: "
+                f"{html.escape(str(payment.payment_method))}"
+            )
+        if getattr(payment, "balance_amount", None):
+            lines.append(
+                f"💱 {texts.t('ADMIN_PAYMENT_GATEWAY_AMOUNT', 'Gateway amount')}: "
+                f"{html.escape(str(payment.balance_amount))}"
+            )
+        if getattr(payment, "payer_account", None):
+            lines.append(
+                f"👛 {texts.t('ADMIN_PAYMENT_GATEWAY_ACCOUNT', 'Payer account')}: "
+                f"{html.escape(str(payment.payer_account))}"
+            )
+
+    if record.method == PaymentMethod.MULENPAY:
+        if getattr(payment, "mulen_payment_id", None):
+            lines.append(
+                f"🧾 {texts.t('ADMIN_PAYMENT_GATEWAY_ID', 'Gateway ID')}: "
+                f"{html.escape(str(payment.mulen_payment_id))}"
+            )
+
+    if record.method == PaymentMethod.WATA:
+        if getattr(payment, "order_id", None):
+            lines.append(
+                f"🧾 {texts.t('ADMIN_PAYMENT_GATEWAY_ID', 'Gateway ID')}: "
+                f"{html.escape(str(payment.order_id))}"
+            )
+        if getattr(payment, "terminal_public_id", None):
+            lines.append(
+                f"🏦 Terminal: {html.escape(str(payment.terminal_public_id))}"
+            )
+
+    if record.method == PaymentMethod.HELEKET:
+        if getattr(payment, "order_id", None):
+            lines.append(
+                f"🧾 {texts.t('ADMIN_PAYMENT_GATEWAY_ID', 'Gateway ID')}: "
+                f"{html.escape(str(payment.order_id))}"
+            )
+        if getattr(payment, "payer_amount", None) and getattr(payment, "payer_currency", None):
+            lines.append(
+                f"🪙 {texts.t('ADMIN_PAYMENT_PAYER_AMOUNT', 'Paid amount')}: "
+                f"{html.escape(str(payment.payer_amount))} {html.escape(str(payment.payer_currency))}"
+            )
+
+    if record.method == PaymentMethod.YOOKASSA:
+        if getattr(payment, "payment_method_type", None):
+            lines.append(
+                f"💳 {texts.t('ADMIN_PAYMENT_GATEWAY_METHOD', 'Method')}: "
+                f"{html.escape(str(payment.payment_method_type))}"
+            )
+        if getattr(payment, "confirmation_url", None):
+            lines.append(texts.t("ADMIN_PAYMENT_HAS_LINK", "🔗 Payment link is available above."))
+
+    if record.method == PaymentMethod.CRYPTOBOT:
+        if getattr(payment, "amount", None) and getattr(payment, "asset", None):
+            lines.append(
+                f"🪙 {texts.t('ADMIN_PAYMENT_CRYPTO_AMOUNT', 'Crypto amount')}: "
+                f"{html.escape(str(payment.amount))} {html.escape(str(payment.asset))}"
+            )
+        if getattr(payment, "bot_invoice_url", None) or getattr(payment, "mini_app_invoice_url", None):
+            lines.append(
+                texts.t("ADMIN_PAYMENT_HAS_LINK", "🔗 Payment link is available above.")
+            )
+        if getattr(payment, "status", None):
+            lines.append(
+                f"📊 {texts.t('ADMIN_PAYMENT_GATEWAY_STATUS', 'Gateway status')}: "
+                f"{html.escape(str(payment.status))}"
+            )
+
+    if record.method == PaymentMethod.TELEGRAM_STARS:
+        description = getattr(payment, "description", "") or ""
+        if description:
+            lines.append(f"📝 {html.escape(description)}")
+        if getattr(payment, "external_id", None):
+            lines.append(
+                f"🧾 {texts.t('ADMIN_PAYMENT_GATEWAY_ID', 'Gateway ID')}: "
+                f"{html.escape(str(payment.external_id))}"
+            )
+
+    if _is_checkable(record):
+        lines.append("")
+        lines.append(texts.t("ADMIN_PAYMENT_CHECK_HINT", "ℹ️ You can trigger a manual status check."))
+
+    return "\n".join(lines)
+
+
+def _parse_method_and_id(payload: str, *, prefix: str) -> Optional[tuple[PaymentMethod, int]]:
+    suffix = payload[len(prefix) :]
+    try:
+        method_str, identifier = suffix.rsplit("_", 1)
+        method = PaymentMethod(method_str)
+        payment_id = int(identifier)
+        return method, payment_id
+    except (ValueError, KeyError):
+        return None
+
+
+@admin_required
+@error_handler
+async def show_payments_overview(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    texts = get_texts(db_user.language)
+
+    page = 1
+    if callback.data.startswith("admin_payments_page_"):
+        try:
+            page = int(callback.data.split("_")[-1])
+        except ValueError:
+            page = 1
+
+    records = await list_recent_pending_payments(db)
+    total = len(records)
+    total_pages = max(1, math.ceil(total / PAGE_SIZE))
+    if page < 1:
+        page = 1
+    if page > total_pages:
+        page = total_pages
+
+    start_index = (page - 1) * PAGE_SIZE
+    page_records = records[start_index : start_index + PAGE_SIZE]
+
+    header = texts.t("ADMIN_PAYMENTS_TITLE", "💳 <b>Top-up verification</b>")
+    description = texts.t(
+        "ADMIN_PAYMENTS_DESCRIPTION",
+        "Pending invoices created during the last 24 hours.",
+    )
+    notice = texts.t(
+        "ADMIN_PAYMENTS_NOTICE",
+        "Only invoices younger than 24 hours and waiting for payment can be checked.",
+    )
+
+    lines = [header, "", description]
+
+    if page_records:
+        for idx, record in enumerate(page_records, start=start_index + 1):
+            lines.extend(_build_record_lines(record, index=idx, texts=texts, language=db_user.language))
+            lines.append("")
+        lines.append(notice)
+    else:
+        empty_text = texts.t("ADMIN_PAYMENTS_EMPTY", "No pending top-ups in the last 24 hours.")
+        lines.append("")
+        lines.append(empty_text)
+
+    keyboard = _build_list_keyboard(
+        page_records,
+        page=page,
+        total_pages=total_pages,
+        language=db_user.language,
+    )
+
+    await callback.message.edit_text(
+        "\n".join(line for line in lines if line is not None),
+        parse_mode="HTML",
+        reply_markup=keyboard,
+    )
+    await callback.answer()
+
+
+async def _render_payment_details(
+    callback: types.CallbackQuery,
+    db_user: User,
+    record: PendingPayment,
+) -> None:
+    texts = get_texts(db_user.language)
+    text = _build_payment_details_text(record, texts=texts, language=db_user.language)
+    keyboard = _build_detail_keyboard(record, language=db_user.language)
+    await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+
+
+@admin_required
+@error_handler
+async def show_payment_details(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    parsed = _parse_method_and_id(callback.data, prefix="admin_payment_")
+    if not parsed:
+        await callback.answer("❌ Invalid payment reference", show_alert=True)
+        return
+
+    method, payment_id = parsed
+    record = await get_payment_record(db, method, payment_id)
+    if not record:
+        await callback.answer("❌ Платеж не найден", show_alert=True)
+        return
+
+    await _render_payment_details(callback, db_user, record)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def manual_check_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+) -> None:
+    parsed = _parse_method_and_id(callback.data, prefix="admin_payment_check_")
+    if not parsed:
+        await callback.answer("❌ Invalid payment reference", show_alert=True)
+        return
+
+    method, payment_id = parsed
+    record = await get_payment_record(db, method, payment_id)
+    texts = get_texts(db_user.language)
+
+    if not record:
+        await callback.answer(texts.t("ADMIN_PAYMENT_NOT_FOUND", "Payment not found."), show_alert=True)
+        return
+
+    if not _is_checkable(record):
+        await callback.answer(
+            texts.t("ADMIN_PAYMENT_CHECK_NOT_AVAILABLE", "Manual check is not available for this invoice."),
+            show_alert=True,
+        )
+        return
+
+    payment_service = PaymentService(callback.bot)
+    updated = await run_manual_check(db, method, payment_id, payment_service)
+
+    if not updated:
+        await callback.answer(
+            texts.t("ADMIN_PAYMENT_CHECK_FAILED", "Failed to refresh the payment status."),
+            show_alert=True,
+        )
+        return
+
+    await _render_payment_details(callback, db_user, updated)
+
+    if updated.status != record.status or updated.is_paid != record.is_paid:
+        emoji, status_text = _status_info(updated, texts=texts)
+        message = texts.t(
+            "ADMIN_PAYMENT_CHECK_SUCCESS",
+            "Status updated: {status}",
+        ).format(status=f"{emoji} {status_text}")
+    else:
+        message = texts.t(
+            "ADMIN_PAYMENT_CHECK_NO_CHANGES",
+            "Status is unchanged after the check.",
+        )
+
+    await callback.answer(message, show_alert=True)
+
+
+def register_handlers(dp: Dispatcher) -> None:
+    dp.callback_query.register(manual_check_payment, F.data.startswith("admin_payment_check_"))
+    dp.callback_query.register(
+        show_payment_details,
+        F.data.startswith("admin_payment_") & ~F.data.startswith("admin_payment_check_"),
+    )
+    dp.callback_query.register(show_payments_overview, F.data.startswith("admin_payments_page_"))
+    dp.callback_query.register(show_payments_overview, F.data == "admin_payments")
@@ -0,0 +1,512 @@
+import html
+import logging
+from datetime import datetime
+
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.localization.texts import get_texts
+from app.services.privacy_policy_service import PrivacyPolicyService
+from app.states import AdminStates
+from app.utils.decorators import admin_required, error_handler
+from app.utils.validators import validate_html_tags, get_html_help_text
+
+logger = logging.getLogger(__name__)
+
+
+def _format_timestamp(value: datetime | None) -> str:
+    if not value:
+        return ""
+    try:
+        return value.strftime("%d.%m.%Y %H:%M")
+    except Exception:
+        return ""
+
+
+async def _build_overview(
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    policy = await PrivacyPolicyService.get_policy(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    normalized_language = PrivacyPolicyService.normalize_language(db_user.language)
+    has_content = bool(policy and policy.content and policy.content.strip())
+
+    description = texts.t(
+        "ADMIN_PRIVACY_POLICY_DESCRIPTION",
+        "Политика конфиденциальности отображается в разделе «Инфо».",
+    )
+
+    status_text = texts.t(
+        "ADMIN_PRIVACY_POLICY_STATUS_DISABLED",
+        "⚠️ Показ политики выключен или текст отсутствует.",
+    )
+    if policy and policy.is_enabled and has_content:
+        status_text = texts.t(
+            "ADMIN_PRIVACY_POLICY_STATUS_ENABLED",
+            "✅ Политика активна и показывается пользователям.",
+        )
+    elif policy and policy.is_enabled:
+        status_text = texts.t(
+            "ADMIN_PRIVACY_POLICY_STATUS_ENABLED_EMPTY",
+            "⚠️ Политика включена, но текст пуст — пользователи её не увидят.",
+        )
+
+    updated_at = _format_timestamp(getattr(policy, "updated_at", None))
+    updated_block = ""
+    if updated_at:
+        updated_block = texts.t(
+            "ADMIN_PRIVACY_POLICY_UPDATED_AT",
+            "Последнее обновление: {timestamp}",
+        ).format(timestamp=updated_at)
+
+    preview_block = texts.t(
+        "ADMIN_PRIVACY_POLICY_PREVIEW_EMPTY",
+        "Текст ещё не задан.",
+    )
+    if has_content:
+        preview_title = texts.t(
+            "ADMIN_PRIVACY_POLICY_PREVIEW_TITLE",
+            "<b>Превью текста:</b>",
+        )
+        preview_raw = policy.content.strip()
+        preview_trimmed = preview_raw[:400]
+        if len(preview_raw) > 400:
+            preview_trimmed += "..."
+        preview_block = (
+            f"{preview_title}\n"
+            f"<code>{html.escape(preview_trimmed)}</code>"
+        )
+
+    language_block = texts.t(
+        "ADMIN_PRIVACY_POLICY_LANGUAGE",
+        "Язык: <code>{lang}</code>",
+    ).format(lang=normalized_language)
+
+    header = texts.t(
+        "ADMIN_PRIVACY_POLICY_HEADER",
+        "🛡️ <b>Политика конфиденциальности</b>",
+    )
+    actions_prompt = texts.t(
+        "ADMIN_PRIVACY_POLICY_ACTION_PROMPT",
+        "Выберите действие:",
+    )
+
+    message_parts = [
+        header,
+        description,
+        language_block,
+        status_text,
+    ]
+
+    if updated_block:
+        message_parts.append(updated_block)
+
+    message_parts.append(preview_block)
+    message_parts.append(actions_prompt)
+
+    overview_text = "\n\n".join(part for part in message_parts if part)
+
+    buttons: list[list[types.InlineKeyboardButton]] = []
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PRIVACY_POLICY_EDIT_BUTTON",
+                "✏️ Изменить текст",
+            ),
+            callback_data="admin_privacy_policy_edit",
+        )
+    ])
+
+    if has_content:
+        buttons.append([
+            types.InlineKeyboardButton(
+                text=texts.t(
+                    "ADMIN_PRIVACY_POLICY_VIEW_BUTTON",
+                    "👀 Просмотреть текущий текст",
+                ),
+                callback_data="admin_privacy_policy_view",
+            )
+        ])
+
+    toggle_text = texts.t(
+        "ADMIN_PRIVACY_POLICY_ENABLE_BUTTON",
+        "✅ Включить показ",
+    )
+    if policy and policy.is_enabled:
+        toggle_text = texts.t(
+            "ADMIN_PRIVACY_POLICY_DISABLE_BUTTON",
+            "🚫 Отключить показ",
+        )
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=toggle_text,
+            callback_data="admin_privacy_policy_toggle",
+        )
+    ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PRIVACY_POLICY_HTML_HELP",
+                "ℹ️ HTML помощь",
+            ),
+            callback_data="admin_privacy_policy_help",
+        )
+    ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.BACK,
+            callback_data="admin_submenu_settings",
+        )
+    ])
+
+    return overview_text, types.InlineKeyboardMarkup(inline_keyboard=buttons), policy
+
+
+@admin_required
+@error_handler
+async def show_privacy_policy_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    overview_text, markup, _ = await _build_overview(db_user, db)
+
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_privacy_policy(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    updated_policy = await PrivacyPolicyService.toggle_enabled(db, db_user.language)
+    logger.info(
+        "Админ %s переключил показ политики конфиденциальности: %s",
+        db_user.telegram_id,
+        "enabled" if updated_policy.is_enabled else "disabled",
+    )
+    status_message = (
+        texts.t("ADMIN_PRIVACY_POLICY_ENABLED", "✅ Политика включена")
+        if updated_policy.is_enabled
+        else texts.t("ADMIN_PRIVACY_POLICY_DISABLED", "🚫 Политика отключена")
+    )
+
+    overview_text, markup, _ = await _build_overview(db_user, db)
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer(status_message)
+
+
+@admin_required
+@error_handler
+async def start_edit_privacy_policy(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    policy = await PrivacyPolicyService.get_policy(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    current_preview = ""
+    if policy and policy.content:
+        preview = policy.content.strip()[:400]
+        if len(policy.content.strip()) > 400:
+            preview += "..."
+        current_preview = (
+            texts.t(
+                "ADMIN_PRIVACY_POLICY_CURRENT_PREVIEW",
+                "Текущий текст (превью):",
+            )
+            + f"\n<code>{html.escape(preview)}</code>\n\n"
+        )
+
+    prompt = texts.t(
+        "ADMIN_PRIVACY_POLICY_EDIT_PROMPT",
+        "Отправьте новый текст политики конфиденциальности. Допускается HTML-разметка.",
+    )
+
+    hint = texts.t(
+        "ADMIN_PRIVACY_POLICY_EDIT_HINT",
+        "Используйте /html_help для справки по тегам.",
+    )
+
+    message_text = (
+        f"📝 <b>{texts.t('ADMIN_PRIVACY_POLICY_EDIT_TITLE', 'Редактирование политики')}</b>\n\n"
+        f"{current_preview}{prompt}\n\n{hint}"
+    )
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PRIVACY_POLICY_HTML_HELP",
+                        "ℹ️ HTML помощь",
+                    ),
+                    callback_data="admin_privacy_policy_help",
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("ADMIN_PRIVACY_POLICY_CANCEL", "❌ Отмена"),
+                    callback_data="admin_privacy_policy_cancel",
+                )
+            ],
+        ]
+    )
+
+    await callback.message.edit_text(message_text, reply_markup=keyboard)
+    await state.set_state(AdminStates.editing_privacy_policy)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def cancel_edit_privacy_policy(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    await state.clear()
+    overview_text, markup, _ = await _build_overview(db_user, db)
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_privacy_policy_edit(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    new_text = message.text or ""
+
+    if len(new_text) > 4000:
+        await message.answer(
+            texts.t(
+                "ADMIN_PRIVACY_POLICY_TOO_LONG",
+                "❌ Текст политики слишком длинный. Максимум 4000 символов.",
+            )
+        )
+        return
+
+    is_valid, error_message = validate_html_tags(new_text)
+    if not is_valid:
+        await message.answer(
+            texts.t(
+                "ADMIN_PRIVACY_POLICY_HTML_ERROR",
+                "❌ Ошибка в HTML: {error}",
+            ).format(error=error_message)
+        )
+        return
+
+    await PrivacyPolicyService.save_policy(db, db_user.language, new_text)
+    logger.info(
+        "Админ %s обновил текст политики конфиденциальности (%d символов)",
+        db_user.telegram_id,
+        len(new_text),
+    )
+    await state.clear()
+
+    success_text = texts.t(
+        "ADMIN_PRIVACY_POLICY_SAVED",
+        "✅ Политика конфиденциальности обновлена.",
+    )
+
+    reply_markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PRIVACY_POLICY_BACK_BUTTON",
+                        "⬅️ К настройкам политики",
+                    ),
+                    callback_data="admin_privacy_policy",
+                )
+            ]
+        ]
+    )
+
+    await message.answer(success_text, reply_markup=reply_markup)
+
+
+@admin_required
+@error_handler
+async def view_privacy_policy(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    policy = await PrivacyPolicyService.get_policy(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    if not policy or not policy.content or not policy.content.strip():
+        await callback.answer(
+            texts.t(
+                "ADMIN_PRIVACY_POLICY_PREVIEW_EMPTY_ALERT",
+                "Текст политики пока не задан.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    content = policy.content.strip()
+    truncated = False
+    max_length = 3800
+    if len(content) > max_length:
+        content = content[: max_length - 3] + "..."
+        truncated = True
+
+    header = texts.t(
+        "ADMIN_PRIVACY_POLICY_VIEW_TITLE",
+        "👀 <b>Текущий текст политики</b>",
+    )
+
+    note = ""
+    if truncated:
+        note = texts.t(
+            "ADMIN_PRIVACY_POLICY_VIEW_TRUNCATED",
+            "\n\n⚠️ Текст сокращён для отображения. Полную версию увидят пользователи в меню.",
+        )
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PRIVACY_POLICY_BACK_BUTTON",
+                        "⬅️ К настройкам политики",
+                    ),
+                    callback_data="admin_privacy_policy",
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PRIVACY_POLICY_EDIT_BUTTON",
+                        "✏️ Изменить текст",
+                    ),
+                    callback_data="admin_privacy_policy_edit",
+                )
+            ],
+        ]
+    )
+
+    await callback.message.edit_text(
+        f"{header}\n\n{content}{note}",
+        reply_markup=keyboard,
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_privacy_policy_html_help(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    help_text = get_html_help_text()
+
+    current_state = await state.get_state()
+
+    buttons: list[list[types.InlineKeyboardButton]] = []
+
+    if current_state == AdminStates.editing_privacy_policy.state:
+        buttons.append([
+            types.InlineKeyboardButton(
+                text=texts.t(
+                    "ADMIN_PRIVACY_POLICY_RETURN_TO_EDIT",
+                    "⬅️ Назад к редактированию",
+                ),
+                callback_data="admin_privacy_policy_edit",
+            )
+        ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PRIVACY_POLICY_BACK_BUTTON",
+                "⬅️ К настройкам политики",
+            ),
+            callback_data="admin_privacy_policy",
+        )
+    ])
+
+    await callback.message.edit_text(
+        help_text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=buttons),
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher) -> None:
+    dp.callback_query.register(
+        show_privacy_policy_management,
+        F.data == "admin_privacy_policy",
+    )
+    dp.callback_query.register(
+        toggle_privacy_policy,
+        F.data == "admin_privacy_policy_toggle",
+    )
+    dp.callback_query.register(
+        start_edit_privacy_policy,
+        F.data == "admin_privacy_policy_edit",
+    )
+    dp.callback_query.register(
+        cancel_edit_privacy_policy,
+        F.data == "admin_privacy_policy_cancel",
+    )
+    dp.callback_query.register(
+        view_privacy_policy,
+        F.data == "admin_privacy_policy_view",
+    )
+    dp.callback_query.register(
+        show_privacy_policy_html_help,
+        F.data == "admin_privacy_policy_help",
+    )
+
+    dp.message.register(
+        process_privacy_policy_edit,
+        AdminStates.editing_privacy_policy,
+    )
@@ -211,6 +211,14 @@ def _format_rubles(amount_kopeks: int) -> str:
    return formatted.replace(",", " ")


+def _format_priority_line(texts, group: PromoGroup) -> str:
+    priority = getattr(group, "priority", 0)
+    return texts.t(
+        "ADMIN_PROMO_GROUP_PRIORITY_LINE",
+        "🎯 Приоритет: {priority}",
+    ).format(priority=priority)
+
+
 def _format_auto_assign_line(texts, group: PromoGroup) -> str:
    threshold = getattr(group, "auto_assign_total_spent_kopeks", 0) or 0

@@ -294,6 +302,7 @@ def _build_edit_menu_content(
    lines = [header]
    lines.extend(_format_discount_lines(texts, group))
    lines.append(_format_addon_discounts_line(texts, group))
+    lines.append(_format_priority_line(texts, group))
    lines.append(_format_auto_assign_line(texts, group))

    period_lines = _format_period_discounts_lines(texts, group, language)
@@ -318,6 +327,15 @@ def _build_edit_menu_content(
                callback_data=f"promo_group_edit_field_{group.id}_name",
            )
        ],
+        [
+            types.InlineKeyboardButton(
+                text=texts.t(
+                    "ADMIN_PROMO_GROUP_EDIT_FIELD_PRIORITY",
+                    "🎯 Приоритет",
+                ),
+                callback_data=f"promo_group_edit_field_{group.id}_priority",
+            )
+        ],
        [
            types.InlineKeyboardButton(
                text=texts.t(
@@ -640,6 +658,32 @@ async def process_create_group_name(message: types.Message, state: FSMContext):
        return

    await state.update_data(new_group_name=name)
+    await state.set_state(AdminStates.creating_promo_group_priority)
+    texts = get_texts((await state.get_data()).get("language", "ru"))
+    await message.answer(
+        texts.t(
+            "ADMIN_PROMO_GROUP_CREATE_PRIORITY_PROMPT",
+            "Введите приоритет группы (0 = базовая, чем больше - тем выше приоритет):",
+        )
+    )
+
+
+async def process_create_group_priority(message: types.Message, state: FSMContext):
+    texts = get_texts((await state.get_data()).get("language", "ru"))
+    try:
+        priority = int(message.text)
+        if priority < 0:
+            raise ValueError
+    except (ValueError, TypeError):
+        await message.answer(
+            texts.t(
+                "ADMIN_PROMO_GROUP_INVALID_PRIORITY",
+                "❌ Приоритет должен быть неотрицательным целым числом",
+            )
+        )
+        return
+
+    await state.update_data(new_group_priority=priority)
    await state.set_state(AdminStates.creating_promo_group_traffic_discount)
    await _prompt_for_discount(
        message,
@@ -772,6 +816,7 @@ async def process_create_group_auto_assign(
        group = await create_promo_group(
            db,
            data["new_group_name"],
+            priority=data.get("new_group_priority", 0),
            traffic_discount_percent=data["new_group_traffic"],
            server_discount_percent=data["new_group_servers"],
            device_discount_percent=data["new_group_devices"],
@@ -862,6 +907,12 @@ async def prompt_edit_promo_group_field(
            "ADMIN_PROMO_GROUP_EDIT_NAME_PROMPT",
            "Введите новое название промогруппы (текущее: {name}):",
        ).format(name=group.name)
+    elif field == "priority":
+        await state.set_state(AdminStates.editing_promo_group_priority)
+        prompt = texts.t(
+            "ADMIN_PROMO_GROUP_EDIT_PRIORITY_PROMPT",
+            "Введите новый приоритет (текущий: {current}):",
+        ).format(current=getattr(group, "priority", 0))
    elif field == "traffic":
        await state.set_state(AdminStates.editing_promo_group_traffic_discount)
        prompt = texts.t(
@@ -935,6 +986,48 @@ async def process_edit_group_name(
    )


+@admin_required
+@error_handler
+async def process_edit_group_priority(
+    message: types.Message,
+    state: FSMContext,
+    db_user,
+    db: AsyncSession,
+):
+    data = await state.get_data()
+    texts = get_texts(data.get("language", db_user.language))
+
+    try:
+        priority = int(message.text)
+        if priority < 0:
+            raise ValueError
+    except (ValueError, TypeError):
+        await message.answer(
+            texts.t(
+                "ADMIN_PROMO_GROUP_INVALID_PRIORITY",
+                "❌ Приоритет должен быть неотрицательным целым числом",
+            )
+        )
+        return
+
+    group = await get_promo_group_by_id(db, data.get("edit_group_id"))
+    if not group:
+        await message.answer("❌ Промогруппа не найдена")
+        await state.clear()
+        return
+
+    group = await update_promo_group(db, group, priority=priority)
+    await state.set_state(AdminStates.editing_promo_group_menu)
+
+    await _send_edit_menu_after_update(
+        message,
+        texts,
+        group,
+        data.get("language", db_user.language),
+        texts.t("ADMIN_PROMO_GROUP_UPDATED", "Промогруппа «{name}» обновлена.").format(name=group.name),
+    )
+
+
@admin_required
@error_handler
 async def process_edit_group_traffic(
@@ -1158,8 +1251,9 @@ async def show_promo_group_members(
        lines = []
        for index, user in enumerate(members, start=offset + 1):
            username = f"@{user.username}" if user.username else "—"
+            user_link = f'<a href="tg://user?id={user.telegram_id}">{user.full_name}</a>'
            lines.append(
-                f"{index}. {user.full_name} (ID {user.id}, {username}, TG {user.telegram_id})"
+                f"{index}. {user_link} (ID {user.id}, {username}, TG {user.telegram_id})"
            )
        body = "\n".join(lines)

@@ -1181,6 +1275,7 @@ async def show_promo_group_members(
    await callback.message.edit_text(
        f"{title}\n\n{body}",
        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML",
    )
    await callback.answer()

@@ -1323,6 +1418,10 @@ def register_handlers(dp: Dispatcher):
    )

    dp.message.register(process_create_group_name, AdminStates.creating_promo_group_name)
+    dp.message.register(
+        process_create_group_priority,
+        AdminStates.creating_promo_group_priority,
+    )
    dp.message.register(
        process_create_group_traffic,
        AdminStates.creating_promo_group_traffic_discount,
@@ -1345,6 +1444,10 @@ def register_handlers(dp: Dispatcher):
    )

    dp.message.register(process_edit_group_name, AdminStates.editing_promo_group_name)
+    dp.message.register(
+        process_edit_group_priority,
+        AdminStates.editing_promo_group_priority,
+    )
    dp.message.register(
        process_edit_group_traffic,
        AdminStates.editing_promo_group_traffic_discount,
@@ -15,8 +15,9 @@ from app.localization.texts import get_texts
 from app.database.crud.promocode import (
    get_promocodes_list, get_promocodes_count, create_promocode,
    get_promocode_statistics, get_promocode_by_code, update_promocode,
-    delete_promocode
+    delete_promocode, get_promocode_by_id
 )
+from app.database.crud.promo_group import get_promo_group_by_id, get_promo_groups_with_counts
 from app.utils.decorators import admin_required, error_handler
 from app.utils.formatters import format_datetime

@@ -81,16 +82,24 @@ async def show_promocodes_list(
    
    for promo in promocodes:
        status_emoji = "✅" if promo.is_active else "❌"
-        type_emoji = {"balance": "💰", "subscription_days": "📅", "trial_subscription": "🎁"}.get(promo.type, "🎫")
-        
+        type_emoji = {
+            "balance": "💰",
+            "subscription_days": "📅",
+            "trial_subscription": "🎁",
+            "promo_group": "🏷️"
+        }.get(promo.type, "🎫")
+
        text += f"{status_emoji} {type_emoji} <code>{promo.code}</code>\n"
        text += f"📊 Использований: {promo.current_uses}/{promo.max_uses}\n"
-        
+
        if promo.type == PromoCodeType.BALANCE.value:
            text += f"💰 Бонус: {settings.format_price(promo.balance_bonus_kopeks)}\n"
        elif promo.type == PromoCodeType.SUBSCRIPTION_DAYS.value:
            text += f"📅 Дней: {promo.subscription_days}\n"
-        
+        elif promo.type == PromoCodeType.PROMO_GROUP.value:
+            if promo.promo_group:
+                text += f"🏷️ Промогруппа: {promo.promo_group.name}\n"
+
        if promo.valid_until:
            text += f"⏰ До: {format_datetime(promo.valid_until)}\n"
        
@@ -129,15 +138,20 @@ async def show_promocode_management(
    db: AsyncSession
 ):
    promo_id = int(callback.data.split('_')[-1])
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
    
    status_emoji = "✅" if promo.is_active else "❌"
-    type_emoji = {"balance": "💰", "subscription_days": "📅", "trial_subscription": "🎁"}.get(promo.type, "🎫")
-    
+    type_emoji = {
+        "balance": "💰",
+        "subscription_days": "📅",
+        "trial_subscription": "🎁",
+        "promo_group": "🏷️"
+    }.get(promo.type, "🎫")
+
    text = f"""
 🎫 <b>Управление промокодом</b>

@@ -145,12 +159,17 @@ async def show_promocode_management(
 {status_emoji} <b>Статус:</b> {'Активен' if promo.is_active else 'Неактивен'}
 📊 <b>Использований:</b> {promo.current_uses}/{promo.max_uses}
 """
-    
+
    if promo.type == PromoCodeType.BALANCE.value:
        text += f"💰 <b>Бонус:</b> {settings.format_price(promo.balance_bonus_kopeks)}\n"
    elif promo.type == PromoCodeType.SUBSCRIPTION_DAYS.value:
        text += f"📅 <b>Дней:</b> {promo.subscription_days}\n"
-    
+    elif promo.type == PromoCodeType.PROMO_GROUP.value:
+        if promo.promo_group:
+            text += f"🏷️ <b>Промогруппа:</b> {promo.promo_group.name} (приоритет: {promo.promo_group.priority})\n"
+        elif promo.promo_group_id:
+            text += f"🏷️ <b>Промогруппа ID:</b> {promo.promo_group_id} (не найдена)\n"
+
    if promo.valid_until:
        text += f"⏰ <b>Действует до:</b> {format_datetime(promo.valid_until)}\n"
    
@@ -200,8 +219,8 @@ async def show_promocode_edit_menu(
    except (ValueError, IndexError):
        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
        return
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
@@ -445,13 +464,14 @@ async def select_promocode_type(
    state: FSMContext
 ):
    promo_type = callback.data.split('_')[-1]
-    
+
    type_names = {
        "balance": "💰 Пополнение баланса",
-        "days": "📅 Дни подписки", 
-        "trial": "🎁 Тестовая подписка"
+        "days": "📅 Дни подписки",
+        "trial": "🎁 Тестовая подписка",
+        "group": "🏷️ Промогруппа"
    }
-    
+
    await state.update_data(promocode_type=promo_type)
    
    await callback.message.edit_text(
@@ -509,6 +529,77 @@ async def process_promocode_code(
            f"Введите количество дней тестовой подписки:"
        )
        await state.set_state(AdminStates.setting_promocode_value)
+    elif promo_type == "group":
+        # Show promo group selection
+        groups_with_counts = await get_promo_groups_with_counts(db, limit=50)
+
+        if not groups_with_counts:
+            await message.answer(
+                "❌ Промогруппы не найдены. Создайте хотя бы одну промогруппу.",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")]
+                ])
+            )
+            await state.clear()
+            return
+
+        keyboard = []
+        text = f"🏷️ <b>Промокод:</b> <code>{code}</code>\n\nВыберите промогруппу для назначения:\n\n"
+
+        for promo_group, user_count in groups_with_counts:
+            text += f"• {promo_group.name} (приоритет: {promo_group.priority}, пользователей: {user_count})\n"
+            keyboard.append([
+                types.InlineKeyboardButton(
+                    text=f"{promo_group.name} (↑{promo_group.priority})",
+                    callback_data=f"promo_select_group_{promo_group.id}"
+                )
+            ])
+
+        keyboard.append([
+            types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_promocodes")
+        ])
+
+        await message.answer(
+            text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        )
+        await state.set_state(AdminStates.selecting_promo_group)
+
+
+@admin_required
+@error_handler
+async def process_promo_group_selection(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    """Handle promo group selection for promocode"""
+    try:
+        promo_group_id = int(callback.data.split('_')[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Ошибка получения ID промогруппы", show_alert=True)
+        return
+
+    promo_group = await get_promo_group_by_id(db, promo_group_id)
+    if not promo_group:
+        await callback.answer("❌ Промогруппа не найдена", show_alert=True)
+        return
+
+    await state.update_data(
+        promo_group_id=promo_group_id,
+        promo_group_name=promo_group.name
+    )
+
+    await callback.message.edit_text(
+        f"🏷️ <b>Промокод для промогруппы</b>\n\n"
+        f"Промогруппа: {promo_group.name}\n"
+        f"Приоритет: {promo_group.priority}\n\n"
+        f"📊 Введите количество использований промокода (или 0 для безлимита):"
+    )
+
+    await state.set_state(AdminStates.setting_promocode_uses)
+    await callback.answer()


@admin_required
@@ -557,8 +648,8 @@ async def handle_edit_value(
    data = await state.get_data()
    promo_id = data.get('editing_promo_id')
    edit_action = data.get('edit_action')
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await message.answer("❌ Промокод не найден")
        await state.clear()
@@ -643,8 +734,8 @@ async def handle_edit_uses(
 ):
    data = await state.get_data()
    promo_id = data.get('editing_promo_id')
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await message.answer("❌ Промокод не найден")
        await state.clear()
@@ -708,17 +799,20 @@ async def process_promocode_expiry(
        promo_type = data.get('promocode_type')
        value = data.get('promocode_value', 0)
        max_uses = data.get('promocode_max_uses', 1)
-        
+        promo_group_id = data.get('promo_group_id')
+        promo_group_name = data.get('promo_group_name')
+
        valid_until = None
        if expiry_days > 0:
            valid_until = datetime.utcnow() + timedelta(days=expiry_days)
-        
+
        type_map = {
            "balance": PromoCodeType.BALANCE,
            "days": PromoCodeType.SUBSCRIPTION_DAYS,
-            "trial": PromoCodeType.TRIAL_SUBSCRIPTION
+            "trial": PromoCodeType.TRIAL_SUBSCRIPTION,
+            "group": PromoCodeType.PROMO_GROUP
        }
-        
+
        promocode = await create_promocode(
            db=db,
            code=code,
@@ -727,27 +821,31 @@ async def process_promocode_expiry(
            subscription_days=value if promo_type in ["days", "trial"] else 0,
            max_uses=max_uses,
            valid_until=valid_until,
-            created_by=db_user.id
+            created_by=db_user.id,
+            promo_group_id=promo_group_id if promo_type == "group" else None
        )
        
        type_names = {
-            "balance": "Пополнение баланса", 
-            "days": "Дни подписки", 
-            "trial": "Тестовая подписка"
+            "balance": "Пополнение баланса",
+            "days": "Дни подписки",
+            "trial": "Тестовая подписка",
+            "group": "Промогруппа"
        }
-        
+
        summary_text = f"""
 ✅ <b>Промокод создан!</b>

 🎫 <b>Код:</b> <code>{promocode.code}</code>
 📝 <b>Тип:</b> {type_names.get(promo_type)}
 """
-        
+
        if promo_type == "balance":
            summary_text += f"💰 <b>Сумма:</b> {settings.format_price(promocode.balance_bonus_kopeks)}\n"
        elif promo_type in ["days", "trial"]:
            summary_text += f"📅 <b>Дней:</b> {promocode.subscription_days}\n"
-        
+        elif promo_type == "group" and promo_group_name:
+            summary_text += f"🏷️ <b>Промогруппа:</b> {promo_group_name}\n"
+
        summary_text += f"📊 <b>Использований:</b> {promocode.max_uses}\n"
        
        if promocode.valid_until:
@@ -775,8 +873,8 @@ async def handle_edit_expiry(
 ):
    data = await state.get_data()
    promo_id = data.get('editing_promo_id')
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await message.answer("❌ Промокод не найден")
        await state.clear()
@@ -822,8 +920,8 @@ async def toggle_promocode_status(
    db: AsyncSession
 ):
    promo_id = int(callback.data.split('_')[-1])
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
@@ -849,8 +947,8 @@ async def confirm_delete_promocode(
    except (ValueError, IndexError):
        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
        return
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
@@ -897,8 +995,8 @@ async def delete_promocode_confirmed(
    except (ValueError, IndexError):
        await callback.answer("❌ Ошибка получения ID промокода", show_alert=True)
        return
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
@@ -921,8 +1019,8 @@ async def show_promocode_stats(
    db: AsyncSession
 ):
    promo_id = int(callback.data.split('_')[-1])
-    
-    promo = await db.get(PromoCode, promo_id)
+
+    promo = await get_promocode_by_id(db, promo_id)
    if not promo:
        await callback.answer("❌ Промокод не найден", show_alert=True)
        return
@@ -1007,6 +1105,7 @@ def register_handlers(dp: Dispatcher):
    dp.callback_query.register(show_promocodes_list, F.data == "admin_promo_list")
    dp.callback_query.register(start_promocode_creation, F.data == "admin_promo_create")
    dp.callback_query.register(select_promocode_type, F.data.startswith("promo_type_"))
+    dp.callback_query.register(process_promo_group_selection, F.data.startswith("promo_select_group_"))
    
    dp.callback_query.register(show_promocode_management, F.data.startswith("promo_manage_"))
    dp.callback_query.register(toggle_promocode_status, F.data.startswith("promo_toggle_"))
@@ -0,0 +1,530 @@
+import html
+import logging
+from datetime import datetime
+
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.localization.texts import get_texts
+from app.services.public_offer_service import PublicOfferService
+from app.states import AdminStates
+from app.utils.decorators import admin_required, error_handler
+from app.utils.validators import validate_html_tags, get_html_help_text
+
+logger = logging.getLogger(__name__)
+
+
+def _format_timestamp(value: datetime | None) -> str:
+    if not value:
+        return ""
+    try:
+        return value.strftime("%d.%m.%Y %H:%M")
+    except Exception:
+        return ""
+
+
+async def _build_overview(
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    offer = await PublicOfferService.get_offer(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    normalized_language = PublicOfferService.normalize_language(db_user.language)
+    has_content = bool(offer and offer.content and offer.content.strip())
+
+    description = texts.t(
+        "ADMIN_PUBLIC_OFFER_DESCRIPTION",
+        "Публичная оферта отображается в разделе «Инфо».",
+    )
+
+    status_text = texts.t(
+        "ADMIN_PUBLIC_OFFER_STATUS_DISABLED",
+        "⚠️ Показ оферты выключен или текст отсутствует.",
+    )
+    if offer and offer.is_enabled and has_content:
+        status_text = texts.t(
+            "ADMIN_PUBLIC_OFFER_STATUS_ENABLED",
+            "✅ Оферта активна и показывается пользователям.",
+        )
+    elif offer and offer.is_enabled:
+        status_text = texts.t(
+            "ADMIN_PUBLIC_OFFER_STATUS_ENABLED_EMPTY",
+            "⚠️ Оферта включена, но текст пуст — пользователи её не увидят.",
+        )
+
+    updated_at = _format_timestamp(getattr(offer, "updated_at", None))
+    updated_block = ""
+    if updated_at:
+        updated_block = texts.t(
+            "ADMIN_PUBLIC_OFFER_UPDATED_AT",
+            "Последнее обновление: {timestamp}",
+        ).format(timestamp=updated_at)
+
+    preview_block = texts.t(
+        "ADMIN_PUBLIC_OFFER_PREVIEW_EMPTY",
+        "Текст ещё не задан.",
+    )
+    if has_content:
+        preview_title = texts.t(
+            "ADMIN_PUBLIC_OFFER_PREVIEW_TITLE",
+            "<b>Превью текста:</b>",
+        )
+        preview_raw = offer.content.strip()
+        preview_trimmed = preview_raw[:400]
+        if len(preview_raw) > 400:
+            preview_trimmed += "..."
+        preview_block = (
+            f"{preview_title}\n"
+            f"<code>{html.escape(preview_trimmed)}</code>"
+        )
+
+    language_block = texts.t(
+        "ADMIN_PUBLIC_OFFER_LANGUAGE",
+        "Язык: <code>{lang}</code>",
+    ).format(lang=normalized_language)
+
+    header = texts.t(
+        "ADMIN_PUBLIC_OFFER_HEADER",
+        "📄 <b>Публичная оферта</b>",
+    )
+    actions_prompt = texts.t(
+        "ADMIN_PUBLIC_OFFER_ACTION_PROMPT",
+        "Выберите действие:",
+    )
+
+    message_parts = [
+        header,
+        description,
+        language_block,
+        status_text,
+    ]
+
+    if updated_block:
+        message_parts.append(updated_block)
+
+    message_parts.append(preview_block)
+    message_parts.append(actions_prompt)
+
+    overview_text = "\n\n".join(part for part in message_parts if part)
+
+    buttons: list[list[types.InlineKeyboardButton]] = []
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PUBLIC_OFFER_EDIT_BUTTON",
+                "✏️ Изменить текст",
+            ),
+            callback_data="admin_public_offer_edit",
+        )
+    ])
+
+    if has_content:
+        buttons.append([
+            types.InlineKeyboardButton(
+                text=texts.t(
+                    "ADMIN_PUBLIC_OFFER_VIEW_BUTTON",
+                    "👀 Просмотреть текущий текст",
+                ),
+                callback_data="admin_public_offer_view",
+            )
+        ])
+
+    toggle_text = texts.t(
+        "ADMIN_PUBLIC_OFFER_ENABLE_BUTTON",
+        "✅ Включить показ",
+    )
+    if offer and offer.is_enabled:
+        toggle_text = texts.t(
+            "ADMIN_PUBLIC_OFFER_DISABLE_BUTTON",
+            "🚫 Отключить показ",
+        )
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=toggle_text,
+            callback_data="admin_public_offer_toggle",
+        )
+    ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PUBLIC_OFFER_HTML_HELP",
+                "ℹ️ HTML помощь",
+            ),
+            callback_data="admin_public_offer_help",
+        )
+    ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.BACK,
+            callback_data="admin_submenu_settings",
+        )
+    ])
+
+    return overview_text, types.InlineKeyboardMarkup(inline_keyboard=buttons), offer
+
+
+@admin_required
+@error_handler
+async def show_public_offer_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    overview_text, markup, _ = await _build_overview(db_user, db)
+
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_public_offer(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    updated_offer = await PublicOfferService.toggle_enabled(db, db_user.language)
+    logger.info(
+        "Админ %s переключил показ публичной оферты: %s",
+        db_user.telegram_id,
+        "enabled" if updated_offer.is_enabled else "disabled",
+    )
+    status_message = (
+        texts.t("ADMIN_PUBLIC_OFFER_ENABLED", "✅ Оферта включена")
+        if updated_offer.is_enabled
+        else texts.t("ADMIN_PUBLIC_OFFER_DISABLED", "🚫 Оферта отключена")
+    )
+
+    overview_text, markup, _ = await _build_overview(db_user, db)
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer(status_message)
+
+
+@admin_required
+@error_handler
+async def start_edit_public_offer(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    offer = await PublicOfferService.get_offer(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    current_preview = ""
+    if offer and offer.content:
+        preview = offer.content.strip()[:400]
+        if len(offer.content.strip()) > 400:
+            preview += "..."
+        current_preview = (
+            texts.t(
+                "ADMIN_PUBLIC_OFFER_CURRENT_PREVIEW",
+                "Текущий текст (превью):",
+            )
+            + f"\n<code>{html.escape(preview)}</code>\n\n"
+        )
+
+    prompt = texts.t(
+        "ADMIN_PUBLIC_OFFER_EDIT_PROMPT",
+        "Отправьте новый текст публичной оферты. Допускается HTML-разметка.",
+    )
+
+    hint = texts.t(
+        "ADMIN_PUBLIC_OFFER_EDIT_HINT",
+        "Используйте /html_help для справки по тегам.",
+    )
+
+    message_text = (
+        f"📝 <b>{texts.t('ADMIN_PUBLIC_OFFER_EDIT_TITLE', 'Редактирование оферты')}</b>\n\n"
+        f"{current_preview}{prompt}\n\n{hint}"
+    )
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PUBLIC_OFFER_HTML_HELP",
+                        "ℹ️ HTML помощь",
+                    ),
+                    callback_data="admin_public_offer_help",
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("ADMIN_PUBLIC_OFFER_CANCEL", "❌ Отмена"),
+                    callback_data="admin_public_offer_cancel",
+                )
+            ],
+        ]
+    )
+
+    await callback.message.edit_text(message_text, reply_markup=keyboard)
+    await state.set_state(AdminStates.editing_public_offer)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def cancel_edit_public_offer(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    await state.clear()
+    overview_text, markup, _ = await _build_overview(db_user, db)
+    await callback.message.edit_text(
+        overview_text,
+        reply_markup=markup,
+    )
+    await callback.answer(
+        get_texts(db_user.language).t(
+            "ADMIN_PUBLIC_OFFER_EDIT_CANCELLED",
+            "Редактирование оферты отменено.",
+        )
+    )
+
+
+@admin_required
+@error_handler
+async def process_public_offer_edit(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    new_text = message.text or ""
+
+    if len(new_text) > 4000:
+        await message.answer(
+            texts.t(
+                "ADMIN_PUBLIC_OFFER_TOO_LONG",
+                "❌ Текст оферты слишком длинный. Максимум 4000 символов.",
+            )
+        )
+        return
+
+    is_valid, error_message = validate_html_tags(new_text)
+    if not is_valid:
+        await message.answer(
+            texts.t(
+                "ADMIN_PUBLIC_OFFER_HTML_ERROR",
+                "❌ Ошибка в HTML: {error}",
+            ).format(error=error_message)
+        )
+        return
+
+    await PublicOfferService.save_offer(db, db_user.language, new_text)
+    logger.info(
+        "Админ %s обновил текст публичной оферты (%d символов)",
+        db_user.telegram_id,
+        len(new_text),
+    )
+    await state.clear()
+
+    success_text = texts.t(
+        "ADMIN_PUBLIC_OFFER_SAVED",
+        "✅ Публичная оферта обновлена.",
+    )
+
+    reply_markup = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PUBLIC_OFFER_BACK_BUTTON",
+                        "⬅️ К настройкам оферты",
+                    ),
+                    callback_data="admin_public_offer",
+                )
+            ]
+        ]
+    )
+
+    await message.answer(success_text, reply_markup=reply_markup)
+
+
+@admin_required
+@error_handler
+async def view_public_offer(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    offer = await PublicOfferService.get_offer(
+        db,
+        db_user.language,
+        fallback=False,
+    )
+
+    if not offer or not offer.content or not offer.content.strip():
+        await callback.answer(
+            texts.t(
+                "ADMIN_PUBLIC_OFFER_PREVIEW_EMPTY_ALERT",
+                "Текст оферты пока не задан.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    content = offer.content.strip()
+    max_length = 3800
+    pages = PublicOfferService.split_content_into_pages(
+        content,
+        max_length=max_length,
+    )
+
+    if not pages:
+        await callback.answer(
+            texts.t(
+                "ADMIN_PUBLIC_OFFER_PREVIEW_EMPTY_ALERT",
+                "Текст оферты пока не задан.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    preview = pages[0]
+    truncated = len(pages) > 1
+
+    header = texts.t(
+        "ADMIN_PUBLIC_OFFER_VIEW_TITLE",
+        "👀 <b>Текущий текст оферты</b>",
+    )
+
+    note = ""
+    if truncated:
+        note = texts.t(
+            "ADMIN_PUBLIC_OFFER_VIEW_TRUNCATED",
+            "\n\n⚠️ Текст сокращён для отображения. Полную версию увидят пользователи в меню.",
+        )
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PUBLIC_OFFER_BACK_BUTTON",
+                        "⬅️ К настройкам оферты",
+                    ),
+                    callback_data="admin_public_offer",
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "ADMIN_PUBLIC_OFFER_EDIT_BUTTON",
+                        "✏️ Изменить текст",
+                    ),
+                    callback_data="admin_public_offer_edit",
+                )
+            ],
+        ]
+    )
+
+    await callback.message.edit_text(
+        f"{header}\n\n{preview}{note}",
+        reply_markup=keyboard,
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_public_offer_html_help(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+    help_text = get_html_help_text()
+
+    current_state = await state.get_state()
+
+    buttons: list[list[types.InlineKeyboardButton]] = []
+
+    if current_state == AdminStates.editing_public_offer.state:
+        buttons.append([
+            types.InlineKeyboardButton(
+                text=texts.t(
+                    "ADMIN_PUBLIC_OFFER_RETURN_TO_EDIT",
+                    "⬅️ Назад к редактированию",
+                ),
+                callback_data="admin_public_offer_edit",
+            )
+        ])
+
+    buttons.append([
+        types.InlineKeyboardButton(
+            text=texts.t(
+                "ADMIN_PUBLIC_OFFER_BACK_BUTTON",
+                "⬅️ К настройкам оферты",
+            ),
+            callback_data="admin_public_offer",
+        )
+    ])
+
+    await callback.message.edit_text(
+        help_text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=buttons),
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher) -> None:
+    dp.callback_query.register(
+        show_public_offer_management,
+        F.data == "admin_public_offer",
+    )
+    dp.callback_query.register(
+        toggle_public_offer,
+        F.data == "admin_public_offer_toggle",
+    )
+    dp.callback_query.register(
+        start_edit_public_offer,
+        F.data == "admin_public_offer_edit",
+    )
+    dp.callback_query.register(
+        cancel_edit_public_offer,
+        F.data == "admin_public_offer_cancel",
+    )
+    dp.callback_query.register(
+        view_public_offer,
+        F.data == "admin_public_offer_view",
+    )
+    dp.callback_query.register(
+        show_public_offer_html_help,
+        F.data == "admin_public_offer_help",
+    )
+
+    dp.message.register(
+        process_public_offer_edit,
+        AdminStates.editing_public_offer,
+    )
@@ -68,7 +68,6 @@ async def show_referral_statistics(
 - Минимальное пополнение: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
 - Бонус за первое пополнение: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
 - Бонус пригласившему: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
- Бонус новому пользователю: {settings.format_price(settings.REFERRED_USER_REWARD)}
 - Комиссия с покупок: {settings.REFERRAL_COMMISSION_PERCENT}%
 - Уведомления: {'✅ Включены' if settings.REFERRAL_NOTIFICATIONS_ENABLED else '❌ Отключены'}

@@ -105,7 +104,6 @@ async def show_referral_statistics(
 - Минимальное пополнение: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
 - Бонус за первое пополнение: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
 - Бонус пригласившему: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
- Бонус новому пользователю: {settings.format_price(settings.REFERRED_USER_REWARD)}
 - Комиссия с покупок: {settings.REFERRAL_COMMISSION_PERCENT}%

 <i>🕐 Время: {current_time}</i>
@@ -190,7 +188,6 @@ async def show_referral_settings(
 • Минимальная сумма пополнения для участия: {settings.format_price(settings.REFERRAL_MINIMUM_TOPUP_KOPEKS)}
 • Бонус за первое пополнение реферала: {settings.format_price(settings.REFERRAL_FIRST_TOPUP_BONUS_KOPEKS)}
 • Бонус пригласившему за первое пополнение: {settings.format_price(settings.REFERRAL_INVITER_BONUS_KOPEKS)}
-• Бонус новому пользователю при регистрации: {settings.format_price(settings.REFERRED_USER_REWARD)}

 <b>Комиссионные:</b>
 • Процент с каждой покупки реферала: {settings.REFERRAL_COMMISSION_PERCENT}%
@@ -1,3 +1,4 @@
+import html
 import logging
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
@@ -15,6 +16,7 @@ from app.database.crud.server_squad import (
    create_server_squad,
    get_available_server_squads,
    update_server_squad_promo_groups,
+    get_server_connected_users,
 )
 from app.database.crud.promo_group import get_promo_groups_with_counts
 from app.services.remnawave_service import RemnaWaveService
@@ -33,6 +35,8 @@ def _build_server_edit_view(server):
        else "Не выбраны"
    )

+    trial_status = "✅ Да" if server.is_trial_eligible else "⚪️ Нет"
+
    text = f"""
 🌐 <b>Редактирование сервера</b>

@@ -49,6 +53,7 @@ def _build_server_edit_view(server):
 • Лимит пользователей: {server.max_users or 'Без лимита'}
 • Текущих пользователей: {server.current_users}
 • Промогруппы: {promo_groups_text}
+• Выдача триала: {trial_status}

 <b>Описание:</b>
 {server.description or 'Не указано'}
@@ -73,6 +78,17 @@ def _build_server_edit_view(server):
                text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}"
            ),
        ],
+        [
+            types.InlineKeyboardButton(
+                text="👥 Юзеры", callback_data=f"admin_server_users_{server.id}"
+            ),
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="🎁 Выдавать сквад" if not server.is_trial_eligible else "🚫 Не выдавать сквад",
+                callback_data=f"admin_server_trial_{server.id}",
+            ),
+        ],
        [
            types.InlineKeyboardButton(
                text="🎯 Промогруппы", callback_data=f"admin_server_edit_promo_{server.id}"
@@ -164,7 +180,7 @@ async def show_servers_menu(
            types.InlineKeyboardButton(text="📈 Подробная статистика", callback_data="admin_servers_stats")
        ],
        [
-            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
        ]
    ]
    
@@ -276,7 +292,7 @@ async def sync_servers_with_remnawave(
            )
            return
        
-        created, updated, disabled = await sync_with_remnawave(db, squads)
+        created, updated, removed = await sync_with_remnawave(db, squads)
        
        await cache.delete_pattern("available_countries*")
        
@@ -286,7 +302,7 @@ async def sync_servers_with_remnawave(
 📊 <b>Результаты:</b>
 • Создано новых серверов: {created}
 • Обновлено существующих: {updated}
-• Отключено неактивных: {disabled}
+• Удалено отсутствующих: {removed}
 • Всего обработано: {len(squads)}

 ℹ️ Новые серверы созданы как недоступные.
@@ -314,7 +330,7 @@ async def sync_servers_with_remnawave(
                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
            ])
        )
-    
+
    await callback.answer()


@@ -343,6 +359,150 @@ async def show_server_edit_menu(
    await callback.answer()


+@admin_required
+@error_handler
+async def show_server_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+
+    payload = callback.data.split("admin_server_users_", 1)[-1]
+    payload_parts = payload.split("_")
+
+    server_id = int(payload_parts[0])
+    page = int(payload_parts[1]) if len(payload_parts) > 1 else 1
+    page = max(page, 1)
+    server = await get_server_squad_by_id(db, server_id)
+
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+
+    users = await get_server_connected_users(db, server_id)
+    total_users = len(users)
+
+    page_size = 10
+    total_pages = max((total_users + page_size - 1) // page_size, 1)
+
+    if page > total_pages:
+        page = total_pages
+
+    start_index = (page - 1) * page_size
+    end_index = start_index + page_size
+    page_users = users[start_index:end_index]
+
+    safe_name = html.escape(server.display_name or "—")
+    safe_uuid = html.escape(server.squad_uuid or "—")
+
+    header = [
+        "🌐 <b>Пользователи сервера</b>",
+        "",
+        f"• Сервер: {safe_name}",
+        f"• UUID: <code>{safe_uuid}</code>",
+        f"• Подключений: {total_users}",
+    ]
+
+    if total_pages > 1:
+        header.append(f"• Страница: {page}/{total_pages}")
+
+    header.append("")
+
+    text = "\n".join(header)
+
+    def _get_status_icon(status_text: str) -> str:
+        if not status_text:
+            return ""
+
+        parts = status_text.split(" ", 1)
+        return parts[0] if parts else status_text
+
+    if users:
+        lines = []
+        for index, user in enumerate(page_users, start=start_index + 1):
+            safe_user_name = html.escape(user.full_name)
+            user_link = f'<a href="tg://user?id={user.telegram_id}">{safe_user_name}</a>'
+            lines.append(f"{index}. {user_link}")
+
+        text += "\n" + "\n".join(lines)
+    else:
+        text += "Пользователи не найдены."
+
+    keyboard: list[list[types.InlineKeyboardButton]] = []
+
+    for user in page_users:
+        display_name = user.full_name
+        if len(display_name) > 30:
+            display_name = display_name[:27] + "..."
+
+        subscription_status = (
+            user.subscription.status_display
+            if user.subscription
+            else "❌ Нет подписки"
+        )
+        status_icon = _get_status_icon(subscription_status)
+
+        if status_icon:
+            button_text = f"{status_icon} {display_name}"
+        else:
+            button_text = display_name
+
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text=button_text,
+                callback_data=f"admin_user_manage_{user.id}",
+            )
+        ])
+
+    if total_pages > 1:
+        navigation_buttons: list[types.InlineKeyboardButton] = []
+
+        if page > 1:
+            navigation_buttons.append(
+                types.InlineKeyboardButton(
+                    text="⬅️ Предыдущая",
+                    callback_data=f"admin_server_users_{server_id}_{page - 1}",
+                )
+            )
+
+        navigation_buttons.append(
+            types.InlineKeyboardButton(
+                text=f"Стр. {page}/{total_pages}",
+                callback_data=f"admin_server_users_{server_id}_{page}",
+            )
+        )
+
+        if page < total_pages:
+            navigation_buttons.append(
+                types.InlineKeyboardButton(
+                    text="Следующая ➡️",
+                    callback_data=f"admin_server_users_{server_id}_{page + 1}",
+                )
+            )
+
+        keyboard.append(navigation_buttons)
+
+    keyboard.append([
+        types.InlineKeyboardButton(
+            text="⬅️ К серверу", callback_data=f"admin_server_edit_{server_id}"
+        )
+    ])
+
+    keyboard.append([
+        types.InlineKeyboardButton(
+            text="⬅️ К списку", callback_data="admin_servers_list"
+        )
+    ])
+
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML",
+    )
+
+    await callback.answer()
+
+
@admin_required
@error_handler
 async def toggle_server_availability(
@@ -377,6 +537,38 @@ async def toggle_server_availability(
    )


+@admin_required
+@error_handler
+async def toggle_server_trial_assignment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+
+    new_status = not server.is_trial_eligible
+    await update_server_squad(db, server_id, is_trial_eligible=new_status)
+
+    status_text = "будет выдаваться" if new_status else "перестанет выдаваться"
+    await callback.answer(f"✅ Сквад {status_text} в триал")
+
+    server = await get_server_squad_by_id(db, server_id)
+
+    text, keyboard = _build_server_edit_view(server)
+
+    await callback.message.edit_text(
+        text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+
+
@admin_required
@error_handler
 async def start_server_edit_price(
@@ -1105,6 +1297,8 @@ def register_handlers(dp: Dispatcher):
        & ~F.data.contains("promo"),
    )
    dp.callback_query.register(toggle_server_availability, F.data.startswith("admin_server_toggle_"))
+    dp.callback_query.register(toggle_server_trial_assignment, F.data.startswith("admin_server_trial_"))
+    dp.callback_query.register(show_server_users, F.data.startswith("admin_server_users_"))

    dp.callback_query.register(start_server_edit_name, F.data.startswith("admin_server_edit_name_"))
    dp.callback_query.register(start_server_edit_price, F.data.startswith("admin_server_edit_price_"))
@@ -4,7 +4,6 @@ from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, func

-from app.config import settings
 from app.states import AdminStates
 from app.database.models import User
 from app.keyboards.admin import get_admin_subscriptions_keyboard
@@ -87,10 +86,6 @@ async def show_subscriptions_menu(
        ],
        [
            types.InlineKeyboardButton(text="📊 Статистика", callback_data="admin_subs_stats"),
-            types.InlineKeyboardButton(text="💰 Настройки цен", callback_data="admin_subs_pricing")
-        ],
-        [
-            types.InlineKeyboardButton(text="🌐 Управление серверами", callback_data="admin_servers"),
            types.InlineKeyboardButton(text="🌍 География", callback_data="admin_subs_countries")
        ],
        [
@@ -277,56 +272,6 @@ async def show_subscriptions_stats(

@admin_required
@error_handler
-async def show_pricing_settings(
-    callback: types.CallbackQuery,
-    db_user: User,
-    db: AsyncSession
-):
-    text = f"""
-⚙️ <b>Настройки цен</b>
-
-<b>Периоды подписки:</b>
- 14 дней: {settings.format_price(settings.PRICE_14_DAYS)}
- 30 дней: {settings.format_price(settings.PRICE_30_DAYS)}
- 60 дней: {settings.format_price(settings.PRICE_60_DAYS)}
- 90 дней: {settings.format_price(settings.PRICE_90_DAYS)}
- 180 дней: {settings.format_price(settings.PRICE_180_DAYS)}
- 360 дней: {settings.format_price(settings.PRICE_360_DAYS)}
-
-<b>Трафик-пакеты:</b>
- 5 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_5GB)}
- 10 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_10GB)}
- 25 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_25GB)}
- 50 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_50GB)}
- 100 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_100GB)}
- 250 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_250GB)}
-
-<b>Дополнительно:</b>
- За устройство: {settings.format_price(settings.PRICE_PER_DEVICE)}
-"""
-    
-    keyboard = [
-      #  [
-      #      types.InlineKeyboardButton(text="📅 Периоды", callback_data="admin_edit_period_prices"),
-      #      types.InlineKeyboardButton(text="📈 Трафик", callback_data="admin_edit_traffic_prices")
-      #  ],
-      #  [
-      #      types.InlineKeyboardButton(text="📱 Устройства", callback_data="admin_edit_device_price")
-      #  ],
-        [
-            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
-        ]
-    ]
-    
-    await callback.message.edit_text(
-        text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
-    )
-    await callback.answer()
-
-
-@admin_required  
-@error_handler
 async def show_countries_management(
    callback: types.CallbackQuery,
    db_user: User,
@@ -487,7 +432,6 @@ def register_handlers(dp: Dispatcher):
    dp.callback_query.register(show_subscriptions_list, F.data == "admin_subs_list")
    dp.callback_query.register(show_expiring_subscriptions, F.data == "admin_subs_expiring")
    dp.callback_query.register(show_subscriptions_stats, F.data == "admin_subs_stats")
-    dp.callback_query.register(show_pricing_settings, F.data == "admin_subs_pricing")
    dp.callback_query.register(show_countries_management, F.data == "admin_subs_countries")
    dp.callback_query.register(send_expiry_reminders, F.data == "admin_send_expiry_reminders")
    
@@ -4,6 +4,7 @@ import html
 import contextlib
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
 from sqlalchemy.ext.asyncio import AsyncSession

 from app.database.models import User
@@ -28,33 +29,63 @@ def _get_support_settings_keyboard(language: str) -> types.InlineKeyboardMarkup:

    rows: list[list[types.InlineKeyboardButton]] = []

+    status_enabled = texts.t("ADMIN_SUPPORT_SETTINGS_STATUS_ENABLED", "Включены")
+    status_disabled = texts.t("ADMIN_SUPPORT_SETTINGS_STATUS_DISABLED", "Отключены")
+
+    def mode_button(label_key: str, default: str, active: bool) -> str:
+        prefix = "🔘" if active else "⚪"
+        return f"{prefix} {texts.t(label_key, default)}"
+
    rows.append([
        types.InlineKeyboardButton(
-            text=("✅ Пункт 'Техподдержка' в меню" if menu_enabled else "🚫 Пункт 'Техподдержка' в меню"),
+            text=(
+                f"{'✅' if menu_enabled else '🚫'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_MENU_LABEL', 'Пункт «Техподдержка» в меню')}"
+            ),
            callback_data="admin_support_toggle_menu"
        )
    ])

    rows.append([
-        types.InlineKeyboardButton(text=("🔘 Тикеты" if mode == "tickets" else "⚪ Тикеты"), callback_data="admin_support_mode_tickets"),
-        types.InlineKeyboardButton(text=("🔘 Контакт" if mode == "contact" else "⚪ Контакт"), callback_data="admin_support_mode_contact"),
-        types.InlineKeyboardButton(text=("🔘 Оба" if mode == "both" else "⚪ Оба"), callback_data="admin_support_mode_both"),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_TICKETS", "Тикеты", mode == "tickets"),
+            callback_data="admin_support_mode_tickets"
+        ),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_CONTACT", "Контакт", mode == "contact"),
+            callback_data="admin_support_mode_contact"
+        ),
+        types.InlineKeyboardButton(
+            text=mode_button("ADMIN_SUPPORT_SETTINGS_MODE_BOTH", "Оба", mode == "both"),
+            callback_data="admin_support_mode_both"
+        ),
    ])

    rows.append([
-        types.InlineKeyboardButton(text="📝 Изменить описание", callback_data="admin_support_edit_desc")
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_EDIT_DESCRIPTION", "📝 Изменить описание"),
+            callback_data="admin_support_edit_desc"
+        )
    ])

    # Notifications block
    rows.append([
        types.InlineKeyboardButton(
-            text=("🔔 Админ-уведомления: Включены" if admin_notif else "🔕 Админ-уведомления: Отключены"),
+            text=(
+                f"{'🔔' if admin_notif else '🔕'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_ADMIN_NOTIFICATIONS', 'Админ-уведомления')}: "
+                f"{status_enabled if admin_notif else status_disabled}"
+            ),
            callback_data="admin_support_toggle_admin_notifications"
        )
    ])
    rows.append([
        types.InlineKeyboardButton(
-            text=("🔔 Пользовательские уведомления: Включены" if user_notif else "🔕 Пользовательские уведомления: Отключены"),
+            text=(
+                f"{'🔔' if user_notif else '🔕'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_USER_NOTIFICATIONS', 'Пользовательские уведомления')}: "
+                f"{status_enabled if user_notif else status_disabled}"
+            ),
            callback_data="admin_support_toggle_user_notifications"
        )
    ])
@@ -62,13 +93,17 @@ def _get_support_settings_keyboard(language: str) -> types.InlineKeyboardMarkup:
    # SLA block
    rows.append([
        types.InlineKeyboardButton(
-            text=("⏰ SLA: Включено" if sla_enabled else "⏹️ SLA: Отключено"),
+            text=(
+                f"{'⏰' if sla_enabled else '⏹️'} "
+                f"{texts.t('ADMIN_SUPPORT_SETTINGS_SLA_LABEL', 'SLA')}: "
+                f"{status_enabled if sla_enabled else status_disabled}"
+            ),
            callback_data="admin_support_toggle_sla"
        )
    ])
    rows.append([
        types.InlineKeyboardButton(
-            text=f"⏳ Время SLA: {sla_minutes} мин",
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_SLA_TIME", "⏳ Время SLA: {minutes} мин").format(minutes=sla_minutes),
            callback_data="admin_support_set_sla_minutes"
        )
    ])
@@ -78,15 +113,18 @@ def _get_support_settings_keyboard(language: str) -> types.InlineKeyboardMarkup:
    mod_count = len(moderators)
    rows.append([
        types.InlineKeyboardButton(
-            text=f"🧑‍⚖️ Модераторы: {mod_count}", callback_data="admin_support_list_moderators"
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_MODERATORS_COUNT", "🧑‍⚖️ Модераторы: {count}").format(count=mod_count),
+            callback_data="admin_support_list_moderators"
        )
    ])
    rows.append([
        types.InlineKeyboardButton(
-            text="➕ Назначить модератора", callback_data="admin_support_add_moderator"
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_ADD_MODERATOR", "➕ Назначить модератора"),
+            callback_data="admin_support_add_moderator"
        ),
        types.InlineKeyboardButton(
-            text="➖ Удалить модератора", callback_data="admin_support_remove_moderator"
+            text=texts.t("ADMIN_SUPPORT_SETTINGS_REMOVE_MODERATOR", "➖ Удалить модератора"),
+            callback_data="admin_support_remove_moderator"
        )
    ])

@@ -107,8 +145,8 @@ async def show_support_settings(
    texts = get_texts(db_user.language)
    desc = SupportSettingsService.get_support_info_text(db_user.language)
    await callback.message.edit_text(
-        "🛟 <b>Настройки поддержки</b>\n\n" +
-        "Режим работы и видимость в меню. Ниже текущее описание меню поддержки:\n\n" +
+        texts.t("ADMIN_SUPPORT_SETTINGS_TITLE", "🛟 <b>Настройки поддержки</b>") + "\n\n" +
+        texts.t("ADMIN_SUPPORT_SETTINGS_DESCRIPTION", "Режим работы и видимость в меню. Ниже текущее описание меню поддержки:") + "\n\n" +
        desc,
        reply_markup=_get_support_settings_keyboard(db_user.language),
        parse_mode="HTML"
@@ -152,24 +190,6 @@ async def toggle_sla(callback: types.CallbackQuery, db_user: User, db: AsyncSess
    await show_support_settings(callback, db_user, db)


-from app.states import SupportSettingsStates
-
-@admin_required
-@error_handler
-async def start_set_sla_minutes(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
-    await callback.message.edit_text(
-        "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):",
-        parse_mode="HTML",
-        reply_markup=types.InlineKeyboardMarkup(
-            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
-        )
-    )
-    await state.set_state(SupportSettingsStates.waiting_for_desc)  # temporary reuse replaced below
-    # we'll manage separate state below
-
-
-from aiogram.fsm.state import State, StatesGroup
-
 class SupportAdvancedStates(StatesGroup):
    waiting_for_sla_minutes = State()
    waiting_for_moderator_id = State()
@@ -178,11 +198,15 @@ class SupportAdvancedStates(StatesGroup):
@admin_required
@error_handler
 async def start_set_sla_minutes(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    await callback.message.edit_text(
-        "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):",
+        texts.t(
+            "ADMIN_SUPPORT_SLA_SETUP_PROMPT",
+            "⏳ <b>Настройка SLA</b>\n\nВведите количество минут ожидания ответа (целое число > 0):"
+        ),
        parse_mode="HTML",
        reply_markup=types.InlineKeyboardMarkup(
-            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
        )
    )
    await state.set_state(SupportAdvancedStates.waiting_for_sla_minutes)
@@ -192,63 +216,53 @@ async def start_set_sla_minutes(callback: types.CallbackQuery, db_user: User, db
@admin_required
@error_handler
 async def handle_sla_minutes(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    text = (message.text or "").strip()
    try:
        minutes = int(text)
        if minutes <= 0 or minutes > 1440:
            raise ValueError()
    except Exception:
-        await message.answer("❌ Введите корректное число минут (1-1440)")
+        await message.answer(texts.t("ADMIN_SUPPORT_SLA_INVALID", "❌ Введите корректное число минут (1-1440)"))
        return
    SupportSettingsService.set_sla_minutes(minutes)
    await state.clear()
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
-    await message.answer("✅ Значение SLA сохранено", reply_markup=markup)
+    await message.answer(texts.t("ADMIN_SUPPORT_SLA_SAVED", "✅ Значение SLA сохранено"), reply_markup=markup)


@admin_required
@error_handler
 async def start_add_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    await callback.message.edit_text(
-        "🧑‍⚖️ <b>Назначение модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+        texts.t(
+            "ADMIN_SUPPORT_ASSIGN_MODERATOR_PROMPT",
+            "🧑‍⚖️ <b>Назначение модератора</b>\n\nОтправьте Telegram ID пользователя (число)"
+        ),
        parse_mode="HTML",
        reply_markup=types.InlineKeyboardMarkup(
-            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
        )
    )
    await state.set_state(SupportAdvancedStates.waiting_for_moderator_id)
    await callback.answer()


-@admin_required
-@error_handler
-async def handle_add_moderator(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
-    text = (message.text or "").strip()
-    try:
-        tid = int(text)
-    except Exception:
-        await message.answer("❌ Введите корректный Telegram ID (число)")
-        return
-    if SupportSettingsService.add_moderator(tid):
-        markup = types.InlineKeyboardMarkup(
-            inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
-        )
-        await message.answer(f"✅ Пользователь {tid} назначен модератором", reply_markup=markup)
-    else:
-        await message.answer("❌ Не удалось сохранить")
-    await state.clear()
-
-
@admin_required
@error_handler
 async def start_remove_moderator(callback: types.CallbackQuery, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    await callback.message.edit_text(
-        "🧑‍⚖️ <b>Удаление модератора</b>\n\nОтправьте Telegram ID пользователя (число)",
+        texts.t(
+            "ADMIN_SUPPORT_REMOVE_MODERATOR_PROMPT",
+            "🧑‍⚖️ <b>Удаление модератора</b>\n\nОтправьте Telegram ID пользователя (число)"
+        ),
        parse_mode="HTML",
        reply_markup=types.InlineKeyboardMarkup(
-            inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+            inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
        )
    )
    await state.set_state(SupportAdvancedStates.waiting_for_moderator_id)
@@ -260,24 +274,32 @@ async def start_remove_moderator(callback: types.CallbackQuery, db_user: User, d
@admin_required
@error_handler
 async def handle_moderator_id(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    data = await state.get_data()
    action = data.get("action", "add")
    text = (message.text or "").strip()
    try:
        tid = int(text)
    except Exception:
-        await message.answer("❌ Введите корректный Telegram ID (число)")
+        await message.answer(texts.t("ADMIN_SUPPORT_INVALID_TELEGRAM_ID", "❌ Введите корректный Telegram ID (число)"))
        return
-    ok = False
    if action == "remove_moderator":
        ok = SupportSettingsService.remove_moderator(tid)
-        msg = "✅ Модератор удалён" if ok else "❌ Не удалось удалить"
+        msg = (
+            texts.t("ADMIN_SUPPORT_MODERATOR_REMOVED_SUCCESS", "✅ Модератор {tid} удалён").format(tid=tid)
+            if ok
+            else texts.t("ADMIN_SUPPORT_MODERATOR_REMOVED_FAIL", "❌ Не удалось удалить модератора")
+        )
    else:
        ok = SupportSettingsService.add_moderator(tid)
-        msg = "✅ Пользователь назначен модератором" if ok else "❌ Не удалось назначить"
+        msg = (
+            texts.t("ADMIN_SUPPORT_MODERATOR_ADDED_SUCCESS", "✅ Пользователь {tid} назначен модератором").format(tid=tid)
+            if ok
+            else texts.t("ADMIN_SUPPORT_MODERATOR_ADDED_FAIL", "❌ Не удалось назначить модератора")
+        )
    await state.clear()
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
    await message.answer(msg, reply_markup=markup)

@@ -285,13 +307,17 @@ async def handle_moderator_id(message: types.Message, db_user: User, db: AsyncSe
@admin_required
@error_handler
 async def list_moderators(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
+    texts = get_texts(db_user.language)
    moderators = SupportSettingsService.get_moderators()
    if not moderators:
-        await callback.answer("Список пуст", show_alert=True)
+        await callback.answer(texts.t("ADMIN_SUPPORT_MODERATORS_EMPTY", "Список пуст"), show_alert=True)
        return
-    text = "🧑‍⚖️ <b>Модераторы</b>\n\n" + "\n".join([f"• <code>{tid}</code>" for tid in moderators])
+    text = (
+        texts.t("ADMIN_SUPPORT_MODERATORS_TITLE", "🧑‍⚖️ <b>Модераторы</b>") +
+        "\n\n" + "\n".join([f"• <code>{tid}</code>" for tid in moderators])
+    )
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_support_settings")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.BACK, callback_data="admin_support_settings")]]
    )
    await callback.message.edit_text(text, parse_mode="HTML", reply_markup=markup)
    await callback.answer()
@@ -328,7 +354,10 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn

    kb_rows: list[list[types.InlineKeyboardButton]] = []
    kb_rows.append([
-        types.InlineKeyboardButton(text="📨 Прислать текст", callback_data="admin_support_send_desc")
+        types.InlineKeyboardButton(
+            text=texts.t("ADMIN_SUPPORT_SEND_DESCRIPTION", "📨 Прислать текст"),
+            callback_data="admin_support_send_desc"
+        )
    ])
    # Подготовим блок контакта (отдельным инлайном)
    from app.config import settings
@@ -338,19 +367,19 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn
    ])

    text_parts = [
-        "📝 <b>Редактирование описания поддержки</b>",
+        texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_TITLE", "📝 <b>Редактирование описания поддержки</b>"),
        "",
-        "Текущее описание:",
+        texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CURRENT", "Текущее описание:"),
        "",
        f"<code>{html.escape(current_desc_plain)}</code>",
    ]
    if support_contact_display:
        text_parts += [
            "",
-            "<b>Контакт для режима \u00abКонтакт\u00bb</b>",
+            texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_TITLE", "<b>Контакт для режима «Контакт»</b>"),
            f"<code>{html.escape(support_contact_display)}</code>",
            "",
-            "Добавьте в описание при необходимости.",
+            texts.t("ADMIN_SUPPORT_EDIT_DESCRIPTION_CONTACT_HINT", "Добавьте в описание при необходимости."),
        ]
    await callback.message.edit_text(
        "\n".join(text_parts),
@@ -364,24 +393,26 @@ async def start_edit_desc(callback: types.CallbackQuery, db_user: User, db: Asyn
@admin_required
@error_handler
 async def handle_new_desc(message: types.Message, db_user: User, db: AsyncSession, state: FSMContext):
+    texts = get_texts(db_user.language)
    new_text = message.html_text or message.text
    SupportSettingsService.set_support_info_text(db_user.language, new_text)
    await state.clear()
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
-    await message.answer("✅ Описание обновлено.", reply_markup=markup)
+    await message.answer(texts.t("ADMIN_SUPPORT_DESCRIPTION_UPDATED", "✅ Описание обновлено."), reply_markup=markup)


@admin_required
@error_handler
 async def send_desc_copy(callback: types.CallbackQuery, db_user: User, db: AsyncSession):
    # send plain text for easy copying
+    texts = get_texts(db_user.language)
    current_desc_html = SupportSettingsService.get_support_info_text(db_user.language)
    current_desc_plain = re.sub(r"<[^>]+>", "", current_desc_html)
    # attach delete button to the sent message
    markup = types.InlineKeyboardMarkup(
-        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+        inline_keyboard=[[types.InlineKeyboardButton(text=texts.t("DELETE_MESSAGE", "🗑 Удалить"), callback_data="admin_support_delete_msg")]]
    )
    if len(current_desc_plain) <= 4000:
        await callback.message.answer(current_desc_plain, reply_markup=markup)
@@ -393,7 +424,7 @@ async def send_desc_copy(callback: types.CallbackQuery, db_user: User, db: Async
            is_last = (chunk + 4000) >= len(current_desc_plain)
            await callback.message.answer(next_chunk, reply_markup=(markup if is_last else None))
            chunk += 4000
-    await callback.answer("Текст отправлен ниже")
+    await callback.answer(texts.t("ADMIN_SUPPORT_DESCRIPTION_SENT", "Текст отправлен ниже"))


@error_handler
@@ -403,15 +434,15 @@ async def delete_sent_message(callback: types.CallbackQuery, db_user: User, db:
        may_delete = (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id))
    except Exception:
        may_delete = False
+    texts = get_texts(db_user.language if db_user else 'ru')
    if not may_delete:
-        texts = get_texts(db_user.language if db_user else 'ru')
        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
        return
    try:
        await callback.message.delete()
    finally:
        with contextlib.suppress(Exception):
-            await callback.answer("Сообщение удалено")
+            await callback.answer(texts.t("ADMIN_SUPPORT_MESSAGE_DELETED", "Сообщение удалено"))


 def register_handlers(dp: Dispatcher):
@@ -0,0 +1,165 @@
+import logging
+from datetime import datetime
+from html import escape
+from pathlib import Path
+
+from aiogram import Dispatcher, F, types
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, FSInputFile
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+LOG_PREVIEW_LIMIT = 2300
+
+
+def _resolve_log_path() -> Path:
+    log_path = Path(settings.LOG_FILE)
+    if not log_path.is_absolute():
+        log_path = Path.cwd() / log_path
+    return log_path
+
+
+def _format_preview_block(text: str) -> str:
+    escaped_text = escape(text) if text else ""
+    return f"<blockquote expandable><pre><code>{escaped_text}</code></pre></blockquote>"
+
+
+def _build_logs_message(log_path: Path) -> str:
+    if not log_path.exists():
+        message = (
+            "🧾 <b>Системные логи</b>\n\n"
+            f"Файл <code>{log_path}</code> пока не создан.\n"
+            "Логи появятся автоматически после первой записи."
+        )
+        return message
+
+    try:
+        content = log_path.read_text(encoding="utf-8", errors="ignore")
+    except Exception as error:  # pragma: no cover - защита от проблем чтения
+        logger.error("Ошибка чтения лог-файла %s: %s", log_path, error)
+        message = (
+            "❌ <b>Ошибка чтения логов</b>\n\n"
+            f"Не удалось прочитать файл <code>{log_path}</code>."
+        )
+        return message
+
+    total_length = len(content)
+    stats = log_path.stat()
+    updated_at = datetime.fromtimestamp(stats.st_mtime)
+
+    if not content:
+        preview_text = "Лог-файл пуст."
+        truncated = False
+    else:
+        preview_text = content[-LOG_PREVIEW_LIMIT:]
+        truncated = total_length > LOG_PREVIEW_LIMIT
+
+    details_lines = [
+        "🧾 <b>Системные логи</b>",
+        "",
+        f"📁 <b>Файл:</b> <code>{log_path}</code>",
+        f"🕒 <b>Обновлен:</b> {updated_at.strftime('%d.%m.%Y %H:%M:%S')}",
+        f"🧮 <b>Размер:</b> {total_length} символов",
+        (
+            f"👇 Показаны последние {LOG_PREVIEW_LIMIT} символов."
+            if truncated
+            else "📄 Показано все содержимое файла."
+        ),
+        "",
+        _format_preview_block(preview_text),
+    ]
+
+    return "\n".join(details_lines)
+
+
+def _get_logs_keyboard() -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_system_logs_refresh")],
+            [InlineKeyboardButton(text="⬇️ Скачать лог", callback_data="admin_system_logs_download")],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_submenu_system")],
+        ]
+    )
+
+
+@admin_required
+@error_handler
+async def show_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+    message = _build_logs_message(log_path)
+
+    reply_markup = _get_logs_keyboard()
+    await callback.message.edit_text(message, reply_markup=reply_markup, parse_mode="HTML")
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def refresh_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+    message = _build_logs_message(log_path)
+
+    reply_markup = _get_logs_keyboard()
+    await callback.message.edit_text(message, reply_markup=reply_markup, parse_mode="HTML")
+    await callback.answer("🔄 Обновлено")
+
+
+@admin_required
+@error_handler
+async def download_system_logs(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    log_path = _resolve_log_path()
+
+    if not log_path.exists() or not log_path.is_file():
+        await callback.answer("❌ Лог-файл не найден", show_alert=True)
+        return
+
+    try:
+        await callback.answer("⬇️ Отправляю лог...")
+
+        document = FSInputFile(log_path)
+        stats = log_path.stat()
+        updated_at = datetime.fromtimestamp(stats.st_mtime).strftime("%d.%m.%Y %H:%M:%S")
+        caption = (
+            f"🧾 Лог-файл <code>{log_path.name}</code>\n"
+            f"📁 Путь: <code>{log_path}</code>\n"
+            f"🕒 Обновлен: {updated_at}"
+        )
+        await callback.message.answer_document(document=document, caption=caption, parse_mode="HTML")
+    except Exception as error:  # pragma: no cover - защита от ошибок отправки
+        logger.error("Ошибка отправки лог-файла %s: %s", log_path, error)
+        await callback.message.answer(
+            "❌ <b>Не удалось отправить лог-файл</b>\n\n"
+            "Проверьте журналы приложения или повторите попытку позже.",
+            parse_mode="HTML",
+        )
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(
+        show_system_logs,
+        F.data == "admin_system_logs",
+    )
+    dp.callback_query.register(
+        refresh_system_logs,
+        F.data == "admin_system_logs_refresh",
+    )
+    dp.callback_query.register(
+        download_system_logs,
+        F.data == "admin_system_logs_download",
+    )
@@ -7,6 +7,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, desc, and_
 from datetime import datetime, timedelta
 import time
+import html

 from app.database.models import User, Ticket, TicketStatus
 from app.database.crud.ticket import TicketCRUD, TicketMessageCRUD
@@ -79,12 +80,16 @@ async def show_admin_tickets(
    ticket_data = []
    for ticket in tickets:
        user_name = ticket.user.full_name if ticket.user else "Unknown"
+        username = ticket.user.username if ticket.user else None
+        telegram_id = ticket.user.telegram_id if ticket.user else None
        ticket_data.append({
            'id': ticket.id,
            'title': ticket.title,
            'status_emoji': ticket.status_emoji,
            'priority_emoji': ticket.priority_emoji,
            'user_name': user_name,
+            'username': username,
+            'telegram_id': telegram_id,
            'is_closed': ticket.is_closed,
            'locked_emoji': ("🔒" if ticket.is_user_reply_blocked else "")
        })
@@ -169,9 +174,25 @@ async def view_admin_ticket(
    }.get(ticket.status, ticket.status)
    
    user_name = ticket.user.full_name if ticket.user else "Unknown"
-    
+    telegram_id_display = ticket.user.telegram_id if ticket.user else "—"
+    username_value = ticket.user.username if ticket.user else None
+
    ticket_text = f"🎫 Тикет #{ticket.id}\n\n"
    ticket_text += f"👤 Пользователь: {user_name}\n"
+    ticket_text += f"🆔 Telegram ID: <code>{telegram_id_display}</code>\n"
+    if username_value:
+        safe_username = html.escape(username_value)
+        ticket_text += f"📱 Username: @{safe_username}\n"
+        ticket_text += (
+            f"🔗 ЛС: <a href=\"tg://resolve?domain={safe_username}\">"
+            f"tg://resolve?domain={safe_username}</a>\n"
+        )
+    else:
+        ticket_text += "📱 Username: отсутствует\n"
+        if ticket.user and ticket.user.telegram_id:
+            chat_link = f"tg://user?id={int(ticket.user.telegram_id)}"
+            ticket_text += f"🔗 Чат по ID: <a href=\"{chat_link}\">{chat_link}</a>\n"
+    ticket_text += "\n"
    ticket_text += f"📝 Заголовок: {ticket.title}\n"
    ticket_text += f"📊 Статус: {ticket.status_emoji} {status_text}\n"
    ticket_text += f"📅 Создан: {ticket.created_at.strftime('%d.%m.%Y %H:%M')}\n"
@@ -201,6 +222,29 @@ async def view_admin_ticket(
        db_user.language,
        is_user_blocked=ticket.is_user_reply_blocked
    )
+    # Кнопка открытия профиля пользователя в админке
+    try:
+        if ticket.user:
+            admin_profile_btn = types.InlineKeyboardButton(
+                text="👤 К пользователю",
+                callback_data=f"admin_user_manage_{ticket.user.id}_from_ticket_{ticket.id}"
+            )
+            keyboard.inline_keyboard.insert(0, [admin_profile_btn])
+    except Exception:
+        pass
+    # Кнопки ЛС и профиль
+    try:
+        if ticket.user and ticket.user.telegram_id and ticket.user.username:
+            safe_username = html.escape(ticket.user.username)
+            buttons_row = []
+            pm_url = f"tg://resolve?domain={safe_username}"
+            buttons_row.append(types.InlineKeyboardButton(text="✉ Написать в ЛС", url=pm_url))
+            profile_url = f"tg://user?id={ticket.user.telegram_id}"
+            buttons_row.append(types.InlineKeyboardButton(text="👤 Профиль", url=profile_url))
+            if buttons_row:
+                keyboard.inline_keyboard.insert(0, buttons_row)
+    except Exception:
+        pass
    if has_photos:
        try:
            keyboard.inline_keyboard.insert(0, [types.InlineKeyboardButton(text=texts.t("TICKET_ATTACHMENTS", "📎 Вложения"), callback_data=f"admin_ticket_attachments_{ticket_id}")])
@@ -336,7 +380,7 @@ async def handle_admin_ticket_reply(
            return

        # Обычный режим ответа админа
-        ticket = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_messages=False)
+        ticket = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_messages=False, load_user=True)
        if not ticket:
            texts = get_texts(db_user.language)
            await message.answer(
@@ -426,6 +470,81 @@ async def mark_ticket_as_answered(
        )


+async def close_all_open_admin_tickets(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    """Закрыть все открытые тикеты."""
+    if not (settings.is_admin(callback.from_user.id) or SupportSettingsService.is_moderator(callback.from_user.id)):
+        texts = get_texts(db_user.language)
+        await callback.answer(texts.ACCESS_DENIED, show_alert=True)
+        return
+
+    texts = get_texts(db_user.language)
+
+    try:
+        closed_ticket_ids = await TicketCRUD.close_all_open_tickets(db)
+    except Exception as error:
+        logger.error("Error closing all open tickets: %s", error)
+        await callback.answer(
+            texts.t("TICKET_UPDATE_ERROR", "❌ Ошибка при обновлении тикета."),
+            show_alert=True
+        )
+        return
+
+    closed_count = len(closed_ticket_ids)
+
+    if closed_count == 0:
+        await callback.answer(
+            texts.t("ADMIN_CLOSE_ALL_OPEN_TICKETS_EMPTY", "ℹ️ Нет открытых тикетов для закрытия."),
+            show_alert=True
+        )
+        return
+
+    try:
+        is_moderator = (
+            not settings.is_admin(callback.from_user.id)
+            and SupportSettingsService.is_moderator(callback.from_user.id)
+        )
+        await TicketCRUD.add_support_audit(
+            db,
+            actor_user_id=db_user.id if db_user else None,
+            actor_telegram_id=callback.from_user.id,
+            is_moderator=is_moderator,
+            action="close_all_tickets",
+            ticket_id=None,
+            target_user_id=None,
+            details={
+                "count": closed_count,
+                "ticket_ids": closed_ticket_ids,
+            }
+        )
+    except Exception as audit_error:
+        logger.warning("Failed to add support audit for bulk close: %s", audit_error)
+
+    # Обновляем список тикетов
+    await show_admin_tickets(callback, db_user, db)
+
+    success_text = texts.t(
+        "ADMIN_CLOSE_ALL_OPEN_TICKETS_SUCCESS",
+        "✅ Закрыто открытых тикетов: {count}"
+    ).format(count=closed_count)
+
+    notification_keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[[types.InlineKeyboardButton(text="🗑 Удалить", callback_data="admin_support_delete_msg")]]
+    )
+
+    try:
+        await callback.message.answer(success_text, reply_markup=notification_keyboard)
+    except Exception:
+        # Если не удалось отправить отдельное сообщение, пробуем ответить алертом
+        try:
+            await callback.answer(success_text, show_alert=True)
+        except Exception:
+            pass
+
+
 async def close_admin_ticket(
    callback: types.CallbackQuery,
    db_user: User,
@@ -445,6 +564,17 @@ async def close_admin_ticket(
            # audit
            try:
                is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+                # обогатим details контактами пользователя тикета
+                details = {}
+                try:
+                    t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                    if t and t.user:
+                        details.update({
+                            "target_telegram_id": t.user.telegram_id,
+                            "target_username": t.user.username,
+                        })
+                except Exception:
+                    pass
                await TicketCRUD.add_support_audit(
                    db,
                    actor_user_id=db_user.id if db_user else None,
@@ -453,7 +583,7 @@ async def close_admin_ticket(
                    action="close_ticket",
                    ticket_id=ticket_id,
                    target_user_id=None,
-                    details={}
+                    details=details
                )
            except Exception:
                pass
@@ -629,7 +759,21 @@ async def handle_admin_block_duration_input(
            ticket_text += f"📝 Заголовок: {updated.title}\n"
            ticket_text += f"📊 Статус: {updated.status_emoji} {status_text}\n"
            ticket_text += f"📅 Создан: {updated.created_at.strftime('%d.%m.%Y %H:%M')}\n"
-            ticket_text += f"🔄 Обновлен: {updated.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+            ticket_text += f"🔄 Обновлен: {updated.updated_at.strftime('%d.%m.%Y %H:%M')}\n"
+            if updated.user and updated.user.telegram_id:
+                ticket_text += f"🆔 Telegram ID: <code>{updated.user.telegram_id}</code>\n"
+                if updated.user.username:
+                    safe_username = html.escape(updated.user.username)
+                    ticket_text += f"📱 Username: @{safe_username}\n"
+                    ticket_text += (
+                        f"🔗 ЛС: <a href=\"tg://resolve?domain={safe_username}\">"
+                        f"tg://resolve?domain={safe_username}</a>\n"
+                    )
+                else:
+                    ticket_text += "📱 Username: отсутствует\n"
+                    chat_link = f"tg://user?id={int(updated.user.telegram_id)}"
+                    ticket_text += f"🔗 Чат по ID: <a href=\"{chat_link}\">{chat_link}</a>\n"
+            ticket_text += "\n"
            if updated.is_user_reply_blocked:
                if updated.user_reply_block_permanent:
                    ticket_text += "🚫 Пользователь заблокирован навсегда для ответов в этом тикете\n"
@@ -645,6 +789,29 @@ async def handle_admin_block_duration_input(
                        ticket_text += "📎 Вложение: фото\n\n"

            kb = get_admin_ticket_view_keyboard(updated.id, updated.is_closed, db_user.language, is_user_blocked=updated.is_user_reply_blocked)
+            # Кнопка открытия профиля пользователя в админке
+            try:
+                if updated.user:
+                    admin_profile_btn = types.InlineKeyboardButton(
+                        text="👤 К пользователю",
+                        callback_data=f"admin_user_manage_{updated.user.id}_from_ticket_{updated.id}"
+                    )
+                    kb.inline_keyboard.insert(0, [admin_profile_btn])
+            except Exception:
+                pass
+            # Кнопки ЛС и профиль при обновлении карточки
+            try:
+                if updated.user and updated.user.telegram_id and updated.user.username:
+                    safe_username = html.escape(updated.user.username)
+                    buttons_row = []
+                    pm_url = f"tg://resolve?domain={safe_username}"
+                    buttons_row.append(types.InlineKeyboardButton(text="✉ Написать в ЛС", url=pm_url))
+                    profile_url = f"tg://user?id={updated.user.telegram_id}"
+                    buttons_row.append(types.InlineKeyboardButton(text="👤 Профиль", url=profile_url))
+                    if buttons_row:
+                        kb.inline_keyboard.insert(0, buttons_row)
+            except Exception:
+                pass
            has_photos = any(getattr(m, "has_media", False) and getattr(m, "media_type", None) == "photo" for m in updated.messages or [])
            if has_photos:
                try:
@@ -699,6 +866,16 @@ async def unblock_user_in_ticket(
        try:
            is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
            ticket_id = int(callback.data.replace("admin_unblock_user_ticket_", ""))
+            details = {}
+            try:
+                t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                if t and t.user:
+                    details.update({
+                        "target_telegram_id": t.user.telegram_id,
+                        "target_username": t.user.username,
+                    })
+            except Exception:
+                pass
            await TicketCRUD.add_support_audit(
                db,
                actor_user_id=db_user.id if db_user else None,
@@ -707,7 +884,7 @@ async def unblock_user_in_ticket(
                action="unblock_user",
                ticket_id=ticket_id,
                target_user_id=None,
-                details={}
+                details=details
            )
        except Exception:
            pass
@@ -741,6 +918,16 @@ async def block_user_permanently(
        # audit
        try:
            is_mod = (not settings.is_admin(callback.from_user.id) and SupportSettingsService.is_moderator(callback.from_user.id))
+            details = {}
+            try:
+                t = await TicketCRUD.get_ticket_by_id(db, ticket_id, load_user=True)
+                if t and t.user:
+                    details.update({
+                        "target_telegram_id": t.user.telegram_id,
+                        "target_username": t.user.username,
+                    })
+            except Exception:
+                pass
            await TicketCRUD.add_support_audit(
                db,
                actor_user_id=db_user.id if db_user else None,
@@ -749,7 +936,7 @@ async def block_user_permanently(
                action="block_user_perm",
                ticket_id=ticket_id,
                target_user_id=None,
-                details={}
+                details=details
            )
        except Exception:
            pass
@@ -768,52 +955,71 @@ async def notify_user_about_ticket_reply(bot: Bot, ticket: Ticket, reply_text: s
        except Exception:
            pass
        from app.localization.texts import get_texts
-        
-        # Получаем тикет с пользователем
-        ticket_with_user = await TicketCRUD.get_ticket_by_id(db, ticket.id, load_user=True)
-        if not ticket_with_user or not ticket_with_user.user:
+
+        # Обеспечим наличие данных пользователя в объекте тикета
+        ticket_with_user = ticket
+        if not getattr(ticket_with_user, "user", None):
+            ticket_with_user = await TicketCRUD.get_ticket_by_id(db, ticket.id, load_user=True)
+
+        user = getattr(ticket_with_user, "user", None)
+        if not user:
            logger.error(f"User not found for ticket #{ticket.id}")
            return
-        
-        texts = get_texts(ticket_with_user.user.language)
-        
+
+        if not getattr(user, "telegram_id", None):
+            logger.error(
+                "Cannot notify ticket #%s user without telegram_id (username=%s)",
+                ticket.id,
+                getattr(user, "username", None),
+            )
+            return
+
+        chat_id = int(user.telegram_id)
+        texts = get_texts(user.language)
+
        # Формируем уведомление
        base_text = texts.t(
-            "TICKET_REPLY_NOTIFICATION", 
+            "TICKET_REPLY_NOTIFICATION",
            "🎫 Получен ответ по тикету #{ticket_id}\n\n{reply_preview}\n\nНажмите кнопку ниже, чтобы перейти к тикету:"
        ).format(
            ticket_id=ticket.id,
            reply_preview=reply_text[:100] + "..." if len(reply_text) > 100 else reply_text
        )
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text=texts.t("VIEW_TICKET", "👁️ Посмотреть тикет"), callback_data=f"view_ticket_{ticket.id}")],
+            [types.InlineKeyboardButton(text=texts.t("CLOSE_NOTIFICATION", "❌ Закрыть уведомление"), callback_data=f"close_ticket_notification_{ticket.id}")]
+        ])
+
        # Если было фото в последнем ответе админа — отправим как фото
        last_message = await TicketMessageCRUD.get_last_message(db, ticket.id)
        if last_message and last_message.has_media and last_message.media_type == "photo" and last_message.is_from_admin:
            caption = base_text
            try:
                await bot.send_photo(
-                    chat_id=ticket_with_user.user.telegram_id,
+                    chat_id=chat_id,
                    photo=last_message.media_file_id,
                    caption=caption,
-                    reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-                        [types.InlineKeyboardButton(text=texts.t("VIEW_TICKET", "👁️ Посмотреть тикет"), callback_data=f"view_ticket_{ticket.id}")],
-                        [types.InlineKeyboardButton(text=texts.t("CLOSE_NOTIFICATION", "❌ Закрыть уведомление"), callback_data=f"close_ticket_notification_{ticket.id}")]
-                    ])
+                    reply_markup=keyboard,
                )
                return
+            except TelegramBadRequest as photo_error:
+                logger.error(
+                    "Не удалось отправить фото-уведомление пользователю %s для тикета %s: %s",
+                    chat_id,
+                    ticket.id,
+                    photo_error,
+                )
            except Exception as e:
                logger.error(f"Не удалось отправить фото-уведомление: {e}")
        # Фоллбек: текстовое уведомление
        await bot.send_message(
-            chat_id=ticket_with_user.user.telegram_id,
+            chat_id=chat_id,
            text=base_text,
-            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-                [types.InlineKeyboardButton(text=texts.t("VIEW_TICKET", "👁️ Посмотреть тикет"), callback_data=f"view_ticket_{ticket.id}")],
-                [types.InlineKeyboardButton(text=texts.t("CLOSE_NOTIFICATION", "❌ Закрыть уведомление"), callback_data=f"close_ticket_notification_{ticket.id}")]
-            ])
+            reply_markup=keyboard,
        )
-        
-        logger.info(f"Ticket #{ticket.id} reply notification sent to user {ticket_with_user.user.telegram_id}")
-        
+
+        logger.info(f"Ticket #{ticket.id} reply notification sent to user {chat_id}")
+
    except Exception as e:
        logger.error(f"Error notifying user about ticket reply: {e}")

@@ -825,7 +1031,8 @@ def register_handlers(dp: Dispatcher):
    dp.callback_query.register(show_admin_tickets, F.data == "admin_tickets")
    dp.callback_query.register(show_admin_tickets, F.data == "admin_tickets_scope_open")
    dp.callback_query.register(show_admin_tickets, F.data == "admin_tickets_scope_closed")
-    
+    dp.callback_query.register(close_all_open_admin_tickets, F.data == "admin_tickets_close_all_open")
+
    dp.callback_query.register(view_admin_ticket, F.data.startswith("admin_view_ticket_"))
    
    # Ответы на тикеты
@@ -0,0 +1,86 @@
+import logging
+
+from aiogram import Dispatcher, F, types
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.subscription import (
+    get_trial_statistics,
+    reset_trials_for_users_without_paid_subscription,
+)
+from app.database.models import User
+from app.keyboards.admin import get_admin_trials_keyboard
+from app.localization.texts import get_texts
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_trials_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    stats = await get_trial_statistics(db)
+    message = texts.t("ADMIN_TRIALS_TITLE", "🧪 Управление триалами") + "\n\n" + texts.t(
+        "ADMIN_TRIALS_STATS",
+        "• Использовано всего: {used}\n"
+        "• Активно сейчас: {active}\n"
+        "• Доступно к сбросу: {resettable}",
+    ).format(
+        used=stats.get("used_trials", 0),
+        active=stats.get("active_trials", 0),
+        resettable=stats.get("resettable_trials", 0),
+    )
+
+    await callback.message.edit_text(
+        message,
+        reply_markup=get_admin_trials_keyboard(db_user.language),
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def reset_trials(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    texts = get_texts(db_user.language)
+
+    reset_count = await reset_trials_for_users_without_paid_subscription(db)
+    stats = await get_trial_statistics(db)
+
+    message = texts.t(
+        "ADMIN_TRIALS_RESET_RESULT",
+        "♻️ Сбросили {reset_count} триалов.\n\n"
+        "• Использовано всего: {used}\n"
+        "• Активно сейчас: {active}\n"
+        "• Доступно к сбросу: {resettable}",
+    ).format(
+        reset_count=reset_count,
+        used=stats.get("used_trials", 0),
+        active=stats.get("active_trials", 0),
+        resettable=stats.get("resettable_trials", 0),
+    )
+
+    await callback.message.edit_text(
+        message,
+        reply_markup=get_admin_trials_keyboard(db_user.language),
+    )
+    await callback.answer(texts.t("ADMIN_TRIALS_RESET_TOAST", "✅ Сброс завершен"))
+
+
+def register_handlers(dp: Dispatcher) -> None:
+    dp.callback_query.register(
+        show_trials_panel,
+        F.data == "admin_trials",
+    )
+    dp.callback_query.register(
+        reset_trials,
+        F.data == "admin_trials_reset",
+    )
@@ -12,6 +12,11 @@ from app.database.crud.user_message import (
 )
 from app.database.models import User
 from app.keyboards.admin import get_admin_main_keyboard
+from app.utils.validators import (
+    get_html_help_text,
+    sanitize_html,
+    validate_html_tags,
+)
 from app.utils.decorators import admin_required, error_handler
 from app.localization.texts import get_texts

@@ -122,8 +127,6 @@ async def add_user_message_start(
    db_user: User,
    db: AsyncSession
 ):
-    from app.utils.validators import get_html_help_text
-    
    await callback.message.edit_text(
        f"📝 <b>Добавление нового сообщения</b>\n\n"
        f"Введите текст сообщения, которое будет показываться в главном меню.\n\n"
@@ -161,8 +164,6 @@ async def process_new_message_text(
        )
        return
    
-    from app.utils.validators import validate_html_tags, get_html_help_text
-    
    is_valid, error_msg = validate_html_tags(message_text)
    if not is_valid:
        await message.answer(
@@ -312,20 +313,22 @@ async def view_user_message(
        return
    
    message = await get_user_message_by_id(db, message_id)
-    
+
    if not message:
        await callback.answer("❌ Сообщение не найдено", show_alert=True)
        return
-    
+
+    safe_content = sanitize_html(message.message_text)
+
    status_text = "🟢 Активно" if message.is_active else "🔴 Неактивно"
-    
+
    text = (
        f"📋 <b>Сообщение ID {message.id}</b>\n\n"
        f"<b>Статус:</b> {status_text}\n"
        f"<b>Создано:</b> {message.created_at.strftime('%d.%m.%Y %H:%M')}\n"
        f"<b>Обновлено:</b> {message.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
        f"<b>Содержимое:</b>\n"
-        f"<blockquote>{message.message_text}</blockquote>"
+        f"<blockquote>{safe_content}</blockquote>"
    )
    
    await callback.message.edit_text(
@@ -455,7 +458,7 @@ async def edit_user_message_start(
    await callback.message.edit_text(
        f"✏️ <b>Редактирование сообщения ID {message.id}</b>\n\n"
        f"<b>Текущий текст:</b>\n"
-        f"<blockquote>{message.message_text}</blockquote>\n\n"
+        f"<blockquote>{sanitize_html(message.message_text)}</blockquote>\n\n"
        f"Введите новый текст сообщения или отправьте /cancel для отмены:",
        parse_mode="HTML"
    )
@@ -489,14 +492,23 @@ async def process_edit_message_text(
        return
    
    new_text = message.text.strip()
-    
+
    if len(new_text) > 4000:
        await message.answer(
            "❌ Сообщение слишком длинное. Максимум 4000 символов.\n"
            "Попробуйте еще раз или отправьте /cancel для отмены."
        )
        return
-    
+
+    is_valid, error_msg = validate_html_tags(new_text)
+    if not is_valid:
+        await message.answer(
+            f"❌ Ошибка в HTML разметке: {error_msg}\n\n"
+            f"Исправьте ошибку и попробуйте еще раз, или отправьте /cancel для отмены.",
+            parse_mode=None
+        )
+        return
+
    try:
        updated_message = await update_user_message(
            db=db,
@@ -511,7 +523,7 @@ async def process_edit_message_text(
                f"<b>ID:</b> {updated_message.id}\n"
                f"<b>Обновлено:</b> {updated_message.updated_at.strftime('%d.%m.%Y %H:%M')}\n\n"
                f"<b>Новый текст:</b>\n"
-                f"<blockquote>{new_text}</blockquote>",
+                f"<blockquote>{sanitize_html(new_text)}</blockquote>",
                reply_markup=get_user_messages_keyboard(db_user.language),
                parse_mode="HTML"
            )
@@ -1,9 +1,9 @@
 import logging
+import re
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
 from app.database.models import User
 from app.states import AdminStates
 from app.keyboards.admin import get_welcome_text_keyboard, get_admin_main_keyboard
@@ -19,6 +19,92 @@ from app.database.crud.welcome_text import (

 logger = logging.getLogger(__name__)

+
+def validate_html_tags(text: str) -> tuple[bool, str]:
+    """
+    Проверяет HTML-теги в тексте на соответствие требованиям Telegram API.
+    
+    Args:
+        text: Текст для проверки
+        
+    Returns:
+        Кортеж из (валидно ли, сообщение об ошибке или None)
+    """
+    # Поддерживаемые теги в parse_mode="HTML" для Telegram API
+    allowed_tags = {
+        'b', 'strong',  # жирный
+        'i', 'em',      # курсив
+        'u', 'ins',     # подчеркнуто
+        's', 'strike', 'del',  # зачеркнуто
+        'code',         # моноширинный для коротких фрагментов
+        'pre',          # моноширинный блок кода
+        'a'             # ссылки
+    }
+    
+    # Убираем плейсхолдеры из строки перед проверкой тегов
+    # Плейсхолдеры имеют формат {ключ}, и не являются тегами
+    placeholder_pattern = r'\{[^{}]+\}'
+    clean_text = re.sub(placeholder_pattern, '', text)
+    
+    # Находим все открывающие и закрывающие теги
+    tag_pattern = r'<(/?)([a-zA-Z]+)(\s[^>]*)?>'
+    tags_with_pos = [(m.group(1), m.group(2), m.group(3), m.start(), m.end()) for m in re.finditer(tag_pattern, clean_text)]
+    
+    for closing, tag, attrs, start_pos, end_pos in tags_with_pos:
+        tag_lower = tag.lower()
+        
+        # Проверяем, является ли тег поддерживаемым
+        if tag_lower not in allowed_tags:
+            return False, f"Неподдерживаемый HTML-тег: <{tag}>. Используйте только теги: {', '.join(sorted(allowed_tags))}"
+        
+        # Проверяем атрибуты для тега <a>
+        if tag_lower == 'a':
+            if closing:
+                continue  # Для закрывающего тега не нужно проверять атрибуты
+            if not attrs:
+                return False, "Тег <a> должен содержать атрибут href, например: <a href='URL'>ссылка</a>"
+            
+            # Проверяем, что есть атрибут href
+            if 'href=' not in attrs.lower():
+                return False, "Тег <a> должен содержать атрибут href, например: <a href='URL'>ссылка</a>"
+            
+            # Проверяем формат URL
+            href_match = re.search(r'href\s*=\s*[\'"]([^\'"]+)[\'"]', attrs, re.IGNORECASE)
+            if href_match:
+                url = href_match.group(1)
+                # Проверяем, что URL начинается с поддерживаемой схемы
+                if not re.match(r'^https?://|^tg://', url, re.IGNORECASE):
+                    return False, f"URL в теге <a> должен начинаться с http://, https:// или tg://. Найдено: {url}"
+            else:
+                return False, "Не удалось извлечь URL из атрибута href тега <a>"
+    
+    # Проверяем парность тегов с использованием стека
+    stack = []
+    for closing, tag, attrs, start_pos, end_pos in tags_with_pos:
+        tag_lower = tag.lower()
+        
+        if tag_lower not in allowed_tags:
+            continue
+            
+        if closing:
+            # Это закрывающий тег
+            if not stack:
+                return False, f"Лишний закрывающий тег: </{tag}>"
+                
+            last_opening_tag = stack.pop()
+            if last_opening_tag.lower() != tag_lower:
+                return False, f"Тег </{tag}> не соответствует открывающему тегу <{last_opening_tag}>"
+        else:
+            # Это открывающий тег
+            stack.append(tag)
+    
+    # Если остались незакрытые теги
+    if stack:
+        unclosed_tags = ", ".join([f"<{tag}>" for tag in stack])
+        return False, f"Незакрытые теги: {unclosed_tags}"
+    
+    return True, None
+
 def get_telegram_formatting_info() -> str:
    return """
 📝 <b>Поддерживаемые теги форматирования:</b>
@@ -44,16 +130,16 @@ async def show_welcome_text_panel(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-    status_text = "включено" if settings['is_enabled'] else "отключено"
+    welcome_settings = await get_current_welcome_text_settings(db)
+    status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+    status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
    
    await callback.message.edit_text(
        f"👋 Управление приветственным текстом\n\n"
        f"{status_emoji} <b>Статус:</b> {status_text}\n\n"
        f"Здесь вы можете управлять текстом, который показывается новым пользователям после регистрации.\n\n"
        f"💡 Доступные плейсхолдеры для автозамены:",
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -89,11 +175,11 @@ async def show_current_welcome_text(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    current_text = settings['text']
-    is_enabled = settings['is_enabled']
-    
-    if not settings['id']:
+    welcome_settings = await get_current_welcome_text_settings(db)
+    current_text = welcome_settings['text']
+    is_enabled = welcome_settings['is_enabled']
+
+    if not welcome_settings['id']:
        status = "📝 Используется стандартный текст:"
    else:
        status = "📝 Текущий приветственный текст:"
@@ -121,7 +207,7 @@ async def show_placeholders_help(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    placeholders = get_available_placeholders()
    placeholders_text = "\n".join([f"• <code>{key}</code>\n  {desc}" for key, desc in placeholders.items()])
    
@@ -137,7 +223,7 @@ async def show_placeholders_help(
    
    await callback.message.edit_text(
        help_text,
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -149,12 +235,12 @@ async def show_formatting_help(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    formatting_info = get_telegram_formatting_info()
    
    await callback.message.edit_text(
        formatting_info,
-        reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+        reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
        parse_mode="HTML"
    )
    await callback.answer()
@@ -167,8 +253,8 @@ async def start_edit_welcome_text(
    db_user: User,
    db: AsyncSession
 ):
-    settings = await get_current_welcome_text_settings(db)
-    current_text = settings['text']
+    welcome_settings = await get_current_welcome_text_settings(db)
+    current_text = welcome_settings['text']
    
    placeholders = get_available_placeholders()
    placeholders_text = "\n".join([f"• <code>{key}</code> - {desc}" for key, desc in placeholders.items()])
@@ -203,12 +289,18 @@ async def process_welcome_text_edit(
        await message.answer("❌ Текст слишком длинный! Максимум 4000 символов.")
        return
    
+    # Проверяем HTML-теги на валидность
+    is_valid, error_msg = validate_html_tags(new_text)
+    if not is_valid:
+        await message.answer(f"❌ Ошибка в HTML-разметке:\n\n{error_msg}")
+        return
+    
    success = await set_welcome_text(db, new_text, db_user.id)
    
    if success:
-        settings = await get_current_welcome_text_settings(db)
-        status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-        status_text = "включено" if settings['is_enabled'] else "отключено"
+        welcome_settings = await get_current_welcome_text_settings(db)
+        status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+        status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
        
        placeholders = get_available_placeholders()
        placeholders_text = "\n".join([f"• <code>{key}</code>" for key in placeholders.keys()])
@@ -219,14 +311,14 @@ async def process_welcome_text_edit(
            f"Новый текст:\n"
            f"<code>{new_text}</code>\n\n"
            f"💡 Будут заменяться плейсхолдеры: {placeholders_text}",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
-        settings = await get_current_welcome_text_settings(db)
+        welcome_settings = await get_current_welcome_text_settings(db)
        await message.answer(
            "❌ Ошибка при сохранении текста. Попробуйте еще раз.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled'])
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled'])
        )
    
    await state.clear()
@@ -242,9 +334,9 @@ async def reset_welcome_text(
    success = await set_welcome_text(db, default_text, db_user.id)
    
    if success:
-        settings = await get_current_welcome_text_settings(db)
-        status_emoji = "🟢" if settings['is_enabled'] else "🔴"
-        status_text = "включено" if settings['is_enabled'] else "отключено"
+        welcome_settings = await get_current_welcome_text_settings(db)
+        status_emoji = "🟢" if welcome_settings['is_enabled'] else "🔴"
+        status_text = "включено" if welcome_settings['is_enabled'] else "отключено"
        
        await callback.message.edit_text(
            f"✅ Приветственный текст сброшен на стандартный!\n\n"
@@ -252,14 +344,14 @@ async def reset_welcome_text(
            f"Стандартный текст:\n"
            f"<code>{default_text}</code>\n\n"
            f"💡 Плейсхолдер <code>{{user_name}}</code> будет заменяться на имя пользователя",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
-        settings = await get_current_welcome_text_settings(db)
+        welcome_settings = await get_current_welcome_text_settings(db)
        await callback.message.edit_text(
            "❌ Ошибка при сбросе текста. Попробуйте еще раз.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled'])
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled'])
        )
    
    await callback.answer()
@@ -281,14 +373,14 @@ async def show_preview_welcome_text(
    test_user = TestUser()
    preview_text = await get_welcome_text_for_user(db, test_user)
    
-    settings = await get_current_welcome_text_settings(db)
+    welcome_settings = await get_current_welcome_text_settings(db)
    
    if preview_text:
        await callback.message.edit_text(
            f"👁️ Предварительный просмотр\n\n"
            f"Как будет выглядеть текст для пользователя 'Иван' (@test_user):\n\n"
            f"<code>{preview_text}</code>",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    else:
@@ -296,7 +388,7 @@ async def show_preview_welcome_text(
            f"👁️ Предварительный просмотр\n\n"
            f"🔴 Приветственные сообщения отключены.\n"
            f"Новые пользователи не будут получать приветственный текст после регистрации.",
-            reply_markup=get_welcome_text_keyboard(db_user.language, settings['is_enabled']),
+            reply_markup=get_welcome_text_keyboard(db_user.language, welcome_settings['is_enabled']),
            parse_mode="HTML"
        )
    
@@ -0,0 +1,3 @@
+from .main import register_balance_handlers
+
+__all__ = ["register_balance_handlers"]
@@ -0,0 +1,272 @@
+import logging
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.decorators import error_handler
+from app.states import BalanceStates
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_cryptobot_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_cryptobot_enabled():
+        await callback.answer("❌ Оплата криптовалютой временно недоступна", show_alert=True)
+        return
+    
+    from app.utils.currency_converter import currency_converter
+    try:
+        current_rate = await currency_converter.get_usd_to_rub_rate()
+        rate_text = f"💱 Текущий курс: 1 USD = {current_rate:.2f} ₽"
+    except Exception as e:
+        logger.warning(f"Не удалось получить курс валют: {e}")
+        current_rate = 95.0
+        rate_text = f"💱 Курс: 1 USD ≈ {current_rate:.0f} ₽"
+    
+    available_assets = settings.get_cryptobot_assets()
+    assets_text = ", ".join(available_assets)
+    
+    # Формируем текст сообщения в зависимости от настройки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        message_text = (
+            f"🪙 <b>Пополнение криптовалютой</b>\n\n"
+            f"Выберите сумму пополнения или введите вручную сумму "
+            f"от 100 до 100,000 ₽:\n\n"
+            f"💰 Доступные активы: {assets_text}\n"
+            f"⚡ Мгновенное зачисление на баланс\n"
+            f"🔒 Безопасная оплата через CryptoBot\n\n"
+            f"{rate_text}\n"
+            f"Сумма будет автоматически конвертирована в USD для оплаты."
+        )
+    else:
+        message_text = (
+            f"🪙 <b>Пополнение криптовалютой</b>\n\n"
+            f"Введите сумму для пополнения от 100 до 100,000 ₽:\n\n"
+            f"💰 Доступные активы: {assets_text}\n"
+            f"⚡ Мгновенное зачисление на баланс\n"
+            f"🔒 Безопасная оплата через CryptoBot\n\n"
+            f"{rate_text}\n"
+            f"Сумма будет автоматически конвертирована в USD для оплаты."
+        )
+    
+    # Создаем клавиатуру
+    keyboard = get_back_keyboard(db_user.language)
+    
+    # Если включен быстрый выбор суммы и не отключены кнопки, добавляем кнопки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            # Вставляем кнопки быстрого выбора перед кнопкой "Назад"
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+    
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+    
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        payment_method="cryptobot",
+        current_rate=current_rate,
+        cryptobot_prompt_message_id=callback.message.message_id,
+        cryptobot_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_cryptobot_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_cryptobot_enabled():
+        await message.answer("❌ Оплата криптовалютой временно недоступна")
+        return
+    
+    amount_rubles = amount_kopeks / 100
+    
+    if amount_rubles < 100:
+        await message.answer("Минимальная сумма пополнения: 100 ₽")
+        return
+    
+    if amount_rubles > 100000:
+        await message.answer("Максимальная сумма пополнения: 100,000 ₽")
+        return
+    
+    try:
+        data = await state.get_data()
+        current_rate = data.get('current_rate')
+        
+        if not current_rate:
+            from app.utils.currency_converter import currency_converter
+            current_rate = await currency_converter.get_usd_to_rub_rate()
+        
+        amount_usd = amount_rubles / current_rate
+        
+        amount_usd = round(amount_usd, 2)
+        
+        if amount_usd < 1:
+            await message.answer("❌ Минимальная сумма для оплаты в USD: 1.00 USD")
+            return
+        
+        if amount_usd > 1000:
+            await message.answer("❌ Максимальная сумма для оплаты в USD: 1,000 USD")
+            return
+        
+        payment_service = PaymentService(message.bot)
+        
+        payment_result = await payment_service.create_cryptobot_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_usd=amount_usd,
+            asset=settings.CRYPTOBOT_DEFAULT_ASSET,
+            description=f"Пополнение баланса на {amount_rubles:.0f} ₽ ({amount_usd:.2f} USD)",
+            payload=f"balance_{db_user.id}_{amount_kopeks}"
+        )
+        
+        if not payment_result:
+            await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        bot_invoice_url = payment_result.get("bot_invoice_url")
+        mini_app_invoice_url = payment_result.get("mini_app_invoice_url")
+        
+        payment_url = bot_invoice_url or mini_app_invoice_url
+        
+        if not payment_url:
+            await message.answer("❌ Ошибка получения ссылки для оплаты. Обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🪙 Оплатить", url=payment_url)],
+            [types.InlineKeyboardButton(text="📊 Проверить статус", callback_data=f"check_cryptobot_{payment_result['local_payment_id']}")],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+        ])
+
+        state_data = await state.get_data()
+        prompt_message_id = state_data.get("cryptobot_prompt_message_id")
+        prompt_chat_id = state_data.get("cryptobot_prompt_chat_id", message.chat.id)
+
+        try:
+            await message.delete()
+        except Exception as delete_error:  # pragma: no cover - depends on bot rights
+            logger.warning(
+                "Не удалось удалить сообщение с суммой CryptoBot: %s",
+                delete_error,
+            )
+
+        if prompt_message_id:
+            try:
+                await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+            except Exception as delete_error:  # pragma: no cover - diagnostics
+                logger.warning(
+                    "Не удалось удалить сообщение с запросом суммы CryptoBot: %s",
+                    delete_error,
+                )
+
+        invoice_message = await message.answer(
+            f"🪙 <b>Оплата криптовалютой</b>\n\n"
+            f"💰 Сумма к зачислению: {amount_rubles:.0f} ₽\n"
+            f"💵 К оплате: {amount_usd:.2f} USD\n"
+            f"🪙 Актив: {payment_result['asset']}\n"
+            f"💱 Курс: 1 USD = {current_rate:.2f} ₽\n"
+            f"🆔 ID платежа: {payment_result['invoice_id'][:8]}...\n\n"
+            f"📱 <b>Инструкция:</b>\n"
+            f"1. Нажмите кнопку 'Оплатить'\n"
+            f"2. Выберите удобный актив\n"
+            f"3. Переведите указанную сумму\n"
+            f"4. Деньги поступят на баланс автоматически\n\n"
+            f"🔒 Оплата проходит через защищенную систему CryptoBot\n"
+            f"⚡ Поддерживаемые активы: USDT, TON, BTC, ETH\n\n"
+            f"❓ Если возникнут проблемы, обратитесь в {settings.get_support_contact_display_html()}",
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+
+        await state.update_data(
+            cryptobot_invoice_message_id=invoice_message.message_id,
+            cryptobot_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.clear()
+        
+        logger.info(f"Создан CryptoBot платеж для пользователя {db_user.telegram_id}: "
+                   f"{amount_rubles:.0f} ₽ ({amount_usd:.2f} USD), ID: {payment_result['invoice_id']}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания CryptoBot платежа: {e}")
+        await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+        await state.clear()
+
+
+@error_handler
+async def check_cryptobot_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        
+        from app.database.crud.cryptobot import get_cryptobot_payment_by_id
+        payment = await get_cryptobot_payment_by_id(db, local_payment_id)
+        
+        if not payment:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+        
+        status_emoji = {
+            "active": "⏳",
+            "paid": "✅",
+            "expired": "❌"
+        }
+        
+        status_text = {
+            "active": "Ожидает оплаты",
+            "paid": "Оплачен",
+            "expired": "Истек"
+        }
+        
+        emoji = status_emoji.get(payment.status, "❓")
+        status = status_text.get(payment.status, "Неизвестно")
+        
+        message_text = (f"🪙 Статус платежа:\n\n"
+                       f"🆔 ID: {payment.invoice_id[:8]}...\n"
+                       f"💰 Сумма: {payment.amount} {payment.asset}\n"
+                       f"📊 Статус: {emoji} {status}\n"
+                       f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n")
+        
+        if payment.is_paid:
+            message_text += "\n✅ Платеж успешно завершен!\n\nСредства зачислены на баланс."
+        elif payment.is_pending:
+            message_text += "\n⏳ Платеж ожидает оплаты. Нажмите кнопку 'Оплатить' выше."
+        elif payment.is_expired:
+            message_text += (
+                f"\n❌ Платеж истек. Обратитесь в {settings.get_support_contact_display()}"
+            )
+        
+        await callback.answer(message_text, show_alert=True)
+        
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса CryptoBot платежа: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
@@ -0,0 +1,309 @@
+import logging
+from datetime import datetime
+from typing import Optional
+
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy import update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.states import BalanceStates
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_heleket_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+) -> None:
+    texts = get_texts(db_user.language)
+
+    if not settings.is_heleket_enabled():
+        await callback.answer("❌ Оплата через Heleket недоступна", show_alert=True)
+        return
+
+    markup = settings.get_heleket_markup_percent()
+    markup_text: Optional[str]
+    if markup > 0:
+        label = texts.t("PAYMENT_HELEKET_MARKUP_LABEL", "Наценка провайдера")
+        markup_text = f"{label}: {markup:.0f}%"
+    elif markup < 0:
+        label = texts.t("PAYMENT_HELEKET_DISCOUNT_LABEL", "Скидка провайдера")
+        markup_text = f"{label}: {abs(markup):.0f}%"
+    else:
+        markup_text = None
+
+    message_lines = [
+        "🪙 <b>Пополнение через Heleket</b>",
+        "\n",
+        "Введите сумму пополнения от 100 до 100,000 ₽:",
+        "",
+        "⚡ Мгновенное зачисление", "🔒 Безопасная оплата",
+    ]
+
+    if markup_text:
+        message_lines.extend(["", markup_text])
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+
+        quick_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_buttons:
+            keyboard.inline_keyboard = quick_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        "\n".join(filter(None, message_lines)),
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        payment_method="heleket",
+        heleket_prompt_message_id=callback.message.message_id,
+        heleket_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_heleket_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+) -> None:
+    texts = get_texts(db_user.language)
+
+    if not settings.is_heleket_enabled():
+        await message.answer("❌ Оплата через Heleket недоступна")
+        return
+
+    amount_rubles = amount_kopeks / 100
+
+    if amount_rubles < 100:
+        await message.answer("Минимальная сумма пополнения: 100 ₽")
+        return
+
+    if amount_rubles > 100000:
+        await message.answer("Максимальная сумма пополнения: 100,000 ₽")
+        return
+
+    payment_service = PaymentService(message.bot)
+
+    result = await payment_service.create_heleket_payment(
+        db=db,
+        user_id=db_user.id,
+        amount_kopeks=amount_kopeks,
+        description=f"Пополнение баланса на {amount_rubles:.0f} ₽",
+        language=db_user.language,
+    )
+
+    if not result:
+        await message.answer(
+            "❌ Не удалось создать счёт в Heleket. Попробуйте позже или обратитесь в поддержку."
+        )
+        await state.clear()
+        return
+
+    payment_url = result.get("payment_url")
+    if not payment_url:
+        await message.answer("❌ Не удалось получить ссылку для оплаты Heleket")
+        await state.clear()
+        return
+
+    payer_amount = result.get("payer_amount")
+    payer_currency = result.get("payer_currency")
+    exchange_rate = result.get("exchange_rate")
+    discount_percent = result.get("discount_percent")
+
+    details = [
+        "🪙 <b>Оплата через Heleket</b>",
+        "",
+        f"💰 Сумма к зачислению: {amount_rubles:.0f} ₽",
+    ]
+
+    if payer_amount and payer_currency:
+        details.append(f"🪙 К оплате: {payer_amount} {payer_currency}")
+
+    markup_percent: Optional[float] = None
+    if discount_percent is not None:
+        try:
+            discount_int = int(discount_percent)
+            markup_percent = -discount_int
+        except (TypeError, ValueError):
+            markup_percent = None
+
+    if markup_percent:
+        label_markup = texts.t("PAYMENT_HELEKET_MARKUP_LABEL", "Наценка провайдера")
+        label_discount = texts.t("PAYMENT_HELEKET_DISCOUNT_LABEL", "Скидка провайдера")
+        absolute = abs(markup_percent)
+        if markup_percent > 0:
+            details.append(f"📈 {label_markup}: +{absolute}%")
+        else:
+            details.append(f"📉 {label_discount}: {absolute}%")
+
+    if payer_amount and payer_currency:
+        try:
+            payer_amount_float = float(payer_amount)
+            if payer_amount_float > 0:
+                rub_per_currency = amount_rubles / payer_amount_float
+                details.append(
+                    f"💱 Курс: 1 {payer_currency} ≈ {rub_per_currency:.2f} ₽"
+                )
+        except (TypeError, ValueError, ZeroDivisionError):
+            pass
+
+    details.extend(
+        [
+            "",
+            "📱 Инструкция:",
+            "1. Нажмите кнопку 'Оплатить'",
+            "2. Перейдите на страницу Heleket",
+            "3. Оплатите указанную сумму",
+            "4. Баланс пополнится автоматически",
+        ]
+    )
+
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(text=texts.t("PAY_WITH_COINS_BUTTON", "🪙 Оплатить"), url=payment_url)],
+        [
+            types.InlineKeyboardButton(
+                text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                callback_data=f"check_heleket_{result['local_payment_id']}"
+            )
+        ],
+        [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+    ])
+
+    state_data = await state.get_data()
+    prompt_message_id = state_data.get("heleket_prompt_message_id")
+    prompt_chat_id = state_data.get("heleket_prompt_chat_id", message.chat.id)
+
+    try:
+        await message.delete()
+    except Exception as delete_error:  # pragma: no cover - depends on bot rights
+        logger.warning("Не удалось удалить сообщение с суммой Heleket: %s", delete_error)
+
+    if prompt_message_id:
+        try:
+            await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+        except Exception as delete_error:  # pragma: no cover - diagnostic
+            logger.warning(
+                "Не удалось удалить сообщение с запросом суммы Heleket: %s",
+                delete_error,
+            )
+
+    invoice_message = await message.answer(
+        "\n".join(details), parse_mode="HTML", reply_markup=keyboard
+    )
+
+    try:
+        from app.services import payment_service as payment_module
+
+        payment = await payment_module.get_heleket_payment_by_id(db, result["local_payment_id"])
+        if payment:
+            metadata = dict(getattr(payment, "metadata_json", {}) or {})
+            metadata["invoice_message"] = {
+                "chat_id": invoice_message.chat.id,
+                "message_id": invoice_message.message_id,
+            }
+            await db.execute(
+                update(payment.__class__)
+                .where(payment.__class__.id == payment.id)
+                .values(metadata_json=metadata, updated_at=datetime.utcnow())
+            )
+            await db.commit()
+    except Exception as error:  # pragma: no cover - diagnostics
+        logger.warning("Не удалось сохранить сообщение Heleket: %s", error)
+
+    await state.update_data(
+        heleket_invoice_message_id=invoice_message.message_id,
+        heleket_invoice_chat_id=invoice_message.chat.id,
+    )
+
+    await state.clear()
+
+
+@error_handler
+async def check_heleket_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+) -> None:
+    try:
+        local_payment_id = int(callback.data.split("_")[-1])
+    except (ValueError, IndexError):
+        await callback.answer("Некорректный идентификатор платежа", show_alert=True)
+        return
+
+    from app.database.crud.heleket import get_heleket_payment_by_id
+
+    payment = await get_heleket_payment_by_id(db, local_payment_id)
+    if not payment:
+        await callback.answer("Платёж не найден", show_alert=True)
+        return
+
+    language = getattr(payment.user, "language", None) or settings.DEFAULT_LANGUAGE
+    texts = get_texts(language)
+
+    if payment.is_paid:
+        message = texts.t("HELEKET_PAYMENT_ALREADY_PAID", "✅ Платёж уже зачислен")
+        await callback.answer(message, show_alert=True)
+        return
+
+    payment_service = PaymentService(callback.bot)
+    updated_payment = await payment_service.sync_heleket_payment_status(
+        db,
+        local_payment_id=local_payment_id,
+    )
+
+    if updated_payment:
+        payment = updated_payment
+
+    if payment.is_paid:
+        message = texts.t("HELEKET_PAYMENT_SUCCESS", "✅ Платёж зачислен на баланс")
+        await callback.answer(message, show_alert=True)
+        return
+
+    status_normalized = (payment.status or "").lower()
+    status_messages = {
+        "check": texts.t("HELEKET_STATUS_CHECK", "⏳ Ожидание оплаты"),
+        "process": texts.t("HELEKET_STATUS_PROCESS", "⚙️ Платёж обрабатывается"),
+        "confirm_check": texts.t("HELEKET_STATUS_CONFIRM_CHECK", "⛓ Ожидание подтверждений сети"),
+        "wrong_amount": texts.t("HELEKET_STATUS_WRONG_AMOUNT", "❗️ Оплачена неверная сумма"),
+        "wrong_amount_waiting": texts.t(
+            "HELEKET_STATUS_WRONG_AMOUNT_WAITING",
+            "❗️ Недостаточная сумма, ожидаем доплату",
+        ),
+        "paid_over": texts.t("HELEKET_STATUS_PAID_OVER", "✅ Платёж зачислен (с переплатой)"),
+        "paid": texts.t("HELEKET_STATUS_PAID", "✅ Платёж зачислен"),
+        "cancel": texts.t("HELEKET_STATUS_CANCEL", "🚫 Платёж отменён"),
+        "fail": texts.t("HELEKET_STATUS_FAIL", "❌ Ошибка при оплате"),
+        "system_fail": texts.t("HELEKET_STATUS_SYSTEM_FAIL", "❌ Системная ошибка Heleket"),
+        "refund_process": texts.t("HELEKET_STATUS_REFUND_PROCESS", "↩️ Возврат обрабатывается"),
+        "refund_fail": texts.t("HELEKET_STATUS_REFUND_FAIL", "⚠️ Ошибка возврата"),
+        "refund_paid": texts.t("HELEKET_STATUS_REFUND_PAID", "✅ Возврат выполнен"),
+        "locked": texts.t("HELEKET_STATUS_LOCKED", "🔒 Средства заблокированы"),
+    }
+
+    message = status_messages.get(status_normalized)
+    if message is None:
+        template = texts.t("HELEKET_STATUS_UNKNOWN", "ℹ️ Статус платежа: {status}")
+        status_value = payment.status or status_normalized or "—"
+        try:
+            message = template.format(status=status_value)
+        except Exception:  # pragma: no cover - defensive formatting
+            message = f"ℹ️ Статус платежа: {status_value}"
+
+    await callback.answer(message, show_alert=True)
@@ -0,0 +1,983 @@
+import html
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import BalanceStates
+from app.database.crud.user import add_user_balance
+from app.utils.price_display import calculate_user_price, format_price_button
+from app.utils.pricing_utils import format_period_description
+from app.database.crud.transaction import (
+    get_user_transactions, get_user_transactions_count,
+    create_transaction
+)
+from app.database.models import User, TransactionType, PaymentMethod
+from app.keyboards.inline import (
+    get_balance_keyboard, get_payment_methods_keyboard,
+    get_back_keyboard, get_pagination_keyboard
+)
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.pagination import paginate_list
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+TRANSACTIONS_PER_PAGE = 10
+
+
+def get_quick_amount_buttons(language: str, user: User) -> list:
+    """
+    Generate quick amount buttons with user-specific pricing and discounts.
+
+    Args:
+        language: User's language for formatting
+        user: User object to calculate personalized discounts
+
+    Returns:
+        List of button rows for inline keyboard
+    """
+    if not settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED or settings.DISABLE_TOPUP_BUTTONS:
+        return []
+
+    from app.localization.texts import get_texts
+    texts = get_texts(language)
+
+    buttons = []
+    periods = settings.get_available_subscription_periods()
+    periods = periods[:6]  # Limit to 6 periods
+
+    for period in periods:
+        price_attr = f"PRICE_{period}_DAYS"
+        if hasattr(settings, price_attr):
+            base_price_kopeks = getattr(settings, price_attr)
+
+            # Calculate price with user's promo group discount using unified system
+            price_info = calculate_user_price(user, base_price_kopeks, period, "period")
+
+            callback_data = f"quick_amount_{price_info.final_price}"
+
+            # Format button text with discount display
+            period_label = f"{period} дней"
+
+            # For balance buttons, use simpler format without emoji and period label prefix
+            if price_info.has_discount:
+                button_text = (
+                    f"{texts.format_price(price_info.base_price)} ➜ "
+                    f"{texts.format_price(price_info.final_price)} "
+                    f"(-{price_info.discount_percent}%) • {period_label}"
+                )
+            else:
+                button_text = f"{texts.format_price(price_info.final_price)} • {period_label}"
+
+            buttons.append(
+                types.InlineKeyboardButton(
+                    text=button_text,
+                    callback_data=callback_data
+                )
+            )
+
+    keyboard_rows = []
+    for i in range(0, len(buttons), 2):
+        keyboard_rows.append(buttons[i:i + 2])
+
+    return keyboard_rows
+
+
+@error_handler
+async def show_balance_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    balance_text = texts.BALANCE_INFO.format(
+        balance=texts.format_price(db_user.balance_kopeks)
+    )
+    
+    await callback.message.edit_text(
+        balance_text,
+        reply_markup=get_balance_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@error_handler
+async def show_balance_history(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    texts = get_texts(db_user.language)
+    
+    offset = (page - 1) * TRANSACTIONS_PER_PAGE
+    
+    raw_transactions = await get_user_transactions(
+        db, db_user.id, 
+        limit=TRANSACTIONS_PER_PAGE * 3, 
+        offset=offset
+    )
+    
+    seen_transactions = set()
+    unique_transactions = []
+    
+    for transaction in raw_transactions:
+        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
+        transaction_key = (
+            transaction.amount_kopeks,
+            transaction.description,
+            rounded_time
+        )
+        
+        if transaction_key not in seen_transactions:
+            seen_transactions.add(transaction_key)
+            unique_transactions.append(transaction)
+            
+            if len(unique_transactions) >= TRANSACTIONS_PER_PAGE:
+                break
+    
+    all_transactions = await get_user_transactions(db, db_user.id, limit=1000)
+    seen_all = set()
+    total_unique = 0
+    
+    for transaction in all_transactions:
+        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
+        transaction_key = (
+            transaction.amount_kopeks,
+            transaction.description,
+            rounded_time
+        )
+        if transaction_key not in seen_all:
+            seen_all.add(transaction_key)
+            total_unique += 1
+    
+    if not unique_transactions:
+        await callback.message.edit_text(
+            "📊 История операций пуста",
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+        await callback.answer()
+        return
+    
+    text = "📊 <b>История операций</b>\n\n"
+    
+    for transaction in unique_transactions:
+        emoji = "💰" if transaction.type == TransactionType.DEPOSIT.value else "💸"
+        amount_text = f"+{texts.format_price(transaction.amount_kopeks)}" if transaction.type == TransactionType.DEPOSIT.value else f"-{texts.format_price(transaction.amount_kopeks)}"
+        
+        text += f"{emoji} {amount_text}\n"
+        text += f"📝 {transaction.description}\n"
+        text += f"📅 {transaction.created_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+    
+    keyboard = []
+    total_pages = (total_unique + TRANSACTIONS_PER_PAGE - 1) // TRANSACTIONS_PER_PAGE
+    
+    if total_pages > 1:
+        pagination_row = get_pagination_keyboard(
+            page, total_pages, "balance_history", db_user.language
+        )
+        keyboard.extend(pagination_row)
+    
+    keyboard.append([
+        types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@error_handler
+async def handle_balance_history_pagination(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    page = int(callback.data.split('_')[-1])
+    await show_balance_history(callback, db_user, db, page)
+
+
+@error_handler
+async def show_payment_methods(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    from app.utils.payment_utils import get_payment_methods_text
+    from app.database.crud.subscription import get_subscription_by_user_id
+    from app.utils.pricing_utils import calculate_months_from_days, apply_percentage_discount
+    from app.config import settings
+    from app.services.subscription_service import SubscriptionService
+
+    texts = get_texts(db_user.language)
+    payment_text = get_payment_methods_text(db_user.language)
+
+    # Добавляем информацию о текущем тарифе пользователя
+    subscription = await get_subscription_by_user_id(db, db_user.id)
+    tariff_info = ""
+    if subscription and not subscription.is_trial:
+        # Рассчитываем приблизительную стоимость продления на 30 дней
+        duration_days = 30  # Берем для примера 30 дней
+        current_traffic = subscription.traffic_limit_gb
+        current_connected_squads = subscription.connected_squads or []
+        current_device_limit = subscription.device_limit or settings.DEFAULT_DEVICE_LIMIT
+
+        try:
+            # Получаем цены для текущих параметров
+            from app.config import PERIOD_PRICES
+            base_price_original = PERIOD_PRICES.get(duration_days, 0)
+            period_discount_percent = db_user.get_promo_discount("period", duration_days)
+            base_price, base_discount_total = apply_percentage_discount(
+                base_price_original,
+                period_discount_percent,
+            )
+
+            # Рассчитываем стоимость серверов
+            from app.services.subscription_service import SubscriptionService
+            subscription_service = SubscriptionService()
+            servers_price_per_month, per_server_monthly_prices = await subscription_service.get_countries_price_by_uuids(
+                current_connected_squads,
+                db,
+                promo_group_id=db_user.promo_group_id,
+            )
+            servers_discount_percent = db_user.get_promo_discount("servers", duration_days)
+            total_servers_price = 0
+            for server_price in per_server_monthly_prices:
+                discounted_per_month, discount_per_month = apply_percentage_discount(
+                    server_price,
+                    servers_discount_percent,
+                )
+                total_servers_price += discounted_per_month
+
+            # Рассчитываем стоимость трафика
+            traffic_price_per_month = settings.get_traffic_price(current_traffic)
+            traffic_discount_percent = db_user.get_promo_discount("traffic", duration_days)
+            traffic_discounted_per_month, traffic_discount_per_month = apply_percentage_discount(
+                traffic_price_per_month,
+                traffic_discount_percent,
+            )
+
+            # Рассчитываем стоимость устройств
+            additional_devices = max(0, (current_device_limit or 0) - settings.DEFAULT_DEVICE_LIMIT)
+            devices_price_per_month = additional_devices * settings.PRICE_PER_DEVICE
+            devices_discount_percent = db_user.get_promo_discount("devices", duration_days)
+            devices_discounted_per_month, devices_discount_per_month = apply_percentage_discount(
+                devices_price_per_month,
+                devices_discount_percent,
+            )
+
+            # Общая стоимость
+            months_in_period = calculate_months_from_days(duration_days)
+            total_price = (
+                base_price +
+                total_servers_price * months_in_period +
+                traffic_discounted_per_month * months_in_period +
+                devices_discounted_per_month * months_in_period
+            )
+            
+            traffic_value = current_traffic or 0
+            if traffic_value <= 0:
+                traffic_display = texts.t("TRAFFIC_UNLIMITED_SHORT", "Безлимит")
+            else:
+                traffic_display = texts.format_traffic(traffic_value)
+
+            current_tariff_desc = (
+                f"📱 Подписка: {len(current_connected_squads)} серверов, "
+                f"{traffic_display}, {current_device_limit} устр."
+            )
+            estimated_price_info = f"💰 Стоимость продления (примерно): {texts.format_price(total_price)} за {duration_days} дней"
+            
+            tariff_info = f"\n\n📋 <b>Ваш текущий тариф:</b>\n{current_tariff_desc}\n{estimated_price_info}"
+        except Exception as e:
+            logger.warning(f"Не удалось рассчитать стоимость текущей подписки для пользователя {db_user.id}: {e}")
+            tariff_info = ""
+
+    full_text = payment_text + tariff_info
+
+    keyboard = get_payment_methods_keyboard(0, db_user.language)
+
+    try:
+        await callback.message.edit_text(
+            full_text,
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+    except TelegramBadRequest:
+        try:
+            await callback.message.edit_caption(
+                full_text,
+                reply_markup=keyboard,
+                parse_mode="HTML"
+            )
+        except TelegramBadRequest:
+            try:
+                await callback.message.delete()
+            except TelegramBadRequest:
+                pass
+            await callback.message.answer(
+                full_text,
+                reply_markup=keyboard,
+                parse_mode="HTML"
+            )
+
+    await callback.answer()
+
+
+@error_handler
+async def handle_payment_methods_unavailable(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    texts = get_texts(db_user.language)
+    
+    await callback.answer(
+        texts.t(
+            "PAYMENT_METHODS_UNAVAILABLE_ALERT",
+            "⚠️ В данный момент автоматические способы оплаты временно недоступны. Для пополнения баланса обратитесь в техподдержку.",
+        ),
+        show_alert=True
+    )
+
+
+@error_handler
+async def handle_successful_topup_with_cart(
+    user_id: int,
+    amount_kopeks: int,
+    bot,
+    db: AsyncSession
+):
+    from app.database.crud.user import get_user_by_id
+    from aiogram.fsm.context import FSMContext
+    from aiogram.fsm.storage.base import StorageKey
+    from app.bot import dp
+    
+    user = await get_user_by_id(db, user_id)
+    if not user:
+        return
+    
+    storage = dp.storage
+    key = StorageKey(bot_id=bot.id, chat_id=user.telegram_id, user_id=user.telegram_id)
+    
+    try:
+        state_data = await storage.get_data(key)
+        current_state = await storage.get_state(key)
+        
+        if (current_state == "SubscriptionStates:cart_saved_for_topup" and 
+            state_data.get('saved_cart')):
+            
+            texts = get_texts(user.language)
+            total_price = state_data.get('total_price', 0)
+            
+            keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(
+                    text="🛒 Вернуться к оформлению подписки", 
+                    callback_data="return_to_saved_cart"
+                )],
+                [types.InlineKeyboardButton(
+                    text="💰 Мой баланс", 
+                    callback_data="menu_balance"
+                )],
+                [types.InlineKeyboardButton(
+                    text="🏠 Главное меню", 
+                    callback_data="back_to_menu"
+                )]
+            ])
+            
+            success_text = (
+                f"✅ Баланс пополнен на {texts.format_price(amount_kopeks)}!\n\n"
+                f"💰 Текущий баланс: {texts.format_price(user.balance_kopeks)}\n\n"
+                f"⚠️ <b>Важно:</b> Пополнение баланса не активирует подписку автоматически. "
+                f"Обязательно активируйте подписку отдельно!\n\n"
+                f"🔄 При наличии сохранённой корзины подписки и включенной автопокупке, "
+                f"подписка будет приобретена автоматически после пополнения баланса.\n\n"
+                f"🛒 У вас есть сохраненная корзина подписки\n"
+                f"Стоимость: {texts.format_price(total_price)}\n\n"
+                f"Хотите продолжить оформление?"
+            )
+            
+            await bot.send_message(
+                chat_id=user.telegram_id,
+                text=success_text,
+                reply_markup=keyboard,
+                parse_mode="HTML"
+            )
+            
+    except Exception as e:
+        logger.error(f"Ошибка обработки успешного пополнения с корзиной: {e}")
+
+
+@error_handler
+async def request_support_topup(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_support_topup_enabled():
+        await callback.answer(
+            texts.t(
+                "SUPPORT_TOPUP_DISABLED",
+                "Пополнение через поддержку отключено. Попробуйте другой способ оплаты.",
+            ),
+            show_alert=True,
+        )
+        return
+
+    support_text = f"""
+🛠️ <b>Пополнение через поддержку</b>
+
+Для пополнения баланса обратитесь в техподдержку:
+{settings.get_support_contact_display_html()}
+
+Укажите:
+• ID: {db_user.telegram_id}
+• Сумму пополнения
+• Способ оплаты
+
+⏰ Время обработки: 1-24 часа
+
+<b>Доступные способы:</b>
+• Криптовалюта
+• Переводы между банками
+• Другие платежные системы
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(
+            text="💬 Написать в поддержку",
+            url=settings.get_support_contact_url() or "https://t.me/"
+        )],
+        [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+    ])
+    
+    await callback.message.edit_text(
+        support_text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_topup_amount(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+
+    try:
+        if not message.text:
+            if message.successful_payment:
+                logger.info(
+                    "Получено сообщение об успешном платеже без текста, "
+                    "обработчик суммы пополнения завершает работу"
+                )
+                await state.clear()
+                return
+
+            await message.answer(
+                texts.INVALID_AMOUNT,
+                reply_markup=get_back_keyboard(db_user.language)
+            )
+            return
+
+        amount_text = message.text.strip()
+        if not amount_text:
+            await message.answer(
+                texts.INVALID_AMOUNT,
+                reply_markup=get_back_keyboard(db_user.language)
+            )
+            return
+
+        amount_rubles = float(amount_text.replace(',', '.'))
+
+        if amount_rubles < 1:
+            await message.answer("Минимальная сумма пополнения: 1 ₽")
+            return
+        
+        if amount_rubles > 50000:
+            await message.answer("Максимальная сумма пополнения: 50,000 ₽")
+            return
+        
+        amount_kopeks = int(amount_rubles * 100)
+        data = await state.get_data()
+        payment_method = data.get("payment_method", "stars")
+        
+        if payment_method in ["yookassa", "yookassa_sbp"]:
+            if amount_kopeks < settings.YOOKASSA_MIN_AMOUNT_KOPEKS:
+                min_rubles = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
+                await message.answer(f"❌ Минимальная сумма для оплаты через YooKassa: {min_rubles:.0f} ₽")
+                return
+            
+            if amount_kopeks > settings.YOOKASSA_MAX_AMOUNT_KOPEKS:
+                max_rubles = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
+                await message.answer(f"❌ Максимальная сумма для оплаты через YooKassa: {max_rubles:,.0f} ₽".replace(',', ' '))
+                return
+        
+        if payment_method == "stars":
+            from .stars import process_stars_payment_amount
+            await process_stars_payment_amount(message, db_user, amount_kopeks, state)
+        elif payment_method == "yookassa":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "yookassa_sbp":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_sbp_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_sbp_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+            from .mulenpay import process_mulenpay_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "platega":
+            from app.database.database import AsyncSessionLocal
+            from .platega import process_platega_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_platega_payment_amount(
+                    message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "wata":
+            from app.database.database import AsyncSessionLocal
+            from .wata import process_wata_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_wata_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "pal24":
+            from app.database.database import AsyncSessionLocal
+            from .pal24 import process_pal24_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "cryptobot":
+            from app.database.database import AsyncSessionLocal
+            from .cryptobot import process_cryptobot_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_cryptobot_payment_amount(message, db_user, db, amount_kopeks, state)
+        elif payment_method == "heleket":
+            from app.database.database import AsyncSessionLocal
+            from .heleket import process_heleket_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_heleket_payment_amount(message, db_user, db, amount_kopeks, state)
+        else:
+            await message.answer("Неизвестный способ оплаты")
+        
+    except ValueError:
+        await message.answer(
+            texts.INVALID_AMOUNT,
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+
+
+@error_handler
+async def handle_sbp_payment(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        
+        from app.database.crud.yookassa import get_yookassa_payment_by_local_id
+        payment = await get_yookassa_payment_by_local_id(db, local_payment_id)
+        
+        if not payment:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+        
+        import json
+        metadata = json.loads(payment.metadata_json) if payment.metadata_json else {}
+        confirmation_token = metadata.get("confirmation_token")
+        
+        if not confirmation_token:
+            await callback.answer("❌ Токен подтверждения не найден", show_alert=True)
+            return
+        
+        await callback.message.answer(
+            f"Для оплаты через СБП откройте приложение вашего банка и подтвердите платеж.\\n\\n"
+            f"Если у вас не открылось банковское приложение автоматически, вы можете:\\n"
+            f"1. Скопировать этот токен: <code>{confirmation_token}</code>\\n"
+            f"2. Открыть приложение вашего банка\\n"
+            f"3. Найти функцию оплаты по токену\\n"
+            f"4. Вставить токен и подтвердить платеж",
+            parse_mode="HTML"
+        )
+        
+        await callback.answer("Информация об оплате отправлена", show_alert=True)
+        
+    except Exception as e:
+        logger.error(f"Ошибка обработки embedded платежа СБП: {e}")
+        await callback.answer("❌ Ошибка обработки платежа", show_alert=True)
+
+
+@error_handler
+async def handle_quick_amount_selection(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    """
+    Обработчик выбора суммы через кнопки быстрого выбора
+    """
+    # Извлекаем сумму из callback_data
+    try:
+        amount_kopeks = int(callback.data.split('_')[-1])
+        amount_rubles = amount_kopeks / 100
+        
+        # Получаем метод оплаты из состояния
+        data = await state.get_data()
+        payment_method = data.get("payment_method", "yookassa")
+        
+        # Проверяем, какой метод оплаты был выбран и вызываем соответствующий обработчик
+        if payment_method == "yookassa":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "yookassa_sbp":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_sbp_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_sbp_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+            from .mulenpay import process_mulenpay_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "platega":
+            from app.database.database import AsyncSessionLocal
+            from .platega import process_platega_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_platega_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "wata":
+            from app.database.database import AsyncSessionLocal
+            from .wata import process_wata_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_wata_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "pal24":
+            from app.database.database import AsyncSessionLocal
+            from .pal24 import process_pal24_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "cryptobot":
+            from app.database.database import AsyncSessionLocal
+            from .cryptobot import process_cryptobot_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_cryptobot_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "heleket":
+            from app.database.database import AsyncSessionLocal
+            from .heleket import process_heleket_payment_amount
+
+            async with AsyncSessionLocal() as db:
+                await process_heleket_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif payment_method == "stars":
+            from .stars import process_stars_payment_amount
+
+            await process_stars_payment_amount(
+                callback.message, db_user, amount_kopeks, state
+            )
+        else:
+            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
+            return
+
+    except ValueError:
+        await callback.answer("❌ Ошибка обработки суммы", show_alert=True)
+    except Exception as e:
+        logger.error(f"Ошибка обработки быстрого выбора суммы: {e}")
+        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)
+
+
+@error_handler
+async def handle_topup_amount_callback(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    try:
+        _, method, amount_str = callback.data.split("|", 2)
+        amount_kopeks = int(amount_str)
+    except ValueError:
+        await callback.answer("❌ Некорректный запрос", show_alert=True)
+        return
+
+    if amount_kopeks <= 0:
+        await callback.answer("❌ Некорректная сумма", show_alert=True)
+        return
+
+    try:
+        if method == "yookassa":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "yookassa_sbp":
+            from app.database.database import AsyncSessionLocal
+            from .yookassa import process_yookassa_sbp_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_sbp_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "mulenpay":
+            from app.database.database import AsyncSessionLocal
+            from .mulenpay import process_mulenpay_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_mulenpay_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "platega":
+            from app.database.database import AsyncSessionLocal
+            from .platega import process_platega_payment_amount, start_platega_payment
+
+            data = await state.get_data()
+            method_code = int(data.get("platega_method", 0)) if data else 0
+
+            if method_code > 0:
+                async with AsyncSessionLocal() as db:
+                    await process_platega_payment_amount(
+                        callback.message, db_user, db, amount_kopeks, state
+                    )
+            else:
+                await state.update_data(platega_pending_amount=amount_kopeks)
+                await start_platega_payment(callback, db_user, state)
+        elif method == "pal24":
+            from app.database.database import AsyncSessionLocal
+            from .pal24 import process_pal24_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_pal24_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "cryptobot":
+            from app.database.database import AsyncSessionLocal
+            from .cryptobot import process_cryptobot_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_cryptobot_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "heleket":
+            from app.database.database import AsyncSessionLocal
+            from .heleket import process_heleket_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_heleket_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "wata":
+            from app.database.database import AsyncSessionLocal
+            from .wata import process_wata_payment_amount
+            async with AsyncSessionLocal() as db:
+                await process_wata_payment_amount(
+                    callback.message, db_user, db, amount_kopeks, state
+                )
+        elif method == "stars":
+            from .stars import process_stars_payment_amount
+            await process_stars_payment_amount(
+                callback.message, db_user, amount_kopeks, state
+            )
+        elif method == "tribute":
+            from .tribute import start_tribute_payment
+            await start_tribute_payment(callback, db_user)
+            return
+        else:
+            await callback.answer("❌ Неизвестный способ оплаты", show_alert=True)
+            return
+
+        await callback.answer()
+
+    except Exception as error:
+        logger.error(f"Ошибка быстрого пополнения: {error}")
+        await callback.answer("❌ Ошибка обработки запроса", show_alert=True)
+
+
+def register_balance_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_balance_menu,
+        F.data == "menu_balance"
+    )
+    
+    dp.callback_query.register(
+        show_balance_history,
+        F.data == "balance_history"
+    )
+    
+    dp.callback_query.register(
+        handle_balance_history_pagination,
+        F.data.startswith("balance_history_page_")
+    )
+    
+    dp.callback_query.register(
+        show_payment_methods,
+        F.data == "balance_topup"
+    )
+    
+    from .stars import start_stars_payment
+    dp.callback_query.register(
+        start_stars_payment,
+        F.data == "topup_stars"
+    )
+    
+    from .yookassa import start_yookassa_payment
+    dp.callback_query.register(
+        start_yookassa_payment,
+        F.data == "topup_yookassa"
+    )
+    
+    from .yookassa import start_yookassa_sbp_payment
+    dp.callback_query.register(
+        start_yookassa_sbp_payment,
+        F.data == "topup_yookassa_sbp"
+    )
+
+    from .mulenpay import start_mulenpay_payment
+    dp.callback_query.register(
+        start_mulenpay_payment,
+        F.data == "topup_mulenpay"
+    )
+
+    from .wata import start_wata_payment
+    dp.callback_query.register(
+        start_wata_payment,
+        F.data == "topup_wata"
+    )
+
+    from .pal24 import start_pal24_payment
+    dp.callback_query.register(
+        start_pal24_payment,
+        F.data == "topup_pal24"
+    )
+    from .pal24 import handle_pal24_method_selection
+    dp.callback_query.register(
+        handle_pal24_method_selection,
+        F.data.startswith("pal24_method_"),
+    )
+
+    from .platega import start_platega_payment, handle_platega_method_selection
+    dp.callback_query.register(
+        start_platega_payment,
+        F.data == "topup_platega"
+    )
+    dp.callback_query.register(
+        handle_platega_method_selection,
+        F.data.startswith("platega_method_"),
+    )
+
+    from .yookassa import check_yookassa_payment_status
+    dp.callback_query.register(
+        check_yookassa_payment_status,
+        F.data.startswith("check_yookassa_")
+    )
+
+    from .tribute import start_tribute_payment
+    dp.callback_query.register(
+        start_tribute_payment,
+        F.data == "topup_tribute"
+    )
+    
+    dp.callback_query.register(
+        request_support_topup,
+        F.data == "topup_support"
+    )
+    
+    from .yookassa import check_yookassa_payment_status
+    dp.callback_query.register(
+        check_yookassa_payment_status,
+        F.data.startswith("check_yookassa_")
+    )
+    
+    dp.message.register(
+        process_topup_amount,
+        BalanceStates.waiting_for_amount
+    )
+
+    from .cryptobot import start_cryptobot_payment
+    dp.callback_query.register(
+        start_cryptobot_payment,
+        F.data == "topup_cryptobot"
+    )
+    
+    from .cryptobot import check_cryptobot_payment_status
+    dp.callback_query.register(
+        check_cryptobot_payment_status,
+        F.data.startswith("check_cryptobot_")
+    )
+
+    from .heleket import start_heleket_payment, check_heleket_payment_status
+    dp.callback_query.register(
+        start_heleket_payment,
+        F.data == "topup_heleket"
+    )
+    dp.callback_query.register(
+        check_heleket_payment_status,
+        F.data.startswith("check_heleket_")
+    )
+
+    from .mulenpay import check_mulenpay_payment_status
+    dp.callback_query.register(
+        check_mulenpay_payment_status,
+        F.data.startswith("check_mulenpay_")
+    )
+
+    from .wata import check_wata_payment_status
+    dp.callback_query.register(
+        check_wata_payment_status,
+        F.data.startswith("check_wata_")
+    )
+
+    from .pal24 import check_pal24_payment_status
+    dp.callback_query.register(
+        check_pal24_payment_status,
+        F.data.startswith("check_pal24_")
+    )
+
+    from .platega import check_platega_payment_status
+    dp.callback_query.register(
+        check_platega_payment_status,
+        F.data.startswith("check_platega_")
+    )
+
+    dp.callback_query.register(
+        handle_payment_methods_unavailable,
+        F.data == "payment_methods_unavailable"
+    )
+    
+    # Регистрируем обработчик для кнопок быстрого выбора суммы
+    dp.callback_query.register(
+        handle_quick_amount_selection,
+        F.data.startswith("quick_amount_")
+    )
+
+    dp.callback_query.register(
+        handle_topup_amount_callback,
+        F.data.startswith("topup_amount|")
+    )
@@ -0,0 +1,306 @@
+import logging
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.decorators import error_handler
+from app.states import BalanceStates
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_mulenpay_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+    mulenpay_name = settings.get_mulenpay_display_name()
+    mulenpay_name_html = settings.get_mulenpay_display_name_html()
+
+    if not settings.is_mulenpay_enabled():
+        await callback.answer(
+            f"❌ Оплата через {mulenpay_name} временно недоступна",
+            show_alert=True,
+        )
+        return
+
+    message_template = texts.t(
+        "MULENPAY_TOPUP_PROMPT",
+        (
+            "💳 <b>Оплата через {mulenpay_name_html}</b>\n\n"
+            "Введите сумму для пополнения от 100 до 100 000 ₽.\n"
+            "Оплата происходит через защищенную платформу {mulenpay_name}."
+        ),
+    )
+    message_text = message_template.format(
+        mulenpay_name=mulenpay_name,
+        mulenpay_name_html=mulenpay_name_html,
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        payment_method="mulenpay",
+        mulenpay_prompt_message_id=callback.message.message_id,
+        mulenpay_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_mulenpay_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+    mulenpay_name = settings.get_mulenpay_display_name()
+    mulenpay_name_html = settings.get_mulenpay_display_name_html()
+
+    if not settings.is_mulenpay_enabled():
+        await message.answer(f"❌ Оплата через {mulenpay_name} временно недоступна")
+        return
+
+    if amount_kopeks < settings.MULENPAY_MIN_AMOUNT_KOPEKS:
+        await message.answer(
+            f"Минимальная сумма пополнения: {settings.format_price(settings.MULENPAY_MIN_AMOUNT_KOPEKS)}"
+        )
+        return
+
+    if amount_kopeks > settings.MULENPAY_MAX_AMOUNT_KOPEKS:
+        await message.answer(
+            f"Максимальная сумма пополнения: {settings.format_price(settings.MULENPAY_MAX_AMOUNT_KOPEKS)}"
+        )
+        return
+
+    amount_rubles = amount_kopeks / 100
+
+    state_data = await state.get_data()
+    prompt_message_id = state_data.get("mulenpay_prompt_message_id")
+    prompt_chat_id = state_data.get("mulenpay_prompt_chat_id", message.chat.id)
+
+    try:
+        await message.delete()
+    except Exception as delete_error:  # pragma: no cover - depends on bot permissions
+        logger.warning(
+            "Не удалось удалить сообщение с суммой MulenPay: %s", delete_error
+        )
+
+    if prompt_message_id:
+        try:
+            await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+        except Exception as delete_error:  # pragma: no cover - diagnostic
+            logger.warning(
+                "Не удалось удалить сообщение с запросом суммы MulenPay: %s",
+                delete_error,
+            )
+
+    try:
+        payment_service = PaymentService(message.bot)
+        payment_result = await payment_service.create_mulenpay_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+        )
+
+        if not payment_result or not payment_result.get("payment_url"):
+            await message.answer(
+                texts.t(
+                    "MULENPAY_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа {mulenpay_name}. Попробуйте позже или обратитесь в поддержку.",
+                ).format(mulenpay_name=mulenpay_name)
+            )
+            await state.clear()
+            return
+
+        payment_url = payment_result.get("payment_url")
+        mulen_payment_id = payment_result.get("mulen_payment_id")
+        local_payment_id = payment_result.get("local_payment_id")
+
+        keyboard = types.InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    types.InlineKeyboardButton(
+                        text=texts.t(
+                            "MULENPAY_PAY_BUTTON",
+                            "💳 Оплатить через {mulenpay_name}",
+                        ).format(mulenpay_name=mulenpay_name),
+                        url=payment_url,
+                    )
+                ],
+                [
+                    types.InlineKeyboardButton(
+                        text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                        callback_data=f"check_mulenpay_{local_payment_id}",
+                    )
+                ],
+                [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+            ]
+        )
+
+        payment_id_display = mulen_payment_id if mulen_payment_id is not None else local_payment_id
+
+        message_template = texts.t(
+            "MULENPAY_PAYMENT_INSTRUCTIONS",
+            (
+                "💳 <b>Оплата через {mulenpay_name_html}</b>\n\n"
+                "💰 Сумма: {amount}\n"
+                "🆔 ID платежа: {payment_id}\n\n"
+                "📱 <b>Инструкция:</b>\n"
+                "1. Нажмите кнопку 'Оплатить через {mulenpay_name}'\n"
+                "2. Следуйте подсказкам платежной системы\n"
+                "3. Подтвердите перевод\n"
+                "4. Средства зачислятся автоматически\n\n"
+                "❓ Если возникнут проблемы, обратитесь в {support}"
+            ),
+        )
+
+        message_text = message_template.format(
+            amount=settings.format_price(amount_kopeks),
+            payment_id=payment_id_display,
+            support=settings.get_support_contact_display_html(),
+            mulenpay_name=mulenpay_name,
+            mulenpay_name_html=mulenpay_name_html,
+        )
+
+        invoice_message = await message.answer(
+            message_text,
+            reply_markup=keyboard,
+            parse_mode="HTML",
+        )
+
+        try:
+            from app.services import payment_service as payment_module
+
+            payment = await payment_module.get_mulenpay_payment_by_local_id(
+                db, local_payment_id
+            )
+            if payment:
+                payment_metadata = dict(
+                    getattr(payment, "metadata_json", {}) or {}
+                )
+                payment_metadata["invoice_message"] = {
+                    "chat_id": invoice_message.chat.id,
+                    "message_id": invoice_message.message_id,
+                }
+                await payment_module.update_mulenpay_payment_metadata(
+                    db,
+                    payment=payment,
+                    metadata=payment_metadata,
+                )
+        except Exception as error:  # pragma: no cover - diagnostic logging only
+            logger.warning("Не удалось сохранить данные сообщения MulenPay: %s", error)
+
+        await state.update_data(
+            mulenpay_invoice_message_id=invoice_message.message_id,
+            mulenpay_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.clear()
+
+        logger.info(
+            "Создан %s платеж для пользователя %s: %s₽, ID: %s",
+            mulenpay_name,
+            db_user.telegram_id,
+            amount_rubles,
+            payment_id_display,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка создания {mulenpay_name} платежа: {e}")
+        await message.answer(
+            texts.t(
+                "MULENPAY_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа {mulenpay_name}. Попробуйте позже или обратитесь в поддержку.",
+            ).format(mulenpay_name=mulenpay_name)
+        )
+        await state.clear()
+
+
+@error_handler
+async def check_mulenpay_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        payment_service = PaymentService(callback.bot)
+        status_info = await payment_service.get_mulenpay_payment_status(db, local_payment_id)
+
+        if not status_info:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+
+        payment = status_info["payment"]
+
+        status_labels = {
+            "created": ("⏳", "Ожидает оплаты"),
+            "processing": ("⌛", "Обрабатывается"),
+            "success": ("✅", "Оплачен"),
+            "canceled": ("❌", "Отменен"),
+            "error": ("⚠️", "Ошибка"),
+            "hold": ("🔒", "Холд"),
+            "unknown": ("❓", "Неизвестно"),
+        }
+
+        emoji, status_text = status_labels.get(payment.status, ("❓", "Неизвестно"))
+
+        mulenpay_name = settings.get_mulenpay_display_name()
+        message_lines = [
+            f"💳 Статус платежа {mulenpay_name}:\n\n",
+            f"🆔 ID: {payment.mulen_payment_id or payment.id}\n",
+            f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n",
+            f"📊 Статус: {emoji} {status_text}\n",
+            f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n",
+        ]
+
+        if payment.is_paid:
+            message_lines.append("\n✅ Платеж успешно завершен! Средства уже на балансе.")
+        elif payment.status in {"created", "processing"}:
+            message_lines.append(
+                "\n⏳ Платеж еще не завершен. Завершите оплату по ссылке и проверьте статус позже."
+            )
+            if payment.payment_url:
+                message_lines.append(f"\n🔗 Ссылка на оплату: {payment.payment_url}")
+        elif payment.status in {"canceled", "error"}:
+            message_lines.append(
+                f"\n❌ Платеж не был завершен. Попробуйте создать новый платеж или обратитесь в {settings.get_support_contact_display()}"
+            )
+
+        message_text = "".join(message_lines)
+
+        if len(message_text) > 190:
+            await callback.message.answer(message_text)
+            await callback.answer("ℹ️ Статус платежа отправлен в чат", show_alert=True)
+        else:
+            await callback.answer(message_text, show_alert=True)
+
+    except Exception as e:
+        logger.error(
+            f"Ошибка проверки статуса {settings.get_mulenpay_display_name()}: {e}"
+        )
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
@@ -0,0 +1,644 @@
+import html
+import logging
+from datetime import datetime
+from typing import Any, Optional
+
+from aiogram import types
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.context import FSMContext
+from sqlalchemy import update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.database import AsyncSessionLocal
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.decorators import error_handler
+from app.states import BalanceStates
+
+logger = logging.getLogger(__name__)
+
+
+def _get_available_pal24_methods() -> list[str]:
+    methods: list[str] = []
+    if settings.is_pal24_sbp_button_visible():
+        methods.append("sbp")
+    if settings.is_pal24_card_button_visible():
+        methods.append("card")
+    if not methods:
+        methods.append("sbp")
+    return methods
+
+
+async def _send_pal24_payment_message(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    payment_method: str,
+    state: FSMContext,
+) -> None:
+    texts = get_texts(db_user.language)
+
+    try:
+        payment_service = PaymentService(message.bot)
+        payment_result = await payment_service.create_pal24_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+            payment_method=payment_method,
+        )
+
+        if not payment_result:
+            await message.answer(
+                texts.t(
+                    "PAL24_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        sbp_url = (
+            payment_result.get("sbp_url")
+            or payment_result.get("transfer_url")
+        )
+        card_url = payment_result.get("card_url")
+        fallback_url = (
+            payment_result.get("link_page_url")
+            or payment_result.get("link_url")
+        )
+
+        if not (sbp_url or card_url or fallback_url):
+            await message.answer(
+                texts.t(
+                    "PAL24_PAYMENT_ERROR",
+                    "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+                )
+            )
+            await state.clear()
+            return
+
+        if not sbp_url:
+            sbp_url = fallback_url
+
+        bill_id = payment_result.get("bill_id")
+        local_payment_id = payment_result.get("local_payment_id")
+
+        pay_buttons: list[list[types.InlineKeyboardButton]] = []
+        steps: list[str] = []
+        step_counter = 1
+
+        default_sbp_text = texts.t(
+            "PAL24_SBP_PAY_BUTTON",
+            "🏦 Оплатить через PayPalych (СБП)",
+        )
+        sbp_button_text = settings.get_pal24_sbp_button_text(default_sbp_text)
+
+        if sbp_url and settings.is_pal24_sbp_button_visible():
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=sbp_button_text,
+                        url=sbp_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(sbp_button_text))
+            )
+            step_counter += 1
+
+        default_card_text = texts.t(
+            "PAL24_CARD_PAY_BUTTON",
+            "💳 Оплатить банковской картой (PayPalych)",
+        )
+        card_button_text = settings.get_pal24_card_button_text(default_card_text)
+
+        if card_url and card_url != sbp_url and settings.is_pal24_card_button_visible():
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=card_button_text,
+                        url=card_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(card_button_text))
+            )
+            step_counter += 1
+
+        if not pay_buttons and fallback_url and settings.is_pal24_sbp_button_visible():
+            pay_buttons.append(
+                [
+                    types.InlineKeyboardButton(
+                        text=sbp_button_text,
+                        url=fallback_url,
+                    )
+                ]
+            )
+            steps.append(
+                texts.t(
+                    "PAL24_INSTRUCTION_BUTTON",
+                    "{step}. Нажмите кнопку «{button}»",
+                ).format(step=step_counter, button=html.escape(sbp_button_text))
+            )
+            step_counter += 1
+
+        follow_template = texts.t(
+            "PAL24_INSTRUCTION_FOLLOW",
+            "{step}. Следуйте подсказкам платёжной системы",
+        )
+        steps.append(follow_template.format(step=step_counter))
+        step_counter += 1
+
+        confirm_template = texts.t(
+            "PAL24_INSTRUCTION_CONFIRM",
+            "{step}. Подтвердите перевод",
+        )
+        steps.append(confirm_template.format(step=step_counter))
+        step_counter += 1
+
+        success_template = texts.t(
+            "PAL24_INSTRUCTION_COMPLETE",
+            "{step}. Средства зачислятся автоматически",
+        )
+        steps.append(success_template.format(step=step_counter))
+
+        message_template = texts.t(
+            "PAL24_PAYMENT_INSTRUCTIONS",
+            (
+                "🏦 <b>Оплата через PayPalych</b>\n\n"
+                "💰 Сумма: {amount}\n"
+                "🆔 ID счета: {bill_id}\n\n"
+                "📱 <b>Инструкция:</b>\n{steps}\n\n"
+                "❓ Если возникнут проблемы, обратитесь в {support}"
+            ),
+        )
+
+        keyboard_rows = pay_buttons + [
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                    callback_data=f"check_pal24_{local_payment_id}",
+                )
+            ],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+        ]
+
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_rows)
+
+        message_text = message_template.format(
+            amount=settings.format_price(amount_kopeks),
+            bill_id=bill_id,
+            steps="\n".join(steps),
+            support=settings.get_support_contact_display_html(),
+        )
+
+        invoice_message = await message.answer(
+            message_text,
+            reply_markup=keyboard,
+            parse_mode="HTML",
+        )
+
+        try:
+            from app.services import payment_service as payment_module
+
+            payment = await payment_module.get_pal24_payment_by_id(db, local_payment_id)
+            if payment:
+                metadata = dict(getattr(payment, "metadata_json", {}) or {})
+                metadata["invoice_message"] = {
+                    "chat_id": invoice_message.chat.id,
+                    "message_id": invoice_message.message_id,
+                }
+                await db.execute(
+                    update(payment.__class__)
+                    .where(payment.__class__.id == payment.id)
+                    .values(metadata_json=metadata, updated_at=datetime.utcnow())
+                )
+                await db.commit()
+        except Exception as error:  # pragma: no cover - diagnostics
+            logger.warning("Не удалось сохранить сообщение PayPalych: %s", error)
+
+        await state.update_data(
+            pal24_invoice_message_id=invoice_message.message_id,
+            pal24_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.clear()
+
+        logger.info(
+            "Создан PayPalych счет для пользователя %s: %s₽, ID: %s, метод: %s",
+            db_user.telegram_id,
+            amount_kopeks / 100,
+            bill_id,
+            payment_method,
+        )
+
+    except Exception as error:
+        logger.error(f"Ошибка создания PayPalych платежа: {error}")
+        await message.answer(
+            texts.t(
+                "PAL24_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+            )
+        )
+        await state.clear()
+
+@error_handler
+async def start_pal24_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_pal24_enabled():
+        await callback.answer("❌ Оплата через PayPalych временно недоступна", show_alert=True)
+        return
+
+    # Формируем текст сообщения в зависимости от доступных способов оплаты
+    if settings.is_pal24_sbp_button_visible() and settings.is_pal24_card_button_visible():
+        payment_methods_text = "СБП и банковской картой"
+    elif settings.is_pal24_sbp_button_visible():
+        payment_methods_text = "СБП"
+    elif settings.is_pal24_card_button_visible():
+        payment_methods_text = "банковской картой"
+    else:
+        # Если обе кнопки отключены, используем общий текст
+        payment_methods_text = "доступными способами"
+
+    message_text = texts.t(
+        "PAL24_TOPUP_PROMPT",
+        (
+            f"🏦 <b>Оплата через PayPalych ({payment_methods_text})</b>\n\n"
+            "Введите сумму для пополнения от 100 до 1 000 000 ₽.\n"
+            f"Оплата проходит через PayPalych ({payment_methods_text})."
+        ),
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        payment_method="pal24",
+        pal24_prompt_message_id=callback.message.message_id,
+        pal24_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_pal24_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_pal24_enabled():
+        await message.answer("❌ Оплата через PayPalych временно недоступна")
+        return
+
+    if amount_kopeks < settings.PAL24_MIN_AMOUNT_KOPEKS:
+        min_rubles = settings.PAL24_MIN_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Минимальная сумма для оплаты через PayPalych: {min_rubles:.0f} ₽")
+        return
+
+    if amount_kopeks > settings.PAL24_MAX_AMOUNT_KOPEKS:
+        max_rubles = settings.PAL24_MAX_AMOUNT_KOPEKS / 100
+        await message.answer(
+            f"❌ Максимальная сумма для оплаты через PayPalych: {max_rubles:,.0f} ₽".replace(',', ' ')
+        )
+        return
+
+    available_methods = _get_available_pal24_methods()
+
+    state_data = await state.get_data()
+    prompt_message_id = state_data.get("pal24_prompt_message_id")
+    prompt_chat_id = state_data.get("pal24_prompt_chat_id", message.chat.id)
+
+    try:
+        await message.delete()
+    except Exception as delete_error:  # pragma: no cover - depends on bot rights
+        logger.warning("Не удалось удалить сообщение с суммой PayPalych: %s", delete_error)
+
+    if prompt_message_id:
+        try:
+            await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+        except Exception as delete_error:  # pragma: no cover - diagnostic
+            logger.warning(
+                "Не удалось удалить сообщение с запросом суммы PayPalych: %s",
+                delete_error,
+            )
+
+    if len(available_methods) == 1:
+        await _send_pal24_payment_message(
+            message,
+            db_user,
+            db,
+            amount_kopeks,
+            available_methods[0],
+            state,
+        )
+        return
+
+    await state.update_data(pal24_amount_kopeks=amount_kopeks)
+    await state.set_state(BalanceStates.waiting_for_pal24_method)
+
+    method_buttons: list[list[types.InlineKeyboardButton]] = []
+    if "sbp" in available_methods:
+        method_buttons.append(
+            [
+                types.InlineKeyboardButton(
+                    text=settings.get_pal24_sbp_button_text(
+                        texts.t("PAL24_SBP_PAY_BUTTON", "🏦 Оплатить через PayPalych (СБП)")
+                    ),
+                    callback_data="pal24_method_sbp",
+                )
+            ]
+        )
+    if "card" in available_methods:
+        method_buttons.append(
+            [
+                types.InlineKeyboardButton(
+                    text=settings.get_pal24_card_button_text(
+                        texts.t("PAL24_CARD_PAY_BUTTON", "💳 Оплатить банковской картой (PayPalych)")
+                    ),
+                    callback_data="pal24_method_card",
+                )
+            ]
+        )
+
+    method_buttons.append([types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")])
+
+    await message.answer(
+        texts.t(
+            "PAL24_SELECT_PAYMENT_METHOD",
+            "Выберите способ оплаты PayPalych:",
+        ),
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=method_buttons),
+    )
+
+
+@error_handler
+async def handle_pal24_method_selection(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    data = await state.get_data()
+    amount_kopeks = data.get("pal24_amount_kopeks")
+    if not amount_kopeks:
+        texts = get_texts(db_user.language)
+        await callback.answer(
+            texts.t(
+                "PAL24_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа PayPalych. Попробуйте позже или обратитесь в поддержку.",
+            ),
+            show_alert=True,
+        )
+        await state.clear()
+        return
+
+    method = "sbp" if callback.data.endswith("_sbp") else "card"
+
+    await callback.answer()
+
+    async with AsyncSessionLocal() as db:
+        await _send_pal24_payment_message(
+            callback.message,
+            db_user,
+            db,
+            int(amount_kopeks),
+            method,
+            state,
+        )
+
+
+@error_handler
+async def check_pal24_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        payment_service = PaymentService(callback.bot)
+        status_info = await payment_service.get_pal24_payment_status(db, local_payment_id)
+
+        if not status_info:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+
+        payment = status_info["payment"]
+
+        status_labels = {
+            "NEW": ("⏳", "Ожидает оплаты"),
+            "PROCESS": ("⌛", "Обрабатывается"),
+            "SUCCESS": ("✅", "Оплачен"),
+            "FAIL": ("❌", "Отменен"),
+            "UNDERPAID": ("⚠️", "Недоплата"),
+            "OVERPAID": ("⚠️", "Переплата"),
+        }
+
+        emoji, status_text = status_labels.get(payment.status, ("❓", "Неизвестно"))
+
+        metadata = payment.metadata_json or {}
+        links_meta = metadata.get("links") if isinstance(metadata, dict) else None
+        if not isinstance(links_meta, dict):
+            links_meta = {}
+
+        links_info = status_info.get("links") or {}
+
+        def _extract_link(source: Any, keys: tuple[str, ...]) -> Optional[str]:
+            stack: list[Any] = [source]
+            while stack:
+                current = stack.pop()
+                if isinstance(current, dict):
+                    for key in keys:
+                        value = current.get(key)
+                        if value:
+                            return str(value)
+                    stack.extend(current.values())
+                elif isinstance(current, list):
+                    stack.extend(current)
+            return None
+
+        raw_response = metadata.get("raw_response") if isinstance(metadata, dict) else None
+        remote_data = status_info.get("remote_data")
+        transfer_keys = (
+            "transfer_url",
+            "transferUrl",
+            "transfer_link",
+            "transferLink",
+            "transfer",
+            "sbp_url",
+            "sbpUrl",
+            "sbp_link",
+            "sbpLink",
+        )
+        card_keys = (
+            "link_url",
+            "linkUrl",
+            "link",
+            "card_url",
+            "cardUrl",
+            "card_link",
+            "cardLink",
+            "payment_url",
+            "paymentUrl",
+            "url",
+        )
+
+        extra_sbp_link = (
+            _extract_link(raw_response, transfer_keys)
+            if raw_response
+            else None
+        )
+        if not extra_sbp_link and remote_data:
+            extra_sbp_link = _extract_link(remote_data, transfer_keys)
+
+        extra_card_link = (
+            _extract_link(raw_response, card_keys)
+            if raw_response
+            else None
+        )
+        if not extra_card_link and remote_data:
+            extra_card_link = _extract_link(remote_data, card_keys)
+
+        sbp_link = (
+            links_info.get("sbp")
+            or links_meta.get("sbp")
+            or status_info.get("sbp_url")
+            or extra_sbp_link
+            or payment.link_url
+        )
+        card_link = (
+            links_info.get("card")
+            or links_meta.get("card")
+            or status_info.get("card_url")
+            or extra_card_link
+        )
+
+        if not card_link and payment.link_page_url and payment.link_page_url != sbp_link:
+            card_link = payment.link_page_url
+
+        message_lines = [
+            "🏦 Статус платежа PayPalych:",
+            "",
+            f"🆔 ID счета: {payment.bill_id}",
+            f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}",
+            f"📊 Статус: {emoji} {status_text}",
+            f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}",
+        ]
+
+        if payment.is_paid:
+            message_lines.append("")
+            message_lines.append("✅ Платеж успешно завершен! Средства уже на балансе.")
+        elif payment.status in {"NEW", "PROCESS"}:
+            message_lines.append("")
+            message_lines.append("⏳ Платеж еще не завершен. Оплатите счет и проверьте статус позже.")
+            if sbp_link:
+                message_lines.append("")
+                message_lines.append(f"🏦 СБП: {sbp_link}")
+            if card_link and card_link != sbp_link:
+                message_lines.append(f"💳 Банковская карта: {card_link}")
+        elif payment.status in {"FAIL", "UNDERPAID", "OVERPAID"}:
+            message_lines.append("")
+            message_lines.append(
+                f"❌ Платеж не завершен корректно. Обратитесь в {settings.get_support_contact_display()}"
+            )
+
+        from app.localization.texts import get_texts
+        db_user = getattr(callback, 'db_user', None)
+        texts = get_texts(db_user.language if db_user else 'ru') if db_user else get_texts('ru')
+
+        pay_rows: list[list[types.InlineKeyboardButton]] = []
+
+        if not payment.is_paid and payment.status in {"NEW", "PROCESS"}:
+            default_sbp_text = texts.t(
+                "PAL24_SBP_PAY_BUTTON",
+                "🏦 Оплатить через PayPalych (СБП)",
+            )
+            sbp_button_text = settings.get_pal24_sbp_button_text(default_sbp_text)
+
+            if sbp_link and settings.is_pal24_sbp_button_visible():
+                pay_rows.append(
+                    [
+                        types.InlineKeyboardButton(
+                            text=sbp_button_text,
+                            url=sbp_link,
+                        )
+                    ]
+                )
+
+            default_card_text = texts.t(
+                "PAL24_CARD_PAY_BUTTON",
+                "💳 Оплатить банковской картой (PayPalych)",
+            )
+            card_button_text = settings.get_pal24_card_button_text(default_card_text)
+
+            if card_link and settings.is_pal24_card_button_visible():
+                if not pay_rows or pay_rows[-1][0].url != card_link:
+                    pay_rows.append(
+                        [
+                            types.InlineKeyboardButton(
+                                text=card_button_text,
+                                url=card_link,
+                            )
+                        ]
+                    )
+
+        keyboard_rows = pay_rows + [
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                    callback_data=f"check_pal24_{local_payment_id}",
+                )
+            ],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+        ]
+
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_rows)
+        
+        await callback.answer()
+        try:
+            await callback.message.edit_text(
+                "\n".join(message_lines),
+                reply_markup=keyboard,
+                disable_web_page_preview=True,
+            )
+        except TelegramBadRequest as error:
+            if "message is not modified" in str(error).lower():
+                await callback.answer(texts.t("CHECK_STATUS_NO_CHANGES", "Статус не изменился"))
+            else:
+                raise
+
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса PayPalych: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
@@ -0,0 +1,403 @@
+"""Handlers for Platega balance interactions."""
+
+import logging
+from typing import List
+
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.states import BalanceStates
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+
+def _get_active_methods() -> List[int]:
+    methods = settings.get_platega_active_methods()
+    return [code for code in methods if code in {2, 10, 11, 12, 13}]
+
+
+async def _prompt_amount(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    method_code: int,
+) -> None:
+    texts = get_texts(db_user.language)
+    method_name = settings.get_platega_method_display_title(method_code)
+
+    # Всегда фиксируем выбранный метод для последующей обработки
+    await state.update_data(payment_method="platega", platega_method=method_code)
+
+    data = await state.get_data()
+    pending_amount = int(data.get("platega_pending_amount") or 0)
+
+    if pending_amount > 0:
+        # Если сумма уже известна (например, после быстрого выбора),
+        # сразу создаём платеж и сбрасываем временное значение.
+        await state.update_data(platega_pending_amount=None)
+
+        from app.database.database import AsyncSessionLocal
+
+        async with AsyncSessionLocal() as db:
+            await process_platega_payment_amount(
+                message,
+                db_user,
+                db,
+                pending_amount,
+                state,
+            )
+        return
+
+    min_amount_label = settings.format_price(settings.PLATEGA_MIN_AMOUNT_KOPEKS)
+    max_amount_kopeks = settings.PLATEGA_MAX_AMOUNT_KOPEKS
+    max_amount_label = (
+        settings.format_price(max_amount_kopeks)
+        if max_amount_kopeks and max_amount_kopeks > 0
+        else ""
+    )
+
+    default_prompt_body = (
+        "Введите сумму для пополнения от {min_amount} до {max_amount}.\n"
+        if max_amount_kopeks and max_amount_kopeks > 0
+        else "Введите сумму для пополнения от {min_amount}.\n"
+    )
+
+    prompt_template = texts.t(
+        "PLATEGA_TOPUP_PROMPT",
+        (
+            "💳 <b>Оплата через Platega ({method_name})</b>\n\n"
+            f"{default_prompt_body}"
+            "Оплата происходит через Platega."
+        ),
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await message.edit_text(
+        prompt_template.format(
+            method_name=method_name,
+            min_amount=min_amount_label,
+            max_amount=max_amount_label,
+        ),
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        platega_prompt_message_id=message.message_id,
+        platega_prompt_chat_id=message.chat.id,
+    )
+
+
+@error_handler
+async def start_platega_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_platega_enabled():
+        await callback.answer(
+            texts.t(
+                "PLATEGA_TEMPORARILY_UNAVAILABLE",
+                "❌ Оплата через Platega временно недоступна",
+            ),
+            show_alert=True,
+        )
+        return
+
+    active_methods = _get_active_methods()
+    if not active_methods:
+        await callback.answer(
+            texts.t(
+                "PLATEGA_METHODS_NOT_CONFIGURED",
+                "⚠️ На стороне Platega нет доступных методов оплаты",
+            ),
+            show_alert=True,
+        )
+        return
+
+    await state.update_data(payment_method="platega")
+    data = await state.get_data()
+    has_pending_amount = bool(int(data.get("platega_pending_amount") or 0))
+
+    if len(active_methods) == 1:
+        await _prompt_amount(callback.message, db_user, state, active_methods[0])
+        await callback.answer()
+        return
+
+    method_buttons: list[list[types.InlineKeyboardButton]] = []
+    for method_code in active_methods:
+        label = settings.get_platega_method_display_title(method_code)
+        method_buttons.append(
+            [
+                types.InlineKeyboardButton(
+                    text=label,
+                    callback_data=f"platega_method_{method_code}",
+                )
+            ]
+        )
+
+    method_buttons.append(
+        [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+    )
+
+    await callback.message.edit_text(
+        texts.t(
+            "PLATEGA_SELECT_PAYMENT_METHOD",
+            "Выберите способ оплаты Platega:",
+        ),
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=method_buttons),
+    )
+    if not has_pending_amount:
+        await state.set_state(BalanceStates.waiting_for_platega_method)
+    await callback.answer()
+
+
+@error_handler
+async def handle_platega_method_selection(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    try:
+        method_code = int(callback.data.rsplit("_", 1)[-1])
+    except ValueError:
+        await callback.answer("❌ Некорректный способ оплаты", show_alert=True)
+        return
+
+    if method_code not in _get_active_methods():
+        await callback.answer("⚠️ Этот способ сейчас недоступен", show_alert=True)
+        return
+
+    await _prompt_amount(callback.message, db_user, state, method_code)
+    await callback.answer()
+
+
+@error_handler
+async def process_platega_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_platega_enabled():
+        await message.answer(
+            texts.t(
+                "PLATEGA_TEMPORARILY_UNAVAILABLE",
+                "❌ Оплата через Platega временно недоступна",
+            )
+        )
+        return
+
+    data = await state.get_data()
+    method_code = int(data.get("platega_method", 0))
+    if method_code not in _get_active_methods():
+        await message.answer(
+            texts.t(
+                "PLATEGA_METHOD_SELECTION_REQUIRED",
+                "⚠️ Выберите способ оплаты Platega перед вводом суммы",
+            )
+        )
+        await state.set_state(BalanceStates.waiting_for_platega_method)
+        return
+
+    if amount_kopeks < settings.PLATEGA_MIN_AMOUNT_KOPEKS:
+        await message.answer(
+            texts.t(
+                "PLATEGA_AMOUNT_TOO_LOW",
+                "Минимальная сумма для оплаты через Platega: {amount}",
+            ).format(amount=settings.format_price(settings.PLATEGA_MIN_AMOUNT_KOPEKS))
+        )
+        return
+
+    if amount_kopeks > settings.PLATEGA_MAX_AMOUNT_KOPEKS:
+        await message.answer(
+            texts.t(
+                "PLATEGA_AMOUNT_TOO_HIGH",
+                "Максимальная сумма для оплаты через Platega: {amount}",
+            ).format(amount=settings.format_price(settings.PLATEGA_MAX_AMOUNT_KOPEKS))
+        )
+        return
+
+    try:
+        payment_service = PaymentService(message.bot)
+        payment_result = await payment_service.create_platega_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+            payment_method_code=method_code,
+        )
+    except Exception as error:
+        logger.exception("Ошибка создания платежа Platega: %s", error)
+        payment_result = None
+
+    if not payment_result or not payment_result.get("redirect_url"):
+        await message.answer(
+            texts.t(
+                "PLATEGA_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа Platega. Попробуйте позже или обратитесь в поддержку.",
+            )
+        )
+        await state.clear()
+        return
+
+    redirect_url = payment_result.get("redirect_url")
+    local_payment_id = payment_result.get("local_payment_id")
+    transaction_id = payment_result.get("transaction_id")
+    method_title = settings.get_platega_method_display_title(method_code)
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t(
+                        "PLATEGA_PAY_BUTTON",
+                        "💳 Оплатить через {method}",
+                    ).format(method=method_title),
+                    url=redirect_url,
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                    callback_data=f"check_platega_{local_payment_id}",
+                )
+            ],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+        ]
+    )
+
+    instructions_template = texts.t(
+        "PLATEGA_PAYMENT_INSTRUCTIONS",
+        (
+            "💳 <b>Оплата через Platega ({method})</b>\n\n"
+            "💰 Сумма: {amount}\n"
+            "🆔 ID транзакции: {transaction}\n\n"
+            "📱 <b>Инструкция:</b>\n"
+            "1. Нажмите кнопку «Оплатить»\n"
+            "2. Следуйте подсказкам платёжной системы\n"
+            "3. Подтвердите перевод\n"
+            "4. Средства зачислятся автоматически\n\n"
+            "❓ Если возникнут проблемы, обратитесь в {support}"
+        ),
+    )
+
+    state_data = await state.get_data()
+    prompt_message_id = state_data.get("platega_prompt_message_id")
+    prompt_chat_id = state_data.get("platega_prompt_chat_id", message.chat.id)
+
+    try:
+        await message.delete()
+    except Exception as delete_error:  # pragma: no cover - зависит от прав бота
+        logger.warning("Не удалось удалить сообщение с суммой Platega: %s", delete_error)
+
+    if prompt_message_id:
+        try:
+            await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+        except Exception as delete_error:  # pragma: no cover - диагностический лог
+            logger.warning(
+                "Не удалось удалить сообщение с запросом суммы Platega: %s",
+                delete_error,
+            )
+
+    invoice_message = await message.answer(
+        instructions_template.format(
+            method=method_title,
+            amount=settings.format_price(amount_kopeks),
+            transaction=transaction_id or local_payment_id,
+            support=settings.get_support_contact_display_html(),
+        ),
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    try:
+        from app.services import payment_service as payment_module
+
+        payment = await payment_module.get_platega_payment_by_id(db, local_payment_id)
+        if payment:
+            payment_metadata = dict(getattr(payment, "metadata_json", {}) or {})
+            payment_metadata["invoice_message"] = {
+                "chat_id": invoice_message.chat.id,
+                "message_id": invoice_message.message_id,
+            }
+            await payment_module.update_platega_payment(
+                db,
+                payment=payment,
+                metadata=payment_metadata,
+            )
+    except Exception as error:  # pragma: no cover - диагностический лог
+        logger.warning("Не удалось сохранить данные сообщения Platega: %s", error)
+
+    await state.update_data(
+        platega_invoice_message_id=invoice_message.message_id,
+        platega_invoice_chat_id=invoice_message.chat.id,
+    )
+
+    await state.clear()
+
+
+@error_handler
+async def check_platega_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+):
+    try:
+        local_payment_id = int(callback.data.split("_")[-1])
+    except ValueError:
+        await callback.answer("❌ Некорректный идентификатор платежа", show_alert=True)
+        return
+
+    payment_service = PaymentService(callback.bot)
+
+    try:
+        status_info = await payment_service.get_platega_payment_status(db, local_payment_id)
+    except Exception as error:
+        logger.exception("Ошибка проверки статуса Platega: %s", error)
+        await callback.answer("⚠️ Ошибка проверки статуса", show_alert=True)
+        return
+
+    if not status_info:
+        await callback.answer("⚠️ Платёж не найден", show_alert=True)
+        return
+
+    payment = status_info.get("payment")
+    status = status_info.get("status")
+    is_paid = status_info.get("is_paid")
+
+    language = "ru"
+    user = getattr(payment, "user", None)
+    if user and getattr(user, "language", None):
+        language = user.language
+
+    texts = get_texts(language)
+
+    if is_paid:
+        await callback.answer(texts.t("PLATEGA_PAYMENT_ALREADY_CONFIRMED", "✅ Платёж уже зачислен"), show_alert=True)
+    else:
+        await callback.answer(
+            texts.t("PLATEGA_PAYMENT_STATUS", "Текущий статус платежа: {status}").format(status=status),
+            show_alert=True,
+        )
@@ -0,0 +1,132 @@
+import logging
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.states import BalanceStates
+from app.utils.decorators import error_handler
+from app.external.telegram_stars import TelegramStarsService
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_stars_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.TELEGRAM_STARS_ENABLED:
+        await callback.answer("❌ Пополнение через Stars временно недоступно", show_alert=True)
+        return
+
+    # Формируем текст сообщения в зависимости от настройки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        message_text = (
+            f"⭐ <b>Пополнение через Telegram Stars</b>\n\n"
+            f"Выберите сумму пополнения или введите вручную:"
+        )
+    else:
+        message_text = texts.TOP_UP_AMOUNT
+
+    # Создаем клавиатуру
+    keyboard = get_back_keyboard(db_user.language)
+
+    # Если включен быстрый выбор суммы и не отключены кнопки, добавляем кнопки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            # Вставляем кнопки быстрого выбора перед кнопкой "Назад"
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard
+    )
+
+    await state.update_data(
+        stars_prompt_message_id=callback.message.message_id,
+        stars_prompt_chat_id=callback.message.chat.id,
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="stars")
+    await callback.answer()
+
+
+@error_handler
+async def process_stars_payment_amount(
+    message: types.Message,
+    db_user: User,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.TELEGRAM_STARS_ENABLED:
+        await message.answer("⚠️ Оплата Stars временно недоступна")
+        return
+
+    try:
+        amount_rubles = amount_kopeks / 100
+        stars_amount = TelegramStarsService.calculate_stars_from_rubles(amount_rubles)
+        stars_rate = settings.get_stars_rate()
+
+        payment_service = PaymentService(message.bot)
+        invoice_link = await payment_service.create_stars_invoice(
+            amount_kopeks=amount_kopeks,
+            description=f"Пополнение баланса на {texts.format_price(amount_kopeks)}",
+            payload=f"balance_{db_user.id}_{amount_kopeks}"
+        )
+
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⭐ Оплатить", url=invoice_link)],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+        ])
+
+        state_data = await state.get_data()
+
+        prompt_message_id = state_data.get("stars_prompt_message_id")
+        prompt_chat_id = state_data.get("stars_prompt_chat_id", message.chat.id)
+
+        try:
+            await message.delete()
+        except Exception as delete_error:  # pragma: no cover - зависит от прав бота
+            logger.warning("Не удалось удалить сообщение с суммой Stars: %s", delete_error)
+
+        if prompt_message_id:
+            try:
+                await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+            except Exception as delete_error:  # pragma: no cover - диагностический лог
+                logger.warning(
+                    "Не удалось удалить сообщение с запросом суммы Stars: %s",
+                    delete_error,
+                )
+
+        invoice_message = await message.answer(
+            f"⭐ <b>Оплата через Telegram Stars</b>\n\n"
+            f"💰 Сумма: {texts.format_price(amount_kopeks)}\n"
+            f"⭐ К оплате: {stars_amount} звезд\n"
+            f"📊 Курс: {stars_rate}₽ за звезду\n\n"
+            f"Нажмите кнопку ниже для оплаты:",
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+
+        await state.update_data(
+            stars_invoice_message_id=invoice_message.message_id,
+            stars_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.set_state(None)
+
+    except Exception as e:
+        logger.error(f"Ошибка создания Stars invoice: {e}")
+        await message.answer("⚠️ Ошибка создания платежа")
@@ -0,0 +1,71 @@
+import logging
+from aiogram import types
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_tribute_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.TRIBUTE_ENABLED:
+        await callback.answer("❌ Оплата картой временно недоступна", show_alert=True)
+        return
+
+    try:
+        from app.services.tribute_service import TributeService
+
+        tribute_service = TributeService(callback.bot)
+        payment_url = await tribute_service.create_payment_link(
+            user_id=db_user.telegram_id,
+            amount_kopeks=0,
+            description="Пополнение баланса VPN",
+        )
+
+        if not payment_url:
+            await callback.answer("❌ Ошибка создания платежа", show_alert=True)
+            return
+
+        keyboard = types.InlineKeyboardMarkup(
+            inline_keyboard=[
+                [types.InlineKeyboardButton(text="💳 Перейти к оплате", url=payment_url)],
+                [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+            ]
+        )
+
+        message_text = (
+            "💳 <b>Пополнение банковской картой</b>\n\n"
+            "• Введите любую сумму от 100₽\n"
+            "• Безопасная оплата через Tribute\n"
+            "• Мгновенное зачисление на баланс\n"
+            "• Принимаем карты Visa, MasterCard, МИР\n\n"
+            "• 🚨 НЕ ОТПРАВЛЯТЬ ПЛАТЕЖ АНОНИМНО!\n\n"
+            "Нажмите кнопку для перехода к оплате:"
+        )
+
+        await callback.message.edit_text(
+            message_text,
+            reply_markup=keyboard,
+            parse_mode="HTML",
+        )
+
+        TributeService.remember_invoice_message(
+            db_user.telegram_id,
+            callback.message.chat.id,
+            callback.message.message_id,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка создания Tribute платежа: {e}")
+        await callback.answer("❌ Ошибка создания платежа", show_alert=True)
+
+    await callback.answer()
@@ -0,0 +1,282 @@
+import logging
+from datetime import datetime
+from typing import Dict
+
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy import update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService, get_user_by_id as fetch_user_by_id
+from app.states import BalanceStates
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_wata_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_wata_enabled():
+        await callback.answer("❌ Оплата через WATA временно недоступна", show_alert=True)
+        return
+
+    message_text = texts.t(
+        "WATA_TOPUP_PROMPT",
+        (
+            "💳 <b>Оплата через WATA</b>\n\n"
+            "Введите сумму пополнения. Минимальная сумма — {min_amount}, максимальная — {max_amount}.\n"
+            "Оплата происходит через защищенную форму WATA."
+        ),
+    ).format(
+        min_amount=settings.format_price(settings.WATA_MIN_AMOUNT_KOPEKS),
+        max_amount=settings.format_price(settings.WATA_MAX_AMOUNT_KOPEKS),
+    )
+
+    keyboard = get_back_keyboard(db_user.language)
+
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(
+        payment_method="wata",
+        wata_prompt_message_id=callback.message.message_id,
+        wata_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_wata_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext,
+):
+    texts = get_texts(db_user.language)
+
+    if not settings.is_wata_enabled():
+        await message.answer("❌ Оплата через WATA временно недоступна")
+        return
+
+    if amount_kopeks < settings.WATA_MIN_AMOUNT_KOPEKS:
+        await message.answer(
+            texts.t(
+                "WATA_AMOUNT_TOO_LOW",
+                "Минимальная сумма пополнения: {amount}",
+            ).format(amount=settings.format_price(settings.WATA_MIN_AMOUNT_KOPEKS))
+        )
+        return
+
+    if amount_kopeks > settings.WATA_MAX_AMOUNT_KOPEKS:
+        await message.answer(
+            texts.t(
+                "WATA_AMOUNT_TOO_HIGH",
+                "Максимальная сумма пополнения: {amount}",
+            ).format(amount=settings.format_price(settings.WATA_MAX_AMOUNT_KOPEKS))
+        )
+        return
+
+    payment_service = PaymentService(message.bot)
+
+    try:
+        result = await payment_service.create_wata_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            language=db_user.language,
+        )
+    except Exception as error:  # pragma: no cover - handled by decorator logs
+        logger.exception("Ошибка создания WATA платежа: %s", error)
+        result = None
+
+    if not result or not result.get("payment_url"):
+        await message.answer(
+            texts.t(
+                "WATA_PAYMENT_ERROR",
+                "❌ Ошибка создания платежа WATA. Попробуйте позже или обратитесь в поддержку.",
+            )
+        )
+        await state.clear()
+        return
+
+    payment_url = result["payment_url"]
+    payment_link_id = result["payment_link_id"]
+    local_payment_id = result["local_payment_id"]
+
+    keyboard = types.InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("WATA_PAY_BUTTON", "💳 Оплатить через WATA"),
+                    url=payment_url,
+                )
+            ],
+            [
+                types.InlineKeyboardButton(
+                    text=texts.t("CHECK_STATUS_BUTTON", "📊 Проверить статус"),
+                    callback_data=f"check_wata_{local_payment_id}",
+                )
+            ],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")],
+        ]
+    )
+
+    message_template = texts.t(
+        "WATA_PAYMENT_INSTRUCTIONS",
+        (
+            "💳 <b>Оплата через WATA</b>\n\n"
+            "💰 Сумма: {amount}\n"
+            "🆔 ID платежа: {payment_id}\n\n"
+            "📱 <b>Инструкция:</b>\n"
+            "1. Нажмите кнопку 'Оплатить через WATA'\n"
+            "2. Следуйте подсказкам платежной системы\n"
+            "3. Подтвердите перевод\n"
+            "4. Средства зачислятся автоматически\n\n"
+            "❓ Если возникнут проблемы, обратитесь в {support}"
+        ),
+    )
+
+    message_text = message_template.format(
+        amount=settings.format_price(amount_kopeks),
+        payment_id=payment_link_id,
+        support=settings.get_support_contact_display_html(),
+    )
+
+    state_data = await state.get_data()
+    prompt_message_id = state_data.get("wata_prompt_message_id")
+    prompt_chat_id = state_data.get("wata_prompt_chat_id", message.chat.id)
+
+    try:
+        await message.delete()
+    except Exception as delete_error:  # pragma: no cover - depends on bot rights
+        logger.warning("Не удалось удалить сообщение с суммой WATA: %s", delete_error)
+
+    if prompt_message_id:
+        try:
+            await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+        except Exception as delete_error:  # pragma: no cover - diagnostic
+            logger.warning(
+                "Не удалось удалить сообщение с запросом суммы WATA: %s",
+                delete_error,
+            )
+
+    invoice_message = await message.answer(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML",
+    )
+
+    try:
+        from app.services import payment_service as payment_module
+
+        payment = await payment_module.get_wata_payment_by_local_id(db, local_payment_id)
+        if payment:
+            metadata = dict(getattr(payment, "metadata_json", {}) or {})
+            metadata["invoice_message"] = {
+                "chat_id": invoice_message.chat.id,
+                "message_id": invoice_message.message_id,
+            }
+            await db.execute(
+                update(payment.__class__)
+                .where(payment.__class__.id == payment.id)
+                .values(metadata_json=metadata, updated_at=datetime.utcnow())
+            )
+            await db.commit()
+    except Exception as error:  # pragma: no cover - diagnostics
+        logger.warning("Не удалось сохранить сообщение WATA: %s", error)
+
+    await state.update_data(
+        wata_invoice_message_id=invoice_message.message_id,
+        wata_invoice_chat_id=invoice_message.chat.id,
+    )
+
+    await state.clear()
+
+    logger.info(
+        "Создан WATA платеж для пользователя %s: %s₽, ссылка: %s",
+        db_user.telegram_id,
+        amount_kopeks / 100,
+        payment_link_id,
+    )
+
+
+@error_handler
+async def check_wata_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession,
+):
+    try:
+        local_payment_id = int(callback.data.split("_")[-1])
+    except (ValueError, IndexError):
+        await callback.answer("❌ Некорректный идентификатор платежа", show_alert=True)
+        return
+
+    payment_service = PaymentService(callback.bot)
+    status_info = await payment_service.get_wata_payment_status(db, local_payment_id)
+
+    if not status_info:
+        await callback.answer("❌ Платеж не найден", show_alert=True)
+        return
+
+    payment = status_info["payment"]
+
+    user_language = "ru"
+    try:
+        user = await fetch_user_by_id(db, payment.user_id)
+        if user and getattr(user, "language", None):
+            user_language = user.language
+    except Exception as error:
+        logger.debug("Не удалось получить пользователя для WATA статуса: %s", error)
+
+    texts = get_texts(user_language)
+
+    status_labels: Dict[str, Dict[str, str]] = {
+        "Opened": {"emoji": "⏳", "label": texts.t("WATA_STATUS_OPENED", "Ожидает оплаты")},
+        "Closed": {"emoji": "⌛", "label": texts.t("WATA_STATUS_CLOSED", "Обрабатывается")},
+        "Paid": {"emoji": "✅", "label": texts.t("WATA_STATUS_PAID", "Оплачен")},
+        "Declined": {"emoji": "❌", "label": texts.t("WATA_STATUS_DECLINED", "Отклонен")},
+    }
+
+    label_info = status_labels.get(payment.status, {"emoji": "❓", "label": texts.t("WATA_STATUS_UNKNOWN", "Неизвестно")})
+
+    message_lines = [
+        texts.t("WATA_STATUS_TITLE", "💳 <b>Статус платежа WATA</b>"),
+        "",
+        f"🆔 ID: {payment.payment_link_id}",
+        f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}",
+        f"📊 Статус: {label_info['emoji']} {label_info['label']}",
+        f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M') if payment.created_at else '—'}",
+    ]
+
+    if payment.is_paid:
+        message_lines.append("\n✅ Платеж успешно завершен! Средства уже на балансе.")
+    elif payment.status in {"Opened", "Closed"}:
+        message_lines.append(
+            "\n⏳ Платеж еще не завершен. Завершите оплату по ссылке и проверьте статус позже."
+        )
+
+    await callback.message.answer("\n".join(message_lines), parse_mode="HTML")
+    await callback.answer()
@@ -0,0 +1,533 @@
+import logging
+from datetime import datetime
+
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+from sqlalchemy import update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.decorators import error_handler
+from app.states import BalanceStates
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def start_yookassa_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_yookassa_enabled():
+        await callback.answer("❌ Оплата картой через YooKassa временно недоступна", show_alert=True)
+        return
+    
+    min_amount_rub = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
+    max_amount_rub = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
+    
+    # Формируем текст сообщения в зависимости от настройки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        message_text = (
+            f"💳 <b>Оплата банковской картой</b>\n\n"
+            f"Выберите сумму пополнения или введите вручную сумму "
+            f"от {min_amount_rub:.0f} до {max_amount_rub:,.0f} рублей:"
+        )
+    else:
+        message_text = (
+            f"💳 <b>Оплата банковской картой</b>\n\n"
+            f"Введите сумму для пополнения от {min_amount_rub:.0f} до {max_amount_rub:,.0f} рублей:"
+        )
+    
+    # Создаем клавиатуру
+    keyboard = get_back_keyboard(db_user.language)
+    
+    # Если включен быстрый выбор суммы и не отключены кнопки, добавляем кнопки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            # Вставляем кнопки быстрого выбора перед кнопкой "Назад"
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+    
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="yookassa")
+    await state.update_data(
+        yookassa_prompt_message_id=callback.message.message_id,
+        yookassa_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def start_yookassa_sbp_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_yookassa_enabled() or not settings.YOOKASSA_SBP_ENABLED:
+        await callback.answer("❌ Оплата через СБП временно недоступна", show_alert=True)
+        return
+    
+    min_amount_rub = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
+    max_amount_rub = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
+    
+    # Формируем текст сообщения в зависимости от настройки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        message_text = (
+            f"🏦 <b>Оплата через СБП</b>\n\n"
+            f"Выберите сумму пополнения или введите вручную сумму "
+            f"от {min_amount_rub:.0f} до {max_amount_rub:,.0f} рублей:"
+        )
+    else:
+        message_text = (
+            f"🏦 <b>Оплата через СБП</b>\n\n"
+            f"Введите сумму для пополнения от {min_amount_rub:.0f} до {max_amount_rub:,.0f} рублей:"
+        )
+    
+    # Создаем клавиатуру
+    keyboard = get_back_keyboard(db_user.language)
+    
+    # Если включен быстрый выбор суммы и не отключены кнопки, добавляем кнопки
+    if settings.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not settings.DISABLE_TOPUP_BUTTONS:
+        from .main import get_quick_amount_buttons
+        quick_amount_buttons = get_quick_amount_buttons(db_user.language, db_user)
+        if quick_amount_buttons:
+            # Вставляем кнопки быстрого выбора перед кнопкой "Назад"
+            keyboard.inline_keyboard = quick_amount_buttons + keyboard.inline_keyboard
+    
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="yookassa_sbp")
+    await state.update_data(
+        yookassa_prompt_message_id=callback.message.message_id,
+        yookassa_prompt_chat_id=callback.message.chat.id,
+    )
+    await callback.answer()
+
+
+@error_handler
+async def process_yookassa_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_yookassa_enabled():
+        await message.answer("❌ Оплата через YooKassa временно недоступна")
+        return
+    
+    if amount_kopeks < settings.YOOKASSA_MIN_AMOUNT_KOPEKS:
+        min_rubles = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Минимальная сумма для оплаты картой: {min_rubles:.0f} ₽")
+        return
+    
+    if amount_kopeks > settings.YOOKASSA_MAX_AMOUNT_KOPEKS:
+        max_rubles = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Максимальная сумма для оплаты картой: {max_rubles:,.0f} ₽".replace(',', ' '))
+        return
+    
+    try:
+        payment_service = PaymentService(message.bot)
+        
+        payment_result = await payment_service.create_yookassa_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            receipt_email=None,
+            receipt_phone=None,
+            metadata={
+                "user_telegram_id": str(db_user.telegram_id),
+                "user_username": db_user.username or "",
+                "purpose": "balance_topup"
+            }
+        )
+        
+        if not payment_result:
+            await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        confirmation_url = payment_result.get("confirmation_url")
+        if not confirmation_url:
+            await message.answer("❌ Ошибка получения ссылки для оплаты. Обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="💳 Оплатить картой", url=confirmation_url)],
+            [types.InlineKeyboardButton(text="📊 Проверить статус", callback_data=f"check_yookassa_{payment_result['local_payment_id']}")],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+        ])
+        
+        state_data = await state.get_data()
+        prompt_message_id = state_data.get("yookassa_prompt_message_id")
+        prompt_chat_id = state_data.get("yookassa_prompt_chat_id", message.chat.id)
+
+        try:
+            await message.delete()
+        except Exception as delete_error:  # pragma: no cover - зависит от прав бота
+            logger.warning("Не удалось удалить сообщение с суммой YooKassa: %s", delete_error)
+
+        if prompt_message_id:
+            try:
+                await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+            except Exception as delete_error:  # pragma: no cover - диагностический лог
+                logger.warning(
+                    "Не удалось удалить сообщение с запросом суммы YooKassa: %s",
+                    delete_error,
+                )
+
+        invoice_message = await message.answer(
+            f"💳 <b>Оплата банковской картой</b>\n\n"
+            f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
+            f"🆔 ID платежа: {payment_result['yookassa_payment_id'][:8]}...\n\n"
+            f"📱 <b>Инструкция:</b>\n"
+            f"1. Нажмите кнопку 'Оплатить картой'\n"
+            f"2. Введите данные вашей карты\n"
+            f"3. Подтвердите платеж\n"
+            f"4. Деньги поступят на баланс автоматически\n\n"
+            f"🔒 Оплата происходит через защищенную систему YooKassa\n"
+            f"✅ Принимаем карты: Visa, MasterCard, МИР\n\n"
+            f"❓ Если возникнут проблемы, обратитесь в {settings.get_support_contact_display_html()}",
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+
+        try:
+            from app.services import payment_service as payment_module
+
+            payment = await payment_module.get_yookassa_payment_by_local_id(
+                db, payment_result["local_payment_id"]
+            )
+            if payment:
+                metadata = dict(getattr(payment, "metadata_json", {}) or {})
+                metadata["invoice_message"] = {
+                    "chat_id": invoice_message.chat.id,
+                    "message_id": invoice_message.message_id,
+                }
+                await db.execute(
+                    update(payment.__class__)
+                    .where(payment.__class__.id == payment.id)
+                    .values(metadata_json=metadata, updated_at=datetime.utcnow())
+                )
+                await db.commit()
+        except Exception as error:  # pragma: no cover - диагностический лог
+            logger.warning("Не удалось сохранить сообщение YooKassa: %s", error)
+
+        await state.update_data(
+            yookassa_invoice_message_id=invoice_message.message_id,
+            yookassa_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.clear()
+        logger.info(f"Создан платеж YooKassa для пользователя {db_user.telegram_id}: "
+                   f"{amount_kopeks//100}₽, ID: {payment_result['yookassa_payment_id']}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания YooKassa платежа: {e}")
+        await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+        await state.clear()
+
+
+@error_handler
+async def process_yookassa_sbp_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_yookassa_enabled() or not settings.YOOKASSA_SBP_ENABLED:
+        await message.answer("❌ Оплата через СБП временно недоступна")
+        return
+    
+    if amount_kopeks < settings.YOOKASSA_MIN_AMOUNT_KOPEKS:
+        min_rubles = settings.YOOKASSA_MIN_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Минимальная сумма для оплаты через СБП: {min_rubles:.0f} ₽")
+        return
+    
+    if amount_kopeks > settings.YOOKASSA_MAX_AMOUNT_KOPEKS:
+        max_rubles = settings.YOOKASSA_MAX_AMOUNT_KOPEKS / 100
+        await message.answer(f"❌ Максимальная сумма для оплаты через СБП: {max_rubles:,.0f} ₽".replace(',', ' '))
+        return
+    
+    try:
+        payment_service = PaymentService(message.bot)
+        
+        payment_result = await payment_service.create_yookassa_sbp_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=settings.get_balance_payment_description(amount_kopeks),
+            receipt_email=None,
+            receipt_phone=None,
+            metadata={
+                "user_telegram_id": str(db_user.telegram_id),
+                "user_username": db_user.username or "",
+                "purpose": "balance_topup_sbp"
+            }
+        )
+        
+        if not payment_result:
+            await message.answer("❌ Ошибка создания платежа через СБП. Попробуйте позже или обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        confirmation_url = payment_result.get("confirmation_url")
+        qr_confirmation_data = payment_result.get("qr_confirmation_data")
+        
+        if not confirmation_url and not qr_confirmation_data:
+            await message.answer("❌ Ошибка получения данных для оплаты через СБП. Обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        # Подготовим QR-код для вставки в основное сообщение
+        qr_photo = None
+        if qr_confirmation_data:
+            try:
+                # Импортируем необходимые модули для генерации QR-кода
+                import base64
+                from io import BytesIO
+                import qrcode
+                from aiogram.types import BufferedInputFile
+                
+                # Создаем QR-код из полученных данных
+                qr = qrcode.QRCode(version=1, box_size=10, border=5)
+                qr.add_data(qr_confirmation_data)
+                qr.make(fit=True)
+                
+                img = qr.make_image(fill_color="black", back_color="white")
+                
+                # Сохраняем изображение в байты
+                img_bytes = BytesIO()
+                img.save(img_bytes, format='PNG')
+                img_bytes.seek(0)
+                
+                qr_photo = BufferedInputFile(img_bytes.getvalue(), filename="qrcode.png")
+            except ImportError:
+                logger.warning("qrcode библиотека не установлена, QR-код не будет сгенерирован")
+            except Exception as e:
+                logger.error(f"Ошибка генерации QR-кода: {e}")
+        
+        # Если нет QR-данных из YooKassa, но есть URL, генерируем QR-код из URL
+        if not qr_photo and confirmation_url:
+            try:
+                # Импортируем необходимые модули для генерации QR-кода
+                import base64
+                from io import BytesIO
+                import qrcode
+                from aiogram.types import BufferedInputFile
+                
+                # Создаем QR-код из URL
+                qr = qrcode.QRCode(version=1, box_size=10, border=5)
+                qr.add_data(confirmation_url)
+                qr.make(fit=True)
+                
+                img = qr.make_image(fill_color="black", back_color="white")
+                
+                # Сохраняем изображение в байты
+                img_bytes = BytesIO()
+                img.save(img_bytes, format='PNG')
+                img_bytes.seek(0)
+                
+                qr_photo = BufferedInputFile(img_bytes.getvalue(), filename="qrcode.png")
+            except ImportError:
+                logger.warning("qrcode библиотека не установлена, QR-код не будет сгенерирован")
+            except Exception as e:
+                logger.error(f"Ошибка генерации QR-кода из URL: {e}")
+        
+        # Создаем клавиатуру с кнопками для оплаты по ссылке и проверки статуса
+        keyboard_buttons = []
+
+        # Добавляем кнопку оплаты, если доступна ссылка
+        if confirmation_url:
+            keyboard_buttons.append([types.InlineKeyboardButton(text="🔗 Перейти к оплате", url=confirmation_url)])
+        else:
+            # Если ссылка недоступна, предлагаем оплатить через ID платежа в приложении банка
+            keyboard_buttons.append([types.InlineKeyboardButton(text="📱 Оплатить в приложении банка", callback_data="temp_disabled")])
+
+        # Добавляем общие кнопки
+        keyboard_buttons.append([types.InlineKeyboardButton(text="📊 Проверить статус", callback_data=f"check_yookassa_{payment_result['local_payment_id']}")])
+        keyboard_buttons.append([types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")])
+
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
+
+        state_data = await state.get_data()
+        prompt_message_id = state_data.get("yookassa_prompt_message_id")
+        prompt_chat_id = state_data.get("yookassa_prompt_chat_id", message.chat.id)
+
+        try:
+            await message.delete()
+        except Exception as delete_error:  # pragma: no cover - зависит от прав бота
+            logger.warning("Не удалось удалить сообщение с суммой YooKassa (СБП): %s", delete_error)
+
+        if prompt_message_id:
+            try:
+                await message.bot.delete_message(prompt_chat_id, prompt_message_id)
+            except Exception as delete_error:  # pragma: no cover - диагностический лог
+                logger.warning(
+                    "Не удалось удалить сообщение с запросом суммы YooKassa (СБП): %s",
+                    delete_error,
+                )
+
+        # Подготавливаем текст сообщения
+        message_text = (
+            f"🔗 <b>Оплата через СБП</b>\n\n"
+            f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
+            f"🆔 ID платежа: {payment_result['yookassa_payment_id'][:8]}...\n\n"
+        )
+
+        # Добавляем инструкции в зависимости от доступных способов оплаты
+        if not confirmation_url:
+            message_text += (
+                f"📱 <b>Инструкция по оплате:</b>\n"
+                f"1. Откройте приложение вашего банка\n"
+                f"2. Найдите функцию оплаты по реквизитам или перевод по СБП\n"
+                f"3. Введите ID платежа: <code>{payment_result['yookassa_payment_id']}</code>\n"
+                f"4. Подтвердите платеж в приложении банка\n"
+                f"5. Деньги поступят на баланс автоматически\n\n"
+            )
+
+        message_text += (
+            f"🔒 Оплата происходит через защищенную систему YooKassa\n"
+            f"✅ Принимаем СБП от всех банков-участников\n\n"
+            f"❓ Если возникнут проблемы, обратитесь в {settings.get_support_contact_display_html()}"
+        )
+
+        # Отправляем сообщение с инструкциями и клавиатурой
+        # Если есть QR-код, отправляем его как медиа-сообщение
+        if qr_photo:
+            # Используем метод отправки медиа-группы или фото с описанием
+            invoice_message = await message.answer_photo(
+                photo=qr_photo,
+                caption=message_text,
+                reply_markup=keyboard,
+                parse_mode="HTML"
+            )
+        else:
+            # Если QR-код недоступен, отправляем обычное текстовое сообщение
+            invoice_message = await message.answer(
+                message_text,
+                reply_markup=keyboard,
+                parse_mode="HTML"
+            )
+
+        try:
+            from app.services import payment_service as payment_module
+
+            payment = await payment_module.get_yookassa_payment_by_local_id(
+                db, payment_result["local_payment_id"]
+            )
+            if payment:
+                metadata = dict(getattr(payment, "metadata_json", {}) or {})
+                metadata["invoice_message"] = {
+                    "chat_id": invoice_message.chat.id,
+                    "message_id": invoice_message.message_id,
+                }
+                await db.execute(
+                    update(payment.__class__)
+                    .where(payment.__class__.id == payment.id)
+                    .values(metadata_json=metadata, updated_at=datetime.utcnow())
+                )
+                await db.commit()
+        except Exception as error:  # pragma: no cover - диагностический лог
+            logger.warning("Не удалось сохранить сообщение YooKassa (СБП): %s", error)
+
+        await state.update_data(
+            yookassa_invoice_message_id=invoice_message.message_id,
+            yookassa_invoice_chat_id=invoice_message.chat.id,
+        )
+
+        await state.clear()
+        logger.info(f"Создан платеж YooKassa СБП для пользователя {db_user.telegram_id}: "
+                   f"{amount_kopeks//100}₽, ID: {payment_result['yookassa_payment_id']}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания YooKassa СБП платежа: {e}")
+        await message.answer("❌ Ошибка создания платежа через СБП. Попробуйте позже или обратитесь в поддержку.")
+        await state.clear()
+
+
+
+
+
+@error_handler
+async def check_yookassa_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        
+        from app.database.crud.yookassa import get_yookassa_payment_by_local_id
+        payment = await get_yookassa_payment_by_local_id(db, local_payment_id)
+        
+        if not payment:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+        
+        status_emoji = {
+            "pending": "⏳",
+            "waiting_for_capture": "⌛",
+            "succeeded": "✅",
+            "canceled": "❌",
+            "failed": "❌"
+        }
+        
+        status_text = {
+            "pending": "Ожидает оплаты",
+            "waiting_for_capture": "Ожидает подтверждения",
+            "succeeded": "Оплачен",
+            "canceled": "Отменен",
+            "failed": "Ошибка"
+        }
+        
+        emoji = status_emoji.get(payment.status, "❓")
+        status = status_text.get(payment.status, "Неизвестно")
+        
+        message_text = (f"💳 Статус платежа:\n\n"
+                       f"🆔 ID: {payment.yookassa_payment_id[:8]}...\n"
+                       f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n"
+                       f"📊 Статус: {emoji} {status}\n"
+                       f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n")
+        
+        if payment.is_succeeded:
+            message_text += "\n✅ Платеж успешно завершен!\n\nСредства зачислены на баланс."
+        elif payment.is_pending:
+            message_text += "\n⏳ Платеж ожидает оплаты. Нажмите кнопку 'Оплатить' выше."
+        elif payment.is_failed:
+            message_text += (
+                f"\n❌ Платеж не прошел. Обратитесь в {settings.get_support_contact_display()}"
+            )
+        
+        await callback.answer(message_text, show_alert=True)
+        
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса платежа: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
@@ -0,0 +1,256 @@
+import asyncio
+import logging
+from datetime import datetime
+
+from aiogram import Dispatcher, F, types
+from aiogram.exceptions import TelegramBadRequest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.poll import (
+    get_poll_response_by_id,
+    record_poll_answer,
+)
+from app.database.models import PollQuestion, User
+from app.localization.texts import get_texts
+from app.services.poll_service import get_next_question, get_question_option, reward_user_for_poll
+
+logger = logging.getLogger(__name__)
+
+
+async def _delete_message_later(bot, chat_id: int, message_id: int, delay: int = 10) -> None:
+    try:
+        await asyncio.sleep(delay)
+        await bot.delete_message(chat_id, message_id)
+    except Exception as error:  # pragma: no cover - cleanup best effort
+        logger.debug("Не удалось удалить сообщение опроса %s: %s", message_id, error)
+
+
+async def _render_question_text(
+    poll_title: str,
+    question: PollQuestion,
+    current_index: int,
+    total: int,
+    language: str,
+) -> str:
+    texts = get_texts(language)
+    header = texts.t("POLL_QUESTION_HEADER", "<b>Вопрос {current}/{total}</b>").format(
+        current=current_index,
+        total=total,
+    )
+    lines = [f"🗳️ <b>{poll_title}</b>", "", header, "", question.text]
+    return "\n".join(lines)
+
+
+async def _update_poll_message(
+    message: types.Message,
+    text: str,
+    *,
+    reply_markup: types.InlineKeyboardMarkup | None = None,
+    parse_mode: str | None = "HTML",
+) -> bool:
+    try:
+        await message.edit_text(
+            text,
+            reply_markup=reply_markup,
+            parse_mode=parse_mode,
+        )
+        return True
+    except TelegramBadRequest as error:
+        error_text = str(error).lower()
+        if "message is not modified" in error_text:
+            logger.debug(
+                "Опросное сообщение уже актуально, пропускаем обновление: %s",
+                error,
+            )
+            return True
+
+        logger.warning(
+            "Не удалось обновить сообщение опроса %s: %s",
+            message.message_id,
+            error,
+        )
+    except Exception as error:  # pragma: no cover - defensive logging
+        logger.exception(
+            "Непредвиденная ошибка при обновлении сообщения опроса %s: %s",
+            message.message_id,
+            error,
+        )
+
+    return False
+
+
+def _build_options_keyboard(response_id: int, question: PollQuestion) -> types.InlineKeyboardMarkup:
+    buttons: list[list[types.InlineKeyboardButton]] = []
+    for option in sorted(question.options, key=lambda o: o.order):
+        buttons.append(
+            [
+                types.InlineKeyboardButton(
+                    text=option.text,
+                    callback_data=f"poll_answer:{response_id}:{question.id}:{option.id}",
+                )
+            ]
+        )
+    return types.InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
+async def handle_poll_start(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    try:
+        response_id = int(callback.data.split(":")[1])
+    except (IndexError, ValueError):
+        await callback.answer("❌ Опрос не найден", show_alert=True)
+        return
+
+    response = await get_poll_response_by_id(db, response_id)
+    if not response or response.user_id != db_user.id:
+        await callback.answer("❌ Опрос не найден", show_alert=True)
+        return
+
+    texts = get_texts(db_user.language)
+
+    if response.completed_at:
+        await callback.answer(texts.t("POLL_ALREADY_COMPLETED", "Вы уже прошли этот опрос."), show_alert=True)
+        return
+
+    if not response.poll or not response.poll.questions:
+        await callback.answer(texts.t("POLL_EMPTY", "Опрос пока недоступен."), show_alert=True)
+        return
+
+    if not response.started_at:
+        response.started_at = datetime.utcnow()
+        await db.commit()
+
+    index, question = await get_next_question(response)
+    if not question:
+        await callback.answer(texts.t("POLL_ERROR", "Не удалось загрузить вопросы."), show_alert=True)
+        return
+
+    question_text = await _render_question_text(
+        response.poll.title,
+        question,
+        index,
+        len(response.poll.questions),
+        db_user.language,
+    )
+
+    if not await _update_poll_message(
+        callback.message,
+        question_text,
+        reply_markup=_build_options_keyboard(response.id, question),
+    ):
+        await callback.answer(texts.t("POLL_ERROR", "Не удалось показать вопрос."), show_alert=True)
+        return
+    await callback.answer()
+
+
+async def handle_poll_answer(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+):
+    try:
+        _, response_id, question_id, option_id = callback.data.split(":", 3)
+        response_id = int(response_id)
+        question_id = int(question_id)
+        option_id = int(option_id)
+    except (ValueError, IndexError):
+        await callback.answer("❌ Некорректные данные", show_alert=True)
+        return
+
+    response = await get_poll_response_by_id(db, response_id)
+    texts = get_texts(db_user.language)
+
+    if not response or response.user_id != db_user.id:
+        await callback.answer("❌ Опрос не найден", show_alert=True)
+        return
+
+    if not response.poll:
+        await callback.answer(texts.t("POLL_ERROR", "Опрос недоступен."), show_alert=True)
+        return
+
+    if response.completed_at:
+        await callback.answer(texts.t("POLL_ALREADY_COMPLETED", "Вы уже прошли этот опрос."), show_alert=True)
+        return
+
+    question = next((q for q in response.poll.questions if q.id == question_id), None)
+    if not question:
+        await callback.answer(texts.t("POLL_ERROR", "Вопрос не найден."), show_alert=True)
+        return
+
+    option = await get_question_option(question, option_id)
+    if not option:
+        await callback.answer(texts.t("POLL_ERROR", "Вариант ответа не найден."), show_alert=True)
+        return
+
+    await record_poll_answer(
+        db,
+        response_id=response.id,
+        question_id=question.id,
+        option_id=option.id,
+    )
+
+    try:
+        await db.refresh(response, attribute_names=["answers"])
+    except Exception as error:  # pragma: no cover - defensive cache busting
+        logger.debug(
+            "Не удалось обновить локальные ответы опроса %s: %s",
+            response.id,
+            error,
+        )
+        response = await get_poll_response_by_id(db, response.id)
+        if not response:
+            await callback.answer(texts.t("POLL_ERROR", "Опрос недоступен."), show_alert=True)
+            return
+    index, next_question = await get_next_question(response)
+
+    if next_question:
+        question_text = await _render_question_text(
+            response.poll.title,
+            next_question,
+            index,
+            len(response.poll.questions),
+            db_user.language,
+        )
+        if not await _update_poll_message(
+            callback.message,
+            question_text,
+            reply_markup=_build_options_keyboard(response.id, next_question),
+        ):
+            await callback.answer(texts.t("POLL_ERROR", "Не удалось показать вопрос."), show_alert=True)
+            return
+        await callback.answer()
+        return
+
+    response.completed_at = datetime.utcnow()
+    await db.commit()
+
+    reward_amount = await reward_user_for_poll(db, response)
+
+    thanks_lines = [texts.t("POLL_COMPLETED", "🙏 Спасибо за участие в опросе!")]
+    if reward_amount:
+        thanks_lines.append(
+            texts.t(
+                "POLL_REWARD_GRANTED",
+                "Награда {amount} зачислена на ваш баланс.",
+            ).format(amount=settings.format_price(reward_amount))
+        )
+
+    if not await _update_poll_message(
+        callback.message,
+        "\n\n".join(thanks_lines),
+    ):
+        await callback.answer(texts.t("POLL_COMPLETED", "🙏 Спасибо за участие в опросе!"))
+        return
+    asyncio.create_task(
+        _delete_message_later(callback.bot, callback.message.chat.id, callback.message.message_id)
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(handle_poll_start, F.data.startswith("poll_start:"))
+    dp.callback_query.register(handle_poll_answer, F.data.startswith("poll_answer:"))
@@ -1,14 +1,14 @@
 import logging
-from aiogram import Dispatcher, types, F
+from aiogram import Dispatcher, types, F, Bot
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
 from app.states import PromoCodeStates
 from app.database.models import User
 from app.keyboards.inline import get_back_keyboard
 from app.localization.texts import get_texts
 from app.services.promocode_service import PromoCodeService
+from app.services.admin_notification_service import AdminNotificationService
 from app.utils.decorators import error_handler

 logger = logging.getLogger(__name__)
@@ -31,6 +31,47 @@ async def show_promocode_menu(
    await callback.answer()


+async def activate_promocode_for_registration(
+    db: AsyncSession,
+    user_id: int,
+    code: str,
+    bot: Bot = None
+) -> dict:
+    """
+    Активирует промокод для пользователя во время регистрации.
+    Возвращает результат активации без отправки сообщений.
+    """
+    promocode_service = PromoCodeService()
+    result = await promocode_service.activate_promocode(db, user_id, code)
+
+    if result["success"]:
+        logger.info(f"✅ Пользователь {user_id} активировал промокод {code} при регистрации")
+
+        # Отправляем уведомление админу, если бот доступен
+        if bot:
+            try:
+                from app.database.crud.user import get_user_by_id
+                user = await get_user_by_id(db, user_id)
+                if user:
+                    notification_service = AdminNotificationService(bot)
+                    await notification_service.send_promocode_activation_notification(
+                        db,
+                        user,
+                        result.get("promocode", {"code": code}),
+                        result["description"],
+                        result.get("balance_before_kopeks"),
+                        result.get("balance_after_kopeks"),
+                    )
+            except Exception as notify_error:
+                logger.error(
+                    "Ошибка отправки админ уведомления об активации промокода %s: %s",
+                    code,
+                    notify_error,
+                )
+
+    return result
+
+
@error_handler
 async def process_promocode(
    message: types.Message,
@@ -39,9 +80,9 @@ async def process_promocode(
    db: AsyncSession
 ):
    texts = get_texts(db_user.language)
-    
+
    code = message.text.strip()
-    
+
    if not code:
        await message.answer(
            texts.t(
@@ -51,16 +92,14 @@ async def process_promocode(
            reply_markup=get_back_keyboard(db_user.language)
        )
        return
-    
-    promocode_service = PromoCodeService()
-    result = await promocode_service.activate_promocode(db, db_user.id, code)
-    
+
+    result = await activate_promocode_for_registration(db, db_user.id, code, message.bot)
+
    if result["success"]:
        await message.answer(
            texts.PROMOCODE_SUCCESS.format(description=result["description"]),
            reply_markup=get_back_keyboard(db_user.language)
        )
-        logger.info(f"✅ Пользователь {db_user.telegram_id} активировал промокод {code}")
    else:
        error_messages = {
            "not_found": texts.PROMOCODE_INVALID,
@@ -69,13 +108,13 @@ async def process_promocode(
            "already_used_by_user": texts.PROMOCODE_USED,
            "server_error": texts.ERROR
        }
-        
+
        error_text = error_messages.get(result["error"], texts.PROMOCODE_INVALID)
        await message.answer(
            error_text,
            reply_markup=get_back_keyboard(db_user.language)
        )
-    
+
    await state.clear()


@@ -14,6 +14,7 @@ from app.localization.texts import get_texts
 from app.utils.photo_message import edit_or_answer_photo
 from app.utils.user_utils import (
    get_detailed_referral_list,
+    get_effective_referral_commission_percent,
    get_referral_analytics,
    get_user_referral_summary,
 )
@@ -86,7 +87,7 @@ async def show_referral_info(
        + texts.t(
            "REFERRAL_REWARD_COMMISSION",
            "• Комиссия с каждого пополнения реферала: <b>{percent}%</b>",
-        ).format(percent=settings.REFERRAL_COMMISSION_PERCENT)
+        ).format(percent=get_effective_referral_commission_percent(db_user))
        + "\n\n"
        + texts.t("REFERRAL_LINK_TITLE", "🔗 <b>Ваша реферальная ссылка:</b>")
        + f"\n<code>{referral_link}</code>\n\n"
@@ -1,8 +1,10 @@
 import logging
+from decimal import Decimal, ROUND_HALF_UP
 from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.database.models import User
+from app.config import settings
 from app.services.payment_service import PaymentService
 from app.external.telegram_stars import TelegramStarsService
 from app.database.crud.user import get_user_by_telegram_id
@@ -16,9 +18,11 @@ async def handle_pre_checkout_query(query: types.PreCheckoutQuery):
    texts = get_texts(DEFAULT_LANGUAGE)

    try:
-        logger.info(f"📋 Pre-checkout query от {query.from_user.id}: {query.total_amount} XTR, payload: {query.invoice_payload}")
+        logger.info(
+            f"📋 Pre-checkout query от {query.from_user.id}: {query.total_amount} XTR, payload: {query.invoice_payload}"
+        )

-        allowed_prefixes = ("balance_", "admin_stars_test_")
+        allowed_prefixes = ("balance_", "admin_stars_test_", "simple_sub_")

        if not query.invoice_payload or not query.invoice_payload.startswith(allowed_prefixes):
            logger.warning(f"Невалидный payload: {query.invoice_payload}")
@@ -33,6 +37,7 @@ async def handle_pre_checkout_query(query: types.PreCheckoutQuery):

        try:
            from app.database.database import get_db
+
            async for db in get_db():
                user = await get_user_by_telegram_id(db, query.from_user.id)
                if not user:
@@ -75,6 +80,7 @@ async def handle_pre_checkout_query(query: types.PreCheckoutQuery):
 async def handle_successful_payment(
    message: types.Message,
    db: AsyncSession,
+    state: FSMContext,
    **kwargs
 ):
    texts = get_texts(DEFAULT_LANGUAGE)
@@ -104,6 +110,27 @@ async def handle_successful_payment(
            return

        payment_service = PaymentService(message.bot)
+
+        state_data = await state.get_data()
+        prompt_message_id = state_data.get("stars_prompt_message_id")
+        prompt_chat_id = state_data.get("stars_prompt_chat_id", message.chat.id)
+        invoice_message_id = state_data.get("stars_invoice_message_id")
+        invoice_chat_id = state_data.get("stars_invoice_chat_id", message.chat.id)
+
+        for chat_id, message_id, label in [
+            (prompt_chat_id, prompt_message_id, "запрос суммы"),
+            (invoice_chat_id, invoice_message_id, "инвойс Stars"),
+        ]:
+            if message_id:
+                try:
+                    await message.bot.delete_message(chat_id, message_id)
+                except Exception as delete_error:  # pragma: no cover - зависит от прав бота
+                    logger.warning(
+                        "Не удалось удалить сообщение %s после оплаты Stars: %s",
+                        label,
+                        delete_error,
+                    )
+
        success = await payment_service.process_stars_payment(
            db=db,
            user_id=user.id,
@@ -111,9 +138,18 @@ async def handle_successful_payment(
            payload=payment.invoice_payload,
            telegram_payment_charge_id=payment.telegram_payment_charge_id
        )
-        
+
+        await state.update_data(
+            stars_prompt_message_id=None,
+            stars_prompt_chat_id=None,
+            stars_invoice_message_id=None,
+            stars_invoice_chat_id=None,
+        )
+
        if success:
            rubles_amount = TelegramStarsService.calculate_rubles_from_stars(payment.total_amount)
+            amount_kopeks = int((rubles_amount * Decimal(100)).to_integral_value(rounding=ROUND_HALF_UP))
+            amount_text = settings.format_price(amount_kopeks).replace(" ₽", "")

            keyboard = await payment_service.build_topup_success_keyboard(user)

@@ -126,10 +162,14 @@ async def handle_successful_payment(
                    "⭐ Потрачено звезд: {stars_spent}\n"
                    "💰 Зачислено на баланс: {amount} ₽\n"
                    "🆔 ID транзакции: {transaction_id}...\n\n"
+                    "⚠️ <b>Важно:</b> Пополнение баланса не активирует подписку автоматически. "
+                    "Обязательно активируйте подписку отдельно!\n\n"
+                    "🔄 При наличии сохранённой корзины подписки и включенной автопокупке, "
+                    "подписка будет приобретена автоматически после пополнения баланса.\n\n"
                    "Спасибо за пополнение! 🚀",
                ).format(
                    stars_spent=payment.total_amount,
-                    amount=int(rubles_amount),
+                    amount=amount_text,
                    transaction_id=transaction_id_short,
                ),
                parse_mode="HTML",
@@ -137,8 +177,10 @@ async def handle_successful_payment(
            )

            logger.info(
-                f"✅ Stars платеж успешно обработан: "
-                f"пользователь {user.id}, {payment.total_amount} звезд → {int(rubles_amount)}₽"
+                "✅ Stars платеж успешно обработан: пользователь %s, %s звезд → %s",
+                user.id,
+                payment.total_amount,
+                settings.format_price(amount_kopeks),
            )
        else:
            logger.error(f"Ошибка обработки Stars платежа для пользователя {user.id}")
@@ -162,15 +204,15 @@ async def handle_successful_payment(


 def register_stars_handlers(dp: Dispatcher):
-    
+
    dp.pre_checkout_query.register(
        handle_pre_checkout_query,
-        F.currency == "XTR" 
+        F.currency == "XTR"
    )
-    
+
    dp.message.register(
        handle_successful_payment,
        F.successful_payment
    )
-    
+
    logger.info("🌟 Зарегистрированы обработчики Telegram Stars платежей")
--- a/Show More
+++ b/Show More