Merge pull request #104 from machka-pasla/dev

Added freekassa, HWID Devices managment, mandatory sub to channel

.dockerignore

@@ -0,0 +1,92 @@
+# Git
+.git
+.gitignore
+.github
+.gitattributes
+LICENSE
+README.md
+
+
+# CI
+.codeclimate.yml
+.travis.yml
+.taskcluster.yml
+
+# Docker
+docker-compose.yml
+Dockerfile
+.docker
+.dockerignore
+
+# Byte-compiled / optimized / DLL files
+**/__pycache__/
+**/*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.cache
+nosetests.xml
+coverage.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Virtual environment
+.env*
+.venv/
+venv/
+
+# PyCharm
+.idea
+
+# Python mode for VIM
+.ropeproject
+**/.ropeproject
+
+# Vim swap files
+**/*.swp
+
+# VS Code
+.vscode/

.env.example

@@ -1,55 +1,68 @@
 # Telegram Bot Token and Admin IDs
-BOT_TOKEN=your_bot_token_here
-ADMIN_IDS=comma_separated_admin_ids
+BOT_TOKEN=your_bot_token_here                                                 # Telegram bot token
+ADMIN_IDS=comma_separated_admin_ids                                           # Your telegram ID
 
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres
-POSTGRES_HOST=remnawave-tg-shop-db
-POSTGRES_PORT=5432
-POSTGRES_DB=postgres
+# PostgreSQL Database Connection Settings
+POSTGRES_USER=postgres                                                        # Database user name
+POSTGRES_PASSWORD=postgres                                                    # Database password
+POSTGRES_HOST=remnawave-tg-shop-db                                            # Database container name
+POSTGRES_PORT=5432                                                            # Port
+POSTGRES_DB=postgres                                                          # Database name
 
 # Localization and Display
-DEFAULT_LANGUAGE="ru"          # or "en"
-DEFAULT_CURRENCY_SYMBOL="RUB"  # e.g., RUB, USD, EUR
+DEFAULT_LANGUAGE="ru"                                                         # or "en"
+DEFAULT_CURRENCY_SYMBOL="RUB"                                                 # e.g., RUB, USD, EUR
 
 # External Links
-SUPPORT_LINK=https://t.me/your_support_link
-SERVER_STATUS_URL=https://status.yourdomain.tld/status/your_service
-TERMS_OF_SERVICE_URL=https://example.com/tos
-SUBSCRIPTION_MINI_APP_URL=
-START_COMMAND_DESCRIPTION=
-DISABLE_WELCOME_MESSAGE=
+SUPPORT_LINK=https://t.me/your_support_link                                   # Link to the support chat
+SERVER_STATUS_URL=https://status.yourdomain.tld/status/your_service           # Link to the server status page
+TERMS_OF_SERVICE_URL=https://example.com/tos                                  # Link to the terms of service
+SUBSCRIPTION_MINI_APP_URL=                                                    # URL of the subscription mini-app 
+START_COMMAND_DESCRIPTION=                                                    # Description of the /start command
+DISABLE_WELCOME_MESSAGE=                                                      # Disable the welcome message
+MY_DEVICES_SECTION_ENABLED=False                                              # Enable the My Devices section in the subscription menu
+USER_HWID_DEVICE_LIMIT=0                                                      # Default HWID/device limit for panel users (0 = unlimited)
+
+# Required channel subscription
+REQUIRED_CHANNEL_ID=                                                          # Telegram channel ID (e.g. -1001234567890) the user must join
+REQUIRED_CHANNEL_LINK=https://t.me/your_channel                               # Optional: public link/invite button text opens
 
 # Webhook Base URL (used for Telegram and payment providers)
 WEBHOOK_BASE_URL=https://webhooks.yourdomain.tld
 
+# Payment Method Toggles
+YOOKASSA_ENABLED=True                                                         # Turn on YOOKASSA
+FREEKASSA_ENABLED=True                                                        # Turn on FreeKassa
+STARS_ENABLED=True                                                            # Turn on STARS
+TRIBUTE_ENABLED=True                                                          # Turn on TRIBUTE
+CRYPTOPAY_ENABLED=True                                                        # Turn on CRYPTOPAY
+
 # YooKassa Payment Gateway Configuration
-YOOKASSA_SHOP_ID=your_shop_id
-YOOKASSA_SECRET_KEY=your_secret_key
-YOOKASSA_RETURN_URL=https://t.me/your_bot
-YOOKASSA_DEFAULT_RECEIPT_EMAIL=your_email@example.com
-YOOKASSA_VAT_CODE=1
-YOOKASSA_PAYMENT_MODE=full_prepayment
-YOOKASSA_PAYMENT_SUBJECT=payment
+YOOKASSA_SHOP_ID=your_shop_id                                                 # Your store ID in YooKassa
+YOOKASSA_SECRET_KEY=your_secret_key                                           # Your secret key for YooKassa
+YOOKASSA_RETURN_URL=https://t.me/your_bot                                     # URL to which the user will be returned after payment  
+YOOKASSA_DEFAULT_RECEIPT_EMAIL=your_email@example.com                         # Default email for sending receipts
+YOOKASSA_VAT_CODE=1                                                           # VAT code
+YOOKASSA_AUTOPAYMENTS_ENABLED=False                                           # Auto-renew toggle
+
+# FreeKassa Payment Gateway Configuration
+FREEKASSA_MERCHANT_ID=your_shop_id                                            # Your shop ID in FreeKassa
+FREEKASSA_API_KEY=your_api_key                                                # API key for REST requests
+FREEKASSA_SECOND_SECRET=your_second_secret                                    # Secret word #2 (used to verify notifications)
+FREEKASSA_PAYMENT_IP=                                                         # Public IP address reported to FreeKassa
 
 # CryptoBot Payment Gateway Configuration
-CRYPTOPAY_TOKEN=
-CRYPTOPAY_NETWORK=mainnet
-CRYPTOPAY_CURRENCY_TYPE=fiat
-CRYPTOPAY_ASSET=RUB
+CRYPTOPAY_TOKEN=                                                              # API token for CryptoPay
+CRYPTOPAY_NETWORK=mainnet                                                     # Network (mainnet or testnet)
+CRYPTOPAY_CURRENCY_TYPE=fiat                                                  # Currency type (fiat or crypto)
+CRYPTOPAY_ASSET=RUB                                                           # Asset, e.g., RUB, BTC, USDT
 
 # Tribute Payment Gateway Configuration
-TRIBUTE_API_KEY=                                    # API key for verifying Tribute webhook signatures
-TRIBUTE_SKIP_NOTIFICATIONS=True                     # Skip renewal notifications for Tribute payments
-TRIBUTE_SKIP_CANCELLATION_NOTIFICATIONS=False      # Skip cancellation notifications for Tribute payments
+TRIBUTE_API_KEY=                                                              # API key for verifying Tribute webhook signatures
+TRIBUTE_SKIP_NOTIFICATIONS=True                                               # Skip renewal notifications for Tribute payments
+TRIBUTE_SKIP_CANCELLATION_NOTIFICATIONS=False                                 # Skip cancellation notifications for Tribute payments
 
-# Payment Method Toggles
-YOOKASSA_ENABLED=True
-STARS_ENABLED=True
-TRIBUTE_ENABLED=True
-CRYPTOPAY_ENABLED=True
-
-# Subscription Options
+# Subscription Options. Specify cost parameters or payment links here.
 1_MONTH_ENABLED=True
 RUB_PRICE_1_MONTH=150
 STARS_PRICE_1_MONTH=0
@@ -71,59 +84,61 @@ STARS_PRICE_12_MONTHS=0
 TRIBUTE_LINK_12_MONTHS=
 
 # Subscription Notifications
-SUBSCRIPTION_NOTIFICATIONS_ENABLED=True
-SUBSCRIPTION_NOTIFY_ON_EXPIRE=True
-SUBSCRIPTION_NOTIFY_AFTER_EXPIRE=True
-SUBSCRIPTION_NOTIFY_DAYS_BEFORE=3
+SUBSCRIPTION_NOTIFICATIONS_ENABLED=True                                     # Enable subscription
+SUBSCRIPTION_NOTIFY_ON_EXPIRE=True                                          # Notify on subscription
+SUBSCRIPTION_NOTIFY_AFTER_EXPIRE=True                                       # Notify after
+SUBSCRIPTION_NOTIFY_DAYS_BEFORE=3                                           # Days before expiration to notify
 
 
-REFERRAL_ONE_BONUS_PER_REFEREE=False
+REFERRAL_ONE_BONUS_PER_REFEREE=False                                        # Give a bonus only once per referee
 # Referral Bonus Days
+# Bonus for the inviting user
 REFERRAL_BONUS_DAYS_1_MONTH=3
 REFERRAL_BONUS_DAYS_3_MONTHS=7
 REFERRAL_BONUS_DAYS_6_MONTHS=15
 REFERRAL_BONUS_DAYS_12_MONTHS=30
+# Invited User Bonus
 REFEREE_BONUS_DAYS_1_MONTH=1
 REFEREE_BONUS_DAYS_3_MONTHS=3
 REFEREE_BONUS_DAYS_6_MONTHS=7
 REFEREE_BONUS_DAYS_12_MONTHS=15
 
 # Panel API Configuration
-PANEL_API_URL=http://your_panel_api_url/api
-PANEL_API_KEY=your_panel_api_key
-PANEL_WEBHOOK_SECRET=   # secret used to verify panel webhook signatures
+PANEL_API_URL=http://your_panel_api_url/api                                 # URL of the panel API
+PANEL_API_KEY=your_panel_api_key                                            # Panel API key
+PANEL_WEBHOOK_SECRET=                                                       # secret used to verify panel webhook signatures
 
 # User traffic limits (applied for all users)
 # 0 means unlimited
-USER_TRAFFIC_LIMIT_GB=0
-USER_TRAFFIC_STRATEGY="NO_RESET"
+USER_TRAFFIC_LIMIT_GB=0                                                     # Traffic limit for users (0 unlimited)
+USER_TRAFFIC_STRATEGY="NO_RESET"                                            # Traffic reset strategy (NO_RESET, WEEK, MONTH)
 
 # Default Internal Squads for Users (Optional, comma-separated UUIDs)
 USER_SQUAD_UUIDS=uuid1,uuid2,uuid3
 
 # Trial Settings
-TRIAL_ENABLED=True
-TRIAL_DURATION_DAYS=5
-TRIAL_TRAFFIC_LIMIT_GB=0        # 0 for unlimited
-TRIAL_TRAFFIC_STRATEGY="NO_RESET"
+TRIAL_ENABLED=True                                                          # Enable the trial period
+TRIAL_DURATION_DAYS=5                                                       # Duration of the trial period in days
+TRIAL_TRAFFIC_LIMIT_GB=0                                                    # Traffic limit for the trial period (0 = unlimited)
+TRIAL_TRAFFIC_STRATEGY="NO_RESET"                                           # Traffic reset strategy for the trial period (NO_RESET, WEEK, MONTH)
 
 # Web Server Settings (for handling webhooks)
 WEB_SERVER_HOST="0.0.0.0"
 WEB_SERVER_PORT=8080
 
 # Admin Panel Log Pagination
-LOGS_PAGE_SIZE=10
+LOGS_PAGE_SIZE=10                                                           # Number of events in the log
 
 # Admin Logging Configuration
-LOG_CHAT_ID=-1001234567890      # Telegram chat/group ID for admin notifications
-LOG_THREAD_ID=                  # Optional: Thread ID for supergroup messages
-LOG_NEW_USERS=True
-LOG_PAYMENTS=True
-LOG_PROMO_ACTIVATIONS=True
-LOG_TRIAL_ACTIVATIONS=True
-LOG_SUSPICIOUS_ACTIVITY=True
+LOG_CHAT_ID=-1001234567890                                                  # Telegram chat/group ID for admin notifications
+LOG_THREAD_ID=                                                              # Optional: Thread ID for supergroup messages
+LOG_NEW_USERS=True                                                          # Log new user registrations
+LOG_PAYMENTS=True                                                           # Log payments
+LOG_PROMO_ACTIVATIONS=True                                                  # Log promo code activations
+LOG_TRIAL_ACTIVATIONS=True                                                  # Log trial activations
+LOG_SUSPICIOUS_ACTIVITY=True                                                # Log suspicious activity
 
-# Inline Mode Thumbnails
+# Embedded mode thumbnails. Please don't touch this if you don't know what it is.
 INLINE_REFERRAL_THUMBNAIL_URL=https://cdn-icons-png.flaticon.com/512/1077/1077114.png
 INLINE_USER_STATS_THUMBNAIL_URL=https://cdn-icons-png.flaticon.com/512/681/681494.png
 INLINE_FINANCIAL_STATS_THUMBNAIL_URL=https://cdn-icons-png.flaticon.com/512/2769/2769339.png

.gitignore

@@ -14,3 +14,6 @@ __pycache__/
 # Игнорировать Docker артефакты (если вдруг)
 *.log
 *.pid
+locales/ru_backup.json
+locales/en_backup.json
+db/models_old.py

LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 machka-pasla
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -7,10 +7,11 @@
 ### Для пользователей:
 -   **Регистрация и выбор языка:** Поддержка русского и английского языков.
 -   **Просмотр подписки:** Пользователи могут видеть статус своей подписки, дату окончания и ссылку на конфигурацию.
+-   **Мои устройства:** Опциональный раздел для просмотра и отключения подключенных устройств (активируется через переменную `MY_DEVICES_SECTION_ENABLED`).
 -   **Пробная подписка:** Система пробных подписок для новых пользователей (активируется вручную по кнопке).
 -   **Промокоды:** Возможность применять промокоды для получения скидок или бонусных дней.
 -   **Реферальная программа:** Пользователи могут приглашать друзей и получать за это бонусные дни подписки.
--   **Оплата:** Поддержка оплаты через YooKassa, CryptoPay, Telegram Stars и Tribute.
+-   **Оплата:** Поддержка оплаты через YooKassa, FreeKassa (REST API), CryptoPay, Telegram Stars и Tribute.
 
 ### Для администраторов:
 -   **Защищенная админ-панель:** Доступ только для администраторов, указанных в `ADMIN_IDS`.
@@ -27,7 +28,7 @@
 -   **Aiogram 3.x:** Асинхронный фреймворк для Telegram ботов.
 -   **aiohttp:** Для запуска веб-сервера (вебхуки).
 -   **SQLAlchemy 2.x & asyncpg:** Асинхронная работа с базой данных PostgreSQL.
--   **YooKassa, aiocryptopay:** SDK для интеграции с платежными системами.
+-   **YooKassa, FreeKassa API, aiocryptopay:** Интеграции с платежными системами.
 -   **Pydantic:** Для управления настройками из `.env` файла.
 -   **Docker & Docker Compose:** Для контейнеризации и развертывания.
 
@@ -66,6 +67,9 @@
     | `DEFAULT_LANGUAGE` | Язык по умолчанию для новых пользователей. | `ru` |
     | `SUPPORT_LINK` | (Опционально) Ссылка на поддержку. | `https://t.me/your_support` |
     | `SUBSCRIPTION_MINI_APP_URL` | (Опционально) URL Mini App для показа подписки. | `https://t.me/your_bot/app` |
+    | `MY_DEVICES_SECTION_ENABLED` | Включить раздел «Мои устройства» в меню подписки (`true`/`false`). | `false` |
+    | `REQUIRED_CHANNEL_ID` | (Опционально) ID канала, на который пользователь должен подписаться перед использованием. Оставьте пустым, если проверка не нужна. | `-1001234567890` |
+    | `REQUIRED_CHANNEL_LINK` | (Опционально) Публичная ссылка или invite на канал для кнопки «Проверить подписку». | `https://t.me/your_channel` |
     </details>
 
     <details>
@@ -81,6 +85,12 @@
     | `YOOKASSA_SECRET_KEY`| Секретный ключ магазина YooKassa. |
     | `CRYPTOPAY_ENABLED` | Включить/выключить CryptoPay (`true`/`false`). |
     | `CRYPTOPAY_TOKEN` | Токен из вашего CryptoPay App. |
+    | `FREEKASSA_ENABLED` | Включить/выключить FreeKassa (`true`/`false`). |
+    | `FREEKASSA_MERCHANT_ID` | ID вашего магазина в FreeKassa. |
+    | `FREEKASSA_API_KEY` | API-ключ для запросов к FreeKassa REST API. |
+    | `FREEKASSA_SECOND_SECRET` | Секретное слово №2 — используется для проверки уведомлений от FreeKassa. |
+    | `FREEKASSA_PAYMENT_URL` | (Опционально, legacy SCI) Базовый URL платёжной формы FreeKassa. По умолчанию `https://pay.freekassa.ru/`. |
+    | `FREEKASSA_PAYMENT_IP` | Внешний IP вашего сервера, который будет передаваться в запрос оплаты. |
     | `STARS_ENABLED` | Включить/выключить Telegram Stars (`true`/`false`). |
     | `TRIBUTE_ENABLED`| Включить/выключить Tribute (`true`/`false`). |
     </details>
@@ -106,6 +116,9 @@
     | `PANEL_WEBHOOK_SECRET`| Секретный ключ для проверки вебхуков от панели. |
     | `USER_SQUAD_UUIDS` | ID отрядов для новых пользователей. |
     | `USER_TRAFFIC_LIMIT_GB`| Лимит трафика в ГБ (0 - безлимит). |
+    | `USER_HWID_DEVICE_LIMIT`| Лимит устройств (HWID) для новых пользователей (0 - безлимит). |
+
+    > Раздел "Мои устройства" становится доступен пользователям только при включении `MY_DEVICES_SECTION_ENABLED`. Значение лимита устройств при создании записей в панели берётся из `USER_HWID_DEVICE_LIMIT`.
     </gidetails>
 
     <details>
@@ -125,12 +138,13 @@
     Эта команда скачает образ и запустит сервис в фоновом режиме.
 
 4.  **Настройка вебхуков (Обязательно):**
-    Вебхуки являются **обязательным** компонентом для работы бота, так как они используются для получения уведомлений от платежных систем (YooKassa, CryptoPay, Tribute) и панели Remnawave.
+    Вебхуки являются **обязательным** компонентом для работы бота, так как они используются для получения уведомлений от платежных систем (YooKassa, FreeKassa, CryptoPay, Tribute) и панели Remnawave.
 
     Вам понадобится обратный прокси (например, Nginx) для обработки HTTPS-трафика и перенаправления запросов на контейнер с ботом.
 
     **Пути для перенаправления:**
     -   `https://<ваш_домен>/webhook/yookassa` → `http://remnawave-tg-shop:<WEB_SERVER_PORT>/webhook/yookassa`
+    -   `https://<ваш_домен>/webhook/freekassa` → `http://remnawave-tg-shop:<WEB_SERVER_PORT>/webhook/freekassa`
     -   `https://<ваш_домен>/webhook/cryptopay` → `http://remnawave-tg-shop:<WEB_SERVER_PORT>/webhook/cryptopay`
     -   `https://<ваш_домен>/webhook/tribute` → `http://remnawave-tg-shop:<WEB_SERVER_PORT>/webhook/tribute`
     -   `https://<ваш_домен>/webhook/panel` → `http://remnawave-tg-shop:<WEB_SERVER_PORT>/webhook/panel`
@@ -143,6 +157,8 @@
     docker compose logs -f remnawave-tg-shop
     ```
 
+    > 💡 Если включена проверка подписки на канал (`REQUIRED_CHANNEL_ID`), добавьте бота администратором в этот канал. Пользователь увидит кнопку «Проверить подписку», и, после первого успешного подтверждения, дальнейшие действия блокироваться не будут.
+
 ## 🐳 Docker
 
 Файлы `Dockerfile` и `docker-compose.yml` уже настроены для сборки и запуска проекта. `docker-compose.yml` использует готовый образ с GitHub Container Registry, но вы можете раскомментировать `build: .` для локальной сборки.

bot/app/controllers/dispatcher_controller.py

@@ -13,6 +13,7 @@ from bot.middlewares.i18n import I18nMiddleware, get_i18n_instance, JsonI18n
 from bot.middlewares.ban_check_middleware import BanCheckMiddleware
 from bot.middlewares.action_logger_middleware import ActionLoggerMiddleware
 from bot.middlewares.profile_sync import ProfileSyncMiddleware
+from bot.middlewares.channel_subscription import ChannelSubscriptionMiddleware
 
 
 def build_dispatcher(settings: Settings, async_session_factory: sessionmaker) -> tuple[Dispatcher, Bot, Dict]:
@@ -31,8 +32,8 @@ def build_dispatcher(settings: Settings, async_session_factory: sessionmaker) ->
     dp.update.outer_middleware(I18nMiddleware(i18n=i18n_instance, settings=settings))
     dp.update.outer_middleware(ProfileSyncMiddleware())
     dp.update.outer_middleware(BanCheckMiddleware(settings=settings, i18n_instance=i18n_instance))
+    dp.update.outer_middleware(ChannelSubscriptionMiddleware(settings=settings, i18n_instance=i18n_instance))
     dp.update.outer_middleware(ActionLoggerMiddleware(settings=settings))
 
     return dp, bot, {"i18n_instance": i18n_instance}
 
-

bot/app/factories/build_services.py

@@ -12,6 +12,7 @@ from bot.services.stars_service import StarsService
 from bot.services.tribute_service import TributeService
 from bot.services.crypto_pay_service import CryptoPayService
 from bot.services.panel_webhook_service import PanelWebhookService
+from bot.services.freekassa_service import FreeKassaService
 
 
 def build_core_services(
@@ -36,6 +37,14 @@ def build_core_services(
         subscription_service,
         referral_service,
     )
+    freekassa_service = FreeKassaService(
+        bot=bot,
+        settings=settings,
+        i18n=i18n,
+        async_session_factory=async_session_factory,
+        subscription_service=subscription_service,
+        referral_service=referral_service,
+    )
     tribute_service = TributeService(
         bot,
         settings,
@@ -45,7 +54,7 @@ def build_core_services(
         subscription_service,
         referral_service,
     )
-    panel_webhook_service = PanelWebhookService(bot, settings, i18n, async_session_factory)
+    panel_webhook_service = PanelWebhookService(bot, settings, i18n, async_session_factory, panel_service)
     yookassa_service = YooKassaService(
         shop_id=settings.YOOKASSA_SHOP_ID,
         secret_key=settings.YOOKASSA_SECRET_KEY,
@@ -54,6 +63,15 @@ def build_core_services(
         settings_obj=settings,
     )
 
+    # Wire services that depend on each other
+    try:
+        # Attach YooKassa to subscription service for auto-renew charges
+        setattr(subscription_service, "yookassa_service", yookassa_service)
+        # Allow panel webhook to trigger renewals through subscription service
+        setattr(panel_webhook_service, "subscription_service", subscription_service)
+    except Exception:
+        pass
+
     return {
         "panel_service": panel_service,
         "subscription_service": subscription_service,
@@ -61,9 +79,9 @@ def build_core_services(
         "promo_code_service": promo_code_service,
         "stars_service": stars_service,
         "cryptopay_service": cryptopay_service,
+        "freekassa_service": freekassa_service,
         "tribute_service": tribute_service,
         "panel_webhook_service": panel_webhook_service,
         "yookassa_service": yookassa_service,
     }
 
-

bot/app/web/web_server.py

@@ -27,6 +27,7 @@ async def build_and_start_web_app(
         "referral_service",
         "panel_service",
         "stars_service",
+        "freekassa_service",
         "cryptopay_service",
         "tribute_service",
         "panel_webhook_service",
@@ -50,6 +51,7 @@ async def build_and_start_web_app(
     from bot.services.tribute_service import tribute_webhook_route
     from bot.services.crypto_pay_service import cryptopay_webhook_route
     from bot.services.panel_webhook_service import panel_webhook_route
+    from bot.services.freekassa_service import freekassa_webhook_route
 
     tribute_path = settings.tribute_webhook_path
     if tribute_path.startswith("/"):
@@ -61,6 +63,11 @@ async def build_and_start_web_app(
         app.router.add_post(cp_path, cryptopay_webhook_route)
         logging.info(f"CryptoPay webhook route configured at: [POST] {cp_path}")
 
+    fk_path = settings.freekassa_webhook_path
+    if fk_path.startswith("/"):
+        app.router.add_post(fk_path, freekassa_webhook_route)
+        logging.info(f"FreeKassa webhook route configured at: [POST] {fk_path}")
+
     # YooKassa webhook (register only when base URL present and path configured)
     yk_path = settings.yookassa_webhook_path
     if settings.WEBHOOK_BASE_URL and yk_path and yk_path.startswith("/"):
@@ -88,4 +95,3 @@ async def build_and_start_web_app(
     # Run until cancelled
     await asyncio.Event().wait()
 
-

bot/handlers/admin/__init__.py

@@ -8,6 +8,7 @@ from . import statistics
 from . import sync_admin
 from . import logs_admin
 from . import payments
+from . import ads
 
 admin_router_aggregate = Router(name="admin_features_router")
 
@@ -19,5 +20,6 @@ admin_router_aggregate.include_router(statistics.router)
 admin_router_aggregate.include_router(sync_admin.router)
 admin_router_aggregate.include_router(logs_admin.router)
 admin_router_aggregate.include_router(payments.router)
+admin_router_aggregate.include_router(ads.router)
 
 __all__ = ("admin_router_aggregate", )

bot/handlers/admin/ads.py

@@ -0,0 +1,359 @@
+import logging
+from aiogram import Router, F, types
+from aiogram.filters import StateFilter
+from aiogram.fsm.context import FSMContext
+from typing import Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config.settings import Settings
+from bot.middlewares.i18n import JsonI18n
+from db.dal import ad_dal
+from bot.states.admin_states import AdminStates
+
+router = Router(name="admin_ads_router")
+
+
+PAGE_SIZE = 5
+
+
+@router.callback_query(F.data == "admin_action:ads")
+async def show_ads_menu(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    totals = await ad_dal.get_totals(session)
+    total_cost = totals.get("cost", 0.0)
+    total_revenue = totals.get("revenue", 0.0)
+    overview = _("admin_ads_overview", revenue=f"{total_revenue:.2f}", cost=f"{total_cost:.2f}")
+
+    total_count = await ad_dal.count_campaigns(session)
+    if total_count == 0:
+        text = overview + "\n\n" + _("admin_ads_empty")
+        from bot.keyboards.inline.admin_keyboards import get_ads_menu_keyboard
+        reply_markup = get_ads_menu_keyboard(i18n, current_lang)
+    else:
+        current_page = 0
+        total_pages = max(1, (total_count + PAGE_SIZE - 1) // PAGE_SIZE)
+        campaigns = await ad_dal.list_campaigns_paged(session, page=current_page, page_size=PAGE_SIZE)
+        text = overview + "\n\n" + _("admin_ads_header")
+        from bot.keyboards.inline.admin_keyboards import get_ads_list_keyboard
+        reply_markup = get_ads_list_keyboard(i18n, current_lang, campaigns, current_page, total_pages)
+    await callback.message.edit_text(text, reply_markup=reply_markup)
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.callback_query(F.data.startswith("admin_ads:page:"))
+async def ads_list_pagination(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    try:
+        page = int(callback.data.split(":")[2])
+    except Exception:
+        page = 0
+
+    totals = await ad_dal.get_totals(session)
+    overview = _("admin_ads_overview", revenue=f"{totals.get('revenue', 0.0):.2f}", cost=f"{totals.get('cost', 0.0):.2f}")
+    total_count = await ad_dal.count_campaigns(session)
+    total_pages = max(1, (total_count + PAGE_SIZE - 1) // PAGE_SIZE)
+    page = max(0, min(page, total_pages - 1))
+
+    campaigns = await ad_dal.list_campaigns_paged(session, page=page, page_size=PAGE_SIZE)
+    text = overview + "\n\n" + _("admin_ads_header")
+    from bot.keyboards.inline.admin_keyboards import get_ads_list_keyboard
+    reply_markup = get_ads_list_keyboard(i18n, current_lang, campaigns, page, total_pages)
+    try:
+        await callback.message.edit_text(text, reply_markup=reply_markup)
+        await callback.answer()
+    except Exception as e:
+        logging.error(f"Failed to paginate ads list: {e}")
+        await callback.answer()
+
+
+@router.callback_query(F.data.startswith("admin_ads:card:"))
+async def show_ad_card(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    parts = callback.data.split(":")
+    camp_id = int(parts[2])
+    back_page = int(parts[3]) if len(parts) > 3 else 0
+
+    camp = await ad_dal.get_campaign_by_id(session, camp_id)
+    if not camp:
+        await callback.answer(_("admin_promo_not_found"), show_alert=True)
+        return
+    try:
+        stats = await ad_dal.get_campaign_stats(session, camp_id)
+    except Exception:
+        stats = {"starts": 0, "trials": 0, "payers": 0, "revenue": 0.0}
+
+    text = _(
+        "admin_ads_card",
+        id=camp.ad_campaign_id,
+        source=camp.source,
+        start_param=camp.start_param,
+        cost=f"{camp.cost:.2f}",
+        active=_("csv_yes") if camp.is_active else _("csv_no"),
+        starts=stats["starts"],
+        trials=stats["trials"],
+        payers=stats["payers"],
+        revenue=f"{stats['revenue']:.2f}",
+    )
+
+    from bot.keyboards.inline.admin_keyboards import get_ad_card_keyboard
+    reply_markup = get_ad_card_keyboard(i18n, current_lang, camp.ad_campaign_id, back_page)
+    try:
+        await callback.message.edit_text(text, reply_markup=reply_markup, parse_mode="HTML")
+        await callback.answer()
+    except Exception as e:
+        logging.error(f"Failed to show ad card: {e}")
+        await callback.answer()
+
+
+@router.callback_query(F.data.startswith("admin_ads:delete:"))
+async def ads_delete_prompt(callback: types.CallbackQuery, settings: Settings, i18n_data: dict):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    try:
+        _, _, camp_id_str, back_page_str = callback.data.split(":", 3)
+        camp_id = int(camp_id_str)
+        back_page = int(back_page_str)
+    except Exception:
+        await callback.answer(i18n.gettext(current_lang, "error_try_again"), show_alert=True)
+        return
+
+    from bot.keyboards.inline.admin_keyboards import get_confirmation_keyboard
+    confirm_text = i18n.gettext(current_lang, "admin_ads_delete_confirm", id=camp_id)
+    kb = get_confirmation_keyboard(
+        yes_callback_data=f"admin_ads:delete_confirm:{camp_id}:{back_page}",
+        no_callback_data=f"admin_ads:delete_cancel:{camp_id}:{back_page}",
+        i18n_instance=i18n,
+        lang=current_lang,
+    )
+    try:
+        await callback.message.edit_text(confirm_text, reply_markup=kb)
+        await callback.answer()
+    except Exception:
+        await callback.answer()
+
+
+@router.callback_query(F.data.startswith("admin_ads:delete_cancel:"))
+async def ads_delete_cancel(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    # Return to the ad card view
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    try:
+        parts = callback.data.split(":", 3)
+        camp_id = int(parts[2])
+        back_page = int(parts[3])
+    except Exception:
+        await callback.answer(_("error_try_again"), show_alert=True)
+        return
+
+    camp = await ad_dal.get_campaign_by_id(session, camp_id)
+    if not camp:
+        await callback.answer(_("admin_ads_not_found", default="Кампания не найдена."), show_alert=True)
+        return
+    try:
+        stats = await ad_dal.get_campaign_stats(session, camp_id)
+    except Exception:
+        stats = {"starts": 0, "trials": 0, "payers": 0, "revenue": 0.0}
+    text = _(
+        "admin_ads_card",
+        id=camp.ad_campaign_id,
+        source=camp.source,
+        start_param=camp.start_param,
+        cost=f"{camp.cost:.2f}",
+        active=_("csv_yes") if camp.is_active else _("csv_no"),
+        starts=stats["starts"],
+        trials=stats["trials"],
+        payers=stats["payers"],
+        revenue=f"{stats['revenue']:.2f}",
+    )
+    from bot.keyboards.inline.admin_keyboards import get_ad_card_keyboard
+    reply_markup = get_ad_card_keyboard(i18n, current_lang, camp.ad_campaign_id, back_page)
+    try:
+        await callback.message.edit_text(text, reply_markup=reply_markup, parse_mode="HTML")
+        await callback.answer()
+    except Exception:
+        await callback.answer()
+
+
+@router.callback_query(F.data.startswith("admin_ads:delete_confirm:"))
+async def ads_delete_confirm(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    try:
+        parts = callback.data.split(":", 3)
+        camp_id = int(parts[2])
+        back_page = int(parts[3])
+    except Exception:
+        await callback.answer(_("error_try_again"), show_alert=True)
+        return
+
+    existed = await ad_dal.delete_campaign(session, camp_id)
+    if not existed:
+        await callback.answer(_("admin_ads_not_found", default="Кампания не найдена."), show_alert=True)
+        return
+    await session.commit()
+
+    # After delete, show list page (may shift due to fewer items)
+    totals = await ad_dal.get_totals(session)
+    overview = _(
+        "admin_ads_overview",
+        revenue=f"{totals.get('revenue', 0.0):.2f}",
+        cost=f"{totals.get('cost', 0.0):.2f}",
+    )
+    total_count = await ad_dal.count_campaigns(session)
+    total_pages = max(1, (total_count + PAGE_SIZE - 1) // PAGE_SIZE)
+    page = max(0, min(back_page, total_pages - 1))
+    campaigns = await ad_dal.list_campaigns_paged(session, page=page, page_size=PAGE_SIZE)
+    text = overview + "\n\n" + _("admin_ads_header")
+    from bot.keyboards.inline.admin_keyboards import get_ads_list_keyboard
+    reply_markup = get_ads_list_keyboard(i18n, current_lang, campaigns, page, total_pages)
+    try:
+        await callback.message.edit_text(text, reply_markup=reply_markup)
+        await callback.answer(_("admin_ads_deleted_success"), show_alert=True)
+    except Exception:
+        await callback.answer(_("admin_ads_deleted_success"), show_alert=True)
+@router.callback_query(F.data == "admin_action:ads_create")
+async def ads_create_start(callback: types.CallbackQuery, state: FSMContext, settings: Settings, i18n_data: dict):
+    from bot.states.admin_states import AdminStates
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    if not i18n or not callback.message:
+        await callback.answer("Language error.", show_alert=True)
+        return
+
+    await state.set_state(AdminStates.waiting_for_ad_source)
+    await callback.message.edit_text(_("admin_ads_create_source_prompt"))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.message(
+    StateFilter(
+        AdminStates.waiting_for_ad_source,
+        AdminStates.waiting_for_ad_start_param,
+        AdminStates.waiting_for_ad_cost,
+    ),
+    F.text,
+)
+async def ads_create_flow(message: types.Message, state: FSMContext, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_state = await state.get_state()
+    if current_state not in (
+        AdminStates.waiting_for_ad_source.state,
+        AdminStates.waiting_for_ad_start_param.state,
+        AdminStates.waiting_for_ad_cost.state,
+    ):
+        return
+
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    if current_state == AdminStates.waiting_for_ad_source.state:
+        source = message.text.strip()
+        if not source or len(source) > 64:
+            await message.answer(_("admin_ads_invalid_source"))
+            return
+        await state.update_data(ad_source=source)
+        await state.set_state(AdminStates.waiting_for_ad_start_param)
+        await message.answer(_("admin_ads_create_start_param_prompt"))
+        return
+
+    if current_state == AdminStates.waiting_for_ad_start_param.state:
+        start_param = message.text.strip()
+        # Allow alnum underscore dash only
+        import re as _re
+        if not _re.match(r"^[A-Za-z0-9_\-]{2,64}$", start_param):
+            await message.answer(_("admin_ads_invalid_start_param"))
+            return
+        await state.update_data(ad_start_param=start_param)
+        await state.set_state(AdminStates.waiting_for_ad_cost)
+        await message.answer(_("admin_ads_create_cost_prompt"))
+        return
+
+    if current_state == AdminStates.waiting_for_ad_cost.state:
+        text = message.text.replace(",", ".").strip()
+        try:
+            cost = float(text)
+            if cost < 0 or cost > 1e8:
+                raise ValueError()
+        except Exception:
+            await message.answer(_("admin_ads_invalid_cost"))
+            return
+
+        data = await state.get_data()
+        try:
+            campaign = await ad_dal.create_campaign(
+                session,
+                source=data.get("ad_source", "unknown"),
+                start_param=data.get("ad_start_param", "NA"),
+                cost=cost,
+            )
+            await session.commit()
+        except ValueError as ve:
+            await session.rollback()
+            if str(ve) == "ad_campaign_start_param_exists":
+                await message.answer(_("admin_ads_start_param_exists"))
+            else:
+                await message.answer(_("error_occurred_try_again"))
+            return
+        except Exception as e:
+            await session.rollback()
+            logging.error(f"Failed to create ad campaign: {e}", exc_info=True)
+            await message.answer(_("error_occurred_try_again"))
+            return
+
+        await state.clear()
+        _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+        await message.answer(
+            _(
+                "admin_ads_created_success",
+                id=campaign.ad_campaign_id,
+                source=campaign.source,
+                start_param=campaign.start_param,
+                cost=f"{campaign.cost:.2f}",
+            )
+        )
+        # Offer back to ads menu
+        from bot.keyboards.inline.admin_keyboards import get_ads_menu_keyboard
+        await message.answer(_("admin_ads_back_to_menu_hint"), reply_markup=get_ads_menu_keyboard(i18n, current_lang))
+
+

bot/handlers/admin/broadcast.py

@@ -97,14 +97,27 @@ async def process_broadcast_message_handler(
 
     # Отправляем превью-копию того, что будет разослано
     try:
-        await send_message_by_type(
-            bot, 
-            chat_id=message.chat.id, 
-            content=content,
-            parse_mode="HTML",
-            disable_web_page_preview=True,
-            disable_notification=True,
-        )
+        # Для медиа-сообщений используем caption_entities, для текста - entities
+        if content.content_type == "text":
+            await send_message_by_type(
+                bot, 
+                chat_id=message.chat.id, 
+                content=content,
+                parse_mode="HTML",
+                entities=entities,
+                disable_web_page_preview=True,
+                disable_notification=True,
+            )
+        else:
+            await send_message_by_type(
+                bot, 
+                chat_id=message.chat.id, 
+                content=content,
+                parse_mode="HTML",
+                caption_entities=entities,
+                disable_web_page_preview=True,
+                disable_notification=True,
+            )
     except TelegramBadRequest as e:
         await message.answer(
             _(
@@ -263,13 +276,25 @@ async def confirm_broadcast_callback_handler(
         # Queue all messages for sending
         for uid in user_ids:
             try:
-                await send_message_via_queue(
-                    queue_manager, 
-                    uid, 
-                    content,
-                    parse_mode="HTML",
-                    disable_web_page_preview=True,
-                )
+                # Для медиа-сообщений используем caption_entities, для текста - entities
+                if content.content_type == "text":
+                    await send_message_via_queue(
+                        queue_manager, 
+                        uid, 
+                        content,
+                        parse_mode="HTML",
+                        entities=entities,
+                        disable_web_page_preview=True,
+                    )
+                else:
+                    await send_message_via_queue(
+                        queue_manager, 
+                        uid, 
+                        content,
+                        parse_mode="HTML",
+                        caption_entities=entities,
+                        disable_web_page_preview=True,
+                    )
                 sent_count += 1
                 
                 # Log successful queuing
@@ -309,23 +334,87 @@ async def confirm_broadcast_callback_handler(
             await session.rollback()
             logging.error(f"Error committing broadcast logs: {e_commit}")
 
-        # Get queue stats for detailed report
+        # Prepare queue stats presentation
         queue_stats = queue_manager.get_queue_stats()
-        
-        result_message = f"""🚀 Рассылка поставлена в очередь!
-📤 В очередь добавлено: {sent_count}
-❌ Ошибок: {failed_count}
+        back_keyboard = get_back_to_admin_panel_keyboard(current_lang, i18n)
+        initial_user_failed = queue_stats.get("user_failed_messages", 0)
+        initial_group_failed = queue_stats.get("group_failed_messages", 0)
 
-📊 Статус очередей:
-👥 Очередь пользователей: {queue_stats['user_queue_size']} сообщений
-📢 Очередь групп: {queue_stats['group_queue_size']} сообщений
+        def build_queue_status(stats: dict) -> str:
+            dynamic_failed = max(
+                0, stats.get("user_failed_messages", 0) - initial_user_failed
+            ) + max(0, stats.get("group_failed_messages", 0) - initial_group_failed)
+            total_failed = failed_count + dynamic_failed
+            return _(
+                "broadcast_queue_result",
+                default=(
+                    "🚀 Рассылка поставлена в очередь!\n"
+                    "📤 В очередь добавлено: {sent_count}\n"
+                    "❌ Ошибок: {failed_count}\n\n"
+                    "📊 Статус очередей:\n"
+                    "👥 Очередь пользователей: {user_queue_size} сообщений\n"
+                    "📢 Очередь групп: {group_queue_size} сообщений\n\n"
+                    "ℹ️ Сообщения будут отправлены автоматически с соблюдением лимитов Telegram."
+                ),
+                sent_count=sent_count,
+                failed_count=total_failed,
+                user_queue_size=stats["user_queue_size"],
+                group_queue_size=stats["group_queue_size"],
+            )
 
-ℹ️ Сообщения будут отправлены автоматически с соблюдением лимитов Telegram."""
-        await callback.message.answer(
+        result_message = build_queue_status(queue_stats)
+
+        status_message = await callback.message.answer(
             result_message,
-            reply_markup=get_back_to_admin_panel_keyboard(current_lang, i18n),
+            reply_markup=back_keyboard,
         )
 
+        async def auto_update_queue_status() -> None:
+            """Refresh queue stats message twice per second via message edit."""
+            last_text = result_message
+            # Update for up to 2 minutes (240 iterations at 0.5s intervals)
+            max_iterations = 240
+            for _ in range(max_iterations):
+                await asyncio.sleep(0.5)
+
+                stats = queue_manager.get_queue_stats()
+                new_text = build_queue_status(stats)
+                queues_drained = (
+                    stats["user_queue_size"] == 0
+                    and stats["group_queue_size"] == 0
+                    and not stats.get("user_queue_processing")
+                    and not stats.get("group_queue_processing")
+                )
+
+                if new_text != last_text:
+                    try:
+                        await status_message.edit_text(
+                            new_text,
+                            reply_markup=back_keyboard,
+                        )
+                        last_text = new_text
+                    except TelegramBadRequest as e:
+                        if "message is not modified" in str(e):
+                            last_text = new_text
+                        else:
+                            logging.debug(
+                                "Broadcast queue auto-update stopped: %s", e
+                            )
+                            break
+                    except Exception as e:
+                        logging.debug(
+                            "Broadcast queue auto-update unexpected error: %s", e
+                        )
+                        break
+
+                if queues_drained:
+                    # Final refresh already attempted; exit loop.
+                    break
+            else:
+                logging.debug("Broadcast queue auto-update reached time limit.")
+
+        asyncio.create_task(auto_update_queue_status())
+
     elif action == "cancel":
         await callback.message.edit_text(
             _("admin_broadcast_cancelled"),

bot/handlers/admin/common.py

@@ -127,6 +127,12 @@ async def admin_panel_actions_callback_handler(
         from . import payments as admin_payments_handlers
         await admin_payments_handlers.view_payments_handler(
             callback, i18n_data, settings, session)
+    elif action == "ads":
+        from . import ads as admin_ads_handlers
+        await admin_ads_handlers.show_ads_menu(callback, settings, i18n_data, session)
+    elif action == "ads_create":
+        from . import ads as admin_ads_handlers
+        await admin_ads_handlers.ads_create_start(callback, state, settings, i18n_data)
     elif action == "main":
         try:
             await callback.message.edit_text(

bot/handlers/admin/payments.py

@@ -39,7 +39,7 @@ def format_payment_text(payment: Payment, i18n: JsonI18n, lang: str) -> str:
     _ = lambda key, **kwargs: i18n.gettext(lang, key, **kwargs)
     
     status_emoji = "✅" if payment.status == 'succeeded' else (
-        "⏳" if payment.status in ['pending', 'pending_yookassa'] else "❌"
+        "⏳" if payment.status in ['pending', 'pending_yookassa', 'pending_freekassa'] else "❌"
     )
     
     user_info = f"User {payment.user_id}"
@@ -54,7 +54,8 @@ def format_payment_text(payment: Payment, i18n: JsonI18n, lang: str) -> str:
         'yookassa': 'YooKassa',
         'tribute': 'Tribute', 
         'telegram_stars': 'Telegram Stars',
-        'cryptopay': 'CryptoPay'
+        'cryptopay': 'CryptoPay',
+        'freekassa': 'FreeKassa',
     }.get(payment.provider, payment.provider or 'Unknown')
     
     return (
@@ -77,7 +78,7 @@ async def view_payments_handler(callback: types.CallbackQuery, i18n_data: dict,
         return
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
-    page_size = 5  # Показываем по 5 платежей на странице
+    page_size = 5  # Show 5 payments per page
     payments, total_count = await get_payments_with_pagination(session, page, page_size)
     total_pages = (total_count + page_size - 1) // page_size if total_count > 0 else 1
 
@@ -92,7 +93,11 @@ async def view_payments_handler(callback: types.CallbackQuery, i18n_data: dict,
 
     # Format payments text
     text_parts = [_("admin_payments_header", default="💰 <b>Все платежи</b>")]
-    text_parts.append(f"📊 Показано {len(payments)} из {total_count} платежей (стр. {page + 1}/{total_pages})\n")
+    text_parts.append(_("admin_payments_pagination_info", 
+                       shown=len(payments), 
+                       total=total_count, 
+                       current_page=page + 1, 
+                       total_pages=total_pages) + "\n")
     
     for i, payment in enumerate(payments, 1):
         text_parts.append(f"<b>{page * page_size + i}.</b> {format_payment_text(payment, i18n, current_lang)}")
@@ -225,12 +230,12 @@ async def export_payments_csv_handler(callback: types.CallbackQuery, i18n_data:
         await callback.message.reply_document(
             document=file,
             caption=_("admin_payments_export_success", 
-                     default="📊 Экспорт платежей завершен!\nВсего записей: {count}",
+                     default="📊 Payments export completed!\nTotal records: {count}",
                      count=len(all_payments))
         )
         
         await callback.answer(
-            _("admin_export_sent", default="Файл отправлен!"),
+            _("admin_export_sent", default="File sent!"),
             show_alert=False
         )
         
@@ -242,4 +247,4 @@ async def export_payments_csv_handler(callback: types.CallbackQuery, i18n_data:
 @router.callback_query(F.data == "noop")
 async def noop_handler(callback: types.CallbackQuery):
     """Handle no-op callback (for pagination display)."""
-    await callback.answer()
+    await callback.answer()

bot/handlers/admin/promo/manage.py

@@ -126,7 +126,7 @@ async def promo_management_handler(callback: types.CallbackQuery, i18n_data: dic
             builder.row(*pagination_buttons)
     
     # Добавляем кнопки экспорта и возврата
-    builder.row(InlineKeyboardButton(text="📄 Экспорт CSV", callback_data="promo_export_all"))
+    builder.row(InlineKeyboardButton(text=_("admin_promo_export_csv_button"), callback_data="promo_export_all"))
     builder.row(InlineKeyboardButton(text=_("back_to_admin_panel_button"), callback_data="admin_action:main"))
     
     # Формируем заголовок с информацией о страницах
@@ -248,6 +248,7 @@ async def promo_export_activations_handler(callback: types.CallbackQuery, i18n_d
     if not i18n or not callback.message or not current_lang:
         return await callback.answer("Error processing request.", show_alert=True)
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+    export_lang = "en"
 
     try:
         promo_id = int(callback.data.split(":")[1])
@@ -267,7 +268,11 @@ async def promo_export_activations_handler(callback: types.CallbackQuery, i18n_d
         
         output.seek(0)
         file = types.BufferedInputFile(output.getvalue().encode('utf-8'), filename=f"promo_{promo.code}_activations.csv")
-        await callback.message.answer_document(file, caption=_("admin_promo_export_caption", code=promo.code))
+        # Force English caption for exports
+        await callback.message.answer_document(
+            file,
+            caption=i18n.gettext(export_lang, "admin_promo_export_caption", code=promo.code)
+        )
 
     except (ValueError, IndexError):
         await callback.answer(_("admin_promo_not_found"), show_alert=True)
@@ -281,9 +286,10 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
     if not i18n or not callback.message or not current_lang:
         return await callback.answer("Error processing request.", show_alert=True)
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+    export_lang = "en"
 
     try:
-        await callback.answer("📄 Создаю CSV файл...", show_alert=True)
+        await callback.answer(i18n.gettext(export_lang, "admin_promo_export_all_generating"), show_alert=True)
         
         # Получаем все промокоды
         all_promos = await promo_code_dal.get_all_promo_codes_with_details(session, limit=10000, offset=0)
@@ -291,15 +297,22 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
         output = io.StringIO()
         writer = csv.writer(output)
         
-        # Заголовки CSV
+        # CSV headers (forced to English)
         writer.writerow([
-            "Код", "Бонусные дни", "Максимальные активации", "Текущие активации", 
-            "Статус", "Активен", "Действителен до", "Создан", "Создал (Admin ID)"
+            i18n.gettext(export_lang, "admin_promo_csv_code"),
+            i18n.gettext(export_lang, "admin_promo_csv_bonus_days"),
+            i18n.gettext(export_lang, "admin_promo_csv_max_activations"),
+            i18n.gettext(export_lang, "admin_promo_csv_current_activations"),
+            i18n.gettext(export_lang, "admin_promo_csv_status"),
+            i18n.gettext(export_lang, "admin_promo_csv_is_active"),
+            i18n.gettext(export_lang, "admin_promo_csv_valid_until"),
+            i18n.gettext(export_lang, "admin_promo_csv_created_at"),
+            i18n.gettext(export_lang, "admin_promo_csv_created_by_admin_id"),
         ])
         
         for promo in all_promos:
             # Определяем статус
-            status_emoji, status_text = get_promo_status_emoji_and_text(promo, i18n, current_lang)
+            status_emoji, status_text = get_promo_status_emoji_and_text(promo, i18n, export_lang)
             
             # Формируем данные для CSV
             row = [
@@ -308,8 +321,8 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
                 promo.max_activations,
                 promo.current_activations,
                 status_text,
-                "Да" if promo.is_active else "Нет",
-                promo.valid_until.strftime("%Y-%m-%d %H:%M:%S") if promo.valid_until else "Без ограничений",
+                i18n.gettext(export_lang, "csv_yes") if promo.is_active else i18n.gettext(export_lang, "csv_no"),
+                promo.valid_until.strftime("%Y-%m-%d %H:%M:%S") if promo.valid_until else i18n.gettext(export_lang, "admin_promo_valid_indefinitely"),
                 promo.created_at.strftime("%Y-%m-%d %H:%M:%S") if promo.created_at else "N/A",
                 promo.created_by_admin_id or "N/A"
             ]
@@ -324,11 +337,11 @@ async def promo_export_all_handler(callback: types.CallbackQuery, i18n_data: dic
             filename=filename
         )
         
-        caption = f"📄 Экспорт всех промокодов\n📊 Всего: {len(all_promos)} промокодов"
+        caption = i18n.gettext(export_lang, "admin_promo_export_all_caption", count=len(all_promos))
         await callback.message.answer_document(file, caption=caption)
         
     except Exception as e:
-        await callback.answer(f"❌ Ошибка экспорта: {str(e)}", show_alert=True)
+        await callback.answer(f"❌ Export error: {str(e)}", show_alert=True)
 
 
 @router.callback_query(F.data.startswith("promo_delete:"))

bot/handlers/admin/statistics.py

@@ -163,8 +163,7 @@ async def show_statistics_handler(callback: types.CallbackQuery,
             f"\n<b>{_('admin_stats_recent_payments_header')}</b>")
         for payment in last_payments_models:
             status_emoji = "✅" if payment.status == 'succeeded' else (
-                "⏳" if payment.status == 'pending'
-                or payment.status == 'pending_yookassa' else "❌")
+                "⏳" if payment.status in ['pending', 'pending_yookassa', 'pending_freekassa'] else "❌")
 
             user_info = f"User {payment.user_id}"
             if payment.user and payment.user.username:

bot/handlers/admin/sync_admin.py

@@ -136,6 +136,26 @@ async def perform_sync(panel_service: PanelApiService, session: AsyncSession,
                     users_uuid_updated += 1
                     logging.info(f"Updated panel UUID for user {actual_user_id}: {panel_uuid}")
 
+                # Ensure panel description contains Telegram fields
+                try:
+                    if panel_uuid and existing_user:
+                        description_text = "\n".join([
+                            existing_user.username or "",
+                            existing_user.first_name or "",
+                            existing_user.last_name or "",
+                        ])
+                        # Update description only when it differs from the current one on panel
+                        current_panel_description = (panel_user_dict.get("description") or "").strip()
+                        desired_description = description_text.strip()
+                        if desired_description and desired_description != current_panel_description:
+                            await panel_service.update_user_details_on_panel(
+                                panel_uuid, {"description": description_text}
+                            )
+                except Exception as e_desc:
+                    logging.warning(
+                        f"Sync: Failed to update description for panel user {panel_uuid} (tg {actual_user_id}): {e_desc}"
+                    )
+
                 # Sync subscription data
                 panel_expire_at_iso = panel_user_dict.get("expireAt")
                 panel_status = panel_user_dict.get("status", "UNKNOWN")

bot/handlers/admin/user_management.py

@@ -15,9 +15,15 @@ from bot.states.admin_states import AdminStates
 from bot.keyboards.inline.admin_keyboards import get_back_to_admin_panel_keyboard
 from bot.services.subscription_service import SubscriptionService
 from bot.services.panel_api_service import PanelApiService
+from bot.services.referral_service import ReferralService
 from bot.middlewares.i18n import JsonI18n
 from bot.utils import get_message_content, send_direct_message
 from aiogram.utils.keyboard import InlineKeyboardBuilder, InlineKeyboardButton
+from bot.utils.text_sanitizer import (
+    sanitize_display_name,
+    sanitize_username,
+    username_for_display,
+)
 
 router = Router(name="admin_user_management_router")
 USERNAME_REGEX = re.compile(r"^[a-zA-Z0-9_]{5,32}$")
@@ -106,7 +112,8 @@ def get_user_card_keyboard(user_id: int, i18n_instance, lang: str) -> InlineKeyb
 
 async def format_user_card(user: User, session: AsyncSession, 
                           subscription_service: SubscriptionService,
-                          i18n_instance, lang: str) -> str:
+                          i18n_instance, lang: str,
+                          referral_service: Optional[ReferralService] = None) -> str:
     """Format user information as a detailed card"""
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     
@@ -116,8 +123,16 @@ async def format_user_card(user: User, session: AsyncSession,
     
     # User details
     na_value = _("admin_user_na_value", default="N/A")
-    user_name = user.first_name or na_value
-    username_display = f"@{user.username}" if user.username else na_value
+    safe_first_name = sanitize_display_name(user.first_name) if user.first_name else None
+    user_name = safe_first_name or na_value
+    if user.username:
+        sanitized_username = sanitize_username(user.username)
+        if sanitized_username:
+            username_display = f"@{sanitized_username}"
+        else:
+            username_display = username_for_display(user.username, with_at=False)
+    else:
+        username_display = na_value
     registration_date = user.registration_date.strftime('%Y-%m-%d %H:%M') if user.registration_date else na_value
     
     card_parts.append(f"{_('admin_user_id_label', default='🆔 <b>ID:</b>')} {hcode(str(user.user_id))}")
@@ -176,6 +191,17 @@ async def format_user_card(user: User, session: AsyncSession,
         had_subscriptions = await subscription_service.has_had_any_subscription(session, user.user_id)
         trial_status = _("admin_user_trial_used", default="Использовал") if had_subscriptions else _("admin_user_trial_not_used", default="Не использовал")
         card_parts.append(f"{_('admin_user_trial_label', default='🏡 <b>Триал:</b>')} {hcode(trial_status)}")
+
+        # Referral stats
+        if referral_service is not None:
+            try:
+                stats = await referral_service.get_referral_stats(session, user.user_id)
+                invited_count = stats.get('invited_count', 0)
+                purchased_count = stats.get('purchased_count', 0)
+                card_parts.append(f"{_('admin_user_invited_friends_label', default='👥 <b>Приглашено друзей:</b>')} {hcode(str(invited_count))}")
+                card_parts.append(f"{_('admin_user_ref_purchased_label', default='💳 <b>Купили подписку:</b>')} {hcode(str(purchased_count))}")
+            except Exception as e_rs:
+                logging.error(f"Failed to build referral stats for admin card {user.user_id}: {e_rs}")
         
     except Exception as e:
         logging.error(f"Error getting user statistics for {user.user_id}: {e}")
@@ -224,7 +250,8 @@ async def process_user_search_handler(message: types.Message, state: FSMContext,
 
     # Format and send user card
     try:
-        user_card_text = await format_user_card(user_model, session, subscription_service, i18n, current_lang)
+        referral_service = ReferralService(settings, subscription_service, message.bot, i18n)
+        user_card_text = await format_user_card(user_model, session, subscription_service, i18n, current_lang, referral_service)
         keyboard = get_user_card_keyboard(user_model.user_id, i18n, current_lang)
         
         await message.answer(
@@ -420,7 +447,9 @@ async def handle_view_user_logs(callback: types.CallbackQuery, user: User,
             ), show_alert=True)
             return
         
-        logs_text_parts = [f"📜 <b>Последние действия пользователя {user.user_id}:</b>\n"]
+        logs_text_parts = [
+            f"{_('admin_user_recent_actions_title', default='📜 Последние действия пользователя {user_id}:', user_id=user.user_id)}\n"
+        ]
         
         for log in logs:
             timestamp = log.timestamp.strftime('%Y-%m-%d %H:%M') if log.timestamp else 'N/A'
@@ -480,7 +509,10 @@ async def handle_refresh_user_card(callback: types.CallbackQuery, user: User,
             await callback.answer("User not found", show_alert=True)
             return
         
-        user_card_text = await format_user_card(fresh_user, session, subscription_service, i18n_instance, lang)
+        from config.settings import Settings as _Settings
+        _settings = _Settings()
+        referral_service = ReferralService(_settings, subscription_service, callback.message.bot, i18n_instance)
+        user_card_text = await format_user_card(fresh_user, session, subscription_service, i18n_instance, lang, referral_service)
         keyboard = get_user_card_keyboard(fresh_user.user_id, i18n_instance, lang)
         
         try:
@@ -554,7 +586,8 @@ async def process_subscription_days_handler(message: types.Message, state: FSMCo
             # Show updated user card
             user = await user_dal.get_user_by_id(session, target_user_id)
             if user:
-                user_card_text = await format_user_card(user, session, subscription_service, i18n, current_lang)
+                referral_service = ReferralService(settings, subscription_service, message.bot, i18n)
+                user_card_text = await format_user_card(user, session, subscription_service, i18n, current_lang, referral_service)
                 keyboard = get_user_card_keyboard(user.user_id, i18n, current_lang)
                 
                 await message.answer(
@@ -662,7 +695,8 @@ async def process_direct_message_handler(message: types.Message, state: FSMConte
         from bot.services.panel_api_service import PanelApiService
         async with PanelApiService(settings) as panel_service:
             subscription_service = SubscriptionService(settings, panel_service)
-            user_card_text = await format_user_card(target_user, session, subscription_service, i18n, current_lang)
+            referral_service = ReferralService(settings, subscription_service, bot, i18n)
+            user_card_text = await format_user_card(target_user, session, subscription_service, i18n, current_lang, referral_service)
             keyboard = get_user_card_keyboard(target_user.user_id, i18n, current_lang)
             
             await message.answer(
@@ -929,4 +963,4 @@ async def process_unban_user_handler(message: types.Message, state: FSMContext,
             default="❌ Ошибка разблокировки пользователя"
         ))
     
-    await state.clear()
+    await state.clear()

bot/handlers/inline_mode.py

@@ -157,6 +157,7 @@ async def create_user_stats_result(session: AsyncSession, i18n_instance, lang: s
                    "🚫 Заблокированных: <b>{banned}</b>\n"
                    "🎁 Привлечено по реферальной программе: <b>{referral}</b>",
             total=user_stats['total_users'],
+            active_today=user_stats['active_today'],
             paid=user_stats['paid_subscriptions'],
             trial=user_stats['trial_users'],
             inactive=user_stats['inactive_users'],

bot/handlers/user/__init__.py

@@ -1,7 +1,8 @@
 from aiogram import Router
 
 from . import start
-from . import subscription
+# TODO: after splitting subscription into a package, replace this import
+from .subscription import router as subscription_router
 from . import referral
 from . import promo_user
 from . import trial_handler
@@ -11,5 +12,5 @@ user_router_aggregate = Router(name="user_router_aggregate")
 user_router_aggregate.include_router(promo_user.router)
 user_router_aggregate.include_router(trial_handler.router)
 user_router_aggregate.include_router(start.router)
-user_router_aggregate.include_router(subscription.router)
+user_router_aggregate.include_router(subscription_router)
 user_router_aggregate.include_router(referral.router)

bot/handlers/user/payment.py

@@ -12,7 +12,7 @@ from sqlalchemy.orm import sessionmaker
 from yookassa.domain.notification import WebhookNotification
 from yookassa.domain.models.amount import Amount as YooKassaAmount
 
-from db.dal import payment_dal, user_dal
+from db.dal import payment_dal, user_dal, user_billing_dal
 
 from bot.services.subscription_service import SubscriptionService
 from bot.services.referral_service import ReferralService
@@ -22,11 +22,13 @@ from bot.middlewares.i18n import JsonI18n
 from config.settings import Settings
 from bot.services.notification_service import NotificationService
 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
+from bot.utils.text_sanitizer import sanitize_display_name, username_for_display
 
 payment_processing_lock = asyncio.Lock()
 
 YOOKASSA_EVENT_PAYMENT_SUCCEEDED = 'payment.succeeded'
 YOOKASSA_EVENT_PAYMENT_CANCELED = 'payment.canceled'
+YOOKASSA_EVENT_PAYMENT_WAITING_FOR_CAPTURE = 'payment.waiting_for_capture'
 
 
 async def process_successful_payment(session: AsyncSession, bot: Bot,
@@ -40,8 +42,13 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
     subscription_months_str = metadata.get("subscription_months")
     promo_code_id_str = metadata.get("promo_code_id")
     payment_db_id_str = metadata.get("payment_db_id")
+    auto_renew_subscription_id_str = metadata.get(
+        "auto_renew_for_subscription_id")
 
-    if not user_id_str or not subscription_months_str or not payment_db_id_str:
+    # For auto-renew payments, payment_db_id may be absent. In that case,
+    # we will create/ensure a payment record idempotently using provider payment id.
+    if (not user_id_str or not subscription_months_str
+            or (not payment_db_id_str and not auto_renew_subscription_id_str)):
         logging.error(
             f"Missing crucial metadata for payment: {payment_info_from_webhook.get('id')}, metadata: {metadata}"
         )
@@ -51,7 +58,9 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
     try:
         user_id = int(user_id_str)
         subscription_months = int(subscription_months_str)
-        payment_db_id = int(payment_db_id_str)
+        payment_db_id = int(
+            payment_db_id_str) if payment_db_id_str and payment_db_id_str.isdigit() else None
+        is_auto_renew = bool(auto_renew_subscription_id_str and not payment_db_id)
         promo_code_id = int(
             promo_code_id_str
         ) if promo_code_id_str and promo_code_id_str.isdigit() else None
@@ -59,6 +68,44 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
         amount_data = payment_info_from_webhook.get("amount", {})
         payment_value = float(amount_data.get("value", 0.0))
 
+        # If this is an auto-renewal (no payment_db_id in metadata), ensure a payment record exists
+        if payment_db_id is None and auto_renew_subscription_id_str:
+            try:
+                # Create/ensure provider payment by YooKassa payment id for idempotency
+                yk_payment_id_from_hook = payment_info_from_webhook.get("id")
+                from db.dal import payment_dal as _payment_dal
+                ensured_payment = await _payment_dal.ensure_payment_with_provider_id(
+                    session,
+                    user_id=user_id,
+                    amount=payment_value,
+                    currency=amount_data.get("currency", settings.DEFAULT_CURRENCY_SYMBOL),
+                    months=subscription_months,
+                    description=payment_info_from_webhook.get(
+                        "description") or f"Auto-renewal for {subscription_months} months",
+                    provider="yookassa",
+                    provider_payment_id=yk_payment_id_from_hook,
+                )
+                payment_db_id = ensured_payment.payment_id
+                # Also persist yookassa_payment_id field if not set yet
+                try:
+                    await _payment_dal.update_payment_status_by_db_id(
+                        session,
+                        payment_db_id,
+                        payment_info_from_webhook.get("status", "succeeded"),
+                        yk_payment_id_from_hook,
+                    )
+                except Exception:
+                    # Non-fatal; continue processing
+                    logging.exception(
+                        "Failed to backfill yookassa_payment_id for ensured auto-renew payment"
+                    )
+            except Exception as e_ensure:
+                logging.error(
+                    f"Failed to ensure payment record for auto-renew webhook (YK {payment_info_from_webhook.get('id')}): {e_ensure}",
+                    exc_info=True,
+                )
+                return
+
         db_user = await user_dal.get_user_by_id(session, user_id)
         if not db_user:
             logging.error(
@@ -89,6 +136,42 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
 
     try:
         yk_payment_id_from_hook = payment_info_from_webhook.get("id")
+        # Try to capture and save payment method for future charges if available
+        try:
+            payment_method = payment_info_from_webhook.get("payment_method")
+            if getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False) and isinstance(payment_method, dict) and payment_method.get("saved", False):
+                pm_id = payment_method.get("id")
+                pm_type = payment_method.get("type")
+                title = payment_method.get("title")
+                card = payment_method.get("card") or {}
+                account_number = payment_method.get("account_number") or payment_method.get("account")
+                display_network = None
+                display_last4 = None
+                # Build generic display for various instrument types
+                if (pm_type or "").lower() in {"bank_card", "bank-card", "card"}:
+                    display_network = card.get("card_type") or title or "Card"
+                    display_last4 = card.get("last4")
+                elif (pm_type or "").lower() in {"yoo_money", "yoomoney", "yoo-money", "wallet"}:
+                    # Normalize wallet display name to avoid leaking full account from title
+                    display_network = "YooMoney"
+                    if isinstance(account_number, str) and len(account_number) >= 4:
+                        display_last4 = account_number[-4:]
+                    else:
+                        display_last4 = None
+                else:
+                    # Wallets, SBP, etc. — use provided title/type; no last4
+                    display_network = title or (pm_type.upper() if pm_type else "Payment method")
+                    display_last4 = None
+
+                await user_billing_dal.upsert_yk_payment_method(
+                    session,
+                    user_id=user_id,
+                    payment_method_id=pm_id,
+                    card_last4=display_last4,
+                    card_network=display_network,
+                )
+        except Exception:
+            logging.exception("Failed to persist YooKassa payment method from webhook")
         updated_payment_record = await payment_dal.update_payment_status_by_db_id(
             session,
             payment_db_id=payment_db_id,
@@ -137,56 +220,68 @@ async def process_successful_payment(session: AsyncSession, bot: Bot,
             applied_referee_bonus_days_from_referral = referral_bonus_info.get(
                 "referee_bonus_applied_days")
 
+        # Use user's DB language for all user-facing messages
         user_lang = db_user.language_code if db_user and db_user.language_code else settings.DEFAULT_LANGUAGE
         _ = lambda key, **kwargs: i18n.gettext(user_lang, key, **kwargs)
 
-        config_link = activation_details.get("subscription_url") or _(
-            "config_link_not_available"
-        )
-
-        if applied_referee_bonus_days_from_referral and final_end_date_for_user:
-            inviter_name_display = _("friend_placeholder")
-            if db_user and db_user.referred_by_id:
-                inviter = await user_dal.get_user_by_id(
-                    session, db_user.referred_by_id)
-                if inviter and inviter.first_name:
-                    inviter_name_display = inviter.first_name
-                elif inviter and inviter.username:
-                    inviter_name_display = f"@{inviter.username}"
-
+        # For auto-renew charges, avoid re-sending config link; send concise message
+        if is_auto_renew and final_end_date_for_user:
             details_message = _(
-                "payment_successful_with_referral_bonus_full",
-                months=subscription_months,
-                base_end_date=base_subscription_end_date.strftime('%Y-%m-%d'),
-                bonus_days=applied_referee_bonus_days_from_referral,
-                final_end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
-                inviter_name=inviter_name_display,
-                config_link=config_link,
-            )
-        elif applied_promo_bonus_days > 0 and final_end_date_for_user:
-            details_message = _(
-                "payment_successful_with_promo_full",
-                months=subscription_months,
-                bonus_days=applied_promo_bonus_days,
-                end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
-                config_link=config_link,
-            )
-        elif final_end_date_for_user:
-            details_message = _(
-                "payment_successful_full",
+                "yookassa_auto_renewal",
                 months=subscription_months,
                 end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
-                config_link=config_link,
             )
+            details_markup = None
         else:
-            logging.error(
-                f"Critical error: final_end_date_for_user is None for user {user_id} after successful payment logic."
+            config_link = activation_details.get("subscription_url") or _(
+                "config_link_not_available"
             )
-            details_message = _("payment_successful_error_details")
 
-        details_markup = get_connect_and_main_keyboard(
-            user_lang, i18n, settings, config_link
-        )
+            if applied_referee_bonus_days_from_referral and final_end_date_for_user:
+                inviter_name_display = _("friend_placeholder")
+                if db_user and db_user.referred_by_id:
+                    inviter = await user_dal.get_user_by_id(
+                        session, db_user.referred_by_id)
+                    if inviter:
+                        safe_name = sanitize_display_name(inviter.first_name) if inviter.first_name else None
+                        if safe_name:
+                            inviter_name_display = safe_name
+                        elif inviter.username:
+                            inviter_name_display = username_for_display(inviter.username, with_at=False)
+
+                details_message = _(
+                    "payment_successful_with_referral_bonus_full",
+                    months=subscription_months,
+                    base_end_date=base_subscription_end_date.strftime('%Y-%m-%d'),
+                    bonus_days=applied_referee_bonus_days_from_referral,
+                    final_end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
+                    inviter_name=inviter_name_display,
+                    config_link=config_link,
+                )
+            elif applied_promo_bonus_days > 0 and final_end_date_for_user:
+                details_message = _(
+                    "payment_successful_with_promo_full",
+                    months=subscription_months,
+                    bonus_days=applied_promo_bonus_days,
+                    end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
+                    config_link=config_link,
+                )
+            elif final_end_date_for_user:
+                details_message = _(
+                    "payment_successful_full",
+                    months=subscription_months,
+                    end_date=final_end_date_for_user.strftime('%Y-%m-%d'),
+                    config_link=config_link,
+                )
+            else:
+                logging.error(
+                    f"Critical error: final_end_date_for_user is None for user {user_id} after successful payment logic."
+                )
+                details_message = _("payment_successful_error_details")
+
+            details_markup = get_connect_and_main_keyboard(
+                user_lang, i18n, settings, config_link, preserve_message=True
+            )
         try:
             await bot.send_message(
                 user_id,
@@ -313,6 +408,40 @@ async def yookassa_webhook_route(request: web.Request):
             )
             return web.Response(status=200, text="ok_error_no_metadata")
 
+        # Safely extract payment_method details (SDK objects may not have to_dict)
+        pm_obj = getattr(payment_data_from_notification, 'payment_method', None)
+        pm_dict = None
+        if pm_obj is not None:
+            try:
+                card_obj = getattr(pm_obj, 'card', None)
+                pm_dict = {
+                    "id": getattr(pm_obj, 'id', None),
+                    "type": getattr(pm_obj, 'type', None),
+                    "saved": bool(getattr(pm_obj, 'saved', False)),
+                    "title": getattr(pm_obj, 'title', None),
+                    "account_number": (
+                        getattr(pm_obj, 'account_number', None)
+                        if hasattr(pm_obj, 'account_number') else (
+                            getattr(pm_obj, 'account', None)
+                            if hasattr(pm_obj, 'account') else None
+                        )
+                    ),
+                    "card": (
+                        {
+                            "first6": getattr(card_obj, 'first6', None),
+                            "last4": getattr(card_obj, 'last4', None),
+                            "expiry_month": getattr(card_obj, 'expiry_month', None),
+                            "expiry_year": getattr(card_obj, 'expiry_year', None),
+                            "card_type": getattr(card_obj, 'card_type', None),
+                        }
+                        if card_obj is not None
+                        else None
+                    ),
+                }
+            except Exception:
+                logging.exception("Failed to serialize YooKassa payment_method from webhook")
+                pm_dict = None
+
         payment_dict_for_processing = {
             "id":
             str(payment_data_from_notification.id),
@@ -329,6 +458,7 @@ async def yookassa_webhook_route(request: web.Request):
             "description":
             str(payment_data_from_notification.description)
             if payment_data_from_notification.description else None,
+            "payment_method": pm_dict,
         }
 
         async with payment_processing_lock:
@@ -354,6 +484,84 @@ async def yookassa_webhook_route(request: web.Request):
                             session, bot, payment_dict_for_processing,
                             i18n_instance, settings)
                         await session.commit()
+                    elif notification_object.event == YOOKASSA_EVENT_PAYMENT_WAITING_FOR_CAPTURE:
+                        # Bind-only flow: save method and cancel auth if metadata has bind_only
+                        metadata = payment_dict_for_processing.get("metadata", {}) or {}
+                        if getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False) and metadata.get("bind_only") == "1":
+                            try:
+                                user_id_str = metadata.get("user_id")
+                                if user_id_str and user_id_str.isdigit():
+                                    user_id = int(user_id_str)
+                                    payment_method = payment_dict_for_processing.get("payment_method")
+                                    if isinstance(payment_method, dict) and payment_method.get("id"):
+                                        pm_type = payment_method.get("type")
+                                        title = payment_method.get("title")
+                                        card = payment_method.get("card") or {}
+                                        account_number = payment_method.get("account_number") or payment_method.get("account")
+                                        display_network = None
+                                        display_last4 = None
+                                        if (pm_type or "").lower() in {"bank_card", "bank-card", "card"}:
+                                            display_network = card.get("card_type") or title or "Card"
+                                            display_last4 = card.get("last4")
+                                        elif (pm_type or "").lower() in {"yoo_money", "yoomoney", "yoo-money", "wallet"}:
+                                            # Normalize wallet display name to avoid leaking full account from title
+                                            display_network = "YooMoney"
+                                            if isinstance(account_number, str) and len(account_number) >= 4:
+                                                display_last4 = account_number[-4:]
+                                            else:
+                                                display_last4 = None
+                                        else:
+                                            display_network = title or (pm_type.upper() if pm_type else "Payment method")
+                                            display_last4 = None
+                                        await user_billing_dal.upsert_yk_payment_method(
+                                            session,
+                                            user_id=user_id,
+                                            payment_method_id=payment_method.get("id"),
+                                            card_last4=display_last4,
+                                            card_network=display_network,
+                                        )
+                                        await session.commit()
+                                        # Save multi-card entry and mark default if first
+                                        try:
+                                            from db.dal import user_billing_dal as ub
+                                            await ub.upsert_user_payment_method(
+                                                session,
+                                                user_id=user_id,
+                                                provider_payment_method_id=payment_method.get("id"),
+                                                provider="yookassa",
+                                                card_last4=display_last4,
+                                                card_network=display_network,
+                                                set_default=True,
+                                            )
+                                            await session.commit()
+                                        except Exception:
+                                            await session.rollback()
+                                        # Notify user about successful binding with Back button
+                                        try:
+                                            # Use user's DB language for bind success notification
+                                            i18n_lang = settings.DEFAULT_LANGUAGE
+                                            from db.dal import user_dal
+                                            db_user = await user_dal.get_user_by_id(session, user_id)
+                                            if db_user and db_user.language_code:
+                                                i18n_lang = db_user.language_code
+                                            _ = lambda key, **kwargs: i18n_instance.gettext(i18n_lang, key, **kwargs)
+                                            from bot.keyboards.inline.user_keyboards import get_back_to_payment_methods_keyboard
+                                            await bot.send_message(
+                                                chat_id=user_id,
+                                                text=_("payment_method_bound_success"),
+                                                reply_markup=get_back_to_payment_methods_keyboard(i18n_lang, i18n_instance)
+                                            )
+                                        except Exception:
+                                            pass
+                                        # Attempt to cancel the authorization to avoid charge hold
+                                        try:
+                                            yk: YooKassaService = request.app.get('yookassa_service')
+                                            if yk:
+                                                await yk.cancel_payment(payment_dict_for_processing.get("id"))
+                                        except Exception:
+                                            logging.exception("Failed to cancel bind-only payment auth")
+                            except Exception:
+                                logging.exception("Failed to handle bind-only waiting_for_capture webhook")
                 except Exception as e_webhook_db_processing:
                     await session.rollback()
                     logging.error(

bot/handlers/user/start.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from aiogram import Router, F, types, Bot
 from aiogram.utils.text_decorations import html_decoration as hd
 from aiogram.filters import CommandStart, Command
@@ -6,16 +7,23 @@ from aiogram.fsm.context import FSMContext
 from typing import Optional, Union
 from sqlalchemy.ext.asyncio import AsyncSession
 from datetime import datetime, timezone
+from aiogram.exceptions import TelegramAPIError, TelegramBadRequest, TelegramForbiddenError
 
 from db.dal import user_dal
+from db.models import User
 
-from bot.keyboards.inline.user_keyboards import get_main_menu_inline_keyboard, get_language_selection_keyboard
+from bot.keyboards.inline.user_keyboards import (
+    get_main_menu_inline_keyboard,
+    get_language_selection_keyboard,
+    get_channel_subscription_keyboard,
+)
 from bot.services.subscription_service import SubscriptionService
 from bot.services.panel_api_service import PanelApiService
 from bot.services.referral_service import ReferralService
 from bot.services.promo_code_service import PromoCodeService
 from config.settings import Settings
 from bot.middlewares.i18n import JsonI18n
+from bot.utils.text_sanitizer import sanitize_username, sanitize_display_name
 
 router = Router(name="user_start_router")
 
@@ -42,14 +50,14 @@ async def send_main_menu(target_event: Union[types.Message,
                 await target_event.answer(err_msg_fallback, show_alert=True)
             except Exception:
                 pass
-        elif isinstance(target_event, types.Message) and hasattr(
-                target_event, 'chat') and target_event.chat:
+        elif isinstance(target_event, types.Message):
             try:
-                await target_event.chat.send_message(err_msg_fallback)
+                await target_event.answer(err_msg_fallback)
             except Exception:
                 pass
         return
 
+
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
 
     show_trial_button_in_menu = False
@@ -92,33 +100,220 @@ async def send_main_menu(target_event: Union[types.Message,
             await target_message_obj.answer(text, reply_markup=reply_markup)
 
         if isinstance(target_event, types.CallbackQuery):
-            await target_event.answer()
+            try:
+                await target_event.answer()
+            except Exception:
+                pass
     except Exception as e_send_edit:
         logging.warning(
             f"Failed to send/edit main menu (user: {user_id}, is_edit: {is_edit}): {type(e_send_edit).__name__} - {e_send_edit}."
         )
-        if is_edit and target_message_obj and hasattr(
-                target_message_obj, 'chat') and target_message_obj.chat:
+        if is_edit and target_message_obj:
             try:
-                await target_message_obj.chat.send_message(
-                    text, reply_markup=reply_markup)
+                await target_message_obj.answer(text, reply_markup=reply_markup)
             except Exception as e_send_new:
                 logging.error(
                     f"Also failed to send new main menu message for user {user_id}: {e_send_new}"
                 )
         if isinstance(target_event, types.CallbackQuery):
-            await target_event.answer(
-                _("error_occurred_try_again") if is_edit else None)
+            try:
+                await target_event.answer(
+                    _("error_occurred_try_again") if is_edit else None)
+            except Exception:
+                pass
+
+
+async def ensure_required_channel_subscription(
+        event: Union[types.Message, types.CallbackQuery],
+        settings: Settings,
+        i18n: Optional[JsonI18n],
+        current_lang: str,
+        session: AsyncSession,
+        db_user: Optional[User] = None) -> bool:
+    """
+    Verify that the user is a member of the required channel (if configured).
+    Returns True when access can proceed, False when user must subscribe first.
+    """
+    required_channel_id = settings.REQUIRED_CHANNEL_ID
+    if not required_channel_id:
+        return True
+
+    if isinstance(event, types.CallbackQuery):
+        user_id = event.from_user.id
+        bot_instance: Optional[Bot] = getattr(event, "bot", None)
+        if bot_instance is None and event.message:
+            bot_instance = event.message.bot
+        message_obj: Optional[types.Message] = event.message
+    else:
+        user_id = event.from_user.id
+        bot_instance = event.bot if hasattr(event, "bot") else None
+        message_obj = event
+
+    if bot_instance is None:
+        logging.error(
+            "Channel subscription check: bot instance missing for user %s.", user_id
+        )
+        return False
+
+    if user_id in settings.ADMIN_IDS:
+        return True
+
+    if db_user is None:
+        try:
+            db_user = await user_dal.get_user_by_id(session, user_id)
+        except Exception as fetch_error:
+            logging.error(
+                "Channel subscription check: failed to fetch user %s: %s",
+                user_id,
+                fetch_error,
+                exc_info=True,
+            )
+            return False
+
+    if not db_user:
+        logging.warning(
+            "Required channel check skipped because user %s is not persisted yet.",
+            user_id,
+        )
+        return True
+
+    if (db_user.channel_subscription_verified
+            and db_user.channel_subscription_verified_for
+            == required_channel_id):
+        return True
+
+    def translate(key: str, **kwargs) -> str:
+        if i18n:
+            return i18n.gettext(current_lang, key, **kwargs)
+        return key
+
+    now = datetime.now(timezone.utc)
+    is_member = False
+    status_value = None
+
+    try:
+        member = await bot_instance.get_chat_member(required_channel_id, user_id)
+        status = getattr(member, "status", None)
+        status_value = getattr(status, "value", status)
+        allowed_statuses = {"creator", "administrator", "member", "restricted"}
+        if status_value in allowed_statuses:
+            is_member = True
+    except TelegramBadRequest as bad_request:
+        logging.info(
+            "Required channel check: user %s not subscribed (details: %s)",
+            user_id,
+            bad_request,
+        )
+    except TelegramForbiddenError as forbidden_error:
+        logging.error(
+            "Required channel check failed due to insufficient permissions: %s",
+            forbidden_error,
+        )
+        error_text = translate("channel_subscription_check_failed")
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(error_text, show_alert=True)
+            except Exception:
+                pass
+            if message_obj:
+                try:
+                    await message_obj.answer(error_text)
+                except Exception:
+                    pass
+        else:
+            await event.answer(error_text)
+        return False
+    except TelegramAPIError as api_error:
+        logging.error(
+            "Required channel check failed for user %s: %s",
+            user_id,
+            api_error,
+            exc_info=True,
+        )
+        error_text = translate("channel_subscription_check_failed")
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(error_text, show_alert=True)
+            except Exception:
+                pass
+            if message_obj:
+                try:
+                    await message_obj.answer(error_text)
+                except Exception:
+                    pass
+        else:
+            await event.answer(error_text)
+        return False
+
+    update_payload = {
+        "channel_subscription_checked_at": now,
+        "channel_subscription_verified_for": required_channel_id,
+        "channel_subscription_verified": is_member,
+    }
+    try:
+        await user_dal.update_user(session, user_id, update_payload)
+    except Exception as update_error:
+        logging.error(
+            "Failed to persist channel verification result for user %s: %s",
+            user_id,
+            update_error,
+            exc_info=True,
+        )
+
+    if is_member:
+        logging.info(
+            "User %s confirmed as member of required channel %s (status=%s).",
+            user_id,
+            required_channel_id,
+            status_value,
+        )
+        return True
+
+    keyboard = (get_channel_subscription_keyboard(
+        current_lang, i18n, settings.REQUIRED_CHANNEL_LINK
+    )
+               if i18n else None)
+
+    prompt_text = translate("channel_subscription_required")
+
+    if isinstance(event, types.CallbackQuery):
+        if keyboard and event.message:
+            try:
+                await event.message.edit_text(prompt_text, reply_markup=keyboard)
+            except Exception as edit_error:
+                logging.debug(
+                    "Failed to edit prompt message for user %s: %s",
+                    user_id,
+                    edit_error,
+                )
+        if keyboard is None and message_obj:
+            try:
+                await message_obj.answer(prompt_text)
+            except Exception:
+                pass
+        try:
+            await event.answer(prompt_text, show_alert=True)
+        except Exception:
+            pass
+    else:
+        await event.answer(prompt_text, reply_markup=keyboard)
+
+    return False
 
 
 @router.message(CommandStart())
+@router.message(CommandStart(magic=F.args.regexp(r"^ref_(\d+)$").as_("ref_match")))
+@router.message(CommandStart(magic=F.args.regexp(r"^promo_(\w+)$").as_("promo_match")))
+@router.message(CommandStart(magic=F.args.regexp(r"^(?!ref_|promo_)([A-Za-z0-9_\-]{2,64})$").as_("ad_param_match")))
 async def start_command_handler(message: types.Message,
                                 state: FSMContext,
                                 settings: Settings,
                                 i18n_data: dict,
                                 subscription_service: SubscriptionService,
                                 session: AsyncSession,
-                                command: Optional[CommandStart] = None):
+                                ref_match: Optional[re.Match] = None,
+                                promo_match: Optional[re.Match] = None,
+                                ad_param_match: Optional[re.Match] = None):
     await state.clear()
     current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
     i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
@@ -130,36 +325,30 @@ async def start_command_handler(message: types.Message,
 
     referred_by_user_id: Optional[int] = None
     promo_code_to_apply: Optional[str] = None
-    
-    if command and command.args:
-        arg_payload = command.args
-        if arg_payload.startswith("ref_"):
-            try:
-                potential_referrer_id_str = arg_payload.split("_")[1]
-                if potential_referrer_id_str.isdigit():
-                    potential_referrer_id = int(potential_referrer_id_str)
-                    if potential_referrer_id != user_id:
-                        referred_by_user_id = potential_referrer_id
-            except (IndexError, ValueError) as e:
-                logging.warning(
-                    f"Could not parse referral from /start args '{arg_payload}': {e}"
-                )
-        elif arg_payload.startswith("promo_"):
-            try:
-                promo_code_to_apply = arg_payload.split("_")[1]
-                logging.info(f"User {user_id} started with promo code: {promo_code_to_apply}")
-            except (IndexError, ValueError) as e:
-                logging.warning(
-                    f"Could not parse promo code from /start args '{arg_payload}': {e}"
-                )
+    ad_start_param: Optional[str] = None
+
+    if ref_match:
+        potential_referrer_id = int(ref_match.group(1))
+        if await user_dal.get_user_by_id(session, potential_referrer_id):
+            referred_by_user_id = potential_referrer_id
+    elif promo_match:
+        promo_code_to_apply = promo_match.group(1)
+        logging.info(f"User {user_id} started with promo code: {promo_code_to_apply}")
+    elif ad_param_match:
+        ad_start_param = ad_param_match.group(1)
+        logging.info(f"User {user_id} started with ad start param: {ad_start_param}")
+
+    sanitized_username = sanitize_username(user.username)
+    sanitized_first_name = sanitize_display_name(user.first_name)
+    sanitized_last_name = sanitize_display_name(user.last_name)
 
     db_user = await user_dal.get_user_by_id(session, user_id)
     if not db_user:
         user_data_to_create = {
             "user_id": user_id,
-            "username": user.username,
-            "first_name": user.first_name,
-            "last_name": user.last_name,
+            "username": sanitized_username,
+            "first_name": sanitized_first_name,
+            "last_name": sanitized_last_name,
             "language_code": current_lang,
             "referred_by_id": referred_by_user_id,
             "registration_date": datetime.now(timezone.utc)
@@ -178,8 +367,8 @@ async def start_command_handler(message: types.Message,
                     notification_service = NotificationService(message.bot, settings, i18n)
                     await notification_service.notify_new_user_registration(
                         user_id=user_id,
-                        username=user.username,
-                        first_name=user.first_name,
+                        username=sanitized_username,
+                        first_name=sanitized_first_name,
                         referred_by_id=referred_by_user_id
                     )
                 except Exception as e:
@@ -204,12 +393,12 @@ async def start_command_handler(message: types.Message,
                 is_active_now = False
             if not is_active_now:
                 update_payload["referred_by_id"] = referred_by_user_id
-        if user.username != db_user.username:
-            update_payload["username"] = user.username
-        if user.first_name != db_user.first_name:
-            update_payload["first_name"] = user.first_name
-        if user.last_name != db_user.last_name:
-            update_payload["last_name"] = user.last_name
+        if sanitized_username != db_user.username:
+            update_payload["username"] = sanitized_username
+        if sanitized_first_name != db_user.first_name:
+            update_payload["first_name"] = sanitized_first_name
+        if sanitized_last_name != db_user.last_name:
+            update_payload["last_name"] = sanitized_last_name
 
         if update_payload:
             try:
@@ -224,55 +413,75 @@ async def start_command_handler(message: types.Message,
                     f"Failed to update existing user {user_id} in session: {e_update}",
                     exc_info=True)
 
+    # Attribute user to ad campaign if start param provided
+    if ad_start_param:
+        try:
+            from db.dal import ad_dal as _ad_dal
+            campaign = await _ad_dal.get_campaign_by_start_param(session, ad_start_param)
+            if campaign and campaign.is_active:
+                await _ad_dal.ensure_attribution(session, user_id=user_id, campaign_id=campaign.ad_campaign_id)
+                await session.commit()
+        except Exception as e_attr:
+            logging.error(f"Failed to attribute user {user_id} to ad '{ad_start_param}': {e_attr}")
+            try:
+                await session.rollback()
+            except Exception:
+                pass
+
+    if not await ensure_required_channel_subscription(message, settings, i18n,
+                                                      current_lang, session,
+                                                      db_user):
+        return
+
     # Send welcome message if not disabled
     if not settings.DISABLE_WELCOME_MESSAGE:
         await message.answer(_(key="welcome", user_name=hd.quote(user.full_name)))
-    
+
     # Auto-apply promo code if provided via start parameter
     if promo_code_to_apply:
         try:
             from bot.services.promo_code_service import PromoCodeService
             promo_code_service = PromoCodeService(settings, subscription_service, message.bot, i18n)
-            
+
             success, result = await promo_code_service.apply_promo_code(
                 session, user_id, promo_code_to_apply, current_lang
             )
-            
+
             if success:
                 await session.commit()
                 logging.info(f"Auto-applied promo code '{promo_code_to_apply}' for user {user_id}")
-                
+
                 # Get updated subscription details
                 active = await subscription_service.get_active_subscription_details(session, user_id)
                 config_link = active.get("config_link") if active else None
                 config_link = config_link or _("config_link_not_available")
-                
+
                 new_end_date = result if isinstance(result, datetime) else None
-                
+
                 promo_success_text = _(
                     "promo_code_applied_success_full",
                     end_date=(new_end_date.strftime("%d.%m.%Y %H:%M:%S") if new_end_date else "N/A"),
                     config_link=config_link,
                 )
-                
+
                 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
                 await message.answer(
                     promo_success_text,
                     reply_markup=get_connect_and_main_keyboard(current_lang, i18n, settings, config_link),
                     parse_mode="HTML"
                 )
-                
+
                 # Don't show main menu if promo was successfully applied
                 return
             else:
                 await session.rollback()
                 logging.warning(f"Failed to auto-apply promo code '{promo_code_to_apply}' for user {user_id}: {result}")
                 # Continue to show main menu if promo failed
-                
+
         except Exception as e:
             logging.error(f"Error auto-applying promo code '{promo_code_to_apply}' for user {user_id}: {e}")
             await session.rollback()
-    
+
     await send_main_menu(message,
                          settings,
                          i18n_data,
@@ -281,6 +490,57 @@ async def start_command_handler(message: types.Message,
                          is_edit=False)
 
 
+@router.callback_query(F.data == "channel_subscription:verify")
+async def verify_channel_subscription_callback(
+        callback: types.CallbackQuery,
+        settings: Settings,
+        i18n_data: dict,
+        subscription_service: SubscriptionService,
+        session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+
+    db_user = await user_dal.get_user_by_id(session, callback.from_user.id)
+
+    verified = await ensure_required_channel_subscription(
+        callback, settings, i18n, current_lang, session, db_user)
+    if not verified:
+        return
+
+    if db_user and db_user.language_code:
+        current_lang = db_user.language_code
+        i18n_data["current_language"] = current_lang
+
+    if i18n:
+        _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs)
+    else:
+        _ = lambda key, **kwargs: key
+
+    if not settings.DISABLE_WELCOME_MESSAGE:
+        welcome_text = _(key="welcome",
+                         user_name=hd.quote(callback.from_user.full_name))
+        if callback.message:
+            await callback.message.answer(welcome_text)
+        else:
+            fallback_bot: Optional[Bot] = getattr(callback, "bot", None)
+            if fallback_bot:
+                await fallback_bot.send_message(callback.from_user.id,
+                                                welcome_text)
+
+    try:
+        await callback.answer(_(key="channel_subscription_verified_success"),
+                              show_alert=True)
+    except Exception:
+        pass
+
+    await send_main_menu(callback,
+                         settings,
+                         i18n_data,
+                         subscription_service,
+                         session,
+                         is_edit=bool(callback.message))
+
+
 @router.message(Command("language"))
 @router.callback_query(F.data == "main_action:language")
 async def language_command_handler(
@@ -385,10 +645,13 @@ async def main_action_callback_handler(
         await user_subscription_handlers.display_subscription_options(
             callback, i18n_data, settings, session)
     elif action == "my_subscription":
-
         await user_subscription_handlers.my_subscription_command_handler(
             callback, i18n_data, settings, panel_service, subscription_service,
             session, bot)
+    elif action == "my_devices":
+        await user_subscription_handlers.my_devices_command_handler(
+            callback, i18n_data, settings, panel_service, subscription_service,
+            session, bot)
     elif action == "referral":
         await user_referral_handlers.referral_command_handler(
             callback, settings, i18n_data, referral_service, bot, session)
@@ -408,6 +671,13 @@ async def main_action_callback_handler(
                              subscription_service,
                              session,
                              is_edit=True)
+    elif action == "back_to_main_keep":
+        await send_main_menu(callback,
+                             settings,
+                             i18n_data,
+                             subscription_service,
+                             session,
+                             is_edit=False)
     else:
         i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
         _ = lambda key, **kwargs: i18n.gettext(

bot/handlers/user/subscription.py

@@ -1,469 +0,0 @@
-import logging
-from aiogram import Router, F, types, Bot
-from aiogram.filters import Command
-from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, LabeledPrice
-from typing import Optional, Dict, Any, Union
-from datetime import datetime, timezone
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from config.settings import Settings
-from db.dal import payment_dal
-from bot.keyboards.inline.user_keyboards import (
-    get_subscription_options_keyboard, get_payment_method_keyboard,
-    get_payment_url_keyboard, get_back_to_main_menu_markup)
-from bot.services.yookassa_service import YooKassaService
-from bot.services.stars_service import StarsService
-from bot.services.crypto_pay_service import CryptoPayService
-from bot.services.subscription_service import SubscriptionService
-from bot.services.panel_api_service import PanelApiService
-from bot.services.referral_service import ReferralService
-from bot.middlewares.i18n import JsonI18n
-
-router = Router(name="user_subscription_router")
-
-
-async def display_subscription_options(event: Union[types.Message,
-                                                    types.CallbackQuery],
-                                       i18n_data: dict, settings: Settings,
-                                       session: AsyncSession):
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-
-    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs
-                                                  ) if i18n else key
-
-    if not i18n:
-        err_msg = "Language service error."
-        if isinstance(event, types.CallbackQuery):
-            await event.answer(err_msg, show_alert=True)
-        elif isinstance(event, types.Message):
-            await event.answer(err_msg)
-        return
-
-    currency_symbol_val = settings.DEFAULT_CURRENCY_SYMBOL
-    text_content = get_text("select_subscription_period"
-                            ) if settings.subscription_options else get_text(
-                                "no_subscription_options_available")
-
-    reply_markup = get_subscription_options_keyboard(
-        settings.subscription_options, currency_symbol_val, current_lang, i18n
-    ) if settings.subscription_options else get_back_to_main_menu_markup(
-        current_lang, i18n)
-
-    target_message_obj = event.message if isinstance(
-        event, types.CallbackQuery) else event
-    if not target_message_obj:
-        if isinstance(event, types.CallbackQuery):
-            await event.answer(get_text("error_occurred_try_again"),
-                               show_alert=True)
-        return
-
-    if isinstance(event, types.CallbackQuery):
-        try:
-            await target_message_obj.edit_text(text_content,
-                                               reply_markup=reply_markup)
-        except Exception:
-            await target_message_obj.answer(text_content,
-                                            reply_markup=reply_markup)
-        await event.answer()
-    else:
-        await target_message_obj.answer(text_content,
-                                        reply_markup=reply_markup)
-
-
-@router.callback_query(F.data.startswith("subscribe_period:"))
-async def select_subscription_period_callback_handler(
-        callback: types.CallbackQuery, settings: Settings, i18n_data: dict,
-        session: AsyncSession):
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs
-                                                  ) if i18n else key
-
-    if not i18n or not callback.message:
-        await callback.answer(get_text("error_occurred_try_again"),
-                              show_alert=True)
-        return
-
-    try:
-        months = int(callback.data.split(":")[-1])
-    except (ValueError, IndexError):
-        logging.error(
-            f"Invalid subscription period in callback_data: {callback.data}")
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    price_rub = settings.subscription_options.get(months)
-    if price_rub is None:
-        logging.error(
-            f"Price not found for {months} months subscription period in settings.subscription_options."
-        )
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    currency_symbol_val = settings.DEFAULT_CURRENCY_SYMBOL
-    text_content = get_text("choose_payment_method")
-    tribute_url = settings.tribute_payment_links.get(months)
-    stars_price = settings.stars_subscription_options.get(months)
-    reply_markup = get_payment_method_keyboard(
-        months,
-        price_rub,
-        tribute_url,
-        stars_price,
-        currency_symbol_val,
-        current_lang,
-        i18n,
-        settings,
-    )
-
-    try:
-        await callback.message.edit_text(text_content,
-                                         reply_markup=reply_markup)
-    except Exception as e_edit:
-        logging.warning(
-            f"Edit message for payment method selection failed: {e_edit}. Sending new one."
-        )
-        await callback.message.answer(text_content,
-                                      reply_markup=reply_markup)
-    await callback.answer()
-
-
-@router.callback_query(F.data.startswith("pay_stars:"))
-async def pay_stars_callback_handler(
-        callback: types.CallbackQuery, settings: Settings, i18n_data: dict,
-        session: AsyncSession, bot: Bot, stars_service: StarsService):
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-
-    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
-
-    if not i18n or not callback.message:
-        await callback.answer(get_text("error_occurred_try_again"), show_alert=True)
-        return
-
-    try:
-        _, data_payload = callback.data.split(":", 1)
-        months_str, price_str = data_payload.split(":")
-        months = int(months_str)
-        stars_price = int(price_str)
-    except (ValueError, IndexError):
-        logging.error(f"Invalid pay_stars data in callback: {callback.data}")
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    user_id = callback.from_user.id
-    payment_description = get_text("payment_description_subscription", months=months)
-
-    payment_id = await stars_service.create_invoice(
-        session, user_id, months, stars_price, payment_description)
-    if payment_id is None:
-        await callback.message.edit_text(get_text("error_payment_gateway"))
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    await callback.answer()
-
-
-@router.callback_query(F.data.startswith("pay_yk:"))
-async def pay_yk_callback_handler(
-        callback: types.CallbackQuery, settings: Settings, i18n_data: dict,
-        yookassa_service: YooKassaService, session: AsyncSession):
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-
-    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs
-                                                  ) if i18n else key
-
-    if not i18n or not callback.message:
-
-        await callback.answer(get_text("error_occurred_try_again"),
-                              show_alert=True)
-        return
-
-    if not yookassa_service or not yookassa_service.configured:
-        logging.error("YooKassa service is not configured or unavailable.")
-        target_msg_edit = callback.message
-        await target_msg_edit.edit_text(get_text("payment_service_unavailable")
-                                        )
-        await callback.answer(get_text("payment_service_unavailable_alert"),
-                              show_alert=True)
-        return
-
-    try:
-        _, data_payload = callback.data.split(":", 1)
-        months_str, price_str = data_payload.split(":")
-        months = int(months_str)
-        price_rub = float(price_str)
-    except (ValueError, IndexError):
-        logging.error(
-            f"Invalid pay_yk data in callback: {callback.data}")
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    user_id = callback.from_user.id
-
-    payment_description = get_text("payment_description_subscription",
-                                   months=months)
-    currency_code_for_yk = "RUB"
-
-    payment_record_data = {
-        "user_id": user_id,
-        "amount": price_rub,
-        "currency": currency_code_for_yk,
-        "status": "pending_yookassa",
-        "description": payment_description,
-        "subscription_duration_months": months,
-    }
-    db_payment_record = None
-    try:
-        db_payment_record = await payment_dal.create_payment_record(
-            session, payment_record_data)
-        await session.commit()
-        logging.info(
-            f"Payment record {db_payment_record.payment_id} created for user {user_id} with status 'pending_yookassa'."
-        )
-    except Exception as e_db_payment:
-        await session.rollback()
-        logging.error(
-            f"Failed to create payment record in DB for user {user_id}: {e_db_payment}",
-            exc_info=True)
-        await callback.message.edit_text(
-            get_text("error_creating_payment_record"))
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    if not db_payment_record:
-        await callback.message.edit_text(
-            get_text("error_creating_payment_record"))
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    yookassa_metadata = {
-        "user_id": str(user_id),
-        "subscription_months": str(months),
-        "payment_db_id": str(db_payment_record.payment_id),
-    }
-    receipt_email_for_yk = settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL
-
-    payment_response_yk = await yookassa_service.create_payment(
-        amount=price_rub,
-        currency=currency_code_for_yk,
-        description=payment_description,
-        metadata=yookassa_metadata,
-        receipt_email=receipt_email_for_yk)
-
-    if payment_response_yk and payment_response_yk.get("confirmation_url"):
-        try:
-            await payment_dal.update_payment_status_by_db_id(
-                session,
-                payment_db_id=db_payment_record.payment_id,
-                new_status=payment_response_yk.get("status", "pending"),
-                yk_payment_id=payment_response_yk.get("id"))
-            await session.commit()
-        except Exception as e_db_update_ykid:
-            await session.rollback()
-            logging.error(
-                f"Failed to update payment record {db_payment_record.payment_id} with YK ID: {e_db_update_ykid}",
-                exc_info=True)
-            await callback.message.edit_text(
-                get_text("error_payment_gateway_link_failed"))
-            await callback.answer(get_text("error_try_again"), show_alert=True)
-            return
-
-        await callback.message.edit_text(
-            get_text(key="payment_link_message", months=months),
-            reply_markup=get_payment_url_keyboard(
-                payment_response_yk["confirmation_url"], current_lang, i18n),
-            disable_web_page_preview=False)
-    else:
-        try:
-            await payment_dal.update_payment_status_by_db_id(
-                session, db_payment_record.payment_id, "failed_creation")
-            await session.commit()
-        except Exception as e_db_fail_create:
-            await session.rollback()
-            logging.error(
-                f"Additionally failed to update payment record to 'failed_creation': {e_db_fail_create}",
-                exc_info=True)
-
-        logging.error(
-            f"Failed to create payment in YooKassa for user {user_id}, payment_db_id {db_payment_record.payment_id}. Response: {payment_response_yk}"
-        )
-        await callback.message.edit_text(get_text("error_payment_gateway"))
-
-    await callback.answer()
-
-
-@router.callback_query(F.data.startswith("pay_crypto:"))
-async def pay_crypto_callback_handler(
-        callback: types.CallbackQuery, settings: Settings, i18n_data: dict,
-        cryptopay_service: CryptoPayService, session: AsyncSession):
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
-    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
-
-    if not i18n or not callback.message:
-        await callback.answer(get_text("error_occurred_try_again"), show_alert=True)
-        return
-
-    if not cryptopay_service or not cryptopay_service.configured:
-        await callback.message.edit_text(get_text("payment_service_unavailable"))
-        await callback.answer(get_text("payment_service_unavailable_alert"), show_alert=True)
-        return
-
-    try:
-        _, data_payload = callback.data.split(":", 1)
-        months_str, amount_str = data_payload.split(":")
-        months = int(months_str)
-        amount_val = float(amount_str)
-    except (ValueError, IndexError):
-        logging.error(f"Invalid pay_crypto data in callback: {callback.data}")
-        await callback.answer(get_text("error_try_again"), show_alert=True)
-        return
-
-    user_id = callback.from_user.id
-    description = get_text("payment_description_subscription", months=months)
-
-    invoice_url = await cryptopay_service.create_invoice(
-        session, user_id, months, amount_val, description)
-    if invoice_url:
-        await callback.message.edit_text(
-            get_text("payment_link_message", months=months),
-            reply_markup=get_payment_url_keyboard(invoice_url, current_lang, i18n),
-            disable_web_page_preview=False,
-        )
-    else:
-        await callback.message.edit_text(get_text("error_payment_gateway"))
-    await callback.answer()
-
-
-@router.callback_query(F.data == "main_action:subscribe")
-async def reshow_subscription_options_callback(callback: types.CallbackQuery,
-                                               i18n_data: dict,
-                                               settings: Settings,
-                                               session: AsyncSession):
-    await display_subscription_options(callback, i18n_data, settings, session)
-
-
-async def my_subscription_command_handler(
-    event: Union[types.Message, types.CallbackQuery],
-    i18n_data: dict,
-    settings: Settings,
-    panel_service: PanelApiService,
-    subscription_service: SubscriptionService,
-    session: AsyncSession,
-    bot: Bot
-):
-    target = event.message if isinstance(event, types.CallbackQuery) else event
-    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
-    i18n: JsonI18n = i18n_data.get("i18n_instance")
-    get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
-
-    if not i18n or not target:
-        if isinstance(event, types.Message):
-            await event.answer(get_text("error_occurred_try_again"))
-        return
-
-    if not panel_service or not subscription_service:
-        await target.answer(get_text("error_service_unavailable"))
-        return
-
-    active = await subscription_service.get_active_subscription_details(session, event.from_user.id)
-
-    if not active:
-        text = get_text("subscription_not_active")
-
-        buy_button = InlineKeyboardButton(
-            text=get_text("menu_subscribe_inline", default="Купить"),
-            callback_data="main_action:subscribe"
-        )
-        back_markup = get_back_to_main_menu_markup(current_lang, i18n)
-
-        kb = InlineKeyboardMarkup(
-            inline_keyboard=[
-                [buy_button],
-                *back_markup.inline_keyboard
-            ]
-        )
-
-        if isinstance(event, types.CallbackQuery):
-            await event.answer()
-            try:
-                await event.message.edit_text(text, reply_markup=kb)
-            except:
-                await event.message.answer(text, reply_markup=kb)
-        else:
-            await event.answer(text, reply_markup=kb)
-        return
-
-    end_date = active.get("end_date")
-    days_left = (
-        (end_date.date() - datetime.now().date()).days
-        if end_date else 0
-    )
-    text = get_text(
-        "my_subscription_details",
-        end_date=end_date.strftime("%Y-%m-%d") if end_date else "N/A",
-        days_left=max(0, days_left),
-        status=active.get("status_from_panel", get_text("status_active")).capitalize(),
-        config_link=active.get("config_link") or get_text("config_link_not_available"),
-        traffic_limit=(
-            f"{active['traffic_limit_bytes'] / 2**30:.2f} GB"
-            if active.get("traffic_limit_bytes")
-            else get_text("traffic_unlimited")
-        ),
-        traffic_used=(
-            f"{active['traffic_used_bytes'] / 2**30:.2f} GB"
-            if active.get("traffic_used_bytes") is not None
-            else get_text("traffic_na")
-        )
-    )
-    markup = get_back_to_main_menu_markup(current_lang, i18n)
-
-    if isinstance(event, types.CallbackQuery):
-        await event.answer()
-        try:
-            await event.message.edit_text(text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
-        except:
-            await bot.send_message(chat_id=target.chat.id, text=text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
-    else:
-        await target.answer(text, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
-
-
-@router.pre_checkout_query()
-async def stars_pre_checkout_handler(pre_checkout_query: types.PreCheckoutQuery):
-    await pre_checkout_query.answer(ok=True)
-
-
-@router.message(F.successful_payment)
-async def stars_successful_payment_handler(
-        message: types.Message, settings: Settings, i18n_data: dict,
-        session: AsyncSession, stars_service: StarsService):
-    sp = message.successful_payment
-    if not sp or sp.currency != "XTR":
-        return
-
-    payload = sp.invoice_payload or ""
-    try:
-        payment_id_str, months_str = payload.split(":")
-        payment_db_id = int(payment_id_str)
-        months = int(months_str)
-    except (ValueError, IndexError):
-        logging.error(f"Invalid invoice payload for stars payment: {payload}")
-        return
-
-    stars_amount = sp.total_amount
-    await stars_service.process_successful_payment(
-        session, message, payment_db_id, months, stars_amount, i18n_data)
-
-
-@router.message(Command("connect"))
-async def connect_command_handler(message: types.Message, i18n_data: dict,
-                                  settings: Settings,
-                                  panel_service: PanelApiService,
-                                  subscription_service: SubscriptionService,
-                                  session: AsyncSession, bot: Bot):
-    logging.info(f"User {message.from_user.id} used /connect command.")
-    await my_subscription_command_handler(message, i18n_data, settings,
-                                          panel_service, subscription_service,
-                                          session, bot)

bot/handlers/user/subscription/__init__.py

@@ -0,0 +1,17 @@
+from aiogram import Router
+
+from . import core
+from . import payments
+from . import payment_methods
+
+router = Router(name="user_subscription_router")
+
+# Include sub-routers
+router.include_router(core.router)
+router.include_router(payments.router)
+router.include_router(payment_methods.router)
+
+# Re-export commonly used entrypoints for backward compatibility
+from .core import display_subscription_options, my_subscription_command_handler, my_devices_command_handler  # noqa: E402,F401
+
+

bot/handlers/user/subscription/core.py

@@ -0,0 +1,538 @@
+import logging
+from aiogram import Router, F, types, Bot
+from aiogram.filters import Command
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, WebAppInfo
+from typing import Optional, Union
+from datetime import datetime
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+
+from config.settings import Settings
+from bot.keyboards.inline.user_keyboards import (
+    get_subscription_options_keyboard,
+    get_back_to_main_menu_markup,
+    get_autorenew_confirm_keyboard,
+)
+from bot.services.subscription_service import SubscriptionService
+from bot.services.panel_api_service import PanelApiService
+from bot.middlewares.i18n import JsonI18n
+from db.dal import subscription_dal
+from db.models import Subscription
+
+router = Router(name="user_subscription_core_router")
+
+
+async def display_subscription_options(event: Union[types.Message, types.CallbackQuery], i18n_data: dict, settings: Settings, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    if not i18n:
+        err_msg = "Language service error."
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(err_msg, show_alert=True)
+            except Exception:
+                pass
+        elif isinstance(event, types.Message):
+            await event.answer(err_msg)
+        return
+
+    currency_symbol_val = settings.DEFAULT_CURRENCY_SYMBOL
+    text_content = get_text("select_subscription_period") if settings.subscription_options else get_text("no_subscription_options_available")
+
+    reply_markup = (
+        get_subscription_options_keyboard(settings.subscription_options, currency_symbol_val, current_lang, i18n)
+        if settings.subscription_options
+        else get_back_to_main_menu_markup(current_lang, i18n)
+    )
+
+    target_message_obj = event.message if isinstance(event, types.CallbackQuery) else event
+    if not target_message_obj:
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(get_text("error_occurred_try_again"), show_alert=True)
+            except Exception:
+                pass
+        return
+
+    if isinstance(event, types.CallbackQuery):
+        try:
+            await target_message_obj.edit_text(text_content, reply_markup=reply_markup)
+        except Exception:
+            await target_message_obj.answer(text_content, reply_markup=reply_markup)
+        try:
+            await event.answer()
+        except Exception:
+            pass
+    else:
+        await target_message_obj.answer(text_content, reply_markup=reply_markup)
+
+
+@router.callback_query(F.data == "main_action:subscribe")
+async def reshow_subscription_options_callback(callback: types.CallbackQuery, i18n_data: dict, settings: Settings, session: AsyncSession):
+    await display_subscription_options(callback, i18n_data, settings, session)
+
+
+async def my_subscription_command_handler(
+    event: Union[types.Message, types.CallbackQuery],
+    i18n_data: dict,
+    settings: Settings,
+    panel_service: PanelApiService,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    bot: Bot,
+):
+    target = event.message if isinstance(event, types.CallbackQuery) else event
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: JsonI18n = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
+
+    if not i18n or not target:
+        if isinstance(event, types.Message):
+            await event.answer(get_text("error_occurred_try_again"))
+        return
+
+    if not panel_service or not subscription_service:
+        await target.answer(get_text("error_service_unavailable"))
+        return
+
+    active = await subscription_service.get_active_subscription_details(session, event.from_user.id)
+
+    if not active:
+        text = get_text("subscription_not_active")
+
+        buy_button = InlineKeyboardButton(
+            text=get_text("menu_subscribe_inline", default="Купить"), callback_data="main_action:subscribe"
+        )
+        back_markup = get_back_to_main_menu_markup(current_lang, i18n)
+
+        kb = InlineKeyboardMarkup(inline_keyboard=[[buy_button], *back_markup.inline_keyboard])
+
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer()
+            except Exception:
+                pass
+            try:
+                await event.message.edit_text(text, reply_markup=kb)
+            except Exception:
+                await event.message.answer(text, reply_markup=kb)
+        else:
+            await event.answer(text, reply_markup=kb)
+        return
+
+    end_date = active.get("end_date")
+    days_left = (end_date.date() - datetime.now().date()).days if end_date else 0
+    tribute_hint = ""
+    if active.get("status_from_panel", "").lower() == "active":
+        local_sub = await subscription_dal.get_active_subscription_by_user_id(session, event.from_user.id)
+        if local_sub:
+            if local_sub.provider == "tribute":
+                link = None
+                link = settings.tribute_payment_links.get(local_sub.duration_months or 1) if hasattr(settings, "tribute_payment_links") else None
+                tribute_hint = "\n\n" + (
+                    get_text("subscription_tribute_notice_with_link", link=link) if link else get_text("subscription_tribute_notice")
+                )
+
+    text = get_text(
+        "my_subscription_details",
+        end_date=end_date.strftime("%Y-%m-%d") if end_date else "N/A",
+        days_left=max(0, days_left),
+        status=active.get("status_from_panel", get_text("status_active")).capitalize(),
+        config_link=active.get("config_link") or get_text("config_link_not_available"),
+        traffic_limit=(f"{active['traffic_limit_bytes'] / 2**30:.2f} GB" if active.get("traffic_limit_bytes") else get_text("traffic_unlimited")),
+        traffic_used=(
+            f"{active['traffic_used_bytes'] / 2**30:.2f} GB" if active.get("traffic_used_bytes") is not None else get_text("traffic_na")
+        ),
+    )
+
+    base_markup = get_back_to_main_menu_markup(current_lang, i18n)
+    kb = base_markup.inline_keyboard
+    try:
+        local_sub = await subscription_dal.get_active_subscription_by_user_id(session, event.from_user.id)
+        # Build rows to prepend above the base "back" markup
+        prepend_rows = []
+
+        # 1) Mini-app connect button on top if enabled, otherwise fall back to config link URL
+        if settings.SUBSCRIPTION_MINI_APP_URL:
+            prepend_rows.append([
+                InlineKeyboardButton(
+                    text=get_text("connect_button"),
+                    web_app=WebAppInfo(url=settings.SUBSCRIPTION_MINI_APP_URL),
+                )
+            ])
+        else:
+            cfg_link_val = (active or {}).get("config_link")
+            if cfg_link_val:
+                prepend_rows.append([
+                    InlineKeyboardButton(
+                        text=get_text("connect_button"),
+                        url=cfg_link_val,
+                    )
+                ])
+
+        if settings.MY_DEVICES_SECTION_ENABLED:
+            max_devices_value = active.get("max_devices")
+            max_devices_display = get_text("devices_unlimited_label")
+            if max_devices_value not in (None, 0):
+                try:
+                    max_devices_int = int(max_devices_value)
+                    if max_devices_int >= 0:
+                        max_devices_display = str(max_devices_int)
+                except (TypeError, ValueError):
+                    max_devices_display = str(max_devices_value)
+            devices_button_text = get_text(
+                "devices_button",
+                current_devices="?",
+                max_devices=max_devices_display,
+            )
+            prepend_rows.append([
+                InlineKeyboardButton(
+                    text=devices_button_text,
+                    callback_data="main_action:my_devices",
+                )
+            ])
+
+        # 2) Auto-renew toggle (if supported and not tribute)
+        if local_sub and local_sub.provider != "tribute" and getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+            toggle_text = (
+                get_text("autorenew_disable_button") if local_sub.auto_renew_enabled else get_text("autorenew_enable_button")
+            )
+            prepend_rows.append([
+                InlineKeyboardButton(
+                    text=toggle_text,
+                    callback_data=f"toggle_autorenew:{local_sub.subscription_id}:{1 if not local_sub.auto_renew_enabled else 0}",
+                )
+            ])
+
+        # 3) Payment methods management (when autopayments enabled)
+        if getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+            prepend_rows.append([
+                InlineKeyboardButton(text=get_text("payment_methods_manage_button"), callback_data="pm:manage")
+            ])
+
+        if prepend_rows:
+            kb = prepend_rows + kb
+    except Exception:
+        pass
+    markup = InlineKeyboardMarkup(inline_keyboard=kb)
+
+    if isinstance(event, types.CallbackQuery):
+        try:
+            await event.answer()
+        except Exception:
+            pass
+        try:
+            await event.message.edit_text(text + tribute_hint, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
+        except Exception:
+            await bot.send_message(
+                chat_id=target.chat.id,
+                text=text + tribute_hint,
+                reply_markup=markup,
+                parse_mode="HTML",
+                disable_web_page_preview=True,
+            )
+    else:
+        await target.answer(text + tribute_hint, reply_markup=markup, parse_mode="HTML", disable_web_page_preview=True)
+
+
+@router.callback_query(F.data == "main_action:my_devices")
+async def my_devices_command_handler(
+    event: Union[types.Message, types.CallbackQuery],
+    i18n_data: dict,
+    settings: Settings,
+    panel_service: PanelApiService,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    bot: Bot,
+):
+    target = event.message if isinstance(event, types.CallbackQuery) else event
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: JsonI18n = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kw: i18n.gettext(current_lang, key, **kw)
+
+    if not i18n or not target:
+        if isinstance(event, types.Message):
+            await event.answer(get_text("error_occurred_try_again"))
+        return
+
+    if not settings.MY_DEVICES_SECTION_ENABLED:
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(get_text("my_devices_feature_disabled"), show_alert=True)
+            except Exception:
+                pass
+        else:
+            await target.answer(get_text("my_devices_feature_disabled"))
+        return
+
+    # TODO: context?
+    active = await subscription_service.get_active_subscription_details(session, event.from_user.id)
+    if not active or not active.get("user_id"):
+        message = get_text("subscription_not_active")
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(message, show_alert=True)
+            except Exception:
+                pass
+        else:
+            await target.answer(message)
+        return
+
+    devices = await panel_service.get_user_devices(active.get("user_id")) if active else None
+    if not devices:
+        if isinstance(event, types.CallbackQuery):
+            try:
+                await event.answer(get_text("no_devices_found"), show_alert=True)
+            except Exception:
+                pass
+        else:
+            await target.answer(get_text("no_devices_found"))
+        return
+
+    max_devices_value = active.get("max_devices")
+    max_devices_display = get_text("devices_unlimited_label")
+    if max_devices_value not in (None, 0):
+        try:
+            max_devices_int = int(max_devices_value)
+            if max_devices_int >= 0:
+                max_devices_display = str(max_devices_int)
+        except (TypeError, ValueError):
+            max_devices_display = str(max_devices_value)
+
+    if not devices or not devices.get('devices') or len(devices.get('devices')) == 0:
+        text = get_text("no_devices_details_found_message", max_devices=max_devices_display)
+    else:
+        devices_list = []
+        current_devices = len(devices.get('devices') or [])
+        for index, device in enumerate(devices.get('devices') or [], start=1):
+            device_model = device.get('deviceModel') or None
+            platform = device.get('platform') or None
+            user_agent = device.get('userAgent') or None
+            os_version = device.get('osVersion') or None
+            created_at = device.get('createdAt')
+            hwid = device.get('hwid')
+            created_at_str = datetime.fromisoformat(created_at).strftime("%d.%m.%Y %H:%M")
+
+            device_details = get_text("device_details", index=index, device_model=device_model, platform=platform, os_version=os_version, created_at_str=created_at_str, user_agent=user_agent, hwid=hwid)
+            devices_list.append(device_details)
+
+        text = get_text("my_devices_details", devices="\n\n".join(devices_list), current_devices=current_devices, max_devices=max_devices_display)
+
+    base_markup = get_back_to_main_menu_markup(current_lang, i18n, callback_data="main_action:my_subscription")
+    kb = base_markup.inline_keyboard
+
+    devices_kb = []
+    for index, device in enumerate(devices.get('devices') or [], start=1):
+        hwid = device.get('hwid')
+        device_button_text = get_text("disconnect_device_button", hwid=hwid, index=index)
+
+        devices_kb.append([InlineKeyboardButton(text=device_button_text, callback_data=f"disconnect_device:{hwid}")])
+    kb = devices_kb + kb
+    markup = InlineKeyboardMarkup(inline_keyboard=kb)
+
+    if isinstance(event, types.CallbackQuery):
+        try:
+            await event.answer()
+        except Exception:
+            pass
+        try:
+            await event.message.edit_text(text, reply_markup=markup)
+        except Exception:
+            await event.message.answer(text, reply_markup=markup)
+    else:
+        await target.answer(text, reply_markup=markup)
+
+
+@router.callback_query(F.data.startswith("disconnect_device:"))
+async def disconnect_device_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    subscription_service: SubscriptionService,
+    panel_service: PanelApiService,
+    bot: Bot,
+):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    if not settings.MY_DEVICES_SECTION_ENABLED:
+        try:
+            await callback.answer(get_text("my_devices_feature_disabled"), show_alert=True)
+        except Exception:
+            pass
+        return
+
+    try:
+        _, hwid = callback.data.split(":", 1)
+    except Exception:
+        try:
+            await callback.answer(get_text("error_try_again"), show_alert=True)
+        except Exception:
+            pass
+        return
+
+    active = await subscription_service.get_active_subscription_details(session, callback.from_user.id)
+    if not active:
+        await callback.answer(get_text("subscription_not_active"), show_alert=True)
+        return
+
+    success = await panel_service.disconnect_device(active.get("user_id"), hwid)
+    if not success:
+        await callback.answer(get_text("error_try_again"), show_alert=True)
+        return
+    await session.commit()
+    try:
+        await callback.answer(get_text("device_disconnected"))
+    except Exception:
+        pass
+    await my_devices_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+
+
+@router.callback_query(F.data.startswith("toggle_autorenew:"))
+async def toggle_autorenew_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    subscription_service: SubscriptionService,
+    panel_service: PanelApiService,
+    bot: Bot,
+):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    try:
+        _, payload = callback.data.split(":", 1)
+        sub_id_str, enable_str = payload.split(":")
+        sub_id = int(sub_id_str)
+        enable = bool(int(enable_str))
+    except Exception:
+        try:
+            await callback.answer(get_text("error_try_again"), show_alert=True)
+        except Exception:
+            pass
+        return
+
+    sub = await session.get(Subscription, sub_id)
+    if not sub or sub.user_id != callback.from_user.id:
+        await callback.answer(get_text("error_try_again"), show_alert=True)
+        return
+    if sub.provider == "tribute":
+        await callback.answer(get_text("subscription_autorenew_not_supported_for_tribute"), show_alert=True)
+        return
+
+    # Show confirmation popup and inline buttons
+    confirm_text = get_text("autorenew_confirm_enable") if enable else get_text("autorenew_confirm_disable")
+    kb = get_autorenew_confirm_keyboard(enable, sub.subscription_id, current_lang, i18n)
+    try:
+        await callback.message.edit_text(confirm_text, reply_markup=kb)
+    except Exception:
+        try:
+            await callback.message.answer(confirm_text, reply_markup=kb)
+        except Exception:
+            pass
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+    return
+
+
+@router.callback_query(F.data.startswith("autorenew:confirm:"))
+async def confirm_autorenew_handler(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    subscription_service: SubscriptionService,
+    panel_service: PanelApiService,
+    bot: Bot,
+):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    try:
+        _, _, sub_id_str, enable_str = callback.data.split(":", 3)
+        sub_id = int(sub_id_str)
+        enable = bool(int(enable_str))
+    except Exception:
+        try:
+            await callback.answer(get_text("error_try_again"), show_alert=True)
+        except Exception:
+            pass
+        return
+
+    sub = await session.get(Subscription, sub_id)
+    if not sub or sub.user_id != callback.from_user.id:
+        await callback.answer(get_text("error_try_again"), show_alert=True)
+        return
+    if sub.provider == "tribute":
+        await callback.answer(get_text("subscription_autorenew_not_supported_for_tribute"), show_alert=True)
+        return
+
+    await subscription_dal.update_subscription(session, sub.subscription_id, {"auto_renew_enabled": enable})
+    await session.commit()
+    try:
+        await callback.answer(get_text("subscription_autorenew_updated"))
+    except Exception:
+        pass
+    await my_subscription_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+
+
+@router.callback_query(F.data == "autorenew:cancel")
+async def autorenew_cancel_from_webhook_button(
+    callback: types.CallbackQuery,
+    settings: Settings,
+    i18n_data: dict,
+    session: AsyncSession,
+    subscription_service: SubscriptionService,
+    panel_service: PanelApiService,
+    bot: Bot,
+):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    # Disable auto-renew on the active subscription (non-tribute)
+    from db.dal import subscription_dal
+    sub = await subscription_dal.get_active_subscription_by_user_id(session, callback.from_user.id)
+    if not sub:
+        try:
+            await callback.answer(get_text("subscription_not_active"), show_alert=True)
+        except Exception:
+            pass
+        return
+    if sub.provider == "tribute":
+        try:
+            await callback.answer(get_text("subscription_autorenew_not_supported_for_tribute"), show_alert=True)
+        except Exception:
+            pass
+        return
+    await subscription_dal.update_subscription(session, sub.subscription_id, {"auto_renew_enabled": False})
+    await session.commit()
+    try:
+        await callback.answer(get_text("subscription_autorenew_updated"))
+    except Exception:
+        pass
+    await my_subscription_command_handler(callback, i18n_data, settings, panel_service, subscription_service, session, bot)
+
+
+@router.message(Command("connect"))
+async def connect_command_handler(
+    message: types.Message,
+    i18n_data: dict,
+    settings: Settings,
+    panel_service: PanelApiService,
+    subscription_service: SubscriptionService,
+    session: AsyncSession,
+    bot: Bot,
+):
+    logging.info(f"User {message.from_user.id} used /connect command.")
+    await my_subscription_command_handler(message, i18n_data, settings, panel_service, subscription_service, session, bot)

bot/handlers/user/subscription/payment_methods.py

@@ -0,0 +1,458 @@
+from aiogram import Router, F, types
+from typing import Optional, List
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config.settings import Settings
+from bot.keyboards.inline.user_keyboards import (
+    get_payment_methods_list_keyboard,
+    get_payment_method_delete_confirm_keyboard,
+    get_payment_method_details_keyboard,
+    get_bind_url_keyboard,
+)
+from bot.services.yookassa_service import YooKassaService
+from bot.middlewares.i18n import JsonI18n
+from db.dal import user_billing_dal
+from db.models import Payment
+from sqlalchemy.future import select
+
+router = Router(name="user_subscription_payment_methods_router")
+
+
+@router.callback_query(F.data == "pm:manage")
+async def payment_methods_manage(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    from db.dal.user_billing_dal import list_user_payment_methods
+    get_text = _
+    methods = await list_user_payment_methods(session, callback.from_user.id)
+    cards: List[tuple] = []
+
+    def _is_yoomoney_network(network: Optional[str]) -> bool:
+        s = (network or "").lower()
+        return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+
+    def _extract_last4(text: str) -> Optional[str]:
+        digits = "".join(ch for ch in text if ch.isdigit())
+        return digits[-4:] if len(digits) >= 4 else None
+
+    def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
+        if _is_yoomoney_network(network):
+            l4 = last4 or _extract_last4(network or "")
+            if l4:
+                return get_text("payment_method_wallet_title", last4=l4)
+            return get_text("payment_method_wallet_title", last4="****")
+        if last4:
+            network_name = network or get_text("payment_network_card", default="Card")
+            return get_text("payment_method_card_title", network=network_name, last4=last4)
+        network_name = network or get_text("payment_network_generic", default="Payment method")
+        return get_text("payment_method_generic_title", network=network_name)
+
+    for m in methods:
+        title = _format_pm_title(m.card_network, m.card_last4)
+        cards.append((str(m.method_id), title if not m.is_default else f"⭐ {title}"))
+
+    text = get_text("payment_methods_title")
+    if not cards:
+        text += "\n\n" + get_text("payment_method_none")
+
+    await callback.message.edit_text(text, reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.callback_query(F.data == "pm:bind")
+async def payment_method_bind(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession, yookassa_service: YooKassaService):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    metadata = {"user_id": str(callback.from_user.id), "bind_only": "1"}
+    resp = await yookassa_service.create_payment(
+        amount=1.00,
+        currency="RUB",
+        description="Bind card",
+        metadata=metadata,
+        receipt_email=settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL,
+        save_payment_method=True,
+        capture=False,
+        bind_only=True,
+    )
+    if not resp or not resp.get("confirmation_url"):
+        await callback.answer(_("error_payment_gateway"), show_alert=True)
+        return
+    await callback.message.edit_text(_("payment_methods_title"), reply_markup=get_bind_url_keyboard(resp["confirmation_url"], current_lang, i18n))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.callback_query(F.data.startswith("pm:delete_confirm"))
+async def payment_method_delete_confirm(callback: types.CallbackQuery, settings: Settings, i18n_data: dict):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    parts = callback.data.split(":", 2)
+    pm_id = parts[2] if len(parts) >= 3 else ""
+    await callback.message.edit_text(_("payment_method_delete_confirm"), reply_markup=get_payment_method_delete_confirm_keyboard(pm_id, current_lang, i18n))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.callback_query(F.data.startswith("pm:delete"))
+async def payment_method_delete(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+    parts = callback.data.split(":", 2)
+    pm_id_raw = parts[2] if len(parts) >= 3 else ""
+    deleted = False
+
+    try:
+        from db.dal.user_billing_dal import (
+            delete_user_payment_method,
+            delete_user_payment_method_by_provider_id,
+            list_user_payment_methods,
+        )
+        if pm_id_raw:
+            if pm_id_raw.isdigit():
+                deleted = await delete_user_payment_method(session, callback.from_user.id, int(pm_id_raw))
+            else:
+                deleted = await delete_user_payment_method_by_provider_id(session, callback.from_user.id, pm_id_raw)
+        try:
+            legacy_deleted = await user_billing_dal.delete_yk_payment_method(session, callback.from_user.id)
+            deleted = deleted or legacy_deleted
+        except Exception:
+            pass
+        await session.commit()
+
+        methods = await list_user_payment_methods(session, callback.from_user.id)
+        text = _("payment_methods_title")
+        cards = []
+        for m in methods:
+            def _is_yoomoney_network(network: Optional[str]) -> bool:
+                s = (network or "").lower()
+                return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+            def _extract_last4(text: str) -> Optional[str]:
+                digits = "".join(ch for ch in text if ch.isdigit())
+                return digits[-4:] if len(digits) >= 4 else None
+            def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
+                if _is_yoomoney_network(network):
+                    l4 = last4 or _extract_last4(network or "")
+                    if l4:
+                        return _("payment_method_wallet_title", last4=l4)
+                    return _("payment_method_wallet_title", last4="****")
+                if last4:
+                    network_name = network or _("payment_network_card", default="Card")
+                    return _("payment_method_card_title", network=network_name, last4=last4)
+                network_name = network or _("payment_network_generic", default="Payment method")
+                return _("payment_method_generic_title", network=network_name)
+            title = _format_pm_title(m.card_network, m.card_last4)
+            cards.append((str(m.method_id), title if not m.is_default else f"⭐ {title}"))
+        if not cards:
+            text += "\n\n" + _("payment_method_none")
+        msg = _("payment_method_deleted_success") if deleted else _("error_try_again")
+        await callback.message.edit_text(f"{msg}\n\n{text}", reply_markup=get_payment_methods_list_keyboard(cards, 0, current_lang, i18n))
+        try:
+            await callback.answer()
+        except Exception:
+            pass
+        return
+    except Exception:
+        await session.rollback()
+        try:
+            await callback.answer(_("error_try_again"), show_alert=True)
+        except Exception:
+            pass
+
+
+@router.callback_query(F.data.startswith("pm:view"))
+async def payment_method_view(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    billing = await user_billing_dal.get_user_billing(session, callback.from_user.id)
+    if not billing or not billing.yookassa_payment_method_id:
+        from db.dal.user_billing_dal import list_user_payment_methods
+        methods = await list_user_payment_methods(session, callback.from_user.id)
+        if not methods:
+            await callback.answer(_("payment_method_none"), show_alert=True)
+            return
+        parts = callback.data.split(":", 2)
+        pm_id = parts[2] if len(parts) >= 3 else str(methods[0].method_id)
+        sel = next((m for m in methods if str(m.method_id) == pm_id or m.provider_payment_method_id == pm_id), methods[0])
+
+        def _is_yoomoney_network(network: Optional[str]) -> bool:
+            s = (network or "").lower()
+            return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+
+        def _extract_last4(text: str) -> Optional[str]:
+            digits = "".join(ch for ch in text if ch.isdigit())
+            return digits[-4:] if len(digits) >= 4 else None
+
+        def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
+            if _is_yoomoney_network(network):
+                l4 = last4 or _extract_last4(network or "")
+                if l4:
+                    return _("payment_method_wallet_title", last4=l4)
+                return _("payment_method_wallet_title", last4="****")
+            if last4:
+                network_name = network or _("payment_network_card", default="Card")
+                return _("payment_method_card_title", network=network_name, last4=last4)
+            network_name = network or _("payment_network_generic", default="Payment method")
+            return _("payment_method_generic_title", network=network_name)
+
+        title = _format_pm_title(sel.card_network, sel.card_last4)
+        added_at = sel.created_at.strftime('%Y-%m-%d') if getattr(sel, 'created_at', None) else "—"
+        last_tx = "—"
+        try:
+            stmt = (
+                select(Payment)
+                .where(
+                    Payment.user_id == callback.from_user.id,
+                    Payment.status == 'succeeded',
+                    Payment.provider == 'yookassa',
+                )
+                .order_by(Payment.created_at.desc())
+                .limit(1)
+            )
+            result = await session.execute(stmt)
+            lp = result.scalar_one_or_none()
+            if lp and lp.created_at:
+                last_tx = lp.created_at.strftime('%Y-%m-%d')
+        except Exception:
+            pass
+        details = f"{title}\n{_('payment_method_added_at', date=added_at)}\n{_('payment_method_last_tx', date=last_tx)}"
+        await callback.message.edit_text(details, reply_markup=get_payment_method_details_keyboard(str(sel.method_id), current_lang, i18n))
+        try:
+            await callback.answer()
+        except Exception:
+            pass
+        return
+
+    added_at = billing.created_at.strftime('%Y-%m-%d') if getattr(billing, 'created_at', None) else "—"
+    last_tx = "—"
+    try:
+        stmt = (
+            select(Payment)
+            .where(
+                Payment.user_id == callback.from_user.id,
+                Payment.status == 'succeeded',
+                Payment.provider == 'yookassa',
+            )
+            .order_by(Payment.created_at.desc())
+            .limit(1)
+        )
+        result = await session.execute(stmt)
+        last_payment = result.scalar_one_or_none()
+        if last_payment and last_payment.created_at:
+            last_tx = last_payment.created_at.strftime('%Y-%m-%d')
+    except Exception:
+        pass
+
+    def _is_yoomoney_network(network: Optional[str]) -> bool:
+        s = (network or "").lower()
+        return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+
+    def _extract_last4(text: str) -> Optional[str]:
+        digits = "".join(ch for ch in text if ch.isdigit())
+        return digits[-4:] if len(digits) >= 4 else None
+
+    def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
+        if _is_yoomoney_network(network):
+            l4 = last4 or _extract_last4(network or "")
+            if l4:
+                return _("payment_method_wallet_title", last4=l4)
+            return _("payment_method_wallet_title", last4="****")
+        if last4:
+            network_name = network or _("payment_network_card", default="Card")
+            return _("payment_method_card_title", network=network_name, last4=last4)
+        network_name = network or _("payment_network_generic", default="Payment method")
+        return _("payment_method_generic_title", network=network_name)
+
+    title = _format_pm_title(billing.card_network, billing.card_last4)
+    details = f"{title}\n{_('payment_method_added_at', date=added_at)}\n{_('payment_method_last_tx', date=last_tx)}"
+    await callback.message.edit_text(details, reply_markup=get_payment_method_details_keyboard(billing.yookassa_payment_method_id, current_lang, i18n))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+
+@router.callback_query(F.data.startswith("pm:history"))
+async def payment_method_history(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession, yookassa_service: YooKassaService):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    if not getattr(settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+        try:
+            _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+            await callback.answer(_("error_service_unavailable"), show_alert=True)
+        except Exception:
+            pass
+        return
+    _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    from db.dal import payment_dal
+    payments = await payment_dal.get_recent_payment_logs_with_user(session, limit=30, offset=0)
+    user_payments = [p for p in payments if p.user_id == callback.from_user.id]
+
+    selected_pm_provider_id: Optional[str] = None
+    pm_filter_requested: bool = False
+    try:
+        split_a, split_b, split_pm_id = callback.data.split(":", 2)
+        if split_pm_id:
+            pm_filter_requested = True
+            if split_pm_id.isdigit():
+                from db.dal.user_billing_dal import list_user_payment_methods
+                methods = await list_user_payment_methods(session, callback.from_user.id)
+                sel = next((m for m in methods if str(m.method_id) == split_pm_id), None)
+                if sel and sel.provider_payment_method_id:
+                    selected_pm_provider_id = sel.provider_payment_method_id
+            else:
+                selected_pm_provider_id = split_pm_id
+    except Exception:
+        selected_pm_provider_id = None
+        pm_filter_requested = False
+
+    if pm_filter_requested and not selected_pm_provider_id:
+        user_payments = []
+
+    if selected_pm_provider_id:
+        filtered: List[Payment] = []
+        for p in user_payments:
+            if p.provider != 'yookassa':
+                continue
+            if p.yookassa_payment_id and yookassa_service:
+                try:
+                    info = await yookassa_service.get_payment_info(p.yookassa_payment_id)
+                    pm = (info or {}).get("payment_method") or {}
+                    if pm.get("id") == selected_pm_provider_id:
+                        filtered.append(p)
+                        continue
+                except Exception:
+                    pass
+        user_payments = filtered
+
+    if not user_payments:
+        from bot.keyboards.inline.user_keyboards import get_back_to_payment_method_details_keyboard, get_payment_methods_manage_keyboard
+        back_pm_id = ""
+        try:
+            split_a, split_b, back_pm_id = callback.data.split(":", 2)
+        except Exception:
+            back_pm_id = ""
+        back_markup = (
+            get_back_to_payment_method_details_keyboard(back_pm_id, current_lang, i18n)
+            if back_pm_id
+            else get_payment_methods_manage_keyboard(current_lang, i18n, has_card=True)
+        )
+        await callback.message.edit_text(_("payment_method_no_history"), reply_markup=back_markup)
+        return
+
+    def _format_item(p: Payment) -> str:
+        title = p.description or _("subscription_purchase_title", months=p.subscription_duration_months or 1)
+        date_str = p.created_at.strftime('%Y-%m-%d') if p.created_at else "N/A"
+        return f"{date_str} — {title} — {p.amount:.2f} {p.currency}"
+
+    lines = [_format_item(p) for p in user_payments]
+    text = _("payment_method_tx_history_title") + "\n\n" + "\n".join(lines)
+    try:
+        split_a, split_b, split_pm_id_for_back = callback.data.split(":", 2)
+    except Exception:
+        split_pm_id_for_back = ""
+    from bot.keyboards.inline.user_keyboards import get_back_to_payment_method_details_keyboard, get_payment_methods_manage_keyboard
+    back_markup = (
+        get_back_to_payment_method_details_keyboard(split_pm_id_for_back, current_lang, i18n)
+        if split_pm_id_for_back
+        else get_payment_methods_manage_keyboard(current_lang, i18n, has_card=True)
+    )
+    await callback.message.edit_text(text, reply_markup=back_markup)
+
+
+@router.callback_query(F.data.startswith("pm:list:"))
+async def payment_methods_list(callback: types.CallbackQuery, settings: Settings, i18n_data: dict, session: AsyncSession):
+    current_lang = i18n_data.get("current_language", settings.DEFAULT_LANGUAGE)
+    i18n: Optional[JsonI18n] = i18n_data.get("i18n_instance")
+    get_text = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
+
+    from db.dal.user_billing_dal import list_user_payment_methods
+    cards: List[tuple] = []
+    methods = await list_user_payment_methods(session, callback.from_user.id)
+    for m in methods:
+        def _is_yoomoney_network(network: Optional[str]) -> bool:
+            s = (network or "").lower()
+            return "yoomoney" in s or "yoo money" in s or "yoo-money" in s
+        def _extract_last4(text: str) -> Optional[str]:
+            digits = "".join(ch for ch in text if ch.isdigit())
+            return digits[-4:] if len(digits) >= 4 else None
+        def _format_pm_title(network: Optional[str], last4: Optional[str]) -> str:
+            if _is_yoomoney_network(network):
+                l4 = last4 or _extract_last4(network or "")
+                if l4:
+                    return get_text("payment_method_wallet_title", last4=l4)
+                return get_text("payment_method_wallet_title", last4="****")
+            if last4:
+                network_name = network or get_text("payment_network_card", default="Card")
+                return get_text("payment_method_card_title", network=network_name, last4=last4)
+            network_name = network or get_text("payment_network_generic", default="Payment method")
+            return get_text("payment_method_generic_title", network=network_name)
+        title = _format_pm_title(m.card_network, m.card_last4)
+        cards.append((str(m.method_id), title if not m.is_default else f"⭐ {title}"))
+
+    try:
+        _, _, page_str = callback.data.split(":", 2)
+        page = int(page_str)
+    except Exception:
+        page = 0
+
+    text = get_text("payment_methods_title")
+    if not cards:
+        text += "\n\n" + get_text("payment_method_none")
+    await callback.message.edit_text(text, reply_markup=get_payment_methods_list_keyboard(cards, page, current_lang, i18n))
+    try:
+        await callback.answer()
+    except Exception:
+        pass
+
+

bot/handlers/user/trial_handler.py

@@ -11,6 +11,7 @@ from bot.services.notification_service import NotificationService
 from bot.keyboards.inline.user_keyboards import (
     get_trial_confirmation_keyboard,
     get_main_menu_inline_keyboard,
+    get_connect_and_main_keyboard,
 )
 from bot.middlewares.i18n import JsonI18n
 from .start import send_main_menu
@@ -31,7 +32,10 @@ async def request_trial_confirmation_handler(
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     if not i18n or not callback.message:
-        await callback.answer(_("error_occurred_try_again"), show_alert=True)
+        try:
+            await callback.answer(_("error_occurred_try_again"), show_alert=True)
+        except Exception:
+            pass
         return
 
     show_trial_btn_in_menu_if_fail = False
@@ -46,7 +50,10 @@ async def request_trial_confirmation_handler(
                 current_lang, i18n, settings, False
             ),
         )
-        await callback.answer()
+        try:
+            await callback.answer()
+        except Exception:
+            pass
         return
 
     if await subscription_service.has_had_any_subscription(session, user_id):
@@ -56,7 +63,10 @@ async def request_trial_confirmation_handler(
                 current_lang, i18n, settings, False
             ),
         )
-        await callback.answer()
+        try:
+            await callback.answer()
+        except Exception:
+            pass
         return
 
     # Directly activate trial without confirmation
@@ -66,9 +76,13 @@ async def request_trial_confirmation_handler(
 
     final_message_text_in_chat = ""
     show_trial_button_after_action = False
+    config_link_for_trial = None
 
     if activation_result and activation_result.get("activated"):
-        await callback.answer(_("trial_activated_alert"), show_alert=True)
+        try:
+            await callback.answer(_("trial_activated_alert"), show_alert=True)
+        except Exception:
+            pass
 
         end_date_obj = activation_result.get("end_date")
         config_link_for_trial = activation_result.get("subscription_url") or _(
@@ -99,6 +113,14 @@ async def request_trial_confirmation_handler(
         # Send notification to admin about new trial
         notification_service = NotificationService(callback.bot, settings, i18n)
         await notification_service.notify_trial_activation(user_id, end_date_obj)
+        # Mark ad attribution trial if exists
+        try:
+            from db.dal import ad_dal as _ad_dal
+            await _ad_dal.mark_trial_activated(session, user_id)
+            await session.commit()
+        except Exception as e_mark:
+            await session.rollback()
+            logging.error(f"Failed to mark trial for ad attribution for user {user_id}: {e_mark}")
     else:
         message_key_from_service = (
             activation_result.get("message_key", "trial_activation_failed")
@@ -106,7 +128,10 @@ async def request_trial_confirmation_handler(
             else "trial_activation_failed"
         )
         final_message_text_in_chat = _(message_key_from_service)
-        await callback.answer(final_message_text_in_chat, show_alert=True)
+        try:
+            await callback.answer(final_message_text_in_chat, show_alert=True)
+        except Exception:
+            pass
         if (
             settings.TRIAL_ENABLED
             and not await subscription_service.has_had_any_subscription(
@@ -115,13 +140,21 @@ async def request_trial_confirmation_handler(
         ):
             show_trial_button_after_action = True
 
+    reply_markup = (
+        get_connect_and_main_keyboard(
+            current_lang, i18n, settings, config_link_for_trial
+        )
+        if activation_result and activation_result.get("activated")
+        else get_main_menu_inline_keyboard(
+            current_lang, i18n, settings, show_trial_button_after_action
+        )
+    )
+
     try:
         await callback.message.edit_text(
             final_message_text_in_chat,
             parse_mode="HTML",
-            reply_markup=get_main_menu_inline_keyboard(
-                current_lang, i18n, settings, show_trial_button_after_action
-            ),
+            reply_markup=reply_markup,
             disable_web_page_preview=True,
         )
     except Exception as e_edit:
@@ -129,17 +162,11 @@ async def request_trial_confirmation_handler(
             f"Could not edit trial result message: {e_edit}. Sending new one."
         )
 
-        if (
-            callback.message
-            and hasattr(callback.message, "chat")
-            and callback.message.chat
-        ):
-            await callback.message.chat.send_message(
+        if callback.message:
+            await callback.message.answer(
                 final_message_text_in_chat,
                 parse_mode="HTML",
-                reply_markup=get_main_menu_inline_keyboard(
-                    current_lang, i18n, settings, show_trial_button_after_action
-                ),
+                reply_markup=reply_markup,
                 disable_web_page_preview=True,
             )
 
@@ -160,20 +187,29 @@ async def confirm_activate_trial_handler(
     _ = lambda key, **kwargs: i18n.gettext(current_lang, key, **kwargs) if i18n else key
 
     if not i18n or not callback.message:
-        await callback.answer(_("error_occurred_try_again"), show_alert=True)
+        try:
+            await callback.answer(_("error_occurred_try_again"), show_alert=True)
+        except Exception:
+            pass
         return
 
     if not settings.TRIAL_ENABLED:
-        await callback.answer(_("trial_feature_disabled"), show_alert=True)
+        try:
+            await callback.answer(_("trial_feature_disabled"), show_alert=True)
+        except Exception:
+            pass
 
         await send_main_menu(
             callback, settings, i18n_data, subscription_service, session, is_edit=True
         )
         return
     if await subscription_service.has_had_any_subscription(session, user_id):
-        await callback.answer(
-            _("trial_already_had_subscription_or_trial"), show_alert=True
-        )
+        try:
+            await callback.answer(
+                _("trial_already_had_subscription_or_trial"), show_alert=True
+            )
+        except Exception:
+            pass
         await send_main_menu(
             callback, settings, i18n_data, subscription_service, session, is_edit=True
         )
@@ -185,9 +221,13 @@ async def confirm_activate_trial_handler(
 
     final_message_text_in_chat = ""
     show_trial_button_after_action = False
+    config_link_for_trial = None
 
     if activation_result and activation_result.get("activated"):
-        await callback.answer(_("trial_activated_alert"), show_alert=True)
+        try:
+            await callback.answer(_("trial_activated_alert"), show_alert=True)
+        except Exception:
+            pass
 
         end_date_obj = activation_result.get("end_date")
         config_link_for_trial = activation_result.get("subscription_url") or _(
@@ -221,7 +261,10 @@ async def confirm_activate_trial_handler(
             else "trial_activation_failed"
         )
         final_message_text_in_chat = _(message_key_from_service)
-        await callback.answer(final_message_text_in_chat, show_alert=True)
+        try:
+            await callback.answer(final_message_text_in_chat, show_alert=True)
+        except Exception:
+            pass
         if (
             settings.TRIAL_ENABLED
             and not await subscription_service.has_had_any_subscription(
@@ -230,13 +273,21 @@ async def confirm_activate_trial_handler(
         ):
             show_trial_button_after_action = True
 
+    reply_markup = (
+        get_connect_and_main_keyboard(
+            current_lang, i18n, settings, config_link_for_trial
+        )
+        if activation_result and activation_result.get("activated")
+        else get_main_menu_inline_keyboard(
+            current_lang, i18n, settings, show_trial_button_after_action
+        )
+    )
+
     try:
         await callback.message.edit_text(
             final_message_text_in_chat,
             parse_mode="HTML",
-            reply_markup=get_main_menu_inline_keyboard(
-                current_lang, i18n, settings, show_trial_button_after_action
-            ),
+            reply_markup=reply_markup,
             disable_web_page_preview=True,
         )
     except Exception as e_edit:
@@ -244,23 +295,24 @@ async def confirm_activate_trial_handler(
             f"Could not edit trial result message: {e_edit}. Sending new one."
         )
 
-        if (
-            callback.message
-            and hasattr(callback.message, "chat")
-            and callback.message.chat
-        ):
-            await callback.message.chat.send_message(
+        if callback.message:
+            await callback.message.answer(
                 final_message_text_in_chat,
                 parse_mode="HTML",
-                reply_markup=get_main_menu_inline_keyboard(
-                    current_lang, i18n, settings, show_trial_button_after_action
-                ),
+                reply_markup=reply_markup,
                 disable_web_page_preview=True,
             )
 
     if activation_result and activation_result.get("activated") and end_date_obj:
         notification_service = NotificationService(callback.bot, settings, i18n)
         await notification_service.notify_trial_activation(user_id, end_date_obj)
+        try:
+            from db.dal import ad_dal as _ad_dal
+            await _ad_dal.mark_trial_activated(session, user_id)
+            await session.commit()
+        except Exception as e_mark:
+            await session.rollback()
+            logging.error(f"Failed to mark trial for ad attribution for user {user_id}: {e_mark}")
 
 
 @router.callback_query(F.data == "main_action:cancel_trial")

bot/keyboards/inline/admin_keyboards.py

@@ -25,6 +25,10 @@ def get_admin_panel_keyboard(i18n_instance, lang: str,
     builder.button(text=_(key="admin_promo_marketing_section"),
                    callback_data="admin_section:promo_marketing")
     
+    # Реклама
+    builder.button(text=_(key="admin_ads_section", default="📈 Реклама"),
+                   callback_data="admin_action:ads")
+
     # Системные функции
     builder.button(text=_(key="admin_system_functions_section"),
                    callback_data="admin_section:system_functions")
@@ -116,6 +120,82 @@ def get_system_functions_keyboard(i18n_instance, lang: str) -> InlineKeyboardMar
     return builder.as_markup()
 
 
+def get_ads_menu_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.button(text=_(key="admin_ads_create_button", default="➕ Создать кампанию"),
+                   callback_data="admin_action:ads_create")
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(1, 1)
+    return builder.as_markup()
+
+
+def get_ads_list_keyboard(
+    i18n_instance,
+    lang: str,
+    campaigns: list,
+    current_page: int,
+    total_pages: int,
+) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+
+    for c in campaigns:
+        title = f"{c.source}"
+        builder.button(
+            text=title,
+            callback_data=f"admin_ads:card:{c.ad_campaign_id}:{current_page}",
+        )
+
+    # Pagination row (only when needed)
+    if total_pages > 1:
+        row = []
+        if current_page > 0:
+            row.append(
+                InlineKeyboardButton(
+                    text="⬅️ " + _("prev_page_button", default="Prev"),
+                    callback_data=f"admin_ads:page:{current_page - 1}",
+                )
+            )
+        row.append(
+            InlineKeyboardButton(
+                text=f"{current_page + 1}/{total_pages}",
+                callback_data="ads_page_display",
+            )
+        )
+        if current_page < total_pages - 1:
+            row.append(
+                InlineKeyboardButton(
+                    text=_("next_page_button", default="Next") + " ➡️",
+                    callback_data=f"admin_ads:page:{current_page + 1}",
+                )
+            )
+        if row:
+            builder.row(*row)
+
+    builder.button(text=_(key="admin_ads_create_button", default="➕ Создать кампанию"),
+                   callback_data="admin_action:ads_create")
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def get_ad_card_keyboard(i18n_instance, lang: str, campaign_id: int, back_page: int) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    # Dangerous action: Delete campaign
+    builder.button(text=_(key="admin_ads_delete_button", default="🗑 Удалить кампанию"),
+                   callback_data=f"admin_ads:delete:{campaign_id}:{back_page}")
+    builder.button(text=_(key="back_to_ads_list_button", default="⬅️ К списку"),
+                   callback_data=f"admin_ads:page:{back_page}")
+    builder.button(text=_(key="back_to_admin_panel_button"),
+                   callback_data="admin_action:main")
+    builder.adjust(1)
+    return builder.as_markup()
+
+
 def get_logs_menu_keyboard(i18n_instance, lang: str) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()

bot/keyboards/inline/user_keyboards.py

@@ -1,6 +1,6 @@
 from aiogram.utils.keyboard import InlineKeyboardBuilder, InlineKeyboardButton
 from aiogram.types import InlineKeyboardMarkup, WebAppInfo
-from typing import Dict, Optional, List
+from typing import Dict, Optional, List, Tuple
 
 from config.settings import Settings
 
@@ -21,20 +21,12 @@ def get_main_menu_inline_keyboard(
     builder.row(
         InlineKeyboardButton(text=_(key="menu_subscribe_inline"),
                              callback_data="main_action:subscribe"))
-    if settings.SUBSCRIPTION_MINI_APP_URL:
-        builder.row(
-            InlineKeyboardButton(
-                text=_(key="menu_my_subscription_inline"),
-                web_app=WebAppInfo(url=settings.SUBSCRIPTION_MINI_APP_URL),
-            )
-        )
-    else:
-        builder.row(
-            InlineKeyboardButton(
-                text=_(key="menu_my_subscription_inline"),
-                callback_data="main_action:my_subscription",
-            )
+    builder.row(
+        InlineKeyboardButton(
+            text=_(key="menu_my_subscription_inline"),
+            callback_data="main_action:my_subscription",
         )
+    )
 
     referral_button = InlineKeyboardButton(
         text=_(key="menu_referral_inline"),
@@ -126,14 +118,17 @@ def get_payment_method_keyboard(months: int, price: float,
                                 i18n_instance, settings: Settings) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
-    if settings.STARS_ENABLED and stars_price is not None:
-        builder.button(text=_("pay_with_stars_button"),
-                       callback_data=f"pay_stars:{months}:{stars_price}")
-    if settings.TRIBUTE_ENABLED and tribute_url:
-        builder.button(text=_("pay_with_tribute_button"), url=tribute_url)
+    if settings.FREEKASSA_ENABLED:
+        builder.button(text=_("pay_with_sbp_button"),
+                       callback_data=f"pay_fk:{months}:{price}")
     if settings.YOOKASSA_ENABLED:
         builder.button(text=_("pay_with_yookassa_button"),
                        callback_data=f"pay_yk:{months}:{price}")
+    if settings.TRIBUTE_ENABLED and tribute_url:
+        builder.button(text=_("pay_with_tribute_button"), url=tribute_url)
+    if settings.STARS_ENABLED and stars_price is not None:
+        builder.button(text=_("pay_with_stars_button"),
+                       callback_data=f"pay_stars:{months}:{stars_price}")
     if settings.CRYPTOPAY_ENABLED:
         builder.button(text=_("pay_with_cryptopay_button"),
                        callback_data=f"pay_crypto:{months}:{price}")
@@ -143,17 +138,115 @@ def get_payment_method_keyboard(months: int, price: float,
     return builder.as_markup()
 
 
-def get_payment_url_keyboard(payment_url: str, lang: str,
-                             i18n_instance) -> InlineKeyboardMarkup:
+def get_payment_url_keyboard(payment_url: str,
+                             lang: str,
+                             i18n_instance,
+                             back_callback: Optional[str] = None,
+                             back_text_key: str = "back_to_main_menu_button"
+                             ) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
     builder.button(text=_(key="pay_button"), url=payment_url)
-    builder.button(text=_(key="back_to_main_menu_button"),
-                   callback_data="main_action:back_to_main")
+    if back_callback:
+        builder.button(text=_(key=back_text_key), callback_data=back_callback)
+    else:
+        builder.button(text=_(key="back_to_main_menu_button"),
+                       callback_data="main_action:back_to_main")
     builder.adjust(1)
     return builder.as_markup()
 
 
+def get_yk_autopay_choice_keyboard(
+    months: int,
+    price: float,
+    lang: str,
+    i18n_instance,
+    has_saved_cards: bool = True,
+) -> InlineKeyboardMarkup:
+    """Keyboard for choosing between saved card charge or new card payment when auto-renew is enabled."""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    price_str = str(price)
+    if has_saved_cards:
+        builder.row(
+            InlineKeyboardButton(
+                text=_(key="yookassa_autopay_pay_saved_card_button"),
+                callback_data=f"pay_yk_saved_list:{months}:{price_str}",
+            )
+        )
+    builder.row(
+        InlineKeyboardButton(
+            text=_(key="yookassa_autopay_pay_new_card_button"),
+            callback_data=f"pay_yk_new:{months}:{price_str}",
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=_(key="back_to_payment_methods_button"),
+            callback_data=f"subscribe_period:{months}",
+        )
+    )
+    return builder.as_markup()
+
+
+def get_yk_saved_cards_keyboard(
+    cards: List[Tuple[str, str]],
+    months: int,
+    price: float,
+    lang: str,
+    i18n_instance,
+    page: int = 0,
+) -> InlineKeyboardMarkup:
+    """Paginated keyboard for selecting a saved YooKassa card."""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    per_page = 5
+    total = len(cards)
+    start = page * per_page
+    end = min(total, start + per_page)
+    price_str = str(price)
+
+    for method_id, title in cards[start:end]:
+        builder.row(
+            InlineKeyboardButton(
+                text=title,
+                callback_data=f"pay_yk_use_saved:{months}:{price_str}:{method_id}",
+            )
+        )
+
+    nav_buttons: List[InlineKeyboardButton] = []
+    if start > 0:
+        nav_buttons.append(
+            InlineKeyboardButton(
+                text="⬅️",
+                callback_data=f"pay_yk_saved_list:{months}:{price_str}:{page-1}",
+            )
+        )
+    if end < total:
+        nav_buttons.append(
+            InlineKeyboardButton(
+                text="➡️",
+                callback_data=f"pay_yk_saved_list:{months}:{price_str}:{page+1}",
+            )
+        )
+    if nav_buttons:
+        builder.row(*nav_buttons)
+
+    builder.row(
+        InlineKeyboardButton(
+            text=_(key="yookassa_autopay_pay_new_card_button"),
+            callback_data=f"pay_yk_new:{months}:{price_str}",
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=_(key="back_to_autopay_method_choice_button"),
+            callback_data=f"pay_yk:{months}:{price_str}",
+        )
+    )
+    return builder.as_markup()
+
+
 def get_referral_link_keyboard(lang: str,
                                i18n_instance) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
@@ -167,11 +260,16 @@ def get_referral_link_keyboard(lang: str,
 
 
 def get_back_to_main_menu_markup(lang: str,
-                                 i18n_instance) -> InlineKeyboardMarkup:
+                                 i18n_instance,
+                                 callback_data: Optional[str] = None) -> InlineKeyboardMarkup:
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
-    builder.button(text=_(key="back_to_main_menu_button"),
-                   callback_data="main_action:back_to_main")
+    if callback_data:
+        builder.button(text=_(key="back_to_main_menu_button"),
+                       callback_data=callback_data)
+    else:
+        builder.button(text=_(key="back_to_main_menu_button"),
+                       callback_data="main_action:back_to_main")
     return builder.as_markup()
 
 
@@ -193,11 +291,49 @@ def get_user_banned_keyboard(support_link: Optional[str], lang: str,
     return builder.as_markup()
 
 
+def get_channel_subscription_keyboard(
+        lang: str,
+        i18n_instance,
+        channel_link: Optional[str],
+        include_check_button: bool = True) -> Optional[InlineKeyboardMarkup]:
+    """
+    Return keyboard with buttons to open the required channel and trigger a subscription re-check.
+    """
+    if i18n_instance is None:
+        return None
+
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+
+    has_buttons = False
+
+    if channel_link:
+        builder.button(
+            text=_(key="channel_subscription_join_button"),
+            url=channel_link,
+        )
+        has_buttons = True
+
+    if include_check_button:
+        builder.button(
+            text=_(key="channel_subscription_verify_button"),
+            callback_data="channel_subscription:verify",
+        )
+        has_buttons = True
+
+    if not has_buttons:
+        return None
+
+    builder.adjust(1)
+    return builder.as_markup()
+
+
 def get_connect_and_main_keyboard(
         lang: str,
         i18n_instance,
         settings: Settings,
-        config_link: Optional[str]) -> InlineKeyboardMarkup:
+        config_link: Optional[str],
+        preserve_message: bool = False) -> InlineKeyboardMarkup:
     """Keyboard with a connect button and a back to main menu button."""
     _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
     builder = InlineKeyboardBuilder()
@@ -221,11 +357,133 @@ def get_connect_and_main_keyboard(
             )
         )
 
+    back_callback = "main_action:back_to_main_keep" if preserve_message else "main_action:back_to_main"
     builder.row(
         InlineKeyboardButton(
             text=_("back_to_main_menu_button"),
-            callback_data="main_action:back_to_main",
+            callback_data=back_callback,
         )
     )
 
     return builder.as_markup()
+
+
+def get_payment_methods_manage_keyboard(lang: str, i18n_instance, has_card: bool) -> InlineKeyboardMarkup:
+    """Deprecated in favor of get_payment_methods_list_keyboard. Kept for backward compatibility."""
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=_(key="payment_method_bind_button"), callback_data="pm:bind")
+    )
+    builder.row(
+        InlineKeyboardButton(text=_(key="back_to_main_menu_button"), callback_data="main_action:back_to_main")
+    )
+    return builder.as_markup()
+
+
+def get_payment_methods_list_keyboard(
+    cards: List[Tuple[str, str]],
+    page: int,
+    lang: str,
+    i18n_instance,
+) -> InlineKeyboardMarkup:
+    """
+    Build a paginated list of saved payment methods.
+    cards: list of tuples (payment_method_id, display_title)
+    page: 0-based page index
+    """
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    per_page = 5
+    total = len(cards)
+    start = page * per_page
+    end = start + per_page
+    for pm_id, title in cards[start:end]:
+        builder.row(
+            InlineKeyboardButton(text=title, callback_data=f"pm:view:{pm_id}")
+        )
+
+    # Pagination controls if needed
+    nav_buttons: List[InlineKeyboardButton] = []
+    if start > 0:
+        nav_buttons.append(InlineKeyboardButton(text="⬅️", callback_data=f"pm:list:{page-1}"))
+    if end < total:
+        nav_buttons.append(InlineKeyboardButton(text="➡️", callback_data=f"pm:list:{page+1}"))
+    if nav_buttons:
+        builder.row(*nav_buttons)
+
+    # Bind new card and back
+    builder.row(InlineKeyboardButton(text=_(key="payment_method_bind_button"), callback_data="pm:bind"))
+    builder.row(InlineKeyboardButton(text=_(key="back_to_main_menu_button"), callback_data="main_action:back_to_main"))
+    return builder.as_markup()
+
+
+def get_payment_method_delete_confirm_keyboard(pm_id: str, lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=_(key="yes_button"), callback_data=f"pm:delete:{pm_id}"),
+        InlineKeyboardButton(text=_(key="cancel_button"), callback_data=f"pm:view:{pm_id}"),
+    )
+    return builder.as_markup()
+
+
+def get_payment_method_details_keyboard(pm_id: str, lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=_(key="payment_method_tx_history_title"), callback_data=f"pm:history:{pm_id}")
+    )
+    builder.row(
+        InlineKeyboardButton(text=_(key="payment_method_delete_button"), callback_data=f"pm:delete_confirm:{pm_id}")
+    )
+    builder.row(
+        InlineKeyboardButton(text=_(key="back_to_main_menu_button"), callback_data="pm:list:0")
+    )
+    return builder.as_markup()
+
+
+def get_bind_url_keyboard(bind_url: str, lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.button(text=_(key="payment_method_bind_button"), url=bind_url)
+    builder.button(text=_(key="back_to_main_menu_button"), callback_data="pm:manage")
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def get_back_to_payment_methods_keyboard(lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=_(key="back_to_main_menu_button"), callback_data="pm:list:0"))
+    return builder.as_markup()
+
+
+def get_back_to_payment_method_details_keyboard(pm_id: str, lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    # Back one step: return to specific payment method details
+    builder.row(InlineKeyboardButton(text=_(key="back_to_main_menu_button"), callback_data=f"pm:view:{pm_id}"))
+    return builder.as_markup()
+
+
+def get_autorenew_cancel_keyboard(lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=_(key="autorenew_disable_button"), callback_data="autorenew:cancel")
+    )
+    builder.row(
+        InlineKeyboardButton(text=_(key="menu_my_subscription_inline"), callback_data="main_action:my_subscription")
+    )
+    return builder.as_markup()
+
+
+def get_autorenew_confirm_keyboard(enable: bool, sub_id: int, lang: str, i18n_instance) -> InlineKeyboardMarkup:
+    _ = lambda key, **kwargs: i18n_instance.gettext(lang, key, **kwargs)
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=_(key="yes_button"), callback_data=f"autorenew:confirm:{sub_id}:{1 if enable else 0}"),
+        InlineKeyboardButton(text=_(key="no_button"), callback_data="main_action:my_subscription"),
+    )
+    return builder.as_markup()

bot/main_bot.py

@@ -199,6 +199,7 @@ async def on_shutdown_configured(dispatcher: Dispatcher):
     for service_key in (
         "panel_service",
         "cryptopay_service",
+        "freekassa_service",
         "tribute_service",
         "panel_webhook_service",
         "yookassa_service",
@@ -293,6 +294,8 @@ async def run_bot(settings_param: Settings):
 
     main_tasks.append(asyncio.create_task(web_server_task(), name="AIOHTTPServerTask"))
 
+    # Recurring billing moved to panel webhook (24h before expiry). No periodic task needed here.
+
     logging.info("Starting bot in Webhook mode with AIOHTTP server...")
     logging.info(f"Starting bot with main tasks: {[task.get_name() for task in main_tasks]}")
 

bot/middlewares/channel_subscription.py

@@ -0,0 +1,138 @@
+import logging
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from aiogram import BaseMiddleware
+from aiogram.types import (
+    CallbackQuery,
+    Message,
+    Update,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config.settings import Settings
+from db.dal import user_dal
+from bot.middlewares.i18n import JsonI18n
+from bot.keyboards.inline.user_keyboards import get_channel_subscription_keyboard
+
+
+class ChannelSubscriptionMiddleware(BaseMiddleware):
+    """
+    Blocks access to handlers for users who have not yet passed the required channel subscription check.
+    The /start command is allowed through so that the handler can re-run the verification.
+    """
+
+    def __init__(self, settings: Settings, i18n_instance: JsonI18n):
+        super().__init__()
+        self.settings = settings
+        self.i18n_main_instance = i18n_instance
+
+    async def __call__(
+        self,
+        handler: Callable[[Update, Dict[str, Any]], Awaitable[Any]],
+        event: Update,
+        data: Dict[str, Any],
+    ) -> Any:
+        required_channel_id = self.settings.REQUIRED_CHANNEL_ID
+        if not required_channel_id:
+            return await handler(event, data)
+
+        event_user = data.get("event_from_user")
+        if not event_user or event_user.id in self.settings.ADMIN_IDS:
+            return await handler(event, data)
+
+        # Allow /start to reach the handler so the check can be re-run.
+        message_object: Optional[Message] = event.message
+        if (
+            message_object
+            and message_object.text
+            and message_object.text.startswith("/start")
+        ):
+            return await handler(event, data)
+
+        session: AsyncSession = data["session"]
+        try:
+            db_user = await user_dal.get_user_by_id(session, event_user.id)
+        except Exception as db_error:
+            logging.error(
+                "ChannelSubscriptionMiddleware: failed to fetch user %s: %s",
+                event_user.id,
+                db_error,
+                exc_info=True,
+            )
+            return await handler(event, data)
+
+        if not db_user:
+            return await handler(event, data)
+
+        if (
+            db_user.channel_subscription_verified
+            and db_user.channel_subscription_verified_for == required_channel_id
+        ):
+            return await handler(event, data)
+
+        i18n_payload: Dict[str, Any] = data.get("i18n_data", {})
+        current_lang: str = i18n_payload.get(
+            "current_language", self.settings.DEFAULT_LANGUAGE
+        )
+        i18n_instance: Optional[JsonI18n] = i18n_payload.get(
+            "i18n_instance", self.i18n_main_instance
+        )
+
+        def translate(key: str) -> str:
+            if i18n_instance:
+                return i18n_instance.gettext(current_lang, key)
+            return key
+
+        keyboard = (
+            get_channel_subscription_keyboard(
+                current_lang, i18n_instance, self.settings.REQUIRED_CHANNEL_LINK
+            )
+            if i18n_instance
+            else None
+        )
+        prompt_text = translate("channel_subscription_required")
+
+        if event.callback_query:
+            await self._handle_callback(event.callback_query, prompt_text, keyboard, data)
+            return
+
+        if message_object:
+            await message_object.answer(prompt_text, reply_markup=keyboard)
+        else:
+            bot_instance = data["bot"]
+            await bot_instance.send_message(
+                chat_id=event_user.id,
+                text=prompt_text,
+                reply_markup=keyboard,
+            )
+        return
+
+    async def _handle_callback(
+        self,
+        callback: CallbackQuery,
+        prompt_text: str,
+        keyboard,
+        data: Dict[str, Any],
+    ) -> None:
+        try:
+            await callback.answer(prompt_text, show_alert=True)
+        except Exception:
+            pass
+
+        if callback.message:
+            try:
+                await callback.message.answer(prompt_text, reply_markup=keyboard)
+            except Exception as send_error:
+                logging.error(
+                    "ChannelSubscriptionMiddleware: failed to send prompt for callback in chat %s: %s",
+                    callback.message.chat.id,
+                    send_error,
+                    exc_info=True,
+                )
+        else:
+            bot_instance = data["bot"]
+            await bot_instance.send_message(
+                chat_id=callback.from_user.id,
+                text=prompt_text,
+                reply_markup=keyboard,
+            )

bot/middlewares/i18n.py

@@ -45,10 +45,27 @@ class JsonI18n:
                         exc_info=True)
 
     def gettext(self, lang_code: Optional[str], key: str, **kwargs) -> str:
-        effective_lang_code = lang_code if lang_code and lang_code in self.locales_data else self.default_lang
+        # Determine effective language with robust fallback
+        if lang_code and lang_code in self.locales_data:
+            effective_lang_code = lang_code
+        elif self.default_lang in self.locales_data:
+            effective_lang_code = self.default_lang
+        elif 'en' in self.locales_data:
+            effective_lang_code = 'en'
+        else:
+            effective_lang_code = lang_code or self.default_lang
 
         lang_data = self.locales_data.get(effective_lang_code)
         if lang_data is None:
+            # Try explicit fallback to English if available
+            fallback_data = self.locales_data.get('en')
+            if fallback_data is not None:
+                text = fallback_data.get(key)
+                if text is not None:
+                    try:
+                        return text.format(**kwargs) if kwargs else text
+                    except Exception:
+                        return text
             logging.warning(
                 f"No language data for '{effective_lang_code}' (default '{self.default_lang}' also missing). Key '{key}' will be returned as is."
             )

bot/middlewares/profile_sync.py

@@ -6,6 +6,7 @@ from aiogram.types import Update, User as TgUser
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from db.dal import user_dal
+from bot.utils.text_sanitizer import sanitize_username, sanitize_display_name, username_for_display
 
 
 class ProfileSyncMiddleware(BaseMiddleware):
@@ -24,18 +25,40 @@ class ProfileSyncMiddleware(BaseMiddleware):
                 db_user = await user_dal.get_user_by_id(session, tg_user.id)
                 if db_user:
                     update_payload: Dict[str, Any] = {}
-                    if db_user.username != tg_user.username:
-                        update_payload["username"] = tg_user.username
-                    if db_user.first_name != tg_user.first_name:
-                        update_payload["first_name"] = tg_user.first_name
-                    if db_user.last_name != tg_user.last_name:
-                        update_payload["last_name"] = tg_user.last_name
+                    sanitized_username = sanitize_username(tg_user.username)
+                    sanitized_first_name = sanitize_display_name(tg_user.first_name)
+                    sanitized_last_name = sanitize_display_name(tg_user.last_name)
+
+                    if db_user.username != sanitized_username:
+                        update_payload["username"] = sanitized_username
+                    if db_user.first_name != sanitized_first_name:
+                        update_payload["first_name"] = sanitized_first_name
+                    if db_user.last_name != sanitized_last_name:
+                        update_payload["last_name"] = sanitized_last_name
 
                     if update_payload:
                         await user_dal.update_user(session, tg_user.id, update_payload)
                         logging.info(
                             f"ProfileSyncMiddleware: Updated user {tg_user.id} profile fields: {list(update_payload.keys())}"
                         )
+
+                        # Also update description on panel if linked
+                        try:
+                            panel_service = data.get("panel_service")
+                            if panel_service and db_user.panel_user_uuid:
+                                description_text = "\n".join([
+                                    username_for_display(tg_user.username, with_at=False) if sanitized_username is not None else "",
+                                    sanitized_first_name or "",
+                                    sanitized_last_name or "",
+                                ]).strip()
+                                await panel_service.update_user_details_on_panel(
+                                    db_user.panel_user_uuid,
+                                    {"description": description_text},
+                                )
+                        except Exception as e_upd_desc:
+                            logging.warning(
+                                f"ProfileSyncMiddleware: Failed to update panel description for user {tg_user.id}: {e_upd_desc}"
+                            )
             except Exception as e:
                 logging.error(
                     f"ProfileSyncMiddleware: Failed to sync profile for user {getattr(tg_user, 'id', 'N/A')}: {e}",
@@ -44,4 +67,3 @@ class ProfileSyncMiddleware(BaseMiddleware):
 
         return await handler(event, data)
 
-

bot/services/crypto_pay_service.py

@@ -16,6 +16,7 @@ from bot.services.referral_service import ReferralService
 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
 from bot.services.notification_service import NotificationService
 from db.dal import payment_dal, user_dal
+from bot.utils.text_sanitizer import sanitize_display_name, username_for_display
 
 
 class CryptoPayService:
@@ -67,18 +68,28 @@ class CryptoPayService:
             logging.error("CryptoPayService not configured")
             return None
 
-        payment_record = await payment_dal.create_payment_record(
-            session,
-            {
-                "user_id": user_id,
-                "amount": float(amount),
-                "currency": self.settings.CRYPTOPAY_ASSET,
-                "status": "pending_cryptopay",
-                "description": description,
-                "subscription_duration_months": months,
-                "provider": "cryptopay",
-            },
-        )
+        # Create pending payment in DB and commit to persist
+        try:
+            payment_record = await payment_dal.create_payment_record(
+                session,
+                {
+                    "user_id": user_id,
+                    "amount": float(amount),
+                    "currency": self.settings.CRYPTOPAY_ASSET,
+                    "status": "pending_cryptopay",
+                    "description": description,
+                    "subscription_duration_months": months,
+                    "provider": "cryptopay",
+                },
+            )
+            await session.commit()
+        except Exception as e_db_create:
+            await session.rollback()
+            logging.error(
+                f"Failed to create cryptopay payment record for user {user_id}: {e_db_create}",
+                exc_info=True,
+            )
+            return None
         payload = json.dumps({
             "user_id": str(user_id),
             "subscription_months": str(months),
@@ -93,12 +104,21 @@ class CryptoPayService:
                 description=description,
                 payload=payload,
             )
-            await payment_dal.update_provider_payment_and_status(
-                session,
-                payment_record.payment_id,
-                str(invoice.invoice_id),
-                str(invoice.status),
-            )
+            try:
+                await payment_dal.update_provider_payment_and_status(
+                    session,
+                    payment_record.payment_id,
+                    str(invoice.invoice_id),
+                    str(invoice.status),
+                )
+                await session.commit()
+            except Exception as e_db_update:
+                await session.rollback()
+                logging.error(
+                    f"Failed to update cryptopay payment record {payment_record.payment_id}: {e_db_update}",
+                    exc_info=True,
+                )
+                return None
             return invoice.bot_invoice_url
         except Exception as e:
             logging.error(f"CryptoPay invoice creation failed: {e}", exc_info=True)
@@ -155,6 +175,7 @@ class CryptoPayService:
                 return
 
             db_user = await user_dal.get_user_by_id(session, user_id)
+            # Use DB language for user-facing messages
             lang = db_user.language_code if db_user and db_user.language_code else settings.DEFAULT_LANGUAGE
             _ = lambda k, **kw: i18n.gettext(lang, k, **kw)
 
@@ -169,10 +190,12 @@ class CryptoPayService:
                 inviter_name_display = _("friend_placeholder")
                 if db_user and db_user.referred_by_id:
                     inviter = await user_dal.get_user_by_id(session, db_user.referred_by_id)
-                    if inviter and inviter.first_name:
-                        inviter_name_display = inviter.first_name
-                    elif inviter and inviter.username:
-                        inviter_name_display = f"@{inviter.username}"
+                    if inviter:
+                        safe_name = sanitize_display_name(inviter.first_name) if inviter.first_name else None
+                        if safe_name:
+                            inviter_name_display = safe_name
+                        elif inviter.username:
+                            inviter_name_display = username_for_display(inviter.username, with_at=False)
                 text = _("payment_successful_with_referral_bonus_full",
                          months=months,
                          base_end_date=activation["end_date"].strftime('%Y-%m-%d'),
@@ -186,7 +209,9 @@ class CryptoPayService:
                          end_date=final_end.strftime('%Y-%m-%d'),
                          config_link=config_link)
 
-            markup = get_connect_and_main_keyboard(lang, i18n, settings, config_link)
+            markup = get_connect_and_main_keyboard(
+                lang, i18n, settings, config_link, preserve_message=True
+            )
             try:
                 await bot.send_message(
                     user_id,

bot/services/freekassa_service.py

@@ -0,0 +1,406 @@
+import asyncio
+from datetime import datetime
+import hashlib
+import hmac
+import json
+import logging
+import time
+from decimal import Decimal, ROUND_HALF_UP
+from typing import Optional, Dict, Any, Tuple
+
+from aiohttp import ClientSession, ClientTimeout, web
+from aiogram import Bot
+from sqlalchemy.orm import sessionmaker
+
+from config.settings import Settings
+from bot.middlewares.i18n import JsonI18n
+from bot.services.subscription_service import SubscriptionService
+from bot.services.referral_service import ReferralService
+from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
+from bot.services.notification_service import NotificationService
+from db.dal import payment_dal, user_dal
+from bot.utils.text_sanitizer import sanitize_display_name, username_for_display
+
+
+class FreeKassaService:
+    def __init__(
+        self,
+        *,
+        bot: Bot,
+        settings: Settings,
+        i18n: JsonI18n,
+        async_session_factory: sessionmaker,
+        subscription_service: SubscriptionService,
+        referral_service: ReferralService,
+    ):
+        self.bot = bot
+        self.settings = settings
+        self.i18n = i18n
+        self.async_session_factory = async_session_factory
+        self.subscription_service = subscription_service
+        self.referral_service = referral_service
+
+        self.shop_id: Optional[str] = settings.FREEKASSA_MERCHANT_ID
+        self.api_key: Optional[str] = settings.FREEKASSA_API_KEY
+        self.second_secret: Optional[str] = settings.FREEKASSA_SECOND_SECRET
+        self.default_currency: str = (settings.DEFAULT_CURRENCY_SYMBOL or "RUB").upper()
+        self.server_ip: Optional[str] = settings.FREEKASSA_PAYMENT_IP
+
+        self.api_base_url: str = "https://api.fk.life/v1"
+        self._timeout = ClientTimeout(total=15)
+        self._session: Optional[ClientSession] = None
+        self._nonce_lock = asyncio.Lock()
+        self._last_nonce = int(time.time() * 1000)
+
+        self.configured: bool = bool(settings.FREEKASSA_ENABLED and self.shop_id and self.api_key)
+        if not self.configured:
+            logging.warning("FreeKassaService initialized but not fully configured. Payments disabled.")
+        if settings.FREEKASSA_ENABLED and not self.server_ip:
+            logging.warning("FreeKassaService: FREEKASSA_PAYMENT_IP is not set. Requests may be rejected by the provider.")
+
+    @staticmethod
+    def _format_amount(amount: float) -> str:
+        """Format amount for payloads and signature with two decimal places."""
+        quantized = Decimal(str(amount)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+        return f"{quantized:.2f}"
+
+    async def create_order(
+        self,
+        *,
+        payment_db_id: int,
+        user_id: int,
+        months: int,
+        amount: float,
+        currency: Optional[str],
+        method_code: int,
+        email: Optional[str] = None,
+        ip_address: Optional[str] = None,
+        extra_params: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[bool, Dict[str, Any]]:
+        if not self.configured:
+            logging.error("FreeKassaService is not configured. Cannot create order.")
+            return False, {"message": "service_not_configured"}
+
+        ip_address = ip_address or self.server_ip
+        if not ip_address:
+            logging.error("FreeKassaService: payment IP is required but not configured.")
+            return False, {"message": "missing_ip"}
+
+        email = email or f"{user_id}@telegram.org"
+        amount_str = self._format_amount(amount)
+        currency_code = (currency or self.default_currency or "RUB").upper()
+
+        payload: Dict[str, Any] = {
+            "shopId": int(self.shop_id),
+            "nonce": await self._generate_nonce(),
+            "paymentId": str(payment_db_id),
+            "i": int(method_code),
+            "amount": amount_str,
+            "currency": currency_code,
+            "email": email,
+            "ip": ip_address,
+            "us_user_id": str(user_id),
+            "us_months": str(months),
+            "us_payment_db_id": str(payment_db_id),
+        }
+
+        if extra_params:
+            for key, value in extra_params.items():
+                if value is None:
+                    continue
+                payload[key] = value
+
+        payload["signature"] = self._sign_payload(payload)
+
+        session = await self._get_session()
+        url = f"{self.api_base_url}/orders/create"
+        try:
+            async with session.post(url, json=payload) as response:
+                response_text = await response.text()
+                try:
+                    response_data = json.loads(response_text) if response_text else {}
+                except json.JSONDecodeError:
+                    logging.error("FreeKassa create_order: failed to decode JSON: %s", response_text)
+                    return False, {"status": response.status, "message": "invalid_json", "raw": response_text}
+
+                if response.status != 200 or response_data.get("type") != "success":
+                    logging.error(
+                        "FreeKassa create_order: API returned error (status=%s, body=%s)",
+                        response.status,
+                        response_data,
+                    )
+                    return False, {"status": response.status, "message": response_data}
+
+                return True, response_data
+        except Exception as exc:
+            logging.error("FreeKassa create_order: request failed: %s", exc, exc_info=True)
+            return False, {"message": str(exc)}
+
+    async def _get_session(self) -> ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = ClientSession(timeout=self._timeout)
+        return self._session
+
+    async def _generate_nonce(self) -> int:
+        async with self._nonce_lock:
+            candidate = int(time.time() * 1000)
+            if candidate <= self._last_nonce:
+                candidate = self._last_nonce + 1
+            self._last_nonce = candidate
+            return candidate
+
+    def _sign_payload(self, payload: Dict[str, Any]) -> str:
+        if not self.api_key:
+            raise RuntimeError("FreeKassa API key is not configured.")
+        items = [
+            (key, value)
+            for key, value in payload.items()
+            if key != "signature" and value is not None
+        ]
+        items.sort(key=lambda pair: pair[0])
+        message = "|".join(str(value) for _, value in items)
+        return hmac.new(self.api_key.encode("utf-8"), message.encode("utf-8"), hashlib.sha256).hexdigest()
+
+    async def close(self) -> None:
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    def _validate_signature(
+        self,
+        merchant_order_id: str,
+        amount: str,
+        provided_signature: str,
+        payload: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        if not provided_signature:
+            return False
+
+        if self.shop_id and self.second_secret:
+            signature_source = f"{self.shop_id}:{amount}:{self.second_secret}:{merchant_order_id}"
+            expected_signature = hashlib.md5(signature_source.encode("utf-8")).hexdigest()
+            if expected_signature.lower() == provided_signature.lower():
+                return True
+
+        if self.api_key and payload:
+            items = [
+                (key, value)
+                for key, value in payload.items()
+                if key not in {"signature", "SIGN"} and value is not None
+            ]
+            items.sort(key=lambda pair: pair[0])
+            message = "|".join(str(value) for _, value in items)
+            alt_signature = hmac.new(self.api_key.encode("utf-8"), message.encode("utf-8"), hashlib.sha256).hexdigest()
+            if alt_signature.lower() == provided_signature.lower():
+                return True
+
+        return False
+
+    async def webhook_route(self, request: web.Request) -> web.Response:
+        if not self.configured:
+            return web.Response(status=503, text="freekassa_disabled")
+
+        try:
+            data = await request.post()
+        except Exception as e:
+            logging.error(f"FreeKassa webhook: failed to read POST data: {e}")
+            return web.Response(status=400, text="bad_request")
+
+        payload_dict: Dict[str, Any]
+        if data:
+            payload_dict = {str(k): v for k, v in data.items()}
+        else:
+            try:
+                json_payload = await request.json()
+                payload_dict = {str(k): v for k, v in json_payload.items()} if isinstance(json_payload, dict) else {}
+                data = json_payload
+            except Exception:
+                payload_dict = {}
+                data = {}
+
+        def _get(key: str, default: Optional[str] = None) -> Optional[str]:
+            if isinstance(data, dict):
+                return data.get(key) or data.get(key.lower()) or default
+            return payload_dict.get(key) or payload_dict.get(key.lower()) or default
+
+        merchant_id = _get("MERCHANT_ID")
+        if merchant_id != self.shop_id:
+            logging.error(f"FreeKassa webhook: merchant mismatch (got {merchant_id})")
+            return web.Response(status=403, text="merchant_mismatch")
+
+        signature = _get("SIGN") or _get("signature")
+        if not signature:
+            logging.error("FreeKassa webhook: missing signature")
+            return web.Response(status=400, text="missing_signature")
+
+        order_id_str = _get("MERCHANT_ORDER_ID") or _get("ORDER_ID") or _get("o")
+        amount_str = _get("AMOUNT") or _get("OA") or _get("amount")
+        provider_payment_id = _get("intid") or _get("payment_id") or _get("transaction_id")
+
+        if not order_id_str or not amount_str:
+            logging.error("FreeKassa webhook: missing order_id or amount")
+            return web.Response(status=400, text="missing_data")
+
+        if not self._validate_signature(order_id_str, amount_str, signature, payload_dict):
+            logging.error("FreeKassa webhook: invalid signature")
+            return web.Response(status=403, text="invalid_signature")
+
+        try:
+            payment_db_id = int(order_id_str)
+        except (TypeError, ValueError):
+            logging.error(f"FreeKassa webhook: invalid order_id value '{order_id_str}'")
+            return web.Response(status=400, text="invalid_order_id")
+
+        async with self.async_session_factory() as session:
+            payment = await payment_dal.get_payment_by_db_id(session, payment_db_id)
+            if not payment:
+                logging.error(f"FreeKassa webhook: payment {payment_db_id} not found")
+                return web.Response(status=404, text="payment_not_found")
+
+            if payment.status == "succeeded":
+                logging.info(f"FreeKassa webhook: payment {payment_db_id} already succeeded")
+                return web.Response(text="YES")
+
+            # Optional amount verification
+            try:
+                amount_decimal = Decimal(amount_str)
+                expected_amount = Decimal(str(payment.amount)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+                if amount_decimal.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) != expected_amount:
+                    logging.warning(
+                        f"FreeKassa webhook: amount mismatch for payment {payment_db_id} "
+                        f"(expected {expected_amount}, got {amount_decimal})"
+                    )
+            except Exception as e:
+                logging.warning(f"FreeKassa webhook: failed to compare amount for payment {payment_db_id}: {e}")
+
+            activation = None
+            referral_bonus = None
+            try:
+                await payment_dal.update_provider_payment_and_status(
+                    session=session,
+                    payment_db_id=payment.payment_id,
+                    provider_payment_id=str(provider_payment_id or f"freekassa:{order_id_str}"),
+                    new_status="succeeded",
+                )
+
+                months = payment.subscription_duration_months or 1
+
+                activation = await self.subscription_service.activate_subscription(
+                    session,
+                    payment.user_id,
+                    months,
+                    float(payment.amount),
+                    payment.payment_id,
+                    provider="freekassa",
+                )
+
+                referral_bonus = await self.referral_service.apply_referral_bonuses_for_payment(
+                    session,
+                    payment.user_id,
+                    months,
+                    current_payment_db_id=payment.payment_id,
+                    skip_if_active_before_payment=False,
+                )
+
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                logging.error(f"FreeKassa webhook: failed to process payment {payment_db_id}: {e}", exc_info=True)
+                return web.Response(status=500, text="processing_error")
+
+            db_user = payment.user or await user_dal.get_user_by_id(session, payment.user_id)
+            lang = db_user.language_code if db_user and db_user.language_code else self.settings.DEFAULT_LANGUAGE
+            _ = lambda k, **kw: self.i18n.gettext(lang, k, **kw) if self.i18n else k
+
+            config_link = None
+            final_end = None
+            months = payment.subscription_duration_months or 1
+            if activation:
+                config_link = activation.get("subscription_url")
+                final_end = activation.get("end_date")
+
+            applied_days = 0
+            if referral_bonus and referral_bonus.get("referee_new_end_date"):
+                final_end = referral_bonus["referee_new_end_date"]
+                applied_days = referral_bonus.get("referee_bonus_applied_days", 0)
+
+            if not final_end and activation and activation.get("end_date"):
+                final_end = activation["end_date"]
+
+            if not config_link:
+                config_link = _("config_link_not_available")
+            if final_end:
+                end_date_str = final_end.strftime("%Y-%m-%d")
+            else:
+                end_date_str = _("config_link_not_available")
+
+            if applied_days:
+                inviter_name_display = _("friend_placeholder")
+                if db_user and db_user.referred_by_id:
+                    inviter = await user_dal.get_user_by_id(session, db_user.referred_by_id)
+                    if inviter:
+                        safe_name = sanitize_display_name(inviter.first_name) if inviter.first_name else None
+                        if safe_name:
+                            inviter_name_display = safe_name
+                        elif inviter.username:
+                            inviter_name_display = username_for_display(inviter.username, with_at=False)
+                text = _(
+                    "payment_successful_with_referral_bonus_full",
+                    months=months,
+                    base_end_date=activation["end_date"].strftime("%Y-%m-%d") if activation and activation.get("end_date") else end_date_str,
+                    bonus_days=applied_days,
+                    final_end_date=end_date_str,
+                    inviter_name=inviter_name_display,
+                    config_link=config_link,
+                )
+            else:
+                text = _(
+                    "payment_successful_full",
+                    months=months,
+                    end_date=end_date_str,
+                    config_link=config_link,
+                )
+            if provider_payment_id:
+                order_info_text = _(
+                    "free_kassa_order_full",
+                    order_id=provider_payment_id,
+                    date=datetime.now().strftime("%Y-%m-%d"),
+                )
+                text = f"{order_info_text}\n{text}"
+
+            markup = get_connect_and_main_keyboard(
+                lang,
+                self.i18n,
+                self.settings,
+                config_link,
+                preserve_message=True,
+            )
+            try:
+                await self.bot.send_message(
+                    payment.user_id,
+                    text,
+                    reply_markup=markup,
+                    parse_mode="HTML",
+                    disable_web_page_preview=True,
+                )
+            except Exception as e:
+                logging.error(f"FreeKassa notification: failed to send message to user {payment.user_id}: {e}")
+
+            try:
+                notification_service = NotificationService(self.bot, self.settings, self.i18n)
+                await notification_service.notify_payment_received(
+                    user_id=payment.user_id,
+                    amount=float(payment.amount),
+                    currency=self.default_currency,
+                    months=months,
+                    payment_provider="freekassa",
+                    username=db_user.username if db_user else None,
+                )
+            except Exception as e:
+                logging.error(f"FreeKassa notification: failed to notify admins: {e}")
+
+        return web.Response(text="YES")
+
+
+async def freekassa_webhook_route(request: web.Request) -> web.Response:
+    service: FreeKassaService = request.app["freekassa_service"]
+    return await service.webhook_route(request)

bot/services/notification_service.py

@@ -10,6 +10,10 @@ from config.settings import Settings
 from sqlalchemy.orm import sessionmaker
 from bot.middlewares.i18n import JsonI18n
 from bot.utils.message_queue import get_queue_manager
+from bot.utils.text_sanitizer import (
+    display_name_or_fallback,
+    username_for_display,
+)
 
 
 class NotificationService:
@@ -19,6 +23,17 @@ class NotificationService:
         self.bot = bot
         self.settings = settings
         self.i18n = i18n
+
+    @staticmethod
+    def _format_user_display(
+        user_id: int,
+        username: Optional[str] = None,
+        first_name: Optional[str] = None,
+    ) -> str:
+        base_display = display_name_or_fallback(first_name, f"ID {user_id}")
+        if username:
+            base_display = f"{base_display} ({username_for_display(username)})"
+        return base_display
     
     async def _send_to_log_channel(self, message: str, thread_id: Optional[int] = None):
         """Send message to configured log channel/group using message queue"""
@@ -101,9 +116,11 @@ class NotificationService:
         admin_lang = self.settings.DEFAULT_LANGUAGE
         _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
         
-        user_display = first_name or f"ID {user_id}"
-        if username:
-            user_display += f" (@{username})"
+        user_display = self._format_user_display(
+            user_id=user_id,
+            username=username,
+            first_name=first_name,
+        )
         
         referral_text = ""
         if referred_by_id:
@@ -134,12 +151,14 @@ class NotificationService:
         admin_lang = self.settings.DEFAULT_LANGUAGE
         _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
         
-        user_display = f"ID {user_id}"
-        if username:
-            user_display += f" (@{username})"
+        user_display = self._format_user_display(
+            user_id=user_id,
+            username=username,
+        )
         
         provider_emoji = {
             "yookassa": "💳",
+            "freekassa": "💳",
             "cryptopay": "₿",
             "stars": "⭐",
             "tribute": "💎"
@@ -174,9 +193,10 @@ class NotificationService:
         admin_lang = self.settings.DEFAULT_LANGUAGE
         _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
         
-        user_display = f"ID {user_id}"
-        if username:
-            user_display += f" (@{username})"
+        user_display = self._format_user_display(
+            user_id=user_id,
+            username=username,
+        )
         
         message = _(
             "log_promo_activation",
@@ -203,9 +223,10 @@ class NotificationService:
         admin_lang = self.settings.DEFAULT_LANGUAGE
         _ = lambda k, **kw: self.i18n.gettext(admin_lang, k, **kw) if self.i18n else k
         
-        user_display = f"ID {user_id}"
-        if username:
-            user_display += f" (@{username})"
+        user_display = self._format_user_display(
+            user_id=user_id,
+            username=username,
+        )
         
         message = _(
             "log_trial_activation",
@@ -268,9 +289,11 @@ class NotificationService:
         _ = lambda k, **kw: self.i18n.gettext(
             admin_lang, k, **kw) if self.i18n else k
 
-        user_display = first_name or f"ID {user_id}"
-        if username:
-            user_display += f" (@{username})"
+        user_display = self._format_user_display(
+            user_id=user_id,
+            username=username,
+            first_name=first_name,
+        )
 
         message = _(
             "log_suspicious_promo",
@@ -295,4 +318,4 @@ class NotificationService:
         if to_admins:
             await self._send_to_admins(message)
 
-# Removed legacy helper functions that duplicated NotificationService API
+# Removed legacy helper functions that duplicated NotificationService API

bot/services/panel_api_service.py

@@ -21,11 +21,11 @@ class PanelApiService:
         self.api_key = settings.PANEL_API_KEY
         self._session: Optional[aiohttp.ClientSession] = None
         self.default_client_ip = "127.0.0.1"
-    
+
     async def __aenter__(self):
         """Context manager entry"""
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit - automatically close session"""
         await self.close_session()
@@ -337,6 +337,7 @@ class PanelApiService:
             default_expire_days: int = 1,
             default_traffic_limit_bytes: int = 0,
             default_traffic_limit_strategy: str = "NO_RESET",
+            hwid_device_limit: Optional[int] = None,
             specific_squad_uuids: Optional[List[str]] = None,
             description: Optional[str] = None,
             tag: Optional[str] = None,
@@ -368,6 +369,18 @@ class PanelApiService:
             "trafficLimitStrategy": default_traffic_limit_strategy.upper(),
             "trafficLimitBytes": default_traffic_limit_bytes,
         }
+        hwid_limit_value = hwid_device_limit
+        if hwid_limit_value is None:
+            hwid_limit_value = self.settings.USER_HWID_DEVICE_LIMIT
+        if hwid_limit_value is not None:
+            try:
+                hwid_limit_int = int(hwid_limit_value)
+                if hwid_limit_int >= 0:
+                    payload["hwidDeviceLimit"] = hwid_limit_int
+            except (TypeError, ValueError):
+                logging.warning(
+                    f"Ignoring invalid HWID device limit '{hwid_limit_value}' while creating panel user '{username_on_panel}'."
+                )
         if specific_squad_uuids:
             payload["activeInternalSquads"] = specific_squad_uuids
         if telegram_id is not None: payload["telegramId"] = telegram_id
@@ -455,6 +468,30 @@ class PanelApiService:
             return f"{base_sub_url}/{client_type.lower()}"
         return base_sub_url
 
+    async def get_user_devices(self, user_uuid: str) -> Optional[List[Dict[str, Any]]]:
+        endpoint = f"/hwid/devices/{user_uuid}"
+        response_data = await self._request("GET", endpoint, log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return response_data.get("response")
+        logging.error(
+            f"Failed to get user devices for user {user_uuid}. Response: {response_data}"
+        )
+        return None
+
+    async def disconnect_device(self, user_uuid: str, hwid: str) -> bool:
+        endpoint = f"/hwid/devices/delete"
+        payload = {
+            "userUuid": user_uuid,
+            "hwid": hwid
+        }
+        response_data = await self._request("POST", endpoint, json=payload, log_full_response=False)
+        if response_data and not response_data.get("error") and "response" in response_data:
+            return True
+        logging.error(
+            f"Failed to disconnect device {hwid} for user {user_uuid}. Payload: {payload}, Response: {response_data}"
+        )
+        return False
+
     async def update_bot_db_sync_status(self,
                                         session: AsyncSession,
                                         status: str,
@@ -468,25 +505,24 @@ class PanelApiService:
     async def get_bot_db_last_sync_status(
             self, session: AsyncSession) -> Optional[PanelSyncStatus]:
         return await panel_sync_dal.get_panel_sync_status(session)
-    
-    
+
     async def get_system_stats(self) -> Optional[Dict[str, Any]]:
         """Get system statistics (CPU, memory, users counts)"""
         response_data = await self._request("GET", "/system/stats", log_full_response=False)
         if response_data and not response_data.get("error") and "response" in response_data:
             return response_data.get("response")
         return None
-    
+
     async def get_bandwidth_stats(self) -> Optional[Dict[str, Any]]:
         """Get bandwidth statistics"""
         response_data = await self._request("GET", "/system/stats/bandwidth", log_full_response=False)
         if response_data and not response_data.get("error") and "response" in response_data:
             return response_data.get("response")
         return None
-    
+
     async def get_nodes_statistics(self) -> Optional[Dict[str, Any]]:
         """Get nodes statistics"""
         response_data = await self._request("GET", "/system/stats/nodes", log_full_response=False)
         if response_data and not response_data.get("error") and "response" in response_data:
             return response_data.get("response")
-        return None
+        return None

bot/services/panel_webhook_service.py

@@ -8,8 +8,9 @@ from aiogram.types import InlineKeyboardMarkup
 from sqlalchemy.orm import sessionmaker
 from typing import Optional
 from config.settings import Settings
+from .panel_api_service import PanelApiService
 from bot.middlewares.i18n import JsonI18n
-from bot.keyboards.inline.user_keyboards import get_subscribe_only_markup
+from bot.keyboards.inline.user_keyboards import get_subscribe_only_markup, get_autorenew_cancel_keyboard
 from db.dal import user_dal
 from bot.utils.date_utils import add_months
 
@@ -20,11 +21,12 @@ EVENT_MAP = {
 }
 
 class PanelWebhookService:
-    def __init__(self, bot: Bot, settings: Settings, i18n: JsonI18n, async_session_factory: sessionmaker):
+    def __init__(self, bot: Bot, settings: Settings, i18n: JsonI18n, async_session_factory: sessionmaker, panel_service: PanelApiService):
         self.bot = bot
         self.settings = settings
         self.i18n = i18n
         self.async_session_factory = async_session_factory
+        self.panel_service = panel_service
 
     async def _send_message(
         self,
@@ -72,6 +74,7 @@ class PanelWebhookService:
                     # Extend subscription by the last payment duration (calendar months)
                     new_end_date = add_months(datetime.now(timezone.utc), last_tribute_duration)
                     
+                    # Update local DB subscription
                     await subscription_dal.update_subscription(
                         session,
                         sub.subscription_id,
@@ -81,6 +84,56 @@ class PanelWebhookService:
                             'is_active': True
                         }
                     )
+                    # Update panel expiry to ensure actual service access is extended
+                    try:
+                        panel_payload = {
+                            "uuid": sub.panel_user_uuid,
+                            "expireAt": new_end_date.isoformat(timespec='milliseconds').replace('+00:00', 'Z'),
+                            "status": "ACTIVE",
+                        }
+                        panel_update_resp = await self.panel_service.update_user_details_on_panel(
+                            sub.panel_user_uuid,
+                            panel_payload,
+                            log_response=True,
+                        )
+                        if panel_update_resp:
+                            logging.info(
+                                f"Panel expiry updated for user {user_id} (panel_uuid {sub.panel_user_uuid}) to {new_end_date}"
+                            )
+                    except Exception as e_panel:
+                        logging.error(
+                            f"Failed to update panel expiry for user {user_id} (panel_uuid {sub.panel_user_uuid}): {e_panel}")
+
+                    # Create a succeeded payment record in DB with the same amount/currency as last tribute payment
+                    try:
+                        last_payment = await payment_dal.get_last_tribute_payment(session, user_id)
+                        if last_payment and last_payment.amount and last_payment.currency:
+                            provider_payment_id = (
+                                f"tribute_auto_{user_id}_{sub.subscription_id}_"
+                                f"{new_end_date.strftime('%Y%m%d')}"
+                            )
+                            created_payment = await payment_dal.ensure_payment_with_provider_id(
+                                session,
+                                user_id=user_id,
+                                amount=float(last_payment.amount),
+                                currency=last_payment.currency,
+                                months=last_tribute_duration,
+                                description="Auto-renewal (panel webhook)",
+                                provider="tribute",
+                                provider_payment_id=provider_payment_id,
+                            )
+                            if created_payment:
+                                logging.info(
+                                    f"Auto-renew payment recorded (id={created_payment.payment_id}) for user {user_id} amount={created_payment.amount} {created_payment.currency} months={last_tribute_duration}"
+                                )
+                        else:
+                            logging.warning(
+                                f"Could not create auto-renew payment for user {user_id}: previous tribute payment not found or missing amount/currency")
+                    except Exception as e_pay:
+                        logging.error(
+                            f"Failed to create auto-renew payment record for user {user_id}: {e_pay}",
+                            exc_info=True,
+                        )
                     
                     # Send auto-renewal notification
                     _ = lambda k, **kw: self.i18n.gettext(lang, k, **kw) if self.i18n else k
@@ -132,7 +185,51 @@ class PanelWebhookService:
 
         if event_name in EVENT_MAP:
             days_left, msg_key = EVENT_MAP[event_name]
+            if days_left == 1:
+                # Trigger auto-renew via SubscriptionService (wired in at factory)
+                try:
+                    subscription_service = getattr(self, "subscription_service", None)
+                    if subscription_service:
+                        async with self.async_session_factory() as session:
+                            from db.dal import subscription_dal
+                            sub = await subscription_dal.get_active_subscription_by_user_id(session, user_id)
+                            if sub and sub.auto_renew_enabled and sub.provider != 'tribute':
+                                try:
+                                    ok = await subscription_service.charge_subscription_renewal(session, sub)
+                                    # If initiation succeeded, suppress the 24h reminder by returning early
+                                    if ok:
+                                        await session.commit()
+                                        return
+                                    else:
+                                        await session.rollback()
+                                except Exception:
+                                    await session.rollback()
+                                    logging.exception("Auto-renew attempt (24h) failed")
+                except Exception:
+                    logging.exception("Auto-renew trigger (24h) failed pre-check")
             if days_left <= self.settings.SUBSCRIPTION_NOTIFY_DAYS_BEFORE:
+                # For 48h event, if auto-renew is enabled and not tribute, show special notice with cancel button
+                if days_left == 2:
+                    async with self.async_session_factory() as session:
+                        from db.dal import subscription_dal
+                        sub = await subscription_dal.get_active_subscription_by_user_id(session, user_id)
+                        logging.info(
+                            "48h webhook check: user_id=%s sub_found=%s auto_renew=%s provider=%s",
+                            user_id,
+                            bool(sub),
+                            getattr(sub, 'auto_renew_enabled', None) if sub else None,
+                            getattr(sub, 'provider', None) if sub else None,
+                        )
+                        if sub and sub.auto_renew_enabled and sub.provider != 'tribute':
+                            cancel_kb = get_autorenew_cancel_keyboard(lang, self.i18n)
+                            await self._send_message(
+                                user_id,
+                                lang,
+                                "autorenew_48h_charge_tomorrow_notice",
+                                reply_markup=cancel_kb,
+                                user_name=first_name,
+                            )
+                            return
                 await self._send_message(
                     user_id,
                     lang,

bot/services/stars_service.py

@@ -12,6 +12,7 @@ from .referral_service import ReferralService
 from bot.middlewares.i18n import JsonI18n
 from .notification_service import NotificationService
 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
+from bot.utils.text_sanitizer import sanitize_display_name, username_for_display
 
 
 class StarsService:
@@ -109,8 +110,9 @@ class StarsService:
         if not final_end:
             final_end = activation_details["end_date"]
 
-        current_lang = i18n_data.get("current_language",
-                                     self.settings.DEFAULT_LANGUAGE)
+        # Always use user's language from DB for user-facing messages
+        db_user = await user_dal.get_user_by_id(session, message.from_user.id)
+        current_lang = db_user.language_code if db_user and db_user.language_code else self.settings.DEFAULT_LANGUAGE
         i18n: JsonI18n = i18n_data.get("i18n_instance")
         _ = lambda k, **kw: i18n.gettext(current_lang, k, **kw) if i18n else k
 
@@ -123,10 +125,12 @@ class StarsService:
             db_user = await user_dal.get_user_by_id(session, message.from_user.id)
             if db_user and db_user.referred_by_id:
                 inviter = await user_dal.get_user_by_id(session, db_user.referred_by_id)
-                if inviter and inviter.first_name:
-                    inviter_name_display = inviter.first_name
-                elif inviter and inviter.username:
-                    inviter_name_display = f"@{inviter.username}"
+                if inviter:
+                    safe_name = sanitize_display_name(inviter.first_name) if inviter.first_name else None
+                    if safe_name:
+                        inviter_name_display = safe_name
+                    elif inviter.username:
+                        inviter_name_display = username_for_display(inviter.username, with_at=False)
             success_msg = _(
                 "payment_successful_with_referral_bonus_full",
                 months=months,
@@ -144,7 +148,7 @@ class StarsService:
                 config_link=config_link,
             )
         markup = get_connect_and_main_keyboard(
-            current_lang, i18n, self.settings, config_link
+            current_lang, i18n, self.settings, config_link, preserve_message=True
         )
         try:
             await self.bot.send_message(
@@ -172,4 +176,3 @@ class StarsService:
             )
         except Exception as e:
             logging.error(f"Failed to send stars payment notification: {e}")
-

bot/services/subscription_service.py

@@ -5,7 +5,7 @@ from typing import Optional, Dict, Any, List, Tuple
 from aiogram import Bot
 from bot.middlewares.i18n import JsonI18n
 
-from db.dal import user_dal, subscription_dal, promo_code_dal, payment_dal
+from db.dal import user_dal, subscription_dal, promo_code_dal, payment_dal, user_billing_dal
 from bot.utils.date_utils import add_months
 from db.models import User, Subscription
 
@@ -119,6 +119,11 @@ class SubscriptionService:
                     creation_response = await self.panel_service.create_panel_user(
                         username_on_panel=panel_username_on_panel_standard,
                         telegram_id=user_id,
+                        description="\n".join([
+                            (db_user.username or "") if db_user else "",
+                            (db_user.first_name or "") if db_user else "",
+                            (db_user.last_name or "") if db_user else "",
+                        ]),
                         specific_squad_uuids=self.settings.parsed_user_squad_uuids,
                         default_traffic_limit_bytes=self.settings.user_traffic_limit_bytes,
                         default_traffic_limit_strategy=self.settings.USER_TRAFFIC_STRATEGY,
@@ -142,6 +147,11 @@ class SubscriptionService:
                 creation_response = await self.panel_service.create_panel_user(
                     username_on_panel=panel_username_on_panel_standard,
                     telegram_id=user_id,
+                    description="\n".join([
+                        (db_user.username or "") if db_user else "",
+                        (db_user.first_name or "") if db_user else "",
+                        (db_user.last_name or "") if db_user else "",
+                    ]),
                     specific_squad_uuids=self.settings.parsed_user_squad_uuids,
                     default_traffic_limit_bytes=self.settings.user_traffic_limit_bytes,
                     default_traffic_limit_strategy=self.settings.USER_TRAFFIC_STRATEGY,
@@ -258,8 +268,19 @@ class SubscriptionService:
             logging.info(
                 f"Panel user {current_local_panel_uuid} has telegramId '{panel_telegram_id_from_api}'. Updating on panel to '{user_id}'."
             )
+            # Also set readable description with Telegram fields
             await self.panel_service.update_user_details_on_panel(
-                current_local_panel_uuid, {"telegramId": user_id}
+                current_local_panel_uuid,
+                {
+                    "telegramId": user_id,
+                    "description": "\n".join(
+                        [
+                            (db_user.username or "") if db_user else "",
+                            (db_user.first_name or "") if db_user else "",
+                            (db_user.last_name or "") if db_user else "",
+                        ]
+                    ),
+                },
             )
 
         panel_sub_link_id = panel_user_obj_from_api.get(
@@ -334,6 +355,7 @@ class SubscriptionService:
             "is_active": True,
             "status_from_panel": "TRIAL",
             "traffic_limit_bytes": self.settings.trial_traffic_limit_bytes,
+            "auto_renew_enabled": False,
         }
         try:
             await subscription_dal.upsert_subscription(session, trial_sub_data)
@@ -356,6 +378,15 @@ class SubscriptionService:
             traffic_limit_bytes=self.settings.trial_traffic_limit_bytes,
         )
 
+        # Add user description based on Telegram profile
+        panel_update_payload["description"] = "\n".join(
+            [
+                (db_user.username or "") if db_user else "",
+                (db_user.first_name or "") if db_user else "",
+                (db_user.last_name or "") if db_user else "",
+            ]
+        )
+
         updated_panel_user = await self.panel_service.update_user_details_on_panel(
             panel_user_uuid, panel_update_payload
         )
@@ -479,6 +510,7 @@ class SubscriptionService:
             "traffic_limit_bytes": self.settings.user_traffic_limit_bytes,
             "provider": provider,
             "skip_notifications": provider == "tribute" and self.settings.TRIBUTE_SKIP_NOTIFICATIONS,
+            "auto_renew_enabled": True,
         }
         try:
             new_or_updated_sub = await subscription_dal.upsert_subscription(
@@ -498,6 +530,15 @@ class SubscriptionService:
             traffic_limit_bytes=self.settings.user_traffic_limit_bytes,
         )
 
+        # Add user description based on Telegram profile
+        panel_update_payload["description"] = "\n".join(
+            [
+                (db_user.username or "") if db_user else "",
+                (db_user.first_name or "") if db_user else "",
+                (db_user.last_name or "") if db_user else "",
+            ]
+        )
+
         updated_panel_user = await self.panel_service.update_user_details_on_panel(
             panel_user_uuid, panel_update_payload
         )
@@ -552,10 +593,10 @@ class SubscriptionService:
             )
             start_date = datetime.now(timezone.utc)
             new_end_date_obj = start_date + timedelta(days=bonus_days)
-            
+
             # For promo code activations, use the configured user traffic limit
             traffic_limit = self.settings.user_traffic_limit_bytes if "promo code" in reason.lower() else self.settings.trial_traffic_limit_bytes
-            
+
             bonus_sub_payload = {
                 "user_id": user_id,
                 "panel_user_uuid": panel_uuid,
@@ -594,7 +635,7 @@ class SubscriptionService:
                 ),
                 include_uuid=False,
             )
-            
+
             panel_update_success = (
                 await self.panel_service.update_user_details_on_panel(
                     panel_uuid,
@@ -698,8 +739,12 @@ class SubscriptionService:
             if panel_user_data.get("expireAt")
             else None
         )
+        hwid_limit = panel_user_data.get("hwidDeviceLimit")
+        if hwid_limit is None:
+            hwid_limit = self.settings.USER_HWID_DEVICE_LIMIT
 
         return {
+            "user_id": panel_user_data.get("uuid"),
             "end_date": panel_end_date,
             "status_from_panel": panel_user_data.get("status", "UNKNOWN").upper(),
             "config_link": panel_user_data.get("subscriptionUrl"),
@@ -707,6 +752,7 @@ class SubscriptionService:
             "traffic_used_bytes": panel_user_data.get("usedTrafficBytes"),
             "user_bot_username": db_user.username,
             "is_panel_data": True,
+            "max_devices": hwid_limit,
         }
 
     async def get_subscriptions_ending_soon(
@@ -741,6 +787,62 @@ class SubscriptionService:
                 )
         return results
 
+    async def charge_subscription_renewal(
+        self,
+        session: AsyncSession,
+        sub: Subscription,
+    ) -> bool:
+        """Attempt to charge user using saved payment method. Return True on initiated/handled, False on failure."""
+        if not sub.auto_renew_enabled:
+            return True
+        # If autopayments are disabled globally, skip charging attempts
+        if not getattr(self.settings, 'YOOKASSA_AUTOPAYMENTS_ENABLED', False):
+            return True
+        if sub.provider == "tribute":
+            # Tribute is paid externally; we do not auto-charge here
+            return True
+
+        from db.dal.user_billing_dal import get_user_default_payment_method
+        default_pm = await get_user_default_payment_method(session, sub.user_id)
+        if not default_pm:
+            logging.info(f"Auto-renew skipped: no saved payment method for user {sub.user_id}")
+            return False
+
+        try:
+            from .yookassa_service import YooKassaService  # local import to avoid cycles
+            yk: YooKassaService = self.yookassa_service  # type: ignore[attr-defined]
+        except Exception:
+            yk = None  # type: ignore
+        if not yk or not getattr(yk, 'configured', False):
+            logging.warning("YooKassa unavailable for auto-renew")
+            return False
+
+        months = sub.duration_months or 1
+        amount = self.settings.subscription_options.get(months)
+        if not amount:
+            logging.error(f"Auto-renew price missing for {months} months")
+            return False
+
+        metadata = {
+            "user_id": str(sub.user_id),
+            "auto_renew_for_subscription_id": str(sub.subscription_id),
+            "subscription_months": str(months),
+        }
+        resp = await yk.create_payment(
+            amount=float(amount),
+            currency="RUB",
+            description=f"Auto-renewal for {months} months",
+            metadata=metadata,
+            payment_method_id=default_pm.provider_payment_method_id,
+            save_payment_method=False,
+            capture=True,
+        )
+        if not resp or resp.get("status") not in {"pending", "waiting_for_capture", "succeeded"}:
+            logging.error(f"Auto-renew create_payment failed: {resp}")
+            return False
+        logging.info(f"Auto-renew initiated for user {sub.user_id} payment_id={resp.get('id')}")
+        return True
+
     async def update_last_notification_sent(
         self, session: AsyncSession, user_id: int, subscription_end_date: datetime
     ):

bot/services/tribute_service.py

@@ -16,6 +16,7 @@ from bot.services.referral_service import ReferralService
 from .notification_service import NotificationService
 from bot.keyboards.inline.user_keyboards import get_connect_and_main_keyboard
 from db.dal import payment_dal, user_dal, subscription_dal
+from bot.utils.text_sanitizer import sanitize_display_name, username_for_display
 
 
 def convert_period_to_months(period: Optional[str]) -> int:
@@ -184,10 +185,12 @@ class TributeService:
                         inviter_name_display = _('friend_placeholder')
                         if db_user and db_user.referred_by_id:
                             inviter = await user_dal.get_user_by_id(session, db_user.referred_by_id)
-                            if inviter and inviter.first_name:
-                                inviter_name_display = inviter.first_name
-                            elif inviter and inviter.username:
-                                inviter_name_display = f"@{inviter.username}"
+                            if inviter:
+                                safe_name = sanitize_display_name(inviter.first_name) if inviter.first_name else None
+                                if safe_name:
+                                    inviter_name_display = safe_name
+                                elif inviter.username:
+                                    inviter_name_display = username_for_display(inviter.username, with_at=False)
                         success_msg = _(
                             "payment_successful_with_referral_bonus_full",
                             months=months,
@@ -205,10 +208,15 @@ class TributeService:
                             config_link=config_link,
                         )
                     markup = get_connect_and_main_keyboard(
-                        lang, i18n, settings, config_link
+                        lang,
+                        i18n,
+                        settings,
+                        config_link,
+                        preserve_message=True,
                     )
 
                     try:
+                        # Use user's DB language in success messages prepared above
                         await bot.send_message(
                             int(user_id),
                             success_msg,
@@ -249,8 +257,39 @@ class TributeService:
         from bot.keyboards.inline.user_keyboards import get_subscribe_only_markup
         
         try:
-            # Set all user's subscriptions to expire in 1 day (grace period)
-            await subscription_dal.set_user_subscriptions_cancelled_with_grace(session, user_id, grace_days=1)
+            grace_days = 1
+            grace_end = datetime.now(timezone.utc) + timedelta(days=grace_days)
+
+            active_subscriptions = await subscription_dal.get_active_subscriptions_for_user(session, user_id)
+
+            panel_users_updated: set[str] = set()
+            for sub in active_subscriptions:
+                updated_sub = await subscription_dal.update_subscription(
+                    session,
+                    sub.subscription_id,
+                    {
+                        "end_date": grace_end,
+                        "status_from_panel": "CANCELLED",
+                        "skip_notifications": True,
+                    },
+                )
+
+                panel_uuid = updated_sub.panel_user_uuid if updated_sub else None
+                if panel_uuid and panel_uuid not in panel_users_updated:
+                    panel_users_updated.add(panel_uuid)
+                    panel_payload = {
+                        "expireAt": grace_end.isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+                    }
+                    try:
+                        await self.panel_service.update_user_details_on_panel(
+                            panel_uuid,
+                            panel_payload,
+                            log_response=False,
+                        )
+                    except Exception as panel_err:
+                        logging.error(
+                            f"Failed to update panel expiry for user {user_id} (panel_uuid {panel_uuid}) during Tribute cancellation: {panel_err}")
+
             await session.commit()
             
             # Send notification about cancellation if enabled

bot/services/yookassa_service.py

@@ -61,7 +61,11 @@ class YooKassaService:
             description: str,
             metadata: Dict[str, Any],
             receipt_email: Optional[str] = None,
-            receipt_phone: Optional[str] = None) -> Optional[Dict[str, Any]]:
+            receipt_phone: Optional[str] = None,
+            save_payment_method: bool = False,
+            payment_method_id: Optional[str] = None,
+            capture: bool = True,
+            bind_only: bool = False) -> Optional[Dict[str, Any]]:
         if not self.configured:
             logging.error("YooKassa is not configured. Cannot create payment.")
             return None
@@ -102,13 +106,23 @@ class YooKassaService:
                 "value": str(round(amount, 2)),
                 "currency": currency.upper()
             })
-            builder.set_capture(True)
+            # For binding cards only, do not capture and set minimal amount
+            if bind_only:
+                capture = False
+                amount = max(amount, 1.00)
+            builder.set_capture(capture)
             builder.set_confirmation({
                 "type": ConfirmationType.REDIRECT,
                 "return_url": self.return_url
             })
             builder.set_description(description)
             builder.set_metadata(metadata)
+            if save_payment_method:
+                # Ask YooKassa to save method for off-session charges
+                builder.set_save_payment_method(True)
+            if payment_method_id:
+                # Use a previously saved payment method for merchant-initiated payments
+                builder.set_payment_method_id(payment_method_id)
 
             receipt_items_list: List[Dict[str, Any]] = [{
                 "description":
@@ -122,9 +136,9 @@ class YooKassaService:
                 "vat_code":
                 str(self.settings.YOOKASSA_VAT_CODE),
                 "payment_mode":
-                self.settings.YOOKASSA_PAYMENT_MODE,
+                getattr(self.settings, 'yk_receipt_payment_mode', self.settings.YOOKASSA_PAYMENT_MODE),
                 "payment_subject":
-                self.settings.YOOKASSA_PAYMENT_SUBJECT
+                getattr(self.settings, 'yk_receipt_payment_subject', self.settings.YOOKASSA_PAYMENT_SUBJECT)
             }]
 
             receipt_data_dict: Dict[str, Any] = {
@@ -178,7 +192,8 @@ class YooKassaService:
                 "description_from_yk":
                 response.description,
                 "test_mode":
-                response.test if hasattr(response, 'test') else None
+                response.test if hasattr(response, 'test') else None,
+                "payment_method": getattr(response, 'payment_method', None),
             }
         except Exception as e:
             logging.error(f"YooKassa payment creation failed: {e}",
@@ -204,37 +219,40 @@ class YooKassaService:
                 logging.info(
                     f"YooKassa payment info for {payment_id_in_yookassa}: Status={payment_info_yk.status}, Paid={payment_info_yk.paid}"
                 )
+                pm = getattr(payment_info_yk, 'payment_method', None)
+                pm_payload: Dict[str, Any] = {}
+                if pm:
+                    # Collect common fields, including id and hints for last4
+                    pm_id = getattr(pm, 'id', None)
+                    pm_type = getattr(pm, 'type', None)
+                    pm_title = getattr(pm, 'title', None)
+                    account_number = getattr(pm, 'account_number', None) or getattr(pm, 'account', None)
+                    card_obj = getattr(pm, 'card', None)
+                    last4_val = None
+                    if card_obj and hasattr(card_obj, 'last4'):
+                        last4_val = getattr(card_obj, 'last4')
+                    elif isinstance(account_number, str) and len(account_number) >= 4:
+                        last4_val = account_number[-4:]
+                    pm_payload = {
+                        "id": pm_id,
+                        "type": pm_type,
+                        "title": pm_title,
+                        "card_last4": last4_val,
+                    }
                 return {
-                    "id":
-                    payment_info_yk.id,
-                    "status":
-                    payment_info_yk.status,
-                    "paid":
-                    payment_info_yk.paid,
-                    "amount_value":
-                    float(payment_info_yk.amount.value),
-                    "amount_currency":
-                    payment_info_yk.amount.currency,
-                    "metadata":
-                    payment_info_yk.metadata,
-                    "description":
-                    payment_info_yk.description,
-                    "refundable":
-                    payment_info_yk.refundable,
-                    "created_at":
-                    payment_info_yk.created_at.isoformat() if hasattr(
-                        payment_info_yk.created_at, 'isoformat') else str(
-                            payment_info_yk.created_at),
-                    "captured_at":
-                    payment_info_yk.captured_at.isoformat()
-                    if payment_info_yk.captured_at and hasattr(
-                        payment_info_yk.captured_at, 'isoformat') else None,
-                    "payment_method_type":
-                    payment_info_yk.payment_method.type
-                    if payment_info_yk.payment_method else None,
-                    "test_mode":
-                    payment_info_yk.test
-                    if hasattr(payment_info_yk, 'test') else None
+                    "id": payment_info_yk.id,
+                    "status": payment_info_yk.status,
+                    "paid": payment_info_yk.paid,
+                    "amount_value": float(payment_info_yk.amount.value),
+                    "amount_currency": payment_info_yk.amount.currency,
+                    "metadata": payment_info_yk.metadata,
+                    "description": payment_info_yk.description,
+                    "refundable": payment_info_yk.refundable,
+                    "created_at": payment_info_yk.created_at.isoformat() if hasattr(
+                        payment_info_yk.created_at, 'isoformat') else str(payment_info_yk.created_at),
+                    "captured_at": payment_info_yk.captured_at.isoformat() if getattr(payment_info_yk, 'captured_at', None) and hasattr(payment_info_yk.captured_at, 'isoformat') else None,
+                    "payment_method": pm_payload,
+                    "test_mode": getattr(payment_info_yk, 'test', None),
                 }
             else:
                 logging.warning(
@@ -246,3 +264,16 @@ class YooKassaService:
                 f"YooKassa get payment info for {payment_id_in_yookassa} failed: {e}",
                 exc_info=True)
             return None
+
+    async def cancel_payment(self, payment_id_in_yookassa: str) -> bool:
+        if not self.configured:
+            logging.error("YooKassa is not configured. Cannot cancel payment.")
+            return False
+        try:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, lambda: YooKassaPayment.cancel(payment_id_in_yookassa))
+            logging.info(f"Cancelled YooKassa payment {payment_id_in_yookassa}")
+            return True
+        except Exception as e:
+            logging.error(f"Failed to cancel YooKassa payment {payment_id_in_yookassa}: {e}")
+            return False

bot/states/admin_states.py

@@ -28,3 +28,8 @@ class AdminStates(StatesGroup):
     waiting_for_user_search = State()
     waiting_for_subscription_days_to_add = State()
     waiting_for_direct_message_to_user = State()
+
+    # Ads campaigns
+    waiting_for_ad_source = State()
+    waiting_for_ad_start_param = State()
+    waiting_for_ad_cost = State()

bot/utils/message_queue.py

@@ -26,6 +26,8 @@ class MessageQueue:
         self.last_send_times: deque[datetime] = deque()
         self.is_processing = False
         self.delay_between_messages = 1.0 / messages_per_second
+        self.total_sent = 0
+        self.total_failed = 0
         
     async def add_message(self, message: QueuedMessage) -> None:
         """Add message to queue"""
@@ -50,6 +52,7 @@ class MessageQueue:
                 try:
                     await self._send_message(message)
                     self.last_send_times.append(datetime.now())
+                    self.total_sent += 1
                     
                     # Keep only recent send times (last minute)
                     cutoff_time = datetime.now() - timedelta(seconds=60)
@@ -57,6 +60,7 @@ class MessageQueue:
                         self.last_send_times.popleft()
                         
                 except Exception as e:
+                    self.total_failed += 1
                     logging.error(f"Failed to send queued message to {message.chat_id}: {e}")
                     
         finally:
@@ -233,7 +237,11 @@ class MessageQueueManager:
             "group_queue_processing": self.group_queue.is_processing,
             "user_queue_processing": self.user_queue.is_processing,
             "group_recent_sends": len(self.group_queue.last_send_times),
-            "user_recent_sends": len(self.user_queue.last_send_times)
+            "user_recent_sends": len(self.user_queue.last_send_times),
+            "group_failed_messages": self.group_queue.total_failed,
+            "user_failed_messages": self.user_queue.total_failed,
+            "group_sent_messages": self.group_queue.total_sent,
+            "user_sent_messages": self.user_queue.total_sent,
         }
 
 
@@ -250,4 +258,4 @@ def init_queue_manager(bot: Bot) -> MessageQueueManager:
 
 def get_queue_manager() -> Optional[MessageQueueManager]:
     """Get global queue manager instance"""
-    return _queue_manager
+    return _queue_manager

bot/utils/text_sanitizer.py

@@ -0,0 +1,226 @@
+import re
+import unicodedata
+from typing import Optional
+
+_OBFUSCATION_CHARS = " .\\-/\\\\•﹒٫＿․·∙‧ꞏ‒–—﹘﹣⁻−"
+
+_URL_PATTERNS = [
+    re.compile(r"(?i)https?://\S+"),
+    re.compile(r"(?i)www\.\S+"),
+    re.compile(r"(?i)tg://\S+"),
+    re.compile(r"(?i)telegram\.me\S*"),
+    re.compile(r"(?i)t\.me/\+\S*"),
+    re.compile(r"(?i)joinchat\S*"),
+]
+
+_OBFUSCATED_DOMAIN_PATTERNS = [
+    re.compile(
+        r"(?i)[tт][\s{}\u2022]*[\.{}\u2022]*[\s{}\u2022]*[mм][eе]".format(
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+        )
+    ),
+    re.compile(
+        r"(?i)[tт][{}\s]*[eе][{}\s]*[lłl1i|][{}\s]*[eе]"
+        r"[{}\s]*[gɢgqг][{}\s]*[rр][{}\s]*[aа]"
+        r"[{}\s]*(?:[mм]|rn)".format(
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+            re.escape(_OBFUSCATION_CHARS),
+        )
+    ),
+    re.compile(r"(?i)t\.me\S*"),
+]
+
+_ENGLISH_SERVICE_PATTERNS = [
+    re.compile(r"(?i)telegram"),
+    re.compile(r"(?i)teleqram"),
+    re.compile(r"(?i)teiegram"),
+    re.compile(r"(?i)teieqram"),
+    re.compile(r"(?i)telegrarn"),
+    re.compile(r"(?i)service"),
+    re.compile(r"(?i)notif(?:ication)?"),
+    re.compile(r"(?i)system"),
+    re.compile(r"(?i)security"),
+    re.compile(r"(?i)safety"),
+    re.compile(r"(?i)support"),
+    re.compile(r"(?i)moderation"),
+    re.compile(r"(?i)review"),
+    re.compile(r"(?i)compliance"),
+    re.compile(r"(?i)abuse"),
+    re.compile(r"(?i)spam"),
+    re.compile(r"(?i)report"),
+]
+
+_RUSSIAN_SERVICE_PATTERNS = [
+    re.compile(r"(?i)телеграм\w*"),
+    re.compile(r"(?i)служебн\w*"),
+    re.compile(r"(?i)уведомлен\w*"),
+    re.compile(r"(?i)поддержк\w*"),
+    re.compile(r"(?i)безопасн\w*"),
+    re.compile(r"(?i)модерац\w*"),
+    re.compile(r"(?i)жалоб\w*"),
+    re.compile(r"(?i)абуз\w*"),
+]
+
+_PRE_LOWER_TRANSLATION = str.maketrans(
+    {
+        "I": "l",
+        "İ": "l",
+        "Q": "g",
+        "＠": " ",
+    }
+)
+
+_POST_LOWER_TRANSLATION = str.maketrans(
+    {
+        "а": "a",
+        "б": "b",
+        "в": "v",
+        "г": "g",
+        "д": "d",
+        "е": "e",
+        "ё": "e",
+        "ж": "zh",
+        "з": "z",
+        "и": "i",
+        "і": "i",
+        "й": "i",
+        "к": "k",
+        "л": "l",
+        "м": "m",
+        "н": "n",
+        "о": "o",
+        "п": "p",
+        "р": "r",
+        "с": "s",
+        "т": "t",
+        "у": "u",
+        "ф": "f",
+        "х": "h",
+        "ц": "c",
+        "ч": "ch",
+        "ш": "sh",
+        "щ": "sh",
+        "ъ": "",
+        "ы": "y",
+        "ь": "",
+        "э": "e",
+        "ю": "yu",
+        "я": "ya",
+        "＿": "_",
+    }
+)
+
+_NORMALIZED_BANNED_TOKENS = {
+    "tme",
+    "telegram",
+    "teleqram",
+    "teiegram",
+    "teieqram",
+    "telegrarn",
+    "joinchat",
+    "http",
+    "https",
+    "www",
+    "tg",
+    "service",
+    "notification",
+    "system",
+    "security",
+    "safety",
+    "support",
+    "moderation",
+    "review",
+    "compliance",
+    "abuse",
+    "spam",
+    "report",
+}
+
+_USERNAME_PLACEHOLDER = "клиент"
+
+
+def _normalize_for_detection(value: str) -> str:
+    if not value:
+        return ""
+
+    normalized = unicodedata.normalize("NFKD", value)
+    normalized = normalized.translate(_PRE_LOWER_TRANSLATION)
+    normalized = normalized.lower()
+    normalized = "".join(
+        ch for ch in normalized if unicodedata.category(ch) != "Mn"
+    )
+    normalized = normalized.translate(_POST_LOWER_TRANSLATION)
+    normalized = normalized.replace("rn", "m")
+
+    pattern = rf"[{re.escape(_OBFUSCATION_CHARS)}\s]+"
+    normalized = re.sub(pattern, "", normalized)
+    normalized = re.sub(r"[^a-z0-9]+", "", normalized)
+    return normalized
+
+
+def _remove_patterns(value: str) -> str:
+    updated = value
+    for pattern in (
+        _URL_PATTERNS
+        + _OBFUSCATED_DOMAIN_PATTERNS
+        + _ENGLISH_SERVICE_PATTERNS
+        + _RUSSIAN_SERVICE_PATTERNS
+    ):
+        updated = pattern.sub(" ", updated)
+    return updated
+
+
+def _finalize(value: str) -> Optional[str]:
+    compacted = re.sub(r"\s+", " ", value)
+    compacted = compacted.strip(" \t\r\n-_.,/\\")
+    compacted = compacted.strip()
+    if not compacted:
+        return None
+
+    normalized = _normalize_for_detection(compacted)
+    if any(token in normalized for token in _NORMALIZED_BANNED_TOKENS):
+        return None
+    return compacted
+
+
+def sanitize_display_name(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    clean = value.replace("@", " ")
+    clean = _remove_patterns(clean)
+    return _finalize(clean)
+
+
+def sanitize_username(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    clean = value.strip()
+    clean = clean.lstrip("@")
+    clean = _remove_patterns(clean)
+    return _finalize(clean)
+
+
+def username_for_display(username: Optional[str], with_at: bool = False) -> str:
+    sanitized = sanitize_username(username)
+    if not sanitized:
+        return _USERNAME_PLACEHOLDER
+    return f"@{sanitized}" if with_at else sanitized
+
+
+def display_name_or_fallback(
+    first_name: Optional[str],
+    fallback: Optional[str] = None,
+) -> str:
+    sanitized = sanitize_display_name(first_name)
+    if sanitized:
+        return sanitized
+    if fallback is not None:
+        return fallback
+    return _USERNAME_PLACEHOLDER

config/settings.py

@@ -23,6 +23,12 @@ class Settings(BaseSettings):
     SUPPORT_LINK: Optional[str] = Field(default=None)
     SERVER_STATUS_URL: Optional[str] = Field(default=None)
     TERMS_OF_SERVICE_URL: Optional[str] = Field(default=None)
+    REQUIRED_CHANNEL_ID: Optional[int] = Field(
+        default=None,
+        description="Telegram channel ID the user must join to access the bot")
+    REQUIRED_CHANNEL_LINK: Optional[str] = Field(
+        default=None,
+        description="Public username or invite link to the required channel for join button")
 
     YOOKASSA_SHOP_ID: Optional[str] = None
     YOOKASSA_SECRET_KEY: Optional[str] = None
@@ -30,8 +36,11 @@ class Settings(BaseSettings):
 
     YOOKASSA_DEFAULT_RECEIPT_EMAIL: Optional[str] = Field(default=None)
     YOOKASSA_VAT_CODE: int = Field(default=1)
+    # Deprecated: explicit receipt fields are now derived from YOOKASSA_AUTOPAYMENTS_ENABLED
     YOOKASSA_PAYMENT_MODE: str = Field(default="full_prepayment")
     YOOKASSA_PAYMENT_SUBJECT: str = Field(default="service")
+    # Single toggle to enable recurring payments (saving cards, managing payment methods, auto-renew)
+    YOOKASSA_AUTOPAYMENTS_ENABLED: bool = Field(default=False)
 
     WEBHOOK_BASE_URL: Optional[str] = None
 
@@ -41,6 +50,14 @@ class Settings(BaseSettings):
     CRYPTOPAY_ASSET: str = Field(default="RUB")
     CRYPTOPAY_ENABLED: bool = Field(default=True)
 
+    FREEKASSA_ENABLED: bool = Field(default=False)
+    FREEKASSA_MERCHANT_ID: Optional[str] = None
+    FREEKASSA_FIRST_SECRET: Optional[str] = None
+    FREEKASSA_SECOND_SECRET: Optional[str] = None
+    FREEKASSA_PAYMENT_URL: str = Field(default="https://pay.freekassa.ru/")
+    FREEKASSA_API_KEY: Optional[str] = None
+    FREEKASSA_PAYMENT_IP: Optional[str] = None
+
     YOOKASSA_ENABLED: bool = Field(default=True)
     STARS_ENABLED: bool = Field(default=True)
     TRIBUTE_ENABLED: bool = Field(default=True)
@@ -120,6 +137,15 @@ class Settings(BaseSettings):
 
     START_COMMAND_DESCRIPTION: Optional[str] = Field(default=None)
     DISABLE_WELCOME_MESSAGE: bool = Field(default=False, description="Disable welcome message on /start command")
+
+    MY_DEVICES_SECTION_ENABLED: bool = Field(
+        default=False,
+        description="Enable the My Devices section in the subscription menu"
+    )
+    USER_HWID_DEVICE_LIMIT: Optional[int] = Field(
+        default=None,
+        description="Default hardware device limit for panel users (0 = unlimited)"
+    )
     
     # Inline mode thumbnail URLs
     INLINE_REFERRAL_THUMBNAIL_URL: str = Field(default="https://cdn-icons-png.flaticon.com/512/1077/1077114.png")
@@ -233,6 +259,32 @@ class Settings(BaseSettings):
             return f"{base.rstrip('/')}{self.cryptopay_webhook_path}"
         return None
 
+    @computed_field
+    @property
+    def freekassa_webhook_path(self) -> str:
+        return "/webhook/freekassa"
+
+    @computed_field
+    @property
+    def freekassa_full_webhook_url(self) -> Optional[str]:
+        base = self.WEBHOOK_BASE_URL
+        if base:
+            return f"{base.rstrip('/')}{self.freekassa_webhook_path}"
+        return None
+
+    # Computed YooKassa receipt fields based on recurring toggle
+    @computed_field
+    @property
+    def yk_receipt_payment_mode(self) -> str:
+        # If autopayments are enabled, use service; otherwise full prepayment
+        return "service" if self.YOOKASSA_AUTOPAYMENTS_ENABLED else "full_prepayment"
+
+    @computed_field
+    @property
+    def yk_receipt_payment_subject(self) -> str:
+        # If autopayments are enabled, use full_payment; otherwise payment
+        return "full_payment" if self.YOOKASSA_AUTOPAYMENTS_ENABLED else "payment"
+
     @computed_field
     @property
     def subscription_options(self) -> Dict[int, float]:
@@ -315,6 +367,22 @@ class Settings(BaseSettings):
         if isinstance(v, str) and v.strip() == '':
             return None
         return v
+
+    @field_validator('REQUIRED_CHANNEL_LINK', mode='before')
+    @classmethod
+    def sanitize_optional_link(cls, v):
+        if isinstance(v, str) and not v.strip():
+            return None
+        return v
+    
+    @field_validator('USER_HWID_DEVICE_LIMIT', mode='before')
+    @classmethod
+    def validate_optional_int(cls, v):
+        if isinstance(v, str):
+            v = v.strip()
+            if not v:
+                return None
+        return v
     
     # Notification types
     LOG_NEW_USERS: bool = Field(default=True, description="Send notifications for new user registrations")
@@ -350,6 +418,22 @@ def get_settings() -> Settings:
                 logging.warning(
                     "CRITICAL: YooKassa credentials (SHOP_ID or SECRET_KEY) are not set. Payments will not work."
                 )
+            if _settings_instance.FREEKASSA_ENABLED:
+                if (
+                    not _settings_instance.FREEKASSA_MERCHANT_ID
+                    or not _settings_instance.FREEKASSA_API_KEY
+                ):
+                    logging.warning(
+                        "CRITICAL: FreeKassa is enabled but SHOP_ID or API key is missing. FreeKassa payments will not work."
+                    )
+                if not _settings_instance.FREEKASSA_SECOND_SECRET:
+                    logging.warning(
+                        "WARNING: FreeKassa second secret is not set. Incoming payment notifications cannot be verified."
+                    )
+                if not _settings_instance.subscription_options:
+                    logging.warning(
+                        "CRITICAL: FreeKassa is enabled but no subscription prices are configured (RUB_PRICE_*). Users will not see payment buttons."
+                    )
 
         except ValidationError as e:
             logging.critical(

db/dal/__init__.py

@@ -0,0 +1,21 @@
+from . import user_dal
+from . import payment_dal
+from . import subscription_dal
+from . import promo_code_dal
+from . import panel_sync_dal
+from . import message_log_dal
+from . import user_billing_dal
+from . import ad_dal
+
+__all__ = (
+    "user_dal",
+    "payment_dal",
+    "subscription_dal",
+    "promo_code_dal",
+    "panel_sync_dal",
+    "message_log_dal",
+    "user_billing_dal",
+    "ad_dal",
+)
+
+

db/dal/ad_dal.py

@@ -0,0 +1,182 @@
+import logging
+from typing import Optional, List, Dict, Any, Tuple
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from sqlalchemy.orm import selectinload
+from sqlalchemy import update, delete, func, and_
+
+from ..models import AdCampaign, AdAttribution, Payment
+
+
+async def create_campaign(
+    session: AsyncSession, *, source: str, start_param: str, cost: float
+) -> AdCampaign:
+    existing = await get_campaign_by_start_param(session, start_param)
+    if existing:
+        raise ValueError("ad_campaign_start_param_exists")
+
+    campaign = AdCampaign(source=source, start_param=start_param, cost=float(cost))
+    session.add(campaign)
+    await session.flush()
+    await session.refresh(campaign)
+    logging.info(
+        f"AdCampaign created id={campaign.ad_campaign_id}, source={source}, start={start_param}, cost={cost}"
+    )
+    return campaign
+
+
+async def get_campaign_by_id(session: AsyncSession, campaign_id: int) -> Optional[AdCampaign]:
+    stmt = select(AdCampaign).where(AdCampaign.ad_campaign_id == campaign_id)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def get_campaign_by_start_param(session: AsyncSession, start_param: str) -> Optional[AdCampaign]:
+    clean = start_param.strip()
+    stmt = select(AdCampaign).where(AdCampaign.start_param == clean)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def list_campaigns(session: AsyncSession, *, only_active: bool = False) -> List[AdCampaign]:
+    stmt = select(AdCampaign).order_by(AdCampaign.created_at.desc())
+    if only_active:
+        stmt = stmt.where(AdCampaign.is_active == True)
+    result = await session.execute(stmt)
+    return result.scalars().all()
+
+
+async def toggle_campaign_active(session: AsyncSession, campaign_id: int, is_active: bool) -> bool:
+    stmt = (
+        update(AdCampaign)
+        .where(AdCampaign.ad_campaign_id == campaign_id)
+        .values(is_active=is_active)
+    )
+    result = await session.execute(stmt)
+    return result.rowcount > 0
+
+
+async def ensure_attribution(session: AsyncSession, *, user_id: int, campaign_id: int) -> AdAttribution:
+    existing = await get_attribution_for_user(session, user_id)
+    if existing:
+        return existing
+    attrib = AdAttribution(user_id=user_id, ad_campaign_id=campaign_id)
+    session.add(attrib)
+    await session.flush()
+    await session.refresh(attrib)
+    logging.info(f"AdAttribution created for user {user_id} -> campaign {campaign_id}")
+    return attrib
+
+
+async def get_attribution_for_user(session: AsyncSession, user_id: int) -> Optional[AdAttribution]:
+    stmt = select(AdAttribution).where(AdAttribution.user_id == user_id)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def mark_trial_activated(session: AsyncSession, user_id: int) -> bool:
+    stmt = (
+        update(AdAttribution)
+        .where(and_(AdAttribution.user_id == user_id, AdAttribution.trial_activated_at.is_(None)))
+        .values(trial_activated_at=func.now())
+    )
+    result = await session.execute(stmt)
+    return result.rowcount > 0
+
+
+async def get_campaign_stats(session: AsyncSession, campaign_id: int) -> Dict[str, Any]:
+    # Starts (attributed users)
+    starts_stmt = select(func.count(AdAttribution.user_id)).where(
+        AdAttribution.ad_campaign_id == campaign_id
+    )
+    starts = (await session.execute(starts_stmt)).scalar() or 0
+
+    # Trials
+    trials_stmt = select(func.count(AdAttribution.user_id)).where(
+        and_(AdAttribution.ad_campaign_id == campaign_id, AdAttribution.trial_activated_at.is_not(None))
+    )
+    trials = (await session.execute(trials_stmt)).scalar() or 0
+
+    # Payers (unique users with succeeded payments)
+    payers_stmt = select(func.count(func.distinct(Payment.user_id))).select_from(Payment).where(
+        and_(
+            Payment.status == "succeeded",
+            Payment.user_id.in_(
+                select(AdAttribution.user_id).where(AdAttribution.ad_campaign_id == campaign_id)
+            ),
+        )
+    )
+    payers = (await session.execute(payers_stmt)).scalar() or 0
+
+    # Revenue sum
+    revenue_stmt = select(func.coalesce(func.sum(Payment.amount), 0.0)).select_from(Payment).where(
+        and_(
+            Payment.status == "succeeded",
+            Payment.user_id.in_(
+                select(AdAttribution.user_id).where(AdAttribution.ad_campaign_id == campaign_id)
+            ),
+        )
+    )
+    revenue = float((await session.execute(revenue_stmt)).scalar() or 0.0)
+
+    return {
+        "starts": int(starts),
+        "trials": int(trials),
+        "payers": int(payers),
+        "revenue": revenue,
+    }
+
+
+async def count_campaigns(session: AsyncSession, *, only_active: bool = False) -> int:
+    stmt = select(func.count(AdCampaign.ad_campaign_id))
+    if only_active:
+        stmt = stmt.where(AdCampaign.is_active == True)
+    return int((await session.execute(stmt)).scalar() or 0)
+
+
+async def list_campaigns_paged(
+    session: AsyncSession, *, page: int, page_size: int, only_active: bool = False
+) -> List[AdCampaign]:
+    offset = max(0, page) * max(1, page_size)
+    stmt = select(AdCampaign).order_by(AdCampaign.created_at.desc()).offset(offset).limit(page_size)
+    if only_active:
+        stmt = stmt.where(AdCampaign.is_active == True)
+    result = await session.execute(stmt)
+    return result.scalars().all()
+
+
+async def get_totals(session: AsyncSession) -> Dict[str, float]:
+    # Total cost across all campaigns
+    total_cost_stmt = select(func.coalesce(func.sum(AdCampaign.cost), 0.0))
+    total_cost = float((await session.execute(total_cost_stmt)).scalar() or 0.0)
+
+    # Total revenue from all attributed users (unique users counted across all campaigns)
+    revenue_stmt = select(func.coalesce(func.sum(Payment.amount), 0.0)).select_from(Payment).where(
+        and_(
+            Payment.status == "succeeded",
+            Payment.user_id.in_(select(AdAttribution.user_id)),
+        )
+    )
+    total_revenue = float((await session.execute(revenue_stmt)).scalar() or 0.0)
+
+    return {"cost": total_cost, "revenue": total_revenue}
+
+
+async def delete_campaign(session: AsyncSession, campaign_id: int) -> bool:
+    """Delete ad campaign by id along with related attributions.
+
+    Returns True if campaign existed and was deleted, False otherwise.
+    """
+    try:
+        campaign = await session.get(AdCampaign, campaign_id)
+        if not campaign:
+            return False
+        await session.delete(campaign)
+        await session.flush()
+        logging.info(f"AdCampaign deleted id={campaign_id}")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to delete AdCampaign id={campaign_id}: {e}", exc_info=True)
+        raise
+
+

db/dal/payment_dal.py

@@ -251,3 +251,14 @@ async def get_last_tribute_payment_duration(session: AsyncSession, user_id: int)
     
     result = await session.execute(stmt)
     return result.scalar_one_or_none()
+
+
+async def get_last_tribute_payment(
+        session: AsyncSession, user_id: int) -> Optional[Payment]:
+    """Return the most recent succeeded Tribute payment for the user."""
+    stmt = (select(Payment).where(
+        and_(Payment.user_id == user_id, Payment.provider == 'tribute',
+             Payment.status == 'succeeded')).order_by(
+                 Payment.created_at.desc()).limit(1))
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()

db/dal/subscription_dal.py

@@ -14,13 +14,15 @@ async def get_active_subscription_by_user_id(
         user_id: int,
         panel_user_uuid: Optional[str] = None) -> Optional[Subscription]:
     stmt = select(Subscription).where(
-        Subscription.user_id == user_id, Subscription.is_active == True,
-        Subscription.end_date > datetime.now(timezone.utc))
+        Subscription.user_id == user_id,
+        Subscription.is_active == True,
+        Subscription.end_date > datetime.now(timezone.utc),
+    )
     if panel_user_uuid:
         stmt = stmt.where(Subscription.panel_user_uuid == panel_user_uuid)
-    stmt = stmt.order_by(Subscription.end_date.desc())
+    stmt = stmt.order_by(Subscription.end_date.desc()).limit(1)
     result = await session.execute(stmt)
-    return result.scalar_one_or_none()
+    return result.scalars().first()
 
 
 async def get_subscription_by_panel_subscription_uuid(
@@ -53,6 +55,11 @@ async def update_subscription(
     return sub
 
 
+async def set_auto_renew(session: AsyncSession, subscription_id: int, enabled: bool) -> Optional[Subscription]:
+    """Toggle auto_renew_enabled for a subscription."""
+    return await update_subscription(session, subscription_id, {"auto_renew_enabled": enabled})
+
+
 async def set_user_subscriptions_cancelled_with_grace(
         session: AsyncSession, user_id: int, grace_days: int = 1) -> int:
     """Mark all active user subscriptions as cancelled with a short grace period.

db/dal/user_billing_dal.py

@@ -0,0 +1,164 @@
+from typing import Optional, Dict, Any, List
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update
+from sqlalchemy.sql import func
+
+from db.models import UserBilling, UserPaymentMethod
+
+
+async def get_user_billing(session: AsyncSession, user_id: int) -> Optional[UserBilling]:
+    stmt = select(UserBilling).where(UserBilling.user_id == user_id)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def upsert_yk_payment_method(
+    session: AsyncSession,
+    *,
+    user_id: int,
+    payment_method_id: str,
+    card_last4: Optional[str] = None,
+    card_network: Optional[str] = None,
+) -> UserBilling:
+    existing = await get_user_billing(session, user_id)
+    if existing:
+        existing.yookassa_payment_method_id = payment_method_id
+        existing.card_last4 = card_last4
+        existing.card_network = card_network
+        existing.updated_at = func.now()
+        await session.flush()
+        await session.refresh(existing)
+        return existing
+    record = UserBilling(
+        user_id=user_id,
+        yookassa_payment_method_id=payment_method_id,
+        card_last4=card_last4,
+        card_network=card_network,
+    )
+    session.add(record)
+    await session.flush()
+    await session.refresh(record)
+    return record
+
+
+async def delete_yk_payment_method(session: AsyncSession, user_id: int) -> bool:
+    existing = await get_user_billing(session, user_id)
+    if not existing:
+        return False
+    existing.yookassa_payment_method_id = None
+    existing.card_last4 = None
+    existing.card_network = None
+    existing.updated_at = func.now()
+    await session.flush()
+    await session.refresh(existing)
+    return True
+
+
+# Multi-card support API
+async def upsert_user_payment_method(
+    session: AsyncSession,
+    *,
+    user_id: int,
+    provider_payment_method_id: str,
+    provider: str = "yookassa",
+    card_last4: Optional[str] = None,
+    card_network: Optional[str] = None,
+    set_default: bool = False,
+) -> UserPaymentMethod:
+    existing_stmt = select(UserPaymentMethod).where(UserPaymentMethod.provider_payment_method_id == provider_payment_method_id)
+    result = await session.execute(existing_stmt)
+    existing: Optional[UserPaymentMethod] = result.scalar_one_or_none()
+    if existing:
+        existing.card_last4 = card_last4
+        existing.card_network = card_network
+        if set_default:
+            # unset previous defaults
+            await session.execute(
+                update(UserPaymentMethod)
+                .where(UserPaymentMethod.user_id == user_id)
+                .values(is_default=False)
+            )
+            existing.is_default = True
+        existing.updated_at = func.now()
+        await session.flush()
+        await session.refresh(existing)
+        return existing
+    if set_default:
+        await session.execute(
+            update(UserPaymentMethod)
+            .where(UserPaymentMethod.user_id == user_id)
+            .values(is_default=False)
+        )
+    record = UserPaymentMethod(
+        user_id=user_id,
+        provider=provider,
+        provider_payment_method_id=provider_payment_method_id,
+        card_last4=card_last4,
+        card_network=card_network,
+        is_default=set_default,
+    )
+    session.add(record)
+    await session.flush()
+    await session.refresh(record)
+    return record
+
+
+async def list_user_payment_methods(session: AsyncSession, user_id: int, provider: Optional[str] = None) -> List[UserPaymentMethod]:
+    stmt = select(UserPaymentMethod).where(UserPaymentMethod.user_id == user_id)
+    if provider:
+        stmt = stmt.where(UserPaymentMethod.provider == provider)
+    stmt = stmt.order_by(UserPaymentMethod.is_default.desc(), UserPaymentMethod.created_at.desc())
+    result = await session.execute(stmt)
+    return result.scalars().all()
+
+
+async def get_user_default_payment_method(session: AsyncSession, user_id: int, provider: str = "yookassa") -> Optional[UserPaymentMethod]:
+    stmt = select(UserPaymentMethod).where(
+        UserPaymentMethod.user_id == user_id,
+        UserPaymentMethod.provider == provider,
+        UserPaymentMethod.is_default == True,
+    )
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def set_user_default_payment_method(session: AsyncSession, user_id: int, method_id: int) -> bool:
+    methods = await list_user_payment_methods(session, user_id)
+    if not any(m.method_id == method_id for m in methods):
+        return False
+    await session.execute(update(UserPaymentMethod).where(UserPaymentMethod.user_id == user_id).values(is_default=False))
+    await session.execute(update(UserPaymentMethod).where(UserPaymentMethod.method_id == method_id).values(is_default=True))
+    return True
+
+
+async def delete_user_payment_method(session: AsyncSession, user_id: int, method_id: int) -> bool:
+    stmt = select(UserPaymentMethod).where(UserPaymentMethod.method_id == method_id, UserPaymentMethod.user_id == user_id)
+    result = await session.execute(stmt)
+    method = result.scalar_one_or_none()
+    if not method:
+        return False
+    await session.delete(method)
+    await session.flush()
+    return True
+
+
+async def delete_user_payment_method_by_provider_id(
+    session: AsyncSession,
+    user_id: int,
+    provider_payment_method_id: str,
+) -> bool:
+    """Delete a saved payment method by its provider payment_method.id for a specific user.
+
+    Useful when callbacks pass the provider id (e.g., YooKassa pm_...) instead of our internal method_id.
+    """
+    stmt = select(UserPaymentMethod).where(
+        UserPaymentMethod.user_id == user_id,
+        UserPaymentMethod.provider_payment_method_id == provider_payment_method_id,
+    )
+    result = await session.execute(stmt)
+    method: Optional[UserPaymentMethod] = result.scalar_one_or_none()
+    if not method:
+        return False
+    await session.delete(method)
+    await session.flush()
+    return True

db/database_setup.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm import sessionmaker
 
 from config.settings import Settings
 from .models import Base
+from .migrator import run_database_migrations
 
 async_engine = None
 
@@ -62,6 +63,7 @@ async def init_db(settings: Settings, session_factory: sessionmaker):
 
     async with async_engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
+        await conn.run_sync(run_database_migrations)
     logging.info(
         "PostgreSQL database initialized/checked successfully using SQLAlchemy."
     )

db/migrator.py

@@ -0,0 +1,98 @@
+import logging
+from dataclasses import dataclass
+from typing import Callable, List, Set
+
+from sqlalchemy import inspect, text
+from sqlalchemy.engine import Connection
+
+
+@dataclass(frozen=True)
+class Migration:
+    id: str
+    description: str
+    upgrade: Callable[[Connection], None]
+
+
+def _ensure_migrations_table(connection: Connection) -> None:
+    connection.execute(
+        text(
+            """
+            CREATE TABLE IF NOT EXISTS schema_migrations (
+                id VARCHAR(255) PRIMARY KEY,
+                applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+            )
+            """
+        )
+    )
+
+
+def _migration_0001_add_channel_subscription_fields(connection: Connection) -> None:
+    inspector = inspect(connection)
+    columns: Set[str] = {col["name"] for col in inspector.get_columns("users")}
+    statements: List[str] = []
+
+    if "channel_subscription_verified" not in columns:
+        statements.append(
+            "ALTER TABLE users ADD COLUMN channel_subscription_verified BOOLEAN"
+        )
+    if "channel_subscription_checked_at" not in columns:
+        statements.append(
+            "ALTER TABLE users ADD COLUMN channel_subscription_checked_at TIMESTAMPTZ"
+        )
+    if "channel_subscription_verified_for" not in columns:
+        statements.append(
+            "ALTER TABLE users ADD COLUMN channel_subscription_verified_for BIGINT"
+        )
+
+    for stmt in statements:
+        connection.execute(text(stmt))
+
+
+MIGRATIONS: List[Migration] = [
+    Migration(
+        id="0001_add_channel_subscription_fields",
+        description="Add columns to track required channel subscription verification",
+        upgrade=_migration_0001_add_channel_subscription_fields,
+    ),
+]
+
+
+def run_database_migrations(connection: Connection) -> None:
+    """
+    Apply pending migrations sequentially. Already applied revisions are skipped.
+    """
+    _ensure_migrations_table(connection)
+
+    applied_revisions: Set[str] = {
+        row[0]
+        for row in connection.execute(
+            text("SELECT id FROM schema_migrations")
+        )
+    }
+
+    for migration in MIGRATIONS:
+        if migration.id in applied_revisions:
+            continue
+
+        logging.info(
+            "Migrator: applying %s – %s", migration.id, migration.description
+        )
+        try:
+            with connection.begin_nested():
+                migration.upgrade(connection)
+                connection.execute(
+                    text(
+                        "INSERT INTO schema_migrations (id) VALUES (:revision)"
+                    ),
+                    {"revision": migration.id},
+                )
+        except Exception as exc:
+            logging.error(
+                "Migrator: failed to apply %s (%s)",
+                migration.id,
+                migration.description,
+                exc_info=True,
+            )
+            raise exc
+        else:
+            logging.info("Migrator: migration %s applied successfully", migration.id)

db/models.py

@@ -24,6 +24,10 @@ class User(Base):
     referred_by_id = Column(BigInteger,
                             ForeignKey("users.user_id"),
                             nullable=True)
+    channel_subscription_verified = Column(Boolean, nullable=True)
+    channel_subscription_checked_at = Column(DateTime(timezone=True),
+                                             nullable=True)
+    channel_subscription_verified_for = Column(BigInteger, nullable=True)
 
     referrer = relationship("User", remote_side=[user_id], backref="referrals")
     subscriptions = relationship("Subscription",
@@ -72,6 +76,7 @@ class Subscription(Base):
     last_notification_sent = Column(DateTime(timezone=True), nullable=True)
     provider = Column(String, nullable=True)
     skip_notifications = Column(Boolean, default=False)
+    auto_renew_enabled = Column(Boolean, default=True, index=True)
 
     user = relationship("User", back_populates="subscriptions")
 
@@ -112,6 +117,37 @@ class Payment(Base):
                                    back_populates="payments_where_used")
 
 
+class UserBilling(Base):
+    __tablename__ = "user_billing"
+
+    user_id = Column(BigInteger, ForeignKey("users.user_id"), primary_key=True)
+    # Saved payment method for off-session recurring charges (YooKassa)
+    yookassa_payment_method_id = Column(String, nullable=True, unique=True)
+    card_last4 = Column(String, nullable=True)
+    card_network = Column(String, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now(), nullable=True)
+
+    user = relationship("User")
+
+class UserPaymentMethod(Base):
+    __tablename__ = "user_payment_methods"
+
+    method_id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(BigInteger, ForeignKey("users.user_id"), nullable=False, index=True)
+    provider = Column(String, nullable=False, default="yookassa", index=True)
+    provider_payment_method_id = Column(String, nullable=False, unique=True, index=True)
+    card_last4 = Column(String, nullable=True)
+    card_network = Column(String, nullable=True)
+    is_default = Column(Boolean, default=False, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now(), nullable=True)
+
+    user = relationship("User")
+    __table_args__ = (
+        UniqueConstraint('user_id', 'provider_payment_method_id', name='uq_user_provider_method'),
+    )
+
 class PromoCode(Base):
     __tablename__ = "promo_codes"
 
@@ -195,3 +231,35 @@ class PanelSyncStatus(Base):
     subscriptions_synced = Column(Integer, default=0)
 
     __table_args__ = (UniqueConstraint('id'), )
+
+
+class AdCampaign(Base):
+    __tablename__ = "ad_campaigns"
+
+    ad_campaign_id = Column(Integer, primary_key=True, autoincrement=True)
+    source = Column(String, nullable=False, index=True)
+    start_param = Column(String, nullable=False, unique=True, index=True)
+    cost = Column(Float, nullable=False, default=0.0)
+    is_active = Column(Boolean, default=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    attributions = relationship(
+        "AdAttribution",
+        back_populates="campaign",
+        cascade="all, delete-orphan",
+    )
+
+    def __repr__(self):
+        return f"<AdCampaign(id={self.ad_campaign_id}, source='{self.source}', start_param='{self.start_param}', cost={self.cost})>"
+
+
+class AdAttribution(Base):
+    __tablename__ = "ad_attributions"
+
+    user_id = Column(BigInteger, ForeignKey("users.user_id"), primary_key=True, index=True)
+    ad_campaign_id = Column(Integer, ForeignKey("ad_campaigns.ad_campaign_id"), nullable=False, index=True)
+    first_start_at = Column(DateTime(timezone=True), server_default=func.now())
+    trial_activated_at = Column(DateTime(timezone=True), nullable=True)
+
+    user = relationship("User")
+    campaign = relationship("AdCampaign", back_populates="attributions")

docker-compose.yml

@@ -11,6 +11,9 @@ services:
     volumes:
       - ./locales:/app/locales
     restart: unless-stopped
+    depends_on:
+      remnawave-tg-shop-db:
+        condition: service_healthy
 
   remnawave-tg-shop-db:
     image: postgres:17
@@ -23,6 +26,11 @@ services:
     networks:
       - remnawave-network
     restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
 
 networks:
   remnawave-network:

locales/en.json

@@ -1,110 +1,101 @@
 {
   "welcome": "Welcome, {user_name}!",
+  "channel_subscription_required": "To use the bot, join the channel and tap \"Check subscription\".",
+  "channel_subscription_join_button": "Open channel",
+  "channel_subscription_verify_button": "Check subscription",
+  "channel_subscription_check_failed": "Couldn't verify the subscription. Please try again later or contact support.",
+  "channel_subscription_verified_success": "✅ Subscription confirmed! You're good to go.",
   "main_menu_greeting": "Hi, {user_name}! 👋\nWhat would you like to do?",
-
   "menu_activate_trial_button": "🆓 Free Trial",
   "menu_subscribe_inline": "🚀 Purchase",
   "menu_my_subscription_inline": "🔐 My Subscription",
+  "no_subscription_options_available": "Subscription issuance is not configured by the bot administrator",
   "menu_referral_inline": "🎁 Referrals",
+  "referral_no_bonuses_configured": "Sorry, the referral program is currently disabled",
   "menu_apply_promo_button": "🎟 Promo Code",
   "menu_language_settings_inline": "🌐 Language",
   "menu_server_status_button": "📊 Status",
   "menu_support_button": "💬 Support",
   "menu_terms_button": "📄 Terms of Service",
   "back_to_main_menu_button": "⬅️ Back",
-
-  "choose_language": "Choose language / Выберите язык:",
+  "choose_language": "Choose language:",
   "language_set_alert": "Language changed!",
   "error_occurred_try_again": "An error occurred, please try again.",
   "error_try_again": "Please try again.",
   "error_displaying_menu": "Error displaying menu.",
   "main_menu_unknown_action": "Unknown action.",
-
   "select_subscription_period": "Select subscription period:",
-  "no_subscription_options_available": "No subscription options available at the moment.",
   "subscribe_for_months_button": "{months} mo. - {price} {currency_symbol}",
   "choose_payment_method": "Choose payment method:",
   "pay_button": "💳 Pay",
   "pay_with_yookassa_button": "💳 YooKassa",
+  "yookassa_autopay_flow_prompt": "Auto-renew is enabled. Choose how you'd like to pay:",
+  "yookassa_autopay_pay_saved_card_button": "💳 Pay with saved card",
+  "yookassa_autopay_pay_new_card_button": "➕ Pay with new card",
+  "yookassa_autopay_choose_saved_card": "Choose a saved card to charge:",
+  "yookassa_autopay_no_saved_cards": "No saved cards found. Pay with a new card or link one in Payment Methods.",
+  "back_to_autopay_method_choice_button": "⬅️ Back",
+  "yookassa_autopay_charge_initiated": "Charge request sent to the selected card. We'll notify you once the payment completes.",
+  "pay_with_sbp_button": "📱 SBP",
+  "back_to_payment_methods_button": "⬅️ Back",
   "pay_with_cryptopay_button": "💎 CryptoBot",
   "pay_with_tribute_button": "❤️ Tribute",
   "pay_with_stars_button": "🌟 Telegram Stars",
   "connect_button": "🔗 Connect",
   "cancel_button": "❌ Cancel",
+
+  "devices_button": "📱 My Devices ({current_devices}/{max_devices})",
+  "my_devices_details": "📱 <b>My Devices ({current_devices}/{max_devices})</b>\n\n{devices}\n\nYou can disconnect a device by selecting it from the list below.\n<blockquote><i>Note: If you disconnect a device, it will be automatically connected again when you use it next. Before deleting, make sure you have deleted the subscription from the application.</i></blockquote>",
+  "no_devices_details_found_message": "📱 <b>My Devices</b>\n\nYou don't have any devices yet.\nYou have {max_devices} devices available. You can connect them by clicking the \"🔗 Connect\" button in the subscription menu.",
+  "device_details": "{index}) <b>{device_model} ({platform} {os_version})</b>\nDate connected: <b>{created_at_str}</b>\nUser Agent: <b>{user_agent}</b>\nHWID: <code>{hwid}</code>",
+  "disconnect_device_button": "🚫 Disconnect {hwid} ({index})",
+  "device_disconnected": "Device disconnected successfully.",
+  "no_devices_found": "Error loading device list.",
+  "devices_unlimited_label": "Unlimited",
+  "my_devices_feature_disabled": "The My Devices section is currently unavailable.",
+
   "payment_description_subscription": "Subscription payment for {months} mo.",
-  "payment_service_unavailable": "Payment service temporarily unavailable. Please try again later.",
-  "payment_service_unavailable_alert": "Payment service unavailable",
-  "error_creating_payment_record": "Error creating payment record. Please try again later.",
-  "error_payment_gateway_link_failed": "Failed to get payment link. Please contact support.",
   "payment_link_message": "To pay for {months} mo. subscription, click the button below:",
-  "error_payment_gateway": "Payment gateway error. Please try again later or contact support.",
+  "free_kassa_order_info": "Order #{order_id} from {date}",
+  "payment_invoice_sent_message": "Telegram has sent the invoice above. Complete the payment or pick another method below.",
   "payment_successful_error_details": "✅ Payment succeeded, but an error occurred displaying details. Your subscription is active. Contact support if anything is wrong.",
   "payment_successful_full": "✅ Payment successful!\nYour {months}-month subscription is active until {end_date}.\n\nConnection key:\n<code>{config_link}</code>\n\nTo connect, open the link and follow the instructions 👇",
-  "payment_successful_with_promo_full": "✅ Payment successful!\nYour {months}-month subscription (with promo bonus +{bonus_days} days) is active until {end_date}.\n\nConnection key:\n<code>{config_link}</code>\n\nTo connect, open the link and follow the instructions 👇",
   "payment_successful_with_referral_bonus_full": "✅ Payment successful!\nYour {months}-month subscription (base end date: {base_end_date}) has been extended by {bonus_days} bonus days for referral from {inviter_name} and is now active until {final_end_date}.\n\nConnection key:\n<code>{config_link}</code>\n\nTo connect, open the link and follow the instructions 👇",
   "payment_failed": "❌ Payment failed or was cancelled. Please try again or contact support.",
-  "error_processing_your_payment": "An error occurred processing your payment after success. Please contact support with the details.",
-
-  "my_subscription_details": "<b>🔐 My Subscription:</b>\n\nStatus: <b>{status}</b>\nActive until: <b>{end_date}</b> (days left: {days_left})\n\nTraffic: <b>{traffic_used}</b> of <b>{traffic_limit}</b>\n\nConfiguration link:\n<code>{config_link}</code>",
   "config_link_not_available": "not available, contact support",
-  "subscription_not_active": "You have no active subscription.\nWould you like to purchase one?",
-  "status_active": "Active",
-  "status_expired": "Expired",
-  "status_disabled": "Disabled",
   "traffic_unlimited": "Unlimited",
-  "traffic_na": "n/a",
-  "error_service_unavailable": "Service temporarily unavailable. Please try again later.",
-
   "promo_code_prompt": "Please enter your promo code:",
   "promo_code_not_found": "Promo code <code>{code}</code> not found, expired, or already used the maximum number of times.",
   "promo_code_already_used_by_user": "You have already used promo code <code>{code}</code>.",
-  "promo_code_no_active_subscription": "You must have an active subscription to apply this promo code.",
   "promo_code_applied_success_full": "✅ Promo code applied successfully!\nSubscription active until {end_date}.\n\nConnection key:\n<code>{config_link}</code>\n\nTo connect, open the link and follow the instructions 👇",
   "error_applying_promo_bonus": "Failed to apply promo bonus. Please try again later or contact support.",
   "promo_input_cancelled_short": "Promo code entry cancelled.",
-
   "trial_feature_disabled": "Free trial is currently unavailable.",
   "trial_already_had_subscription_or_trial": "You have already used a free trial or had a paid subscription. Free trial is available only once for new users.",
-  "trial_confirm_prompt": "Would you like to activate a free trial for {days} days with {traffic_gb} GB traffic limit?",
   "trial_confirm_activate_button": "✅ Activate!",
   "trial_activated_alert": "Trial activated!",
-  "trial_activated_details_message": "🚀 Your {days}-day free trial is activated!\n\nValid until: <b>{end_date}</b>\nTraffic: <b>{traffic_gb} GB</b>\n\nYour configuration link:\n<code>{config_link}</code>",
-  "trial_activation_failed": "Failed to activate free trial. Please try again later.",
-  "trial_activation_failed_panel_link": "Failed to link your account to the server for trial activation. Please try again later.",
-  "trial_activation_failed_db": "Database error during trial activation. Please try again later.",
-  "trial_activation_failed_panel_update": "Failed to update trial details on the server. Please try again later.",
-  "user_not_found_for_trial": "Your account was not found in the system. Please run /start first.",
+  "trial_activated_details_message": "✅ Trial activated!\nYour {days}-day trial is active until {end_date}.\n\nConnection key:\n<code>{config_link}</code>\n\nTo connect, open the link and follow the instructions 👇",
   "yes_button": "Yes",
   "no_button": "No",
-  "trial_cancelled_short": "Activation cancelled.",
-
   "referral_program_info_new": "🎁 <b>Referral Program</b>\n\n📊 <b>Your stats:</b>\n👥 Friends invited: <b>{invited_count}</b>\n💳 Purchased subscription: <b>{purchased_count}</b>\n\n🔗 Your link:\n<code>{referral_link}</code>\n\n💰 <b>Invitation bonuses:</b>\n{bonus_details}\n\n📢 Share the link with friends and get bonuses!",
   "referral_bonus_per_period": "\n\n🎁 For a friend's {months}-month subscription:\n  ➢ You: <b>{inviter_bonus_days} days</b>\n  ➢ Friend: <b>{referee_bonus_days} days</b>",
-  "no_bonus_days": "0",
-  "referral_no_bonuses_configured": "\nNo referral bonuses configured.",
-  "referral_link_for_copying_reminder": "The link is above. Press and hold to copy.",
   "referral_share_message_button": "📩 Message for friend",
   "referral_friend_message": "🚀 Hey! Try this VPN - it's fast, reliable and affordable!\n\n🎁 Use my link to get bonus days with your subscription!\n\n{referral_link}",
   "friend_placeholder": "friend",
   "referral_bonus_inviter_notification_extended": "🎉 Congrats! Your friend {referee_name} paid for a subscription. You received {days} bonus days! Your subscription is now active until {new_end_date}.",
   "referral_bonus_inviter_notification_new_sub": "🎉 Congrats! Your friend {referee_name} paid for a subscription. You received a {days}-day bonus subscription! It is active until {new_end_date}.",
-
   "user_is_banned": "🚫 Your account is banned. Please contact support.",
-
   "admin_panel_title": "Admin Panel",
   "admin_stats_button": "📊 Statistics",
   "admin_broadcast_button": "📢 Broadcast",
   "admin_create_promo_button": "🎁 Create Promo",
   "admin_create_bulk_promo_button": "📦 Bulk Create",
-  "admin_manage_promos_button": "🛠 Manage",
-  "admin_view_promos_button": "👀 List",
   "admin_ban_user_button": "🚫 Ban",
   "admin_unban_user_button": "✅ Unban",
   "admin_view_banned_users_button": "📜 Ban List",
   "admin_view_logs_menu_button": "📄 Logs",
   "admin_sync_panel_button": "🔄 Sync",
   "admin_unknown_action": "Unknown admin action.",
-  
   "admin_stats_and_monitoring_section": "📊 Statistics",
   "admin_user_management_section": "👥 Users",
   "admin_promo_marketing_section": "🎁 Promos",
@@ -112,18 +103,13 @@
   "admin_ban_management_section": "🚫 Bans",
   "admin_users_management_button": "👤 Management",
   "back_to_user_management_button": "⬅️ To Users",
-  "admin_action_cancelled_default": "Action cancelled. Returning to menu.",
-  "admin_action_cancelled_default_alert": "Action cancelled",
   "back_to_admin_panel_button": "⬅️ To Admin",
-
   "admin_stats_header": "📊 Bot Statistics",
   "admin_enhanced_users_stats_header": "Users",
   "admin_financial_stats_header": "Financial Statistics",
-  "admin_stats_users": "👥 Users: Total - {total_users}, Banned - {banned_users}, Active Subs - {active_subs}",
   "admin_stats_recent_payments_header": "Recent Payments:",
   "admin_stats_payment_item": "{status_emoji} {amount} {currency} from {user_info} ({p_status}) [{p_date}]",
   "admin_stats_no_payments_found": "No payments found yet.",
-  
   "admin_view_payments_button": "💰 Payments",
   "admin_payments_header": "💰 <b>All Payments</b>",
   "admin_no_payments_found": "No payments found.",
@@ -132,7 +118,6 @@
   "admin_no_payments_to_export": "No payments to export.",
   "admin_payments_export_success": "📊 Payments export completed!\nTotal records: {count}",
   "admin_export_sent": "File sent!",
-  
   "admin_csv_payment_id": "ID",
   "admin_csv_user_id": "User ID",
   "admin_csv_username": "Username",
@@ -152,9 +137,7 @@
   "admin_stats_sync_subs_synced": "Subscriptions Synced",
   "admin_stats_sync_details_label": "Details",
   "admin_sync_status_never_run": "Panel sync never run.",
-
   "admin_broadcast_enter_message": "Enter the broadcast message (HTML supported):",
-  "admin_broadcast_confirm_prompt": "You are about to send the following message:\n\n{message_preview}\n\nConfirm sending?",
   "admin_broadcast_confirm_prompt_short": "The message above will be sent. Confirm?",
   "broadcast_target_all_button": "👥 All",
   "broadcast_target_active_button": "✅ Active",
@@ -164,39 +147,47 @@
   "admin_broadcast_sending_started": "Starting broadcast...",
   "admin_broadcast_error_no_message": "Error: no message to broadcast.",
   "admin_broadcast_error_no_message_alert": "Broadcast message is empty!",
-  "admin_broadcast_finished_stats": "🏁 Broadcast finished!\nSent: {sent_count}\nFailed: {failed_count}",
   "admin_broadcast_cancelled": "Broadcast cancelled.",
   "admin_broadcast_cancelled_alert": "Broadcast cancelled!",
   "admin_broadcast_cancelled_nav_back": "Broadcast cancelled. You are returned to the admin panel.",
-
-  "admin_broadcast_invalid_html": "❌ Invalid HTML in message. Please send valid HTML (Telegram-supported tags) or remove tags.",
-
-  "admin_promo_create_prompt": "Enter promo details in the format: CODE BONUS_DAYS MAX_USES [VALIDITY_DAYS]\nExample: <code>{example_format}</code>\n(Validity is optional; default is indefinite)",
-  "admin_promo_invalid_format": "Invalid format. Please use: CODE BONUS_DAYS MAX_USES [VALIDITY_DAYS]",
+  "broadcast_queue_result": "🚀 Broadcast queued!\n📤 Enqueued: {sent_count}\n❌ Errors: {failed_count}\n\n📊 Queue Status:\n👥 User queue: {user_queue_size} messages\n📢 Group queue: {group_queue_size} messages\n\nℹ️ Messages will be sent automatically within Telegram limits.",
   "admin_promo_invalid_code_format": "Code must be 3–30 alphanumeric characters.",
   "admin_promo_invalid_bonus_days": "Bonus days must be a positive number.",
   "admin_promo_invalid_max_activations": "Max activations must be a positive number.",
-  "admin_promo_invalid_bonus_or_activations": "Bonus days and max uses must be positive numbers.",
   "admin_promo_invalid_validity_days": "Validity period (in days) must be a positive number.",
-  "admin_promo_invalid_values": "Invalid values. {error}",
-  "admin_promo_invalid_format_general": "Promo parsing error. Check the format.",
   "admin_promo_created_success": "✅ Promo code <code>{code}</code> created successfully!\nBonus: {bonus_days} days\nMax uses: {max_activations}\nValid until: {valid_until_str}.",
-  "admin_promo_creation_failed_duplicate": "❌ Error: Promo code <code>{code}</code> already exists.",
-  "admin_promo_creation_failed": "❌ Failed to create promo code. Please try again later.",
+  "admin_promo_set_validity_days": "⏰ Set validity (days)",
+  "admin_back_to_panel": "⬅️ Back to panel",
+  "admin_promo_unlimited": "♾️ Unlimited",
+  "admin_bulk_promo_created_title": "📦 Bulk creation completed",
+  "admin_bulk_promo_created_stats": "📊 Created: <b>{created}</b> of <b>{total}</b>",
+  "admin_bulk_promo_settings": "🎁 Bonus days: <b>{bonus_days}</b>\n📊 Max activations: <b>{max_activations}</b>\n⏰ Validity: <b>{validity}</b>",
+  "admin_promo_list_page_info": "Page {current}/{total} ({count} promo codes)",
+  "admin_queue_status_button": "📊 Queue Status",
+  "admin_queue_status_title": "📊 Message Queue Status",
+  "admin_queue_status_info": "📤 <b>Message Queues:</b>\n\n👥 <b>Users (25 msg/sec):</b>\n   📋 In queue: {user_queue_size}\n   🔄 Processing: {user_processing}\n   📈 Sent per minute: {user_recent}\n\n📢 <b>Groups/channels (15 msg/min):</b>\n   📋 In queue: {group_queue_size}\n   🔄 Processing: {group_processing}\n   📈 Sent per minute: {group_recent}",
   "admin_active_promos_list_header": "Active Promo Codes:",
   "admin_no_active_promos": "No active promo codes.",
-  "admin_promo_list_item": "<code>{code}</code>: +{bonus}d, {current}/{max} used, valid until {valid_until}",
   "admin_promo_valid_indefinitely": "indefinite",
-  "admin_promo_valid_until_display": "until {date}",
-  "admin_manage_promos_title": "Manage Promo Codes",
   "admin_promo_edit_button": "✏️ Edit",
   "admin_promo_delete_button": "🗑 Delete",
-  "admin_promo_edit_prompt": "Send new details for <code>{code}</code> in format: CODE BONUS_DAYS MAX_USES [VALIDITY_DAYS]",
-  "admin_promo_updated_success": "Promo {code} updated.",
   "admin_promo_deleted_success": "Promo {code} deleted.",
   "admin_promo_not_found": "Promo not found.",
   "admin_promo_export_csv_button": "📄 Export to CSV",
   "admin_promo_export_caption": "📄 Activations for promo code {code}",
+  "admin_promo_export_all_generating": "📄 Generating CSV...",
+  "admin_promo_export_all_caption": "📄 Export of all promo codes\n📊 Total: {count} promo codes",
+  "admin_promo_csv_code": "Code",
+  "admin_promo_csv_bonus_days": "Bonus Days",
+  "admin_promo_csv_max_activations": "Max Activations",
+  "admin_promo_csv_current_activations": "Current Activations",
+  "admin_promo_csv_status": "Status",
+  "admin_promo_csv_is_active": "Active",
+  "admin_promo_csv_valid_until": "Valid Until",
+  "admin_promo_csv_created_at": "Created",
+  "admin_promo_csv_created_by_admin_id": "Created By (Admin ID)",
+  "csv_yes": "Yes",
+  "csv_no": "No",
   "admin_promo_edit_select_field": "Select a field to edit:",
   "admin_promo_prompt_bonus_days": "Enter the new number of bonus days:",
   "admin_promo_prompt_max_activations": "Enter the new maximum number of activations:",
@@ -206,85 +197,46 @@
   "admin_promo_edit_bonus_days": "🎁 Bonus Days",
   "admin_promo_edit_max_activations": "🔢 Max Activations",
   "admin_promo_edit_validity": "⏰ Validity",
-
   "admin_ban_user_prompt": "Enter user ID or @username to ban:",
-  "admin_user_not_found_in_bot_db": "User <code>{user_id}</code> not found in bot database.",
-  "admin_cannot_ban_self_or_admin": "You cannot ban yourself or another admin.",
   "admin_user_already_banned": "User {user_id_or_username} is already banned.",
-  "admin_user_banned_success_combined": "✅ User {user_id_or_username} banned in bot {panel_status_part}.",
-  "admin_panel_ban_success_part": "and on panel",
-  "admin_panel_ban_fail_part": ", but failed to ban on panel",
-  "admin_user_ban_failed_local_db_error": "❌ Failed to ban user in local database.",
   "admin_unban_user_prompt": "Enter user ID or @username to unban:",
-  "admin_user_not_banned": "User {user_id_or_username} is not banned.",
-  "admin_user_unbanned_success_combined": "✅ User {user_id_or_username} unbanned in bot {panel_status_part}.",
-  "admin_panel_unban_success_part": "and on panel",
-  "admin_panel_unban_fail_part": ", but failed to unban on panel",
-  "admin_user_unban_failed_local_db_error": "❌ Failed to unban user in local database.",
-  "admin_no_banned_users": "There are no banned users at the moment.",
-  "admin_banned_list_title": "Banned Users (page {current_page}/{total_pages}):",
+  "admin_user_not_banned": "⚠️ User is not banned",
   "admin_banned_user_button_text": "{user_display} (ID: {user_id})",
   "prev_page_button": "⬅️ Prev.",
   "next_page_button": "Next ➡️",
-  "admin_user_card_title": "User Profile: {user_display}",
-  "user_card_info": "ID: <code>{user_id}</code>\nUsername: @{username}\nName: {first_name} {last_name}\nLanguage: {language_code}\nPanel UUID: <code>{panel_user_uuid}</code>\nStatus: <b>{ban_status}</b>\nRegistered: {reg_date}\nSubscription until: <b>{sub_end_date}</b>",
-  "user_card_banned": "BANNED",
-  "user_card_active": "Active",
-  "user_card_sub_na": "n/a",
+  "admin_user_card_title": "User Card",
   "user_card_ban_button": "🚫 Ban",
   "user_card_unban_button": "✅ Unban",
   "user_card_back_to_banned_list_button": "⬅️ Back to Ban List",
-  "admin_confirm_action_title": "Confirm: {action_text}",
-  "ban_verb_l": "ban",
-  "unban_verb_l": "unban",
-  "admin_confirm_ban_prompt": "Are you sure you want to ban {user_display} (ID: {user_id})?",
-  "admin_confirm_unban_prompt": "Are you sure you want to unban {user_display} (ID: {user_id})?",
-  "admin_user_banned_from_card_alert": "User {user_display} (ID: {user_id}) has been banned.",
-  "admin_user_unbanned_from_card_alert": "User {user_display} (ID: {user_id}) has been unbanned.",
-  "admin_user_ban_failed_db_error": "Error banning user in database.",
-  "admin_user_unban_failed_db_error": "Error unbanning user in database.",
-  "admin_panel_status_update_fail_part": ", but panel status not updated",
-
   "admin_logs_menu_title": "Logs Menu:",
   "admin_view_all_logs_button": "📜 All Message Logs",
   "admin_view_user_logs_prompt_button": "👤 User Logs",
   "admin_export_logs_csv_button": "📄 Export to CSV",
-  "admin_all_logs_title": "All Logs (page {current_page}/{total_pages}):",
   "admin_no_logs_found": "No logs found.",
   "admin_log_entry_format": "<code>{timestamp_str}</code> - <b>{user_display}</b> (ID: {user_id})\n  <i>{event_type}</i>: {content_preview}",
-  "system_or_unknown_user": "System/Unknown",
   "admin_prompt_for_user_id_or_username_logs": "Enter user ID or @username to view logs:",
   "admin_log_user_not_found": "User \"{input}\" not found in bot database.",
-  "admin_user_logs_title": "Logs for {user_display} (page {current_page}/{total_pages}):",
-
   "sync_started_simple": "🔄 Starting synchronization...",
   "sync_success_simple": "✅ Synchronization completed successfully",
   "sync_failed_simple": "❌ Synchronization failed",
   "sync_errors_simple": "⚠️ Synchronization completed with errors ({errors_count} errors)",
   "sync_critical_error": "❌ Critical synchronization error",
-  "no_errors_placeholder": "none",
   "admin_sync_initiated_from_panel": "Sync initiated...",
-  "admin_panel_user_creation_failed": "❌ Failed to create panel user for TG ID {user_id}. Panel unreachable?",
+  "admin_broadcast_invalid_html": "❌ Invalid HTML in message. Please send valid HTML (Telegram-supported tags) or remove tags.",
   "error_displaying_logs_too_long": "Error: logs too long to display in one message. Try viewing logs for a specific user.",
   "error_displaying_statistics": "Error displaying statistics.",
-  "stub_page_display": "Page",
-
   "subscription_72h_notification": "👋 Hi, {user_name}!\n\n⏳ Your VPN subscription expires in 3 days — {end_date}.\n\nPlease renew it using the button below.",
   "subscription_48h_notification": "👋 Hi, {user_name}!\n\n⏳ Your VPN subscription expires in 2 days — {end_date}.\n\nPlease renew it using the button below.",
   "subscription_24h_notification": "👋 Hi, {user_name}!\n\n⏳ Your VPN subscription expires in 1 day — {end_date}.\n\nPlease renew it using the button below.",
   "subscription_expired_notification": "👋 Hi, {user_name}!\n\n⛔ Your VPN subscription expired on {end_date}.\n\nPlease renew it using the button below.",
   "subscription_expired_yesterday_notification": "👋 Hi, {user_name}!\n\n⏳ Your VPN subscription expired yesterday ({end_date}).\n\nPlease renew it using the button below.",
+  "autorenew_48h_charge_tomorrow_notice": "🔔 Reminder\n\nTomorrow an automatic charge will occur to renew your subscription. If you don't want auto-renew, disable it using the button below.",
+  "autorenew_confirm_enable": "🔄 Enable auto-renew? An automatic charge will be attempted before your subscription ends.",
+  "autorenew_confirm_disable": "🛑 Disable auto-renew? No further automatic charges will occur.",
   "tribute_subscription_cancelled": "🚨 <b>Subscription Cancelled</b>\n\nYour Tribute subscription has been cancelled. You have 24 hours to restore access, after which the subscription will be blocked.\n\nTo renew your subscription, press the button below.",
   "tribute_auto_renewal": "🔄 <b>Subscription Auto-Renewed</b>\n\nYour Tribute subscription has been automatically renewed for {months} months.\nNew expiration date: {end_date}",
-
-  "admin_new_trial_notification": "\ud83c\udf21 User {user_id} activated a free trial until {end_date}.",
-
-  "admin_promo_activation_notification": "\ud83c\udf81 Promo code {code} activated by user {user_id} (+{bonus_days}d).",
-
-  "error_unknown": "An unknown error occurred.",
-  
+  "yookassa_auto_renewal": "🔄 <b>Subscription Auto-Renewed</b>\n\nYour subscription was automatically renewed for {months} month(s).\nNew expiration date: {end_date}",
   "admin_user_management_prompt": "👤 User Management\n\nEnter user ID or @username to search:",
-  "admin_user_card_title": "User Card",
   "admin_user_subscription_info": "Subscription Information:",
   "admin_user_reset_trial_button": "🔄 Reset Trial",
   "admin_user_add_subscription_button": "➕ Add Days",
@@ -295,7 +247,7 @@
   "admin_user_search_new_button": "🔍 Find Another",
   "admin_user_view_all_logs_button": "📋 All Actions",
   "admin_user_back_to_card_button": "🔙 Back to Card",
-  
+  "admin_user_recent_actions_title": "📜 Recent actions of user {user_id}:",
   "admin_user_not_found": "❌ User not found: {input}",
   "admin_user_not_found_action": "User not found",
   "admin_user_card_error": "❌ Error displaying user card",
@@ -311,7 +263,6 @@
   "admin_user_unban_success": "✅ User {input} has been unbanned",
   "admin_user_ban_error": "❌ Error banning user",
   "admin_user_unban_error": "❌ Error unbanning user",
-  "admin_user_not_banned": "⚠️ User is not banned",
   "admin_user_send_message_prompt": "✉️ Sending message to user {user_id}\n\nEnter message text:",
   "admin_user_message_too_long": "❌ Message too long (maximum 4000 characters)",
   "admin_user_message_sent_success": "✅ Message sent to user {user_id}",
@@ -319,27 +270,13 @@
   "admin_user_no_logs": "📜 User has no actions",
   "admin_user_logs_error": "❌ Error loading user actions",
   "admin_direct_message_signature": "\n\n---\n💬 Message from administrator",
-  
   "inline_user_stats_message": "👥 <b>User Statistics</b>\n\n📊 Total: <b>{total}</b>\n📈 Active today: <b>{active_today}</b>\n💳 With paid subscription: <b>{paid}</b>\n🆓 On trial period: <b>{trial}</b>\n😴 Inactive: <b>{inactive}</b>\n🚫 Banned: <b>{banned}</b>\n🎁 Via referral program: <b>{referral}</b>",
+  "inline_user_stats_description": "Total: {total}, Paid: {active}",
   "inline_admin_user_stats_title": "👥 User Statistics",
-  "inline_admin_user_stats_desc": "Total: {total}, Active: {paid}",
-  
   "inline_financial_stats_message": "💰 <b>Financial Statistics</b>\n\n📅 Today: <b>{today:.2f} RUB</b>\n   ({today_count} payments)\n📅 Week: <b>{week:.2f} RUB</b>\n📅 Month: <b>{month:.2f} RUB</b>\n🏆 All time: <b>{all_time:.2f} RUB</b>",
   "inline_admin_financial_stats_title": "💰 Financial Statistics",
-  "inline_admin_financial_stats_desc": "Today: {today:.2f} RUB",
-  
   "inline_system_stats_message": "🖥 <b>Panel Statistics</b>\n\n🟢 Online: <b>{online}</b>\n📊 Active: <b>{active}</b>\n🔴 Disabled: <b>{disabled}</b>\n⏰ Expired: <b>{expired}</b>\n⚠️ Limited: <b>{limited}</b>\n👥 Total users: <b>{total}</b>\n💾 RAM Usage: <b>{memory:.1f}%</b>\n📊 Week traffic: <b>{week_traffic}</b>\n📊 Month traffic: <b>{month_traffic}</b>\n🔗 Active nodes: <b>{active_nodes}/{total_nodes}</b>",
   "inline_admin_system_stats_title": "🖥 System Statistics",
-  "inline_admin_system_stats_desc": "Online: {online}, Offline: {offline}",
-  
-  "inline_admin_help_message": "🤖 <b>Bot Inline Mode</b>\n\n📱 <b>Available commands:</b>\n\n🎁 <b>ref</b> - share referral link\n👥 <b>stat</b> - user statistics\n💰 <b>financial</b> - financial statistics\n🖥 <b>system</b> - system statistics\n\n💡 Just type @{bot_username} and start typing a command in any chat!",
-  "inline_admin_help_title": "🤖 Inline Help (Admin)",
-  "inline_admin_help_desc": "Available commands: ref, stat, financial, system",
-  
-  "inline_user_help_message": "🤖 <b>Bot Inline Mode</b>\n\n📱 <b>Available commands:</b>\n\n🎁 <b>ref</b> - share referral link\n\n💡 Just type @{bot_username} and start typing 'ref' in any chat!",
-  "inline_user_help_title": "🤖 Inline Help",
-  "inline_user_help_desc": "Available command: ref (referral link)",
-  
   "log_referral_suffix": " (referral from {referrer_id})",
   "log_new_user_registration": "👤 <b>New User</b>\n\n🆔 ID: <code>{user_id}</code>\n👤 Name: {user_display}{referral_text}\n📅 Time: {timestamp}",
   "log_payment_received": "{provider_emoji} <b>Payment Received</b>\n\n👤 User: {user_display}\n💰 Amount: <b>{amount} {currency}</b>\n📅 Period: <b>{months} mo.</b>\n🏦 Provider: {payment_provider}\n🕐 Time: {timestamp}",
@@ -347,28 +284,10 @@
   "log_trial_activation": "🆓 <b>Trial Activated</b>\n\n👤 User: {user_display}\n⏰ Valid until: <b>{end_date}</b>\n🕐 Time: {timestamp}",
   "log_panel_sync": "{status_emoji} <b>Panel Synchronization</b>\n\n📊 Status: <b>{status}</b>\n👥 Users processed: <b>{users_processed}</b>\n📋 Subscriptions synced: <b>{subs_synced}</b>\n🕐 Time: {timestamp}\n\n📝 Details:\n{details}",
   "log_suspicious_promo": "⚠️ <b>Suspicious Promo Code Attempt</b>\n\n👤 User: {user_display}\n🆔 ID: <code>{user_id}</code>\n📝 Input: <pre>{suspicious_input}</pre>\n🕐 Time: {timestamp}",
-
-  "admin_general_cancel_operation": "Operation cancelled ❌",
-  "admin_promo_codes_menu_bulk_create": "📦 Bulk Creation",
-  "admin_bulk_promo_create_prompt": "📦 Bulk Promo Code Creation\n\nEnter data in format:\n<code>quantity|days|description</code>\n\nExample:\n<code>10|7|Weekly promo</code>",
-  "admin_bulk_promo_invalid_format": "❌ Invalid format. Use: quantity|days|description",
-  "admin_bulk_promo_created_success": "✅ Created {count} promo codes for {days} days!",
-  "admin_bulk_promo_codes_file": "📄 All created promo codes in file ({count} pcs.)",
-  
-  "admin_promo_edit_step1_code": "✏️ <b>Editing Promo Code</b>\n\n<b>Step 1 of 4:</b> Promo Code\n\nCurrent code: <b>{current_code}</b>\n\nEnter new promo code (3-30 characters, letters and numbers only) or send current one to keep:",
-  "admin_promo_edit_step2_bonus_days": "✏️ <b>Editing Promo Code</b>\n\n<b>Step 2 of 4:</b> Bonus Days\n\nCode: <b>{code}</b>\nCurrent days: <b>{current_days}</b>\n\nEnter number of bonus days (1-365):",
-  "admin_promo_edit_step3_max_activations": "✏️ <b>Editing Promo Code</b>\n\n<b>Step 3 of 4:</b> Max Activations\n\nCode: <b>{code}</b>\nDays: <b>{days}</b>\nCurrent activations: <b>{current_max}</b>\n\nEnter maximum number of activations (1-10000):",
-  "admin_promo_edit_step4_validity": "✏️ <b>Editing Promo Code</b>\n\n<b>Step 4 of 4:</b> Validity Period\n\nCode: <b>{code}</b>\nDays: <b>{days}</b>\nActivations: <b>{max_act}</b>\nCurrent validity: <b>{current_validity}</b>\n\nChoose the validity period for the promo code:",
-  "admin_promo_edit_unlimited_validity": "♾️ Unlimited",
-  "admin_promo_edit_set_validity": "⏰ Set Period",
-  "admin_promo_edit_enter_validity_days": "⏰ Enter the number of validity days for the promo code (1-365):",
-  "admin_promo_updated_success": "✅ Promo code updated!\n\n🎟 Code: <b>{code}</b>\n🎁 Bonus days: <b>{days}</b>\n🔢 Max activations: <b>{max_act}</b>\n⏰ Valid until: <b>{validity}</b>",
-  "admin_promo_update_failed": "❌ Error updating promo code",
-  
-  "admin_logs_export_csv": "📄 Export to CSV",
   "admin_logs_csv_export_started": "📄 Starting log export to CSV...",
   "admin_logs_csv_export_success": "✅ Logs exported! File attached above.",
-  
+  "admin_user_logs_title": "Logs for {user_display} (page {current_page}/{total_pages}):",
+  "admin_all_logs_title": "All Logs (page {current_page}/{total_pages}):",
   "admin_csv_header_log_id": "Log ID",
   "admin_csv_header_timestamp": "Timestamp",
   "admin_csv_header_user_id": "User ID",
@@ -379,44 +298,23 @@
   "admin_csv_header_is_admin_event": "Admin Event",
   "admin_csv_header_target_user_id": "Target User ID",
   "admin_csv_header_raw_update_preview": "Update Preview",
-  
   "admin_banned_users_empty": "📋 Banned Users\n\nList is empty",
   "admin_banned_users_list": "📋 Banned Users ({count}):\n\n{users}",
-  
   "admin_panel_stats_header": "Panel Statistics",
-  
   "admin_bulk_promo_step1_quantity": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 1 of 4:</b> Quantity\n\nEnter the number of promo codes to create (1-1000):",
   "admin_bulk_promo_step2_bonus_days": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 2 of 4:</b> Bonus Days\n\nQuantity: <b>{quantity}</b>\n\nEnter the number of bonus days (1-365):",
   "admin_bulk_promo_step3_max_activations": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 3 of 4:</b> Max Activations\n\nQuantity: <b>{quantity}</b>\nBonus days: <b>{bonus_days}</b>\n\nEnter the maximum number of activations for each promo code (1-10000):",
   "admin_bulk_promo_step4_validity": "📦 <b>Bulk Promo Code Creation</b>\n\n<b>Step 4 of 4:</b> Validity Period\n\nQuantity: <b>{quantity}</b>\nBonus days: <b>{bonus_days}</b>\nMax activations: <b>{max_activations}</b>\n\nChoose the validity period for promo codes:",
-  
   "admin_bulk_promo_invalid_quantity": "❌ Quantity must be between 1 and 1000",
-  "admin_bulk_promo_invalid_bonus_days": "❌ Bonus days must be between 1 and 365",
-  "admin_bulk_promo_invalid_max_activations": "❌ Max activations must be between 1 and 10000",
-  
-  "admin_bulk_promo_unlimited_validity": "♾️ Unlimited",
-  "admin_bulk_promo_set_validity": "⏰ Set Period",
   "admin_bulk_promo_enter_validity_days": "⏰ Enter the number of validity days for promo codes (1-365):",
-  
   "admin_bulk_promo_creating": "⏳ Creating {quantity} promo codes...",
-  
   "admin_promo_step1_code": "🎟 <b>Create Promo Code</b>\n\n<b>Step 1 of 4:</b> Promo Code\n\nEnter promo code (3-30 characters, letters and numbers only):",
   "admin_promo_step2_bonus_days": "🎟 <b>Create Promo Code</b>\n\n<b>Step 2 of 4:</b> Bonus Days\n\nCode: <b>{code}</b>\n\nEnter the number of bonus days (1-365):",
   "admin_promo_step3_max_activations": "🎟 <b>Create Promo Code</b>\n\n<b>Step 3 of 4:</b> Max Activations\n\nCode: <b>{code}</b>\nBonus days: <b>{bonus_days}</b>\n\nEnter the maximum number of activations (1-10000):",
   "admin_promo_step4_validity": "🎟 <b>Create Promo Code</b>\n\n<b>Step 4 of 4:</b> Validity Period\n\nCode: <b>{code}</b>\nBonus days: <b>{bonus_days}</b>\nMax activations: <b>{max_activations}</b>\n\nChoose the validity period for the promo code:",
-  
   "admin_promo_code_already_exists": "❌ A promo code with this code already exists",
-  "admin_promo_processing_error": "❌ Error processing promo code",
   "admin_promo_unlimited_validity": "♾️ Unlimited",
-  "admin_promo_set_validity": "⏰ Set Period",
   "admin_promo_enter_validity_days": "⏰ Enter the number of validity days for the promo code (1-365):",
-  "admin_promo_skip_description": "⏭️ Skip",
-  "admin_promo_description_too_long": "❌ Description must not exceed 200 characters",
-  "admin_promo_creating": "⏳ Creating promo code...",
-  
-  "admin_panel_back_button": "⬅️ Back",
-  "admin_bulk_promo_creation_failed": "❌ Error creating promo codes: {error}",
-  
   "admin_user_id_label": "🆔 <b>ID:</b>",
   "admin_user_name_label": "👤 <b>Name:</b>",
   "admin_user_username_label": "📱 <b>Username:</b>",
@@ -429,7 +327,6 @@
   "admin_user_traffic_label": "📊 <b>Traffic:</b>",
   "admin_user_subscription_label": "💼 <b>Subscription:</b>",
   "admin_user_trial_label": "🏡 <b>Trial:</b>",
-  
   "admin_user_status_banned": "🚫 Banned",
   "admin_user_status_active": "✅ Active",
   "admin_user_trial_used": "Used",
@@ -437,20 +334,12 @@
   "admin_user_ban_action_banned": "banned",
   "admin_user_ban_action_unbanned": "unbanned",
   "admin_user_na_value": "N/A",
-  
-  "admin_user_subscription_active": "Active until {end_date}",
-  "admin_user_subscription_expired": "Expired {end_date}",
   "admin_user_subscription_none": "No active subscription",
-  
-  "admin_user_logs_count": "Total entries: {count}",
-  "admin_user_logs_entry": "📅 {timestamp}\n📝 {event_type}: {content}",
-  
   "admin_user_actions_count_label": "📜 <b>Total actions:</b>",
+  "admin_user_invited_friends_label": "👥 <b>Friends invited:</b>",
+  "admin_user_ref_purchased_label": "💳 <b>Purchased subscription:</b>",
   "admin_user_subscription_active_until": "⏰ <b>Active until:</b>",
   "admin_user_subscription_error": "Loading error",
-  
-  "admin_bulk_promo_unique_generation_failed": "Failed to create unique promo code",
-  
   "admin_promo_management_button": "🎟 Promo Management",
   "admin_promo_management_title": "🎟 <b>Promo Code Management</b>\n\nSelect a promo code for detailed view:",
   "admin_promo_management_empty": "📭 No promo codes available",
@@ -471,43 +360,28 @@
   "admin_promo_view_activations_button": "📋 Activations",
   "admin_promo_back_to_list_button": "⬅️ Back to list",
   "admin_promo_toggle_success": "✅ Promo code {code} {status}",
-  "admin_promo_toggle_failed": "❌ Error changing promo code status",
   "admin_promo_no_activations": "📋 <b>Activations of promo code: {code}</b>\n\n❌ No activations found",
   "admin_promo_activations_header": "📋 <b>Activations of promo code: {code}</b>\n\n",
   "admin_promo_activation_item": "👤 User ID: <b>{user_id}</b>\n📅 Date: <b>{date}</b>\n",
   "admin_promo_back_to_detail_button": "⬅️ Back to promo",
-  
   "admin_panel_online_label": "Online",
   "admin_panel_active_label": "Active",
   "admin_panel_disabled_label": "Disabled",
-  "admin_panel_offline_label": "Offline",
-  "admin_panel_expired_label": "Expired", 
+  "admin_panel_expired_label": "Expired",
   "admin_panel_limited_label": "Limited",
   "admin_panel_total_users_label": "Total users",
-  "admin_panel_cpu_usage_label": "CPU Usage",
   "admin_panel_memory_usage_label": "RAM Usage",
-  "admin_panel_traffic_today_label": "Traffic today",
   "admin_panel_traffic_week_label": "Traffic this week",
   "admin_panel_traffic_month_label": "Traffic this month",
   "admin_panel_nodes_label": "Active nodes",
   "admin_panel_system_stats_error": "Error getting system statistics",
   "admin_panel_bandwidth_stats_error": "Error getting bandwidth statistics",
-  "admin_panel_nodes_stats_error": "Error getting nodes statistics",
   "admin_panel_stats_fetch_error": "Error fetching panel data",
   "admin_panel_stats_error_details": "Details",
-  
-  "inline_referral_message": "🚀 Hey! Try this VPN - it's fast, reliable and affordable!\n\n🎁 Use my link to get bonus days with your subscription!\n\n{referral_link}",
   "inline_referral_title": "Referral link",
-  "inline_referral_description": "Share referral link to get bonuses", 
-  "inline_stats_title": "Bot statistics",
-  "inline_stats_description": "Total: {total}, Active: {active}",
-  "inline_financial_title": "Financial statistics",
+  "inline_referral_description": "Share referral link to get bonuses",
   "inline_financial_description": "Today: {today} RUB",
-  "inline_system_title": "System statistics", 
   "inline_system_description": "🟢 Online: {online}, 📊 Active: {active}",
-  "inline_admin_help_title": "Commands help",
-  "inline_admin_help_description": "Available commands: ref, stat, financial, system",
-  
   "admin_user_stats_total_label": "Total",
   "admin_user_stats_paid_subs_label": "With paid subscription",
   "admin_user_stats_trial_label": "On trial period",
@@ -519,9 +393,66 @@
   "admin_financial_month_label": "This month",
   "admin_financial_all_time_label": "All time",
   "admin_financial_payments_label": "payments",
-
   "admin_sync_details": "📊 Synchronization Statistics:\n🔍 Panel records checked: {panel_records_checked}\n👥 Users found in DB: {users_found_in_db}\n✨ New users created: {users_created}\n🔄 Users updated: {users_updated}\n📋 Subscriptions synced: {subscriptions_synced_count}\n   ├── Created new: {subscriptions_created}\n   └── Updated existing: {subscriptions_updated}{additional_stats}",
   "admin_sync_no_telegram_id": "\n⚠️ Records without telegramId: {count}",
   "admin_sync_not_found_in_db": "\n❌ Not found in DB: {count}",
-  "admin_sync_errors": "\n🚫 Errors: {count}"
+  "admin_payments_pagination_info": "📊 Showing {shown} of {total} payments (page {current_page}/{total_pages})",
+  "my_subscription_details": "🔐 <b>My Subscription</b>\n\n⏰ Status: <b>{status}</b>\n📅 Active until: <b>{end_date}</b>\n📆 Days left: <b>{days_left}</b>\n\n🔗 Configuration link:\n<code>{config_link}</code>\n\n📊 Traffic:\nLimit: <b>{traffic_limit}</b>\nUsed: <b>{traffic_used}</b>",
+  "autorenew_enable_button": "🔄 Enable auto-renew",
+  "autorenew_disable_button": "🛑 Disable auto-renew",
+  "subscription_autorenew_updated": "Auto-renew settings updated.",
+  "payment_methods_manage_button": "💳 Payment Methods",
+  "payment_methods_title": "💳 <b>Payment Methods</b>",
+  "payment_method_bind_button": "➕ Add method",
+  "payment_method_delete_button": "🗑 Remove",
+  "payment_method_view_button": "ℹ️ Details",
+  "payment_method_none": "You don't have a saved payment method yet.",
+  "payment_method_bound_success": "✅ Payment method added.",
+  "payment_method_deleted_success": "✅ Payment method removed.",
+  "payment_method_delete_confirm": "Remove saved payment method?",
+  "payment_method_card_title": "💳 {network} ••••{last4}",
+  "payment_method_generic_title": "💳 {network}",
+  "payment_method_wallet_title": "💼 YooMoney wallet ••••{last4}",
+  "payment_network_card": "Card",
+  "payment_network_generic": "Payment method",
+  "payment_method_added_at": "Added: {date}",
+  "payment_method_last_tx": "Last transaction: {date}",
+  "payment_method_tx_history_title": "📜 Transactions history",
+  "payment_method_no_history": "No transactions history.",
+  "subscription_purchase_title": "Subscription purchase for {months} mo.",
+  "subscription_tribute_notice": "Paid via Tribute. Renew using your Tribute link.",
+  "subscription_tribute_notice_with_link": "Paid via Tribute. Renew: {link}",
+  "subscription_autorenew_not_supported_for_tribute": "Auto-renew is handled by Tribute. Manage renewal in the Tribute app/link.",
+  "subscription_not_active": "You don't have an active subscription.",
+  "error_service_unavailable": "Service unavailable. Please try again later.",
+  "error_payment_gateway": "Payment service error. Please try again later.",
+  "traffic_na": "N/A",
+  "payment_service_unavailable": "Payment service is unavailable.",
+  "payment_service_unavailable_alert": "Payment service is unavailable. Please try again later.",
+  "error_creating_payment_record": "Error creating payment record. Please try again later.",
+  "error_payment_gateway_link_failed": "Error creating payment link. Please try again later.",
+  "status_active": "Active",
+  "status_inactive": "Inactive",
+  "admin_ads_section": "📈 Ads",
+  "admin_ads_header": "📈 Ad Campaigns:",
+  "admin_ads_empty": "📭 No ad campaigns. Click \"Create\" to add one.",
+  "admin_ads_item": "ID: {id}\nSource: <b>{source}</b>\nstart={start_param}\nCost: {cost} RUB\nActive: {active}\n— Starts: {starts}\n— Trials: {trials}\n— Payers: {payers}\n— Revenue: {revenue} RUB",
+  "admin_ads_create_button": "➕ Create campaign",
+  "admin_ads_create_source_prompt": "Enter source (e.g., AEZA, VK, TG-channel):",
+  "admin_ads_create_start_param_prompt": "Enter start link parameter (e.g., AEZA). Will be used as start=AEZA",
+  "admin_ads_create_cost_prompt": "Enter campaign cost (RUB):",
+  "admin_ads_invalid_source": "❌ Invalid source. Enter up to 64 characters.",
+  "admin_ads_invalid_start_param": "❌ Invalid parameter. Allowed letters/digits/underscore/dash (2-64).",
+  "admin_ads_invalid_cost": "❌ Invalid amount. Enter a non-negative number.",
+  "admin_ads_start_param_exists": "❌ A campaign with this start parameter already exists.",
+  "admin_ads_created_success": "✅ Campaign created!\nID: {id}\nSource: {source}\nParam: {start_param}\nCost: {cost} RUB",
+  "admin_ads_back_to_menu_hint": "Done. Back to Ads section:",
+  "admin_ads_overview": "📈 <b>Ads</b>\n💰 Revenue: <b>{revenue} RUB</b>\n💸 Spent: <b>{cost} RUB</b>",
+  "back_to_ads_list_button": "⬅️ Back to list",
+  "admin_ads_card": "📈 <b>Campaign #{id}</b>\nSource: <b>{source}</b>\nstart=<code>{start_param}</code>\nCost: <b>{cost} RUB</b>\nActive: {active}\n\n👥 Starts: <b>{starts}</b>\n🆓 Trials: <b>{trials}</b>\n💳 Payers: <b>{payers}</b>\n💵 Revenue: <b>{revenue} RUB</b>",
+  "admin_ads_delete_button": "🗑 Delete campaign",
+  "admin_ads_delete_confirm": "Are you sure you want to delete campaign #{id}? This action is irreversible.",
+  "admin_ads_deleted_success": "Campaign deleted.",
+  "admin_ads_not_found": "Campaign not found.",
+  "free_kassa_order_full": "Order #{order_id} from {date}\n\n"
 }

locales/ru.json

@@ -1,110 +1,101 @@
 {
   "welcome": "Добро пожаловать, {user_name}!",
+  "channel_subscription_required": "Чтобы пользоваться ботом, подпишитесь на канал и нажмите \"Проверить подписку\".",
+  "channel_subscription_join_button": "Перейти в канал",
+  "channel_subscription_verify_button": "Проверить подписку",
+  "channel_subscription_check_failed": "Не удалось проверить подписку. Попробуйте позже или обратитесь в поддержку.",
+  "channel_subscription_verified_success": "✅ Подписка подтверждена! Можно продолжать.",
   "main_menu_greeting": "Привет, {user_name}! 👋\nЧто бы вы хотели сделать?",
-
   "menu_activate_trial_button": "🆓 Пробный период",
   "menu_subscribe_inline": "🚀 Купить",
   "menu_my_subscription_inline": "🔐 Моя подписка",
+  "no_subscription_options_available": "Выдача подписки не натроена администратором бота",
   "menu_referral_inline": "🎁 Рефералы",
+  "referral_no_bonuses_configured": "Извините, реферальная программа в данный момент отключена",
   "menu_apply_promo_button": "🎟 Промокод",
   "menu_language_settings_inline": "🌐 Язык",
   "menu_server_status_button": "📊 Статус",
   "menu_support_button": "💬 Поддержка",
   "menu_terms_button": "📄 Условия сервиса",
   "back_to_main_menu_button": "⬅️ Назад",
-  
   "choose_language": "Выберите язык / Select language:",
   "language_set_alert": "Язык изменен!",
   "error_occurred_try_again": "Произошла ошибка, попробуйте снова.",
   "error_try_again": "Попробуйте еще раз.",
   "error_displaying_menu": "Ошибка отображения меню.",
   "main_menu_unknown_action": "Неизвестное действие.",
-
   "select_subscription_period": "Выберите срок подписки:",
-  "no_subscription_options_available": "В данный момент нет доступных вариантов подписки.",
   "subscribe_for_months_button": "{months} мес. - {price} {currency_symbol}",
   "choose_payment_method": "Выберите способ оплаты:",
   "pay_button": "💳 Оплатить",
   "pay_with_yookassa_button": "💳 ЮKassa",
+  "yookassa_autopay_flow_prompt": "Автопродление включено. Выберите, как оплатить подписку:",
+  "yookassa_autopay_pay_saved_card_button": "💳 Оплата привязанной картой",
+  "yookassa_autopay_pay_new_card_button": "➕ Оплата новой картой",
+  "yookassa_autopay_choose_saved_card": "Выберите привязанную карту для списания:",
+  "yookassa_autopay_no_saved_cards": "Сохранённых карт нет. Оплатите новой картой или привяжите карту в разделе «Способы оплаты».",
+  "back_to_autopay_method_choice_button": "⬅️ Назад",
+  "yookassa_autopay_charge_initiated": "Запрос на списание с выбранной карты отправлен. Сообщим, как только платёж завершится.",
+  "pay_with_sbp_button": "📱 СБП",
+  "back_to_payment_methods_button": "⬅️ Назад",
   "pay_with_cryptopay_button": "💎 CryptoBot",
   "pay_with_tribute_button": "❤️ Tribute",
   "pay_with_stars_button": "🌟 Звезды Telegram",
   "connect_button": "🔗 Подключиться",
+
+  "devices_button": "📱 Мои устройства ({current_devices}/{max_devices})",
+  "my_devices_details": "📱 <b>Список ваших устройств ({current_devices}/{max_devices})</b>\n\n{devices}\n\nВы можете отключить устройство, выбрав его в списке ниже.\n<blockquote><i>Примечание: Если вы отключили устройство, оно будет автоматически подключено заново при следующем использовании. Перед удалением убедитесь, что вы удалили подписку из приложения.</i></blockquote>",
+  "no_devices_details_found_message": "📱 <b>Список ваших устройств</b>\n\nУ вас пока нет устройств.\nВам доступно {max_devices} устройств. Подключить их можно через кнопку \"🔗 Подключиться\" в меню подписки.",
+  "device_details": "{index}) <b>{device_model} ({platform} {os_version})</b>\nДата подключения: <b>{created_at_str}</b>\nUser Agent: <b>{user_agent}</b>\nHWID: <code>{hwid}</code>",
+  "disconnect_device_button": "🚫 Отключить {hwid} ({index})",
+  "device_disconnected": "Устройство успешно отключено.",
+  "no_devices_found": "Ошибка загрузки списка устройств.",
+  "devices_unlimited_label": "Без ограничений",
+  "my_devices_feature_disabled": "Раздел \"Мои устройства\" сейчас недоступен.",
+
   "cancel_button": "❌ Отмена",
   "payment_description_subscription": "Оплата подписки на {months} мес.",
-  "payment_service_unavailable": "Платежный сервис временно недоступен. Пожалуйста, попробуйте позже.",
-  "payment_service_unavailable_alert": "Платежный сервис недоступен",
-  "error_creating_payment_record": "Ошибка при создании записи о платеже. Попробуйте позже.",
-  "error_payment_gateway_link_failed": "Не удалось получить ссылку на оплату. Пожалуйста, свяжитесь с поддержкой.",
   "payment_link_message": "Для оплаты подписки на {months} мес., нажмите кнопку ниже:",
-  "error_payment_gateway": "Ошибка платежного шлюза. Попробуйте позже или свяжитесь с поддержкой.",
+  "free_kassa_order_info": "Заказ №{order_id} от {date}",
+  "payment_invoice_sent_message": "Счёт Telegram Stars отправлен выше. Нажмите «Оплатить» или вернитесь к выбору способа ниже.",
   "payment_successful_error_details": "✅ Оплата прошла успешно, но возникла ошибка при отображении деталей. Ваша подписка активна. Свяжитесь с поддержкой, если что-то не так.",
   "payment_successful_full": "✅ Оплата прошла успешно!\nВаша подписка на {months} мес. активна до {end_date}.\n\nКлюч подключения:\n<code>{config_link}</code>\n\nЧтобы подключиться, перейдите по ссылке и следуйте инструкции 👇",
-  "payment_successful_with_promo_full": "✅ Оплата прошла успешно!\nВаша подписка на {months} мес. (с учетом промокода на +{bonus_days} дней) активна до {end_date}.\n\nКлюч подключения:\n<code>{config_link}</code>\n\nЧтобы подключиться, перейдите по ссылке и следуйте инструкции 👇",
   "payment_successful_with_referral_bonus_full": "✅ Оплата прошла успешно!\nВаша подписка на {months} мес. (базовая дата окончания: {base_end_date}) продлена на {bonus_days} бонусных дней за приглашение от {inviter_name} и теперь активна до {final_end_date}.\n\nКлюч подключения:\n<code>{config_link}</code>\n\nЧтобы подключиться, перейдите по ссылке и следуйте инструкции 👇",
   "payment_failed": "❌ Оплата не удалась или была отменена. Пожалуйста, попробуйте еще раз или свяжитесь с поддержкой.",
-  "error_processing_your_payment": "Произошла ошибка при обработке вашего платежа после его успеха. Пожалуйста, свяжитесь с поддержкой, указав детали.",
-
-  "my_subscription_details": "<b>🔐 Моя подписка:</b>\n\nСтатус: <b>{status}</b>\nАктивна до: <b>{end_date}</b> (осталось дней: {days_left})\n\nТрафик: <b>{traffic_used}</b> из <b>{traffic_limit}</b>\n\nСсылка на конфигурацию:\n<code>{config_link}</code>",
   "config_link_not_available": "недоступна, обратитесь в поддержку",
-  "subscription_not_active": "У вас нет активной подписки. \nХотите приобрести?",
-  "status_active": "Активна",
-  "status_expired": "Истекла",
-  "status_disabled": "Отключена",
   "traffic_unlimited": "Безлимитный",
-  "traffic_na": "н/д",
-  "error_service_unavailable": "Сервис временно недоступен. Пожалуйста, попробуйте позже.",
-
   "promo_code_prompt": "Пожалуйста, введите ваш промокод:",
   "promo_code_not_found": "Промокод <code>{code}</code> не найден, истек или уже использован максимальное количество раз.",
   "promo_code_already_used_by_user": "Вы уже активировали промокод <code>{code}</code>.",
-  "promo_code_no_active_subscription": "Для активации этого промокода у вас должна быть активная подписка.",
   "promo_code_applied_success_full": "✅ Промокод успешно применен!\nПодписка активна до {end_date}.\n\nКлюч подключения:\n<code>{config_link}</code>\n\nЧтобы подключиться, перейдите по ссылке и следуйте инструкции 👇",
   "error_applying_promo_bonus": "Не удалось применить бонус по промокоду. Пожалуйста, попробуйте позже или свяжитесь с поддержкой.",
   "promo_input_cancelled_short": "Ввод промокода отменен.",
-
   "trial_feature_disabled": "Пробный период в данный момент недоступен.",
   "trial_already_had_subscription_or_trial": "Вы уже использовали пробный период или у вас была платная подписка. Пробный период доступен только один раз для новых пользователей.",
-  "trial_confirm_prompt": "Хотите активировать бесплатный пробный период на {days} дней с лимитом трафика {traffic_gb}?",
   "trial_confirm_activate_button": "✅ Активировать!",
   "trial_activated_alert": "Пробный период активирован!",
-  "trial_activated_details_message": "🚀 Ваш пробный период на {days} дней активирован!\n\nДействует до: <b>{end_date}</b>\nТрафик: <b>{traffic_gb}</b>\n\nВаша ссылка на конфигурацию:\n<code>{config_link}</code>",
-  "trial_activation_failed": "Не удалось активировать пробный период. Пожалуйста, попробуйте позже.",
-  "trial_activation_failed_panel_link": "Не удалось связать ваш аккаунт с сервером для активации пробного периода. Попробуйте позже.",
-  "trial_activation_failed_db": "Ошибка базы данных при активации пробного периода. Попробуйте позже.",
-  "trial_activation_failed_panel_update": "Не удалось обновить детали на сервере для пробного периода. Попробуйте позже.",
-  "user_not_found_for_trial": "Ваш аккаунт не найден в системе. Пожалуйста, сначала выполните команду /start.",
+  "trial_activated_details_message": "✅ Пробный доступ активирован!\nВаш триал на {days} дн. действует до {end_date}.\n\nКлюч подключения:\n<code>{config_link}</code>\n\nЧтобы подключиться, перейдите по ссылке и следуйте инструкции 👇",
   "yes_button": "Да",
   "no_button": "Нет",
-  "trial_cancelled_short": "Активация отменена.",
-
   "referral_program_info_new": "🎁 <b>Реферальная программа</b>\n\n📊 <b>Твоя статистика:</b>\n👥 Приглашено друзей: <b>{invited_count}</b>\n💳 Купили подписку: <b>{purchased_count}</b>\n\n🔗 Твоя ссылка:\n<code>{referral_link}</code>\n\n💰 <b>Бонусы за приглашения:</b>\n{bonus_details}\n\n📢 Поделись ссылкой с друзьями и получай бонусы!",
   "referral_bonus_per_period": "\n\n🎁 За {months}-мес. подписку друга:\n  ➢ Вы: <b>{inviter_bonus_days} дн.</b>\n  ➢ Друг: <b>{referee_bonus_days} дн.</b>",
-  "no_bonus_days": "0",
-  "referral_no_bonuses_configured": "\nРеферальные бонусы не настроены.",
-  "referral_link_for_copying_reminder": "Ссылка выше. Нажмите и удерживайте для копирования.",
   "referral_share_message_button": "📩 Сообщение для друга",
   "referral_friend_message": "🚀 Привет! Попробуй этот VPN - быстрый, надёжный и доступный!\n\n🎁 По моей ссылке тебе дадут бонусные дни к подписке!\n\n{referral_link}",
   "friend_placeholder": "друг",
   "referral_bonus_inviter_notification_extended": "🎉 Поздравляем! Ваш друг {referee_name} оплатил подписку. Вам начислено {days} бонусных дней! Ваша подписка теперь активна до {new_end_date}.",
   "referral_bonus_inviter_notification_new_sub": "🎉 Поздравляем! Ваш друг {referee_name} оплатил подписку. Вам начислена бонусная подписка на {days} дней! Она активна до {new_end_date}.",
-
   "user_is_banned": "🚫 Ваш аккаунт заблокирован. Пожалуйста, свяжитесь со службой поддержки.",
-
   "admin_panel_title": "Панель администратора",
   "admin_stats_button": "📊 Статистика",
   "admin_broadcast_button": "📢 Рассылка",
   "admin_create_promo_button": "🎁 Создать промо",
   "admin_create_bulk_promo_button": "📦 Массовое создание",
-  "admin_manage_promos_button": "🛠 Управление",
-  "admin_view_promos_button": "👀 Список",
   "admin_ban_user_button": "🚫 Забанить",
   "admin_unban_user_button": "✅ Разбанить",
   "admin_view_banned_users_button": "📜 Бан-лист",
   "admin_view_logs_menu_button": "📄 Логи",
   "admin_sync_panel_button": "🔄 Синхронизация",
   "admin_unknown_action": "Неизвестное действие администратора.",
-  
   "admin_stats_and_monitoring_section": "📊 Статистика",
   "admin_user_management_section": "👥 Пользователи",
   "admin_promo_marketing_section": "🎁 Промокоды",
@@ -112,18 +103,13 @@
   "admin_ban_management_section": "🚫 Блокировки",
   "admin_users_management_button": "👤 Управление",
   "back_to_user_management_button": "⬅️ К пользователям",
-  "admin_action_cancelled_default": "Действие отменено. Возврат в меню.",
-  "admin_action_cancelled_default_alert": "Действие отменено",
   "back_to_admin_panel_button": "⬅️ В админку",
-
   "admin_stats_header": "📊 Статистика Бота",
   "admin_enhanced_users_stats_header": "Пользователи",
   "admin_financial_stats_header": "Финансовая статистика",
-  "admin_stats_users": "👥 Пользователи: Всего - {total_users}, Забанено - {banned_users}, С активной подпиской - {active_subs}",
   "admin_stats_recent_payments_header": "Последние платежи:",
   "admin_stats_payment_item": "{status_emoji} {amount} {currency} от {user_info} ({p_status}) [{p_date}]",
   "admin_stats_no_payments_found": "Платежей пока нет.",
-  
   "admin_view_payments_button": "💰 Платежи",
   "admin_payments_header": "💰 <b>Все платежи</b>",
   "admin_no_payments_found": "Платежи не найдены.",
@@ -132,7 +118,6 @@
   "admin_no_payments_to_export": "Нет платежей для экспорта.",
   "admin_payments_export_success": "📊 Экспорт платежей завершен!\nВсего записей: {count}",
   "admin_export_sent": "Файл отправлен!",
-  
   "admin_csv_payment_id": "ID",
   "admin_csv_user_id": "User ID",
   "admin_csv_username": "Логин",
@@ -152,9 +137,7 @@
   "admin_stats_sync_subs_synced": "Синхронизировано подписок",
   "admin_stats_sync_details_label": "Детали",
   "admin_sync_status_never_run": "Синхронизация с панелью еще не проводилась.",
-
   "admin_broadcast_enter_message": "Введите сообщение для рассылки (HTML поддерживается):",
-  "admin_broadcast_confirm_prompt": "Вы собираетесь отправить следующее сообщение:\n\n{message_preview}\n\nПодтверждаете отправку?",
   "admin_broadcast_confirm_prompt_short": "Сообщение выше будет отправлено. Подтвердить отправку?",
   "broadcast_target_all_button": "👥 Все",
   "broadcast_target_active_button": "✅ Активные",
@@ -164,21 +147,25 @@
   "admin_broadcast_sending_started": "Начинаю рассылку...",
   "admin_broadcast_error_no_message": "Ошибка: сообщение для рассылки не найдено.",
   "admin_broadcast_error_no_message_alert": "Сообщение для рассылки пустое!",
-  "admin_broadcast_finished_stats": "🏁 Рассылка завершена!\nОтправлено: {sent_count}\nНе удалось отправить: {failed_count}",
   "admin_broadcast_cancelled": "Рассылка отменена.",
   "admin_broadcast_cancelled_alert": "Рассылка отменена!",
   "admin_broadcast_cancelled_nav_back": "Рассылка отменена. Вы возвращены в админ-панель.",
-  
-  "admin_promo_create_prompt": "Введите детали промокода в формате: КОД ДНИ_БОНУСА МАКС_АКТИВАЦИЙ [СРОК_ДЕЙСТВИЯ_В_ДНЯХ_ОТ_СЕЙЧАС]\nПример: <code>{example_format}</code>\n(Срок действия необязателен, по умолчанию - бессрочный)",
-  "admin_promo_invalid_format": "Неверный формат ввода. Пожалуйста, используйте: КОД ДНИ_БОНУСА МАКС_АКТИВАЦИЙ [ДНИ_ДЕЙСТВИЯ]",
+  "broadcast_queue_result": "🚀 Рассылка поставлена в очередь!\n📤 В очередь добавлено: {sent_count}\n❌ Ошибок: {failed_count}\n\n📊 Статус очередей:\n👥 Очередь пользователей: {user_queue_size} сообщений\n📢 Очередь групп: {group_queue_size} сообщений\n\nℹ️ Сообщения будут отправлены автоматически с соблюдением лимитов Telegram.",
   "admin_promo_invalid_code_format": "Код должен быть от 3 до 30 символов и содержать только буквы и цифры.",
   "admin_promo_invalid_bonus_days": "Количество бонусных дней должно быть положительным числом.",
   "admin_promo_invalid_max_activations": "Максимальное количество активаций должно быть положительным числом.",
-  "admin_promo_invalid_bonus_or_activations": "Количество бонусных дней и максимальных активаций должны быть положительными числами.",
   "admin_promo_invalid_validity_days": "Срок действия промокода (в днях) должен быть положительным числом.",
-  "admin_promo_invalid_values": "Неверные значения. {error}",
-  "admin_promo_invalid_format_general": "Ошибка парсинга деталей промокода. Проверьте формат.",
   "admin_promo_created_success": "✅ Промокод <code>{code}</code> успешно создан!\nБонус: {bonus_days} дней\nМакс. активаций: {max_activations}\nДействителен: {valid_until_str}",
+  "subscription_72h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 3 дня — {end_date}.\n\nПродлите её по кнопке ниже.",
+  "subscription_48h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 2 дня — {end_date}.\n\nПродлите её по кнопке ниже.",
+  "subscription_24h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 1 день — {end_date}.\n\nПродлите её по кнопке ниже.",
+  "subscription_expired_notification": "👋 Привет, {user_name}!\n\n⛔ Срок вашей подписки на VPN истек ({end_date}).\n\nПродлите её по кнопке ниже.",
+  "subscription_expired_yesterday_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекла сутки назад ({end_date}).\n\nПродлите её по кнопке ниже.",
+  "autorenew_48h_charge_tomorrow_notice": "🔔 Напоминание\n\nЗавтра будет автоматическое списание за продление подписки. Если вы не хотите автопродление — отключите его кнопкой ниже.",
+  "autorenew_confirm_enable": "🔄 Включить автопродление? Перед окончанием подписки будет выполняться автосписание.",
+  "autorenew_confirm_disable": "🛑 Отключить автопродление? Автосписаний больше не будет.",
+  "tribute_subscription_cancelled": "🚨 <b>Подписка отменена</b>\n\nВаша подписка Tribute была отменена. У вас есть 24 часа для восстановления доступа, после чего подписка будет заблокирована.\n\nДля продления подписки нажмите кнопку ниже.",
+  "yookassa_auto_renewal": "🔄 <b>Подписка автоматически продлена</b>\n\nВаша подписка была автоматически продлена на {months} мес.\nНовая дата окончания: {end_date}",
   "admin_promo_set_validity_days": "⏰ Установить срок (дни)",
   "admin_back_to_panel": "⬅️ В панель",
   "admin_promo_unlimited": "♾️ Неограниченно",
@@ -189,22 +176,28 @@
   "admin_queue_status_button": "📊 Статус очередей",
   "admin_queue_status_title": "📊 Статус очередей сообщений",
   "admin_queue_status_info": "📤 <b>Очереди сообщений:</b>\n\n👥 <b>Пользователи (25 сообщ/сек):</b>\n   📋 В очереди: {user_queue_size}\n   🔄 Обрабатывается: {user_processing}\n   📈 Отправлено за минуту: {user_recent}\n\n📢 <b>Группы/каналы (15 сообщ/мин):</b>\n   📋 В очереди: {group_queue_size}\n   🔄 Обрабатывается: {group_processing}\n   📈 Отправлено за минуту: {group_recent}",
-  "admin_promo_creation_failed_duplicate": "❌ Ошибка: Промокод <code>{code}</code> уже существует.",
-  "admin_promo_creation_failed": "❌ Не удалось создать промокод. Пожалуйста, попробуйте позже.",
   "admin_active_promos_list_header": "Активные промокоды:",
   "admin_no_active_promos": "Нет активных промокодов.",
-  "admin_promo_list_item": "<code>{code}</code>: +{bonus}дн, {current}/{max} акт., до {valid_until}",
   "admin_promo_valid_indefinitely": "бессрочно",
-  "admin_promo_valid_until_display": "до {date}",
-  "admin_manage_promos_title": "Управление промокодами",
   "admin_promo_edit_button": "✏️ Изменить",
   "admin_promo_delete_button": "🗑 Удалить",
-  "admin_promo_edit_prompt": "Отправьте новые данные для <code>{code}</code> в формате: КОД ДНИ_БОНУСА МАКС_АКТИВАЦИЙ [СРОК]",
-  "admin_promo_updated_success": "Промокод {code} обновлен.",
   "admin_promo_deleted_success": "Промокод {code} удален.",
   "admin_promo_not_found": "Промокод не найден.",
   "admin_promo_export_csv_button": "📄 Экспорт в CSV",
   "admin_promo_export_caption": "📄 Активации промокода {code}",
+  "admin_promo_export_all_generating": "📄 Создаю CSV файл...",
+  "admin_promo_export_all_caption": "📄 Экспорт всех промокодов\n📊 Всего: {count} промокодов",
+  "admin_promo_csv_code": "Код",
+  "admin_promo_csv_bonus_days": "Бонусные дни",
+  "admin_promo_csv_max_activations": "Максимальные активации",
+  "admin_promo_csv_current_activations": "Текущие активации",
+  "admin_promo_csv_status": "Статус",
+  "admin_promo_csv_is_active": "Активен",
+  "admin_promo_csv_valid_until": "Действителен до",
+  "admin_promo_csv_created_at": "Создан",
+  "admin_promo_csv_created_by_admin_id": "Создал (Admin ID)",
+  "csv_yes": "Да",
+  "csv_no": "Нет",
   "admin_promo_edit_select_field": "Выберите поле для редактирования:",
   "admin_promo_prompt_bonus_days": "Введите новое количество бонусных дней:",
   "admin_promo_prompt_max_activations": "Введите новое максимальное количество активаций:",
@@ -214,86 +207,36 @@
   "admin_promo_edit_bonus_days": "🎁 Бонусные дни",
   "admin_promo_edit_max_activations": "🔢 Макс. активации",
   "admin_promo_edit_validity": "⏰ Срок действия",
-
   "admin_ban_user_prompt": "Введите ID или @username пользователя для блокировки:",
-  "admin_user_not_found_in_bot_db": "Пользователь <code>{user_id}</code> не найден в базе данных бота.",
-  "admin_cannot_ban_self_or_admin": "Вы не можете заблокировать себя или другого администратора.",
   "admin_user_already_banned": "Пользователь {user_id_or_username} уже заблокирован.",
-  "admin_user_banned_success_combined": "✅ Пользователь {user_id_or_username} успешно заблокирован в боте {panel_status_part}.",
-  "admin_panel_ban_success_part": "и на панели",
-  "admin_panel_ban_fail_part": ", но не удалось заблокировать на панели",
-  "admin_user_ban_failed_local_db_error": "❌ Не удалось заблокировать пользователя в локальной БД.",
   "admin_unban_user_prompt": "Введите ID или @username пользователя для разблокировки:",
-  "admin_user_not_banned": "Пользователь {user_id_or_username} не заблокирован.",
-  "admin_user_unbanned_success_combined": "✅ Пользователь {user_id_or_username} успешно разблокирован в боте {panel_status_part}.",
-  "admin_panel_unban_success_part": "и на панели",
-  "admin_panel_unban_fail_part": ", но не удалось разблокировать на панели",
-  "admin_user_unban_failed_local_db_error": "❌ Не удалось разблокировать пользователя в локальной БД.",
-  "admin_no_banned_users": "В данный момент нет заблокированных пользователей.",
-  "admin_banned_list_title": "Список забаненных (стр. {current_page}/{total_pages}):",
+  "admin_user_not_banned": "⚠️ Пользователь не заблокирован",
   "admin_banned_user_button_text": "{user_display} (ID: {user_id})",
   "prev_page_button": "⬅️ Пред.",
   "next_page_button": "След. ➡️",
-  "admin_user_card_title": "Карточка пользователя: {user_display}",
-  "user_card_info": "ID: <code>{user_id}</code>\nUsername: @{username}\nИмя: {first_name} {last_name}\nЯзык: {language_code}\nPanel UUID: <code>{panel_user_uuid}</code>\nСтатус: <b>{ban_status}</b>\nРегистрация: {reg_date}\nПодписка до: <b>{sub_end_date}</b>",
-  "user_card_banned": "ЗАБЛОКИРОВАН",
-  "user_card_active": "Активен",
-  "user_card_sub_na": "н/д",
+  "admin_user_card_title": "Карточка пользователя",
   "user_card_ban_button": "🚫 Заблокировать",
   "user_card_unban_button": "✅ Разблокировать",
   "user_card_back_to_banned_list_button": "⬅️ К списку забаненных",
-  "admin_confirm_action_title": "Подтверждение: {action_text}",
-  "ban_verb_l": "блокировка",
-  "unban_verb_l": "разблокировка",
-  "admin_confirm_ban_prompt": "Вы уверены, что хотите заблокировать пользователя {user_display} (ID: {user_id})?",
-  "admin_confirm_unban_prompt": "Вы уверены, что хотите разблокировать пользователя {user_display} (ID: {user_id})?",
-  "admin_user_banned_from_card_alert": "Пользователь {user_display} (ID: {user_id}) заблокирован.",
-  "admin_user_unbanned_from_card_alert": "Пользователь {user_display} (ID: {user_id}) разблокирован.",
-  "admin_user_ban_failed_db_error": "Ошибка блокировки пользователя в БД.",
-  "admin_user_unban_failed_db_error": "Ошибка разблокировки пользователя в БД.",
-  "admin_panel_status_update_fail_part": ", но статус на панели не обновлен",
-
   "admin_logs_menu_title": "Меню логов:",
   "admin_view_all_logs_button": "📜 Все логи сообщений",
   "admin_view_user_logs_prompt_button": "👤 Логи пользователя",
   "admin_export_logs_csv_button": "📄 Экспорт в CSV",
-  "admin_all_logs_title": "Все логи (стр. {current_page}/{total_pages}):",
   "admin_no_logs_found": "Логи не найдены.",
   "admin_log_entry_format": "<code>{timestamp_str}</code> - <b>{user_display}</b> (ID: {user_id})\n  <i>{event_type}</i>: {content_preview}",
-  "system_or_unknown_user": "Система/Неизв.",
   "admin_prompt_for_user_id_or_username_logs": "Введите ID или @username пользователя для просмотра его логов:",
   "admin_log_user_not_found": "Пользователь по запросу \"{input}\" не найден в базе данных бота.",
-  "admin_user_logs_title": "Логи пользователя {user_display} (стр. {current_page}/{total_pages}):",
-  
   "sync_started_simple": "🔄 Начинаю синхронизацию...",
   "sync_success_simple": "✅ Синхронизация успешно завершена",
   "sync_failed_simple": "❌ Синхронизация завершилась с ошибкой",
   "sync_errors_simple": "⚠️ Синхронизация завершена с ошибками ({errors_count} ошибок)",
   "sync_critical_error": "❌ Критическая ошибка синхронизации",
-  "no_errors_placeholder": "нет",
   "admin_sync_initiated_from_panel": "Синхронизация запущена...",
   "admin_broadcast_invalid_html": "❌ Некорректный HTML в сообщении. Пожалуйста, отправьте корректный HTML (поддерживаются теги Telegram) или уберите теги.",
-  "admin_panel_user_creation_failed": "❌ Не удалось создать пользователя на панели для TG ID {user_id}. Панель недоступна?",
   "error_displaying_logs_too_long": "Ошибка: логи слишком длинные для отображения одним сообщением. Попробуйте найти логи по конкретному пользователю.",
   "error_displaying_statistics": "Ошибка отображения статистики.",
-  "stub_page_display": "Страница",
-
-  "subscription_72h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 3 дня — {end_date}.\n\nПродлите её по кнопке ниже.",
-  "subscription_48h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 2 дня — {end_date}.\n\nПродлите её по кнопке ниже.",
-  "subscription_24h_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекает через 1 день — {end_date}.\n\nПродлите её по кнопке ниже.",
-  "subscription_expired_notification": "👋 Привет, {user_name}!\n\n⛔ Срок вашей подписки на VPN истек ({end_date}).\n\nПродлите её по кнопке ниже.",
-  "subscription_expired_yesterday_notification": "👋 Привет, {user_name}!\n\n⏳ Ваша подписка на VPN истекла сутки назад ({end_date}).\n\nПродлите её по кнопке ниже.",
-  "tribute_subscription_cancelled": "🚨 <b>Подписка отменена</b>\n\nВаша подписка Tribute была отменена. У вас есть 24 часа для восстановления доступа, после чего подписка будет заблокирована.\n\nДля продления подписки нажмите кнопку ниже.",
   "tribute_auto_renewal": "🔄 <b>Подписка автоматически продлена</b>\n\nВаша подписка Tribute была автоматически продлена на {months} мес.\nНовая дата окончания: {end_date}",
-
-  "admin_new_trial_notification": "\ud83c\udf21 Пользователь {user_id} активировал пробный период до {end_date}.",
-
-  "admin_promo_activation_notification": "\ud83c\udf81 Пользователь {user_id} активировал промокод {code} (+{bonus_days} дн.)",
-
-  "error_unknown": "Произошла неизвестная ошибка.",
-  
   "admin_user_management_prompt": "👤 Управление пользователями\n\nВведите ID пользователя или @username для поиска:",
-  "admin_user_card_title": "Карточка пользователя",
   "admin_user_subscription_info": "Информация о подписке:",
   "admin_user_reset_trial_button": "🔄 Сбросить триал",
   "admin_user_add_subscription_button": "➕ Добавить дни",
@@ -304,7 +247,7 @@
   "admin_user_search_new_button": "🔍 Новый поиск",
   "admin_user_view_all_logs_button": "📋 Все логи",
   "admin_user_back_to_card_button": "🔙 К карточке",
-  
+  "admin_user_recent_actions_title": "📜 Последние действия пользователя {user_id}:",
   "admin_user_not_found": "❌ Пользователь не найден: {input}",
   "admin_user_not_found_action": "Пользователь не найден",
   "admin_user_card_error": "❌ Ошибка отображения карточки пользователя",
@@ -320,7 +263,6 @@
   "admin_user_unban_success": "✅ Пользователь {input} разблокирован",
   "admin_user_ban_error": "❌ Ошибка блокировки пользователя",
   "admin_user_unban_error": "❌ Ошибка разблокировки пользователя",
-  "admin_user_not_banned": "⚠️ Пользователь не заблокирован",
   "admin_user_send_message_prompt": "✉️ Отправка сообщения пользователю {user_id}\n\nВведите текст сообщения:",
   "admin_user_message_too_long": "❌ Сообщение слишком длинное (максимум 4000 символов)",
   "admin_user_message_sent_success": "✅ Сообщение отправлено пользователю {user_id}",
@@ -328,26 +270,13 @@
   "admin_user_no_logs": "📜 У пользователя нет действий",
   "admin_user_logs_error": "❌ Ошибка загрузки действий пользователя",
   "admin_direct_message_signature": "\n\n---\n💬 Сообщение от администратора",
-  
-  "inline_user_stats_message": "📊 <b>Статистика Бота</b>\n👥 Пользователи\n\n📊 Всего: <b>{total}</b>\n💳 С платной подпиской: <b>{paid}</b>\n🆓 На пробном периоде: <b>{trial}</b>\n😴 Неактивных: <b>{inactive}</b>\n🚫 Заблокированных: <b>{banned}</b>\n🎁 Привлечено по реферальной программе: <b>{referral}</b>",
+  "inline_user_stats_message": "📊 <b>Статистика Бота</b>\n👥 Пользователи\n\n📊 Всего: <b>{total}</b>\n📈 Активных сегодня: <b>{active_today}</b>\n💳 С платной подпиской: <b>{paid}</b>\n🆓 На пробном периоде: <b>{trial}</b>\n😴 Неактивных: <b>{inactive}</b>\n🚫 Заблокированных: <b>{banned}</b>\n🎁 Привлечено по реферальной программе: <b>{referral}</b>",
   "inline_user_stats_description": "Всего: {total}, Платных: {active}",
   "inline_admin_user_stats_title": "👥 Статистика пользователей",
-  "inline_admin_user_stats_desc": "Всего: {total}, Активных: {paid}",
-  
   "inline_financial_stats_message": "💰 <b>Финансовая статистика</b>\n\n📅 За сегодня: <b>{today:.2f} RUB</b>\n   ({today_count} платежей)\n📅 За неделю: <b>{week:.2f} RUB</b>\n📅 За месяц: <b>{month:.2f} RUB</b>\n🏆 За все время: <b>{all_time:.2f} RUB</b>",
-  "inline_admin_financial_stats_title": "💰 Финансовая статистика", 
-  "inline_admin_financial_stats_desc": "Сегодня: {today:.2f} RUB",
-  
+  "inline_admin_financial_stats_title": "💰 Финансовая статистика",
   "inline_system_stats_message": "🖥 <b>Статистика панели</b>\n\n🟢 Онлайн: <b>{online}</b>\n📊 Активных: <b>{active}</b>\n🔴 Отключенных: <b>{disabled}</b>\n⏰ Истекшие: <b>{expired}</b>\n⚠️ Ограниченные: <b>{limited}</b>\n👥 Всего пользователей: <b>{total}</b>\n💾 Использование RAM: <b>{memory:.1f}%</b>\n📊 Трафик за неделю: <b>{week_traffic}</b>\n📊 Трафик за месяц: <b>{month_traffic}</b>\n🔗 Активных нод: <b>{active_nodes}/{total_nodes}</b>",
   "inline_admin_system_stats_title": "🖥 Системная статистика",
-  "inline_admin_system_stats_desc": "Онлайн: {online}, Офлайн: {offline}",
-  
-  "inline_admin_help_message": "🤖 <b>Inline режим бота</b>\n\n📱 <b>Доступные команды:</b>\n\n🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n👥 <b>стат/stat</b> - статистика пользователей\n💰 <b>финансы</b> - финансовая статистика\n🖥 <b>система</b> - системная статистика\n\n💡 Просто напишите @{bot_username} и начните вводить команду в любом чате!",
-  
-  "inline_user_help_message": "🤖 <b>Inline режим бота</b>\n\n📱 <b>Доступные команды:</b>\n\n🎁 <b>реф/ref</b> - поделиться реферальной ссылкой\n\n💡 Просто напишите @{bot_username} и начните вводить 'реф' в любом чате!",
-  "inline_user_help_title": "🤖 Inline помощь",
-  "inline_user_help_desc": "Доступна команда: реф (реферальная ссылка)",
-  
   "log_referral_suffix": " (реферал от {referrer_id})",
   "log_new_user_registration": "👤 <b>Новый пользователь</b>\n\n🆔 ID: <code>{user_id}</code>\n👤 Имя: {user_display}{referral_text}\n📅 Время: {timestamp}",
   "log_payment_received": "{provider_emoji} <b>Получен платеж</b>\n\n👤 Пользователь: {user_display}\n💰 Сумма: <b>{amount} {currency}</b>\n📅 Период: <b>{months} мес.</b>\n🏦 Провайдер: {payment_provider}\n🕐 Время: {timestamp}",
@@ -355,28 +284,10 @@
   "log_trial_activation": "🆓 <b>Активирован триал</b>\n\n👤 Пользователь: {user_display}\n⏰ Действует до: <b>{end_date}</b>\n🕐 Время: {timestamp}",
   "log_panel_sync": "{status_emoji} <b>Синхронизация с панелью</b>\n\n📊 Статус: <b>{status}</b>\n👥 Обработано пользователей: <b>{users_processed}</b>\n📋 Синхронизировано подписок: <b>{subs_synced}</b>\n🕐 Время: {timestamp}\n\n📝 Детали:\n{details}",
   "log_suspicious_promo": "⚠️ <b>Подозрительная попытка ввода промокода</b>\n\n👤 Пользователь: {user_display}\n🆔 ID: <code>{user_id}</code>\n📝 Ввод: <pre>{suspicious_input}</pre>\n🕐 Время: {timestamp}",
-  
-  "admin_general_cancel_operation": "Операция отменена ❌",
-  "admin_promo_codes_menu_bulk_create": "📦 Массовое создание",
-  "admin_bulk_promo_create_prompt": "📦 Массовое создание промокодов\n\nВведите данные в формате:\n<code>количество|дни|описание</code>\n\nПример:\n<code>10|7|Промо на неделю</code>",
-  "admin_bulk_promo_invalid_format": "❌ Неверный формат. Используйте: количество|дни|описание",
-  "admin_bulk_promo_created_success": "✅ Создано {count} промокодов на {days} дней!",
-  "admin_bulk_promo_codes_file": "📄 Все созданные промокоды в файле ({count} шт.)",
-  
-  "admin_promo_edit_step1_code": "✏️ <b>Редактирование промокода</b>\n\n<b>Шаг 1 из 4:</b> Код промокода\n\nТекущий код: <b>{current_code}</b>\n\nВведите новый код промокода (3-30 символов, только буквы и цифры) или отправьте текущий для сохранения:",
-  "admin_promo_edit_step2_bonus_days": "✏️ <b>Редактирование промокода</b>\n\n<b>Шаг 2 из 4:</b> Бонусные дни\n\nКод: <b>{code}</b>\nТекущие дни: <b>{current_days}</b>\n\nВведите количество бонусных дней (1-365):",
-  "admin_promo_edit_step3_max_activations": "✏️ <b>Редактирование промокода</b>\n\n<b>Шаг 3 из 4:</b> Максимальные активации\n\nКод: <b>{code}</b>\nДни: <b>{days}</b>\nТекущие активации: <b>{current_max}</b>\n\nВведите максимальное количество активаций (1-10000):",
-  "admin_promo_edit_step4_validity": "✏️ <b>Редактирование промокода</b>\n\n<b>Шаг 4 из 4:</b> Срок действия\n\nКод: <b>{code}</b>\nДни: <b>{days}</b>\nАктивации: <b>{max_act}</b>\nТекущий срок: <b>{current_validity}</b>\n\nВыберите срок действия промокода:",
-  "admin_promo_edit_unlimited_validity": "♾️ Неограниченно",
-  "admin_promo_edit_set_validity": "⏰ Установить срок",
-  "admin_promo_edit_enter_validity_days": "⏰ Введите количество дней действия промокода (1-365):",
-  "admin_promo_updated_success": "✅ Промокод обновлен!\n\n🎟 Код: <b>{code}</b>\n🎁 Бонусные дни: <b>{days}</b>\n🔢 Максимальные активации: <b>{max_act}</b>\n⏰ Действует до: <b>{validity}</b>",
-  "admin_promo_update_failed": "❌ Ошибка обновления промокода",
-  
-  "admin_logs_export_csv": "📄 Экспорт в CSV",
   "admin_logs_csv_export_started": "📄 Начинаю экспорт логов в CSV...",
   "admin_logs_csv_export_success": "✅ Логи экспортированы! Файл прикреплен выше.",
-  
+  "admin_user_logs_title": "Логи пользователя {user_display} (стр. {current_page}/{total_pages}):",
+  "admin_all_logs_title": "Все логи (стр. {current_page}/{total_pages}):",
   "admin_csv_header_log_id": "ID Лога",
   "admin_csv_header_timestamp": "Время",
   "admin_csv_header_user_id": "ID Пользователя",
@@ -387,44 +298,23 @@
   "admin_csv_header_is_admin_event": "Админ событие",
   "admin_csv_header_target_user_id": "ID Целевого юзера",
   "admin_csv_header_raw_update_preview": "Превью обновления",
-  
   "admin_banned_users_empty": "📋 Заблокированные пользователи\n\nСписок пуст",
   "admin_banned_users_list": "📋 Заблокированные пользователи ({count}):\n\n{users}",
-  
   "admin_panel_stats_header": "Статистика панели",
-  
   "admin_bulk_promo_step1_quantity": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 1 из 4:</b> Количество промокодов\n\nВведите количество промокодов для создания (1-1000):",
   "admin_bulk_promo_step2_bonus_days": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 2 из 4:</b> Бонусные дни\n\nКоличество: <b>{quantity}</b>\n\nВведите количество бонусных дней (1-365):",
   "admin_bulk_promo_step3_max_activations": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 3 из 4:</b> Максимальные активации\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций для каждого промокода (1-10000):",
   "admin_bulk_promo_step4_validity": "📦 <b>Массовое создание промокодов</b>\n\n<b>Шаг 4 из 4:</b> Срок действия\n\nКоличество: <b>{quantity}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокодов:",
-  
   "admin_bulk_promo_invalid_quantity": "❌ Количество должно быть от 1 до 1000",
-  "admin_bulk_promo_invalid_bonus_days": "❌ Бонусные дни должны быть от 1 до 365",
-  "admin_bulk_promo_invalid_max_activations": "❌ Максимальные активации должны быть от 1 до 10000",
-  
-  "admin_bulk_promo_unlimited_validity": "♾️ Неограниченно",
-  "admin_bulk_promo_set_validity": "⏰ Установить срок",
   "admin_bulk_promo_enter_validity_days": "⏰ Введите количество дней действия промокодов (1-365):",
-  
   "admin_bulk_promo_creating": "⏳ Создаю {quantity} промокодов...",
-  
   "admin_promo_step1_code": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 1 из 4:</b> Код промокода\n\nВведите код промокода (3-30 символов, только буквы и цифры):",
   "admin_promo_step2_bonus_days": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 2 из 4:</b> Бонусные дни\n\nКод: <b>{code}</b>\n\nВведите количество бонусных дней (1-365):",
   "admin_promo_step3_max_activations": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 3 из 4:</b> Максимальные активации\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\n\nВведите максимальное количество активаций (1-10000):",
   "admin_promo_step4_validity": "🎟 <b>Создание промокода</b>\n\n<b>Шаг 4 из 4:</b> Срок действия\n\nКод: <b>{code}</b>\nБонусные дни: <b>{bonus_days}</b>\nМакс. активации: <b>{max_activations}</b>\n\nВыберите срок действия промокода:",
-  
   "admin_promo_code_already_exists": "❌ Промокод с таким кодом уже существует",
-  "admin_promo_processing_error": "❌ Ошибка обработки промокода",
   "admin_promo_unlimited_validity": "♾️ Неограниченно",
-  "admin_promo_set_validity": "⏰ Установить срок",
   "admin_promo_enter_validity_days": "⏰ Введите количество дней действия промокода (1-365):",
-  "admin_promo_skip_description": "⏭️ Пропустить",
-  "admin_promo_description_too_long": "❌ Описание не должно превышать 200 символов",
-  "admin_promo_creating": "⏳ Создаю промокод...",
-  
-  "admin_panel_back_button": "⬅️ Назад",
-  "admin_bulk_promo_creation_failed": "❌ Ошибка создания промокодов: {error}",
-  
   "admin_user_id_label": "🆔 <b>ID:</b>",
   "admin_user_name_label": "👤 <b>Имя:</b>",
   "admin_user_username_label": "📱 <b>Username:</b>",
@@ -437,7 +327,6 @@
   "admin_user_traffic_label": "📊 <b>Трафик:</b>",
   "admin_user_subscription_label": "💼 <b>Подписка:</b>",
   "admin_user_trial_label": "🏡 <b>Триал:</b>",
-  
   "admin_user_status_banned": "🚫 Заблокирован",
   "admin_user_status_active": "✅ Активен",
   "admin_user_trial_used": "Использовал",
@@ -445,20 +334,12 @@
   "admin_user_ban_action_banned": "заблокирован",
   "admin_user_ban_action_unbanned": "разблокирован",
   "admin_user_na_value": "N/A",
-  
-  "admin_user_subscription_active": "Активна до {end_date}",
-  "admin_user_subscription_expired": "Истекла {end_date}",
   "admin_user_subscription_none": "Нет активной подписки",
-  
-  "admin_user_logs_count": "Всего записей: {count}",
-  "admin_user_logs_entry": "📅 {timestamp}\n📝 {event_type}: {content}",
-  
   "admin_user_actions_count_label": "📜 <b>Всего действий:</b>",
+  "admin_user_invited_friends_label": "👥 <b>Приглашено друзей:</b>",
+  "admin_user_ref_purchased_label": "💳 <b>Купили подписку:</b>",
   "admin_user_subscription_active_until": "⏰ <b>Действует до:</b>",
   "admin_user_subscription_error": "Ошибка загрузки",
-  
-  "admin_bulk_promo_unique_generation_failed": "Не удалось создать уникальный промокод",
-  
   "admin_promo_management_button": "🎟 Управление промокодами",
   "admin_promo_management_title": "🎟 <b>Управление промокодами</b>\n\nВыберите промокод для детального просмотра:",
   "admin_promo_management_empty": "📭 Промокоды отсутствуют",
@@ -479,43 +360,28 @@
   "admin_promo_view_activations_button": "📋 Активации",
   "admin_promo_back_to_list_button": "⬅️ К списку",
   "admin_promo_toggle_success": "✅ Промокод {code} {status}",
-  "admin_promo_toggle_failed": "❌ Ошибка изменения статуса промокода",
   "admin_promo_no_activations": "📋 <b>Активации промокода: {code}</b>\n\n❌ Активаций не найдено",
   "admin_promo_activations_header": "📋 <b>Активации промокода: {code}</b>\n\n",
   "admin_promo_activation_item": "👤 User ID: <b>{user_id}</b>\n📅 Дата: <b>{date}</b>\n",
   "admin_promo_back_to_detail_button": "⬅️ К промокоду",
-  
   "admin_panel_online_label": "Онлайн",
   "admin_panel_active_label": "Активных",
   "admin_panel_disabled_label": "Отключенных",
-  "admin_panel_offline_label": "Офлайн", 
   "admin_panel_expired_label": "Истекшие",
   "admin_panel_limited_label": "Ограниченные",
   "admin_panel_total_users_label": "Всего пользователей",
-  "admin_panel_cpu_usage_label": "Загрузка CPU",
   "admin_panel_memory_usage_label": "Использование RAM",
-  "admin_panel_traffic_today_label": "Трафик сегодня",
   "admin_panel_traffic_week_label": "Трафик за неделю",
   "admin_panel_traffic_month_label": "Трафик за месяц",
   "admin_panel_nodes_label": "Активных нод",
   "admin_panel_system_stats_error": "Ошибка получения системной статистики",
   "admin_panel_bandwidth_stats_error": "Ошибка получения статистики трафика",
-  "admin_panel_nodes_stats_error": "Ошибка получения статистики нод",
   "admin_panel_stats_fetch_error": "Ошибка получения данных с панели",
   "admin_panel_stats_error_details": "Детали",
-  
-  "inline_referral_message": "🚀 Привет! Попробуй этот VPN - быстрый, надёжный и доступный!\n\n🎁 По моей ссылке тебе дадут бонусные дни к подписке!\n\n{referral_link}",
   "inline_referral_title": "Реферальная ссылка",
   "inline_referral_description": "Поделиться реферальной ссылкой для получения бонусов",
-  "inline_stats_title": "Статистика бота",
-  "inline_stats_description": "Всего: {total}, Активных: {active}",
-  "inline_financial_title": "Финансовая статистика",
   "inline_financial_description": "Сегодня: {today} RUB",
-  "inline_system_title": "Системная статистика",
   "inline_system_description": "🟢 Онлайн: {online}, 📊 Активных: {active}",
-  "inline_admin_help_title": "Помощь по командам",
-  "inline_admin_help_description": "Доступны команды: реф, стат, финансы, система",
-  
   "admin_user_stats_total_label": "Всего",
   "admin_user_stats_paid_subs_label": "С платной подпиской",
   "admin_user_stats_trial_label": "На пробном периоде",
@@ -527,9 +393,66 @@
   "admin_financial_month_label": "За месяц",
   "admin_financial_all_time_label": "За все время",
   "admin_financial_payments_label": "платежей",
-
   "admin_sync_details": "📊 Статистика синхронизации:\n🔍 Проверено записей панели: {panel_records_checked}\n👥 Найдено пользователей в БД: {users_found_in_db}\n✨ Создано новых пользователей: {users_created}\n🔄 Пользователей обновлено: {users_updated}\n📋 Подписок синхронизировано: {subscriptions_synced_count}\n   ├── Создано новых: {subscriptions_created}\n   └── Обновлено существующих: {subscriptions_updated}{additional_stats}",
   "admin_sync_no_telegram_id": "\n⚠️ Записей без telegramId: {count}",
   "admin_sync_not_found_in_db": "\n❌ Не найдено в БД: {count}",
-  "admin_sync_errors": "\n🚫 Ошибок: {count}"
+  "admin_payments_pagination_info": "📊 Показано {shown} из {total} платежей (стр. {current_page}/{total_pages})",
+  "my_subscription_details": "🔐 <b>Моя подписка</b>\n\n⏰ Статус: <b>{status}</b>\n📅 Действует до: <b>{end_date}</b>\n📆 Осталось дней: <b>{days_left}</b>\n\n🔗 Ссылка на конфигурацию:\n<code>{config_link}</code>\n\n📊 Трафик:\nЛимит: <b>{traffic_limit}</b>\nИспользовано: <b>{traffic_used}</b>",
+  "autorenew_enable_button": "🔄 Включить автопродление",
+  "autorenew_disable_button": "🛑 Отключить автопродление",
+  "subscription_autorenew_updated": "Настройки автопродления обновлены.",
+  "payment_methods_manage_button": "💳 Способы оплаты",
+  "payment_methods_title": "💳 <b>Способы оплаты</b>",
+  "payment_method_bind_button": "➕ Добавить способ",
+  "payment_method_delete_button": "🗑 Удалить",
+  "payment_method_view_button": "ℹ️ Детали",
+  "payment_method_none": "У вас пока нет сохранённого способа оплаты.",
+  "payment_method_bound_success": "✅ Способ оплаты добавлен.",
+  "payment_method_deleted_success": "✅ Способ оплаты удалён.",
+  "payment_method_delete_confirm": "Удалить сохранённый способ оплаты?",
+  "payment_method_card_title": "💳 {network} ••••{last4}",
+  "payment_method_generic_title": "💳 {network}",
+  "payment_method_wallet_title": "💼 Кошелёк YooMoney ••••{last4}",
+  "payment_network_card": "Карта",
+  "payment_network_generic": "Способ оплаты",
+  "payment_method_added_at": "Добавлена: {date}",
+  "payment_method_last_tx": "Последняя операция: {date}",
+  "payment_method_tx_history_title": "📜 История операций",
+  "payment_method_no_history": "История операций отсутствует.",
+  "subscription_purchase_title": "Покупка подписки на {months} мес.",
+  "subscription_tribute_notice": "Оплачено через Tribute. Продление делайте по ссылке Tribute.",
+  "subscription_tribute_notice_with_link": "Оплачено через Tribute. Продлить: {link}",
+  "subscription_autorenew_not_supported_for_tribute": "Автопродление управляется Tribute. Управляйте продлением в приложении/ссылке Tribute.",
+  "subscription_not_active": "У вас нет активной подписки.",
+  "error_service_unavailable": "Сервис недоступен. Попробуйте позже.",
+  "error_payment_gateway": "Ошибка платежного сервиса. Попробуйте позже.",
+  "traffic_na": "N/A",
+  "payment_service_unavailable": "Платежный сервис недоступен.",
+  "payment_service_unavailable_alert": "Платежный сервис недоступен. Попробуйте позже.",
+  "error_creating_payment_record": "Ошибка создания записи платежа. Попробуйте позже.",
+  "error_payment_gateway_link_failed": "Ошибка создания платежной ссылки. Попробуйте позже.",
+  "status_active": "Активна",
+  "status_inactive": "Неактивна",
+  "admin_ads_section": "📈 Реклама",
+  "admin_ads_header": "📈 Рекламные кампании:",
+  "admin_ads_empty": "📭 Рекламные кампании отсутствуют. Нажмите \"Создать\" чтобы добавить новую.",
+  "admin_ads_item": "ID: {id}\nИсточник: <b>{source}</b>\nstart={start_param}\nСтоимость: {cost} RUB\nАктивна: {active}\n— Запустили: {starts}\n— Взяли триал: {trials}\n— Оплатили: {payers}\n— Доход: {revenue} RUB",
+  "admin_ads_create_button": "➕ Создать кампанию",
+  "admin_ads_create_source_prompt": "Введите источник (например: AEZA, VK, TG-канал):",
+  "admin_ads_create_start_param_prompt": "Введите параметр старт-ссылки (например: AEZA). Будет использован как start=AEZA",
+  "admin_ads_create_cost_prompt": "Введите сумму затрат на кампанию (в RUB):",
+  "admin_ads_invalid_source": "❌ Неверный источник. Введите до 64 символов.",
+  "admin_ads_invalid_start_param": "❌ Неверный параметр. Допустимы буквы/цифры/подчёркивания/дефисы (2-64).",
+  "admin_ads_invalid_cost": "❌ Неверная сумма. Введите неотрицательное число.",
+  "admin_ads_start_param_exists": "❌ Кампания с таким start-параметром уже существует.",
+  "admin_ads_created_success": "✅ Кампания создана!\nID: {id}\nИсточник: {source}\nПараметр: {start_param}\nЗатраты: {cost} RUB",
+  "admin_ads_back_to_menu_hint": "Готово. Вернуться к разделу рекламы:",
+  "admin_ads_overview": "📈 <b>Реклама</b>\n💰 Пришло: <b>{revenue} RUB</b>\n💸 Потрачено: <b>{cost} RUB</b>",
+  "back_to_ads_list_button": "⬅️ К списку",
+  "admin_ads_card": "📈 <b>Кампания #{id}</b>\nИсточник: <b>{source}</b>\nstart=<code>{start_param}</code>\nСтоимость: <b>{cost} RUB</b>\nАктивна: {active}\n\n👥 Запустили: <b>{starts}</b>\n🆓 Взяли триал: <b>{trials}</b>\n💳 Оплатили: <b>{payers}</b>\n💵 Доход: <b>{revenue} RUB</b>",
+  "admin_ads_delete_button": "🗑 Удалить кампанию",
+  "admin_ads_delete_confirm": "Вы уверены, что хотите удалить кампанию #{id}? Это действие необратимо.",
+  "admin_ads_deleted_success": "Кампания удалена.",
+  "admin_ads_not_found": "Кампания не найдена.",
+  "free_kassa_order_full": "Заказ №{order_id} от {date}\n\n"
 }