Merge pull request #2861 from BEDOLAGA-DEV/release-please--branches--main

chore(main): release 3.45.2
2026-04-08 18:46:58 +03:00 · 2026-04-08 15:44:09 +00:00 · 2026-04-08 18:42:47 +03:00 · 2026-04-08 18:33:17 +03:00 · 2026-04-07 15:49:54 +03:00 · 2026-04-07 15:49:20 +03:00
300 changed files with 28608 additions and 12202 deletions
@@ -13,6 +13,11 @@ SUPPORT_USERNAME=@support
 # Имя пользователя бота (опционально, автоопределяется)
 # BOT_USERNAME=

+# ===== SOCKS5 ПРОКСИ =====
+# URL SOCKS5 прокси-сервера для маршрутизации трафика бота к Telegram API
+# Формат: socks5://user:password@host:port или socks5://host:port
+# PROXY_URL=socks5://127.0.0.1:1080
+
 # ===== СИСТЕМА ПОДДЕРЖКИ =====
 # Включить меню поддержки в интерфейсе
 SUPPORT_MENU_ENABLED=true
@@ -194,6 +199,9 @@ REMNAWAVE_WEBHOOK_PATH=/remnawave-webhook
 # Сгенерируйте: openssl rand -hex 32
 # ВАЖНО: этот же секрет указывается в панели Remnawave при создании вебхука
 REMNAWAVE_WEBHOOK_SECRET=
+# Уведомления администраторам о потере/восстановлении связи с нодами
+# false = не отправлять события node.connection_lost / node.connection_restored
+REMNAWAVE_WEBHOOK_NOTIFY_NODE_CONNECTION_STATUS=true

 # ===== УВЕДОМЛЕНИЯ ОТ ВЕБХУКОВ (что получают пользователи) =====
 # Глобальный переключатель уведомлений пользователям от вебхуков
@@ -491,16 +499,11 @@ YOOKASSA_WEBHOOK_PORT=8082
 YOOKASSA_MIN_AMOUNT_KOPEKS=5000
 YOOKASSA_MAX_AMOUNT_KOPEKS=1000000

-# Быстрый выбор суммы пополнения через YooKassa
-YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED=true
-
 # Рекуррентные платежи YooKassa (автосохранение карты для автоплатежей)
 YOOKASSA_RECURRENT_ENABLED=false
 # true = карта сохраняется обязательно, false = пользователь решает (чекбокс на стороне YooKassa)
 YOOKASSA_RECURRENT_REQUIRED=true

-# Отключить отображение кнопок выбора суммы пополнения (оставить только ввод вручную)
-DISABLE_TOPUP_BUTTONS=false
 # Отключить пополнение баланса через поддержку
 SUPPORT_TOPUP_ENABLED=true

@@ -519,6 +522,7 @@ NALOGO_STORAGE_PATH=./nalogo_tokens.json  # Путь к файлу с токен
 NALOGO_QUEUE_CHECK_INTERVAL=300           # Интервал проверки очереди чеков (секунды)
 NALOGO_QUEUE_RECEIPT_DELAY=3              # Задержка между отправкой чеков (секунды)
 NALOGO_QUEUE_MAX_ATTEMPTS=10              # Максимум попыток отправки одного чека
+# NALOGO_PROXY_URL=socks5://127.0.0.1:1080  # SOCKS прокси для nalog.ru (если не задан — используется PROXY_URL)

 # ===== НАСТРОЙКИ ОПИСАНИЙ ПЛАТЕЖЕЙ =====
 # Эти настройки позволяют изменить описания платежей,
@@ -610,7 +614,7 @@ PLATEGA_RETURN_URL=
 PLATEGA_FAILED_URL=
 PLATEGA_CURRENCY=RUB
 # Список ID активных методов из кабинета Platega (через запятую)
-PLATEGA_ACTIVE_METHODS=2,10,11,12,13
+PLATEGA_ACTIVE_METHODS=2,11,12,13
 PLATEGA_MIN_AMOUNT_KOPEKS=100
 PLATEGA_MAX_AMOUNT_KOPEKS=100000000
 PLATEGA_WEBHOOK_PATH=/platega-webhook
@@ -1,3 +1,3 @@
 {
-  ".": "3.32.4"
+  ".": "3.45.2"
 }
@@ -1,5 +1,495 @@
 # Changelog

+## [3.45.2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.45.1...v3.45.2) (2026-04-08)
+
+
+### Bug Fixes
+
+* batch bug fixes from user complaints ([31adcfd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/31adcfded4b161bf515d4d6b25b4395e543208f4))
+* batch bug fixes from user complaints ([78f963b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/78f963bf5e7b3439d7614584c4041f88be5beb4a))
+* исправление парсинга черного списка (поддержка '#' и извлечение username) ([357d94d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/357d94d1b0d7fc8036b00cbb6b75175c29821751))
+* исправление парсинга черного списка (поддержка '#' и извлечение username) ([2f71846](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f7184627a0fb598a8c0208905cdecf0e4bb04a7))
+
+## [3.45.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.45.0...v3.45.1) (2026-04-03)
+
+
+### Bug Fixes
+
+* add missing WEBHOOK_TORRENT_DETECTED mapping + dedup before uniq… ([4165eae](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4165eaea7adfdaf683b1ece16c8c93a9c4ed216d))
+* add missing WEBHOOK_TORRENT_DETECTED mapping + dedup before unique index in migration 0053 ([3b5d5a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3b5d5a18a1122ef50868fd038a09109d17795a74))
+
+## [3.45.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.44.0...v3.45.0) (2026-04-03)
+
+
+### New Features
+
+* send torrent blocker notification to user (not just admin) ([2f9d003](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f9d00343bee2980cc89bd24361259073b97127a))
+
+
+### Bug Fixes
+
+* resolve multiple subscription bugs — LIMITED status, trial tariff blocking, traffic reset strategy, classic mode pricing, 100% discount support ([9b7ac47](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9b7ac47f16076e546da62062ff7ce18d7c308988))
+* restore missing import + rewrite user.deleted webhook to properly deactivate all subscriptions ([819f09a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/819f09a68ec95237294bae97f31c644044a3623f))
+* subscription system bugfixes + torrent notifications + user deletion cleanup ([7d24e8d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7d24e8d7047c7a3a1c417e655a6fbccbe5ae577d))
+
+## [3.44.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.43.1...v3.44.0) (2026-04-02)
+
+
+### New Features
+
+* add SberPay as KassaAI sub-method (payment_system_id=43) ([9d63635](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9d636355026ad1e50d045e78ffa21e76cfef0774))
+
+
+### Bug Fixes
+
+* address review issues in PR [#2829](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/issues/2829) webhook intentional deletion guard ([977950b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/977950b97f07eecf089152d3f4e678fda373e1e6))
+* autopay failure notifications ignoring 6h cooldown ([991f0b4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/991f0b43e1e73446690a4fbec7c5c5642ac8c406))
+* middleware disables panel VPN for all subs ignoring per-channel settings ([f284351](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f284351c51a6843db0771a92338ec770d5f0d8d2))
+* NameError in SeverPay guest payment flow ([2d42152](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2d42152f5491b14cc45388e0ffccf8a61848a2f6))
+* notification sent for non-deactivated subs + webhook race condition ([b04157c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b04157c91327d9031e9f603a6ad33c708e27d753))
+* Pal24 card/sbp option not passed to API in cabinet balance topup ([6713921](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/67139218878dca3e75974eb5b5a2ce91d5b1438e))
+* prevent nested state saves and None state loss in promo handler ([b607993](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b607993854d1374e7d7c2afbb7fe5cc8824732f5))
+* promo code activation destroys balance input FSM state ([2466590](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/246659032de812f1d4502029ab139f3104237d5c))
+* remove non-existent Platega method code 10, rename 11 to Карты (RUB) ([033d0da](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/033d0da5e0033a2310431586a291b529e3ccb89a))
+* send telegram_id@telegram.org as email to Kassa AI ([3dc72b0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3dc72b00e751a69966d2d5830492c82e055b72e6))
+* send telegram_id@telegram.org as email to SeverPay ([08ca947](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/08ca947b2b2bb29782c86e7b5d6bea71e2811751))
+
+## [3.43.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.43.0...v3.43.1) (2026-03-31)
+
+
+### Bug Fixes
+
+* prevent MissingGreenlet on subscription.tariff lazy load in webhook handlers ([72170b3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72170b35f5d2af56aa7dcb579a70ecf6af2da3f6))
+* use subscription-level remnawave_uuid in multi-tariff mode for sync and detail pages ([0c284b9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0c284b9e9941b516170fc68a3f63551096cb5a7b))
+
+
+### Documentation
+
+* add Platega partnership to README, highlight partner payment providers ([312cc72](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/312cc728a9321fe9ac90cf1f5201e38465f67f16))
+
+## [3.43.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.42.0...v3.43.0) (2026-03-29)
+
+
+### New Features
+
+* add Remnawave panel 2.7.0 API support ([565c083](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/565c08366bdc1d3dcaba89a8522360e1e4d8c2d8))
+* add SeverPay support to cabinet balance top-up ([092b9f6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/092b9f63b24e8129a8e6f9ac0040f19a35514295))
+* add subscription_id to admin sync endpoints for multi-tariff ([54a19a9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/54a19a9c50d58affd1cd8bc897e360318744e28d))
+* add tariff identification to all notifications for multi-tariff mode ([7dd67e3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7dd67e36b3a8a408239ec53d0ae2cc230dfd726c))
+* add tariff_id to promo codes for trial subscription type ([63e4296](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/63e4296197d7943914267f503782e46befc151d4))
+* **api:** expose email field in UserResponse ([23d1830](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/23d1830644be6ab71da629465604cbb296fa7c02))
+* DELETE /subscriptions/:id for expired/disabled subscriptions ([c27f144](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c27f144b76ad392c5d6909f8f62cb2b065515eed))
+* expose MULTI_TARIFF_ENABLED and MAX_ACTIVE_SUBSCRIPTIONS in admin settings ([2628012](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2628012097893ec93cfcb2b8fe190183cfe53a3b))
+* expose per-inbound traffic breakdown in nodes realtime API ([5d173c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5d173c806af1e3c31854ae92b194016984cfd80e))
+* include countryEmoji and providerName in realtime metrics ([b59c581](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b59c581e916e4f6511514463e149a03cc4fb6f8f))
+* multi-subscription support ([1099c52](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1099c5224c07b4ddc17397b0200f64f22fbf8520))
+* multi-subscription support (1 user = N subscriptions) ([335be66](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/335be66980bfefae9d39e8f549fb4df1780ce3d0))
+* return is_daily and is_daily_paused in subscription list API ([4dd8170](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4dd81702ceb5ee9ff46af16249d0dd145da2e3b6))
+* support email/OAuth users in referral editing and add remove endpoints ([7f60196](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7f60196033fa48f093edd06da8f2162936c76162))
+* trial lifecycle + purchase-options filter for multi-tariff ([048d208](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/048d208bc1aa188c16fc4e01de836e9f1553b561))
+* wheel subscription picker for multi-tariff mode ([24edfb6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/24edfb6c3f83726aff0a7b4566da5762ceb10d72))
+
+
+### Bug Fixes
+
+* accept subscription_id from query param in renew endpoint (consistent with other endpoints) ([824d54b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/824d54b7dc97a7a4df8a7f34e078e3ff018df442))
+* account linking broken in multi-tariff mode (MULTI_TARIFF_ENABLED=true) ([2c12a47](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2c12a4773c8b0614a06acaf5bcef2784cc211a5a))
+* account merge no longer nulls transferred subscriptions' remnawave_uuid ([b0273dc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b0273dc8aeecbbdd3a72c41c885492026f0aea58))
+* add missing ADMIN_PAYMENTS localization keys for ru and en ([4f76f53](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4f76f53d55588387251b80de6ac878589299817e))
+* add period_days validation and zero-price guard to tariff purchase ([cefdfc5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cefdfc54cc8baea3b4e36740d6913b74a8072b6a))
+* add redirect_slashes=False to prevent HTTP 307 redirects on subscription endpoints ([f7f8ea8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f7f8ea87cfd5b182e7e395a9aa95c37bd40e165c))
+* add selectinload for GuestPurchase.user/tariff in gift activation ([84357a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/84357a1e8715cb176191eace7d019544175822f4))
+* add tariff identification to remaining notification gaps ([cddb8d6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cddb8d63326e2849d674de64b2da508103d5922f))
+* add_traffic handler passes FSM state to resolve_subscription for multi-tariff context ([684f286](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/684f286fcd9d2c29b1c02d5fc7c9ebf5631f4878))
+* address remaining review issues in device limit patch ([9726145](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/972614511fb10d2cad91e0b8a52cac4c634fc6d7))
+* address review issues in device limit patch ([34aec03](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34aec0323bd78ff159c9e84bdcf584051b3b0fd4))
+* admin handlers use _resolve_admin_subscription + per-subscription UUID ([147ef6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/147ef6b22b9518fc806939aba435f81121828641))
+* admin panel per-subscription UUID in multi-tariff mode ([56fffc2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/56fffc241572ec1d59370bfdb01945877e34e5a0))
+* admin server/devices/traffic buttons pass subscription_id in multi-tariff ([9a27e6d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9a27e6db3110e171a9cac02728a21cd4a002e9b1))
+* admin tariff purchase now creates separate RemnaWave user per tariff ([95ba739](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/95ba73995820ac5c154226a370979437809d3f8c))
+* assign promo group from tariff on guest purchase ([da11ec6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/da11ec6f946e6a439111c31c6e5387dab4167303))
+* async tariff loading in promocode serialization ([3bec662](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3bec6620b67f0dfe7926a030ee98ef0f08e5673e))
+* auto-purchase processes each autopay subscription independently ([f89e326](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f89e326a19f37ec2189fe01814cd3a4cf69c4d02))
+* back button in subscriptions list uses correct callback ([382e29d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/382e29d3dd20cca8f231e444181703bf72c45c86))
+* back buttons in devices/traffic return to subscription detail in multi-tariff ([319941d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/319941d33a43552c09ba5fb95e1a165dd1603999))
+* block classic subscription renewal/autopay when tariff mode enabled ([cd6913c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cd6913cb849ccefe2b36de786068890c8117b1d8))
+* block legacy subscription renewal bypass in tariff mode ([78209c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/78209c862320ef030134ac7e77c57229b5701cfd))
+* cabinet admin create subscription now creates new RemnaWave user in multi-tariff mode ([31c67d1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/31c67d15657d88df24ba490e0d47a9c3104883af))
+* cabinet purchase_tariff — handle IntegrityError with compensating refund ([1bc2581](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1bc2581669ecc3b47b12283c7fb6988bbe34cb28))
+* cabinet routes use smart subscription fallback + per-subscription UUID ([f83ff26](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f83ff26332c8057f5cbb1725f1d5db74e23af9bf))
+* centralize trial cleanup in CRUD + shared subscription resolver for bot ([355fef8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/355fef846e786b638fdcf8823fc077ace89e8615))
+* comprehensive multi-subscription audit fixes across routes, handlers, and services ([d071269](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d071269b8c4df08f91b3a94e09d3a37686082f8a))
+* comprehensive tariff switch/extend/back button fixes for multi-tariff ([e42bddb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e42bddb868414aec8df55c071adab63a88b30696))
+* contest prize applies to best non-daily subscription in multi-tariff ([d2bbeb8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d2bbeb8624ca1320b38a300de0417f64747a6286))
+* daily tariff switch uses _resolve_subscription instead of searching by new tariff_id ([4e12ab3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4e12ab3458c1c73ed4ffe62ca8688ff917a64e4c))
+* delete subscription from RemnaWave panel + prevent phantom webhook notifications ([a12ffb1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a12ffb1d6c30bc2d73888f5c352c12fc3d0fd95c))
+* device limit decrease, HWID pagination, tariff max enforcement ([931eeb3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/931eeb35689532a892e14bc76a05fea1a8f2cec3))
+* devices button shows menu with buy + manage options in multi-tariff ([f925efb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f925efbfb47de8dc8e5932eab629ee6beb7c61e2))
+* disable redirect_slashes globally to prevent HTTP 307 on subscription endpoints ([06feb3f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/06feb3fff589616b6cf78a2cdf6ba5c33cca7794))
+* distinguish cabinet gift notifications from landing page ([48eaa6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/48eaa6b0724a3f881d144abc723fa8373ee9a67f))
+* eligibility and display use best non-daily subscription in multi-tariff ([76ba19d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/76ba19da175553597599fcbcc8513221078e01f6))
+* fix MiniApp renewal options 500 error for legacy subscriptions ([aa36549](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aa36549bb3bc1e04362750b7eecee23f9ba99d88))
+* gift code activation and multi-tariff subscription sync ([f93c51a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f93c51a6773e706a6fc6f9b6016868e181400762))
+* harden node info display against injection and type errors ([6d167d2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d167d292266a660f0d6fd906db3cdea84e8c9cf))
+* harden webhook signature verification across all payment providers ([8295880](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82958801b5179ff5703e6d11b3b0b30f74581eeb))
+* import Subscription in wheel_service to fix NameError ([34bb87c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34bb87c7baf34b4d9c0c09a6b3fe2b76378d9a66))
+* improve UX for legacy users migrating to tariff mode ([f6f330d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f6f330db4a2e6aa5d14a616b9fd2365577f928a1))
+* load buyer relationship before gift notification, clean up recipient logic ([adb39c6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/adb39c6ef46507966482cdceed8ba03e861285ee))
+* multi-subscription support for promocodes, contests, phantom merge ([6d468e9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d468e9adacc8c111cdb5145dc048f7eea6e93e4))
+* multi-subscription UUID resolution and ownership validation ([d87fb47](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d87fb47e886eebb3a1e75b1dae1982230f7bac72))
+* multi-tariff code review — 13 critical/high bugs fixed across 14 files ([5724906](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/57249065178900a8626181556119464c7d55fd74))
+* multi-tariff MEDIUM/LOW batch — 20 issues across 17 files ([94ed282](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/94ed282381fcc71efdef8b55c2e566b2fcd92c2c))
+* multi-tariff Stage 2 critical fixes — panel sync, guest purchase, cart isolation ([4259ba1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4259ba1cb57020314f478d7efc78c915fce9e9b6))
+* multi-tariff Stage 2 HIGH fixes — 18 issues across 12 files ([c6bedc6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c6bedc6a061cd6ff2010f1345d6bae42e4282fbd))
+* multi-tariff Stage 3 critical fixes — panel sync UUID, admin grant, wheel ([49db5f5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/49db5f5eedb452aac7b12739ce735abb8c3b99d2))
+* multi-tariff Stage 3 HIGH fixes — phantom, cart, yookassa, auto-extend ([aa7e461](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aa7e461c4451fc477ac9a1714c8e2243fe12ba49))
+* multi-tariff Stage 4 critical fixes — keyboards, guest purchase, monitoring, tariff deletion ([a49e52c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a49e52cc92819b10d1d4afc823cf98b534a84a0f))
+* multi-tariff Stage 5 fixes — auth sync, notifications, cart, race guard ([948e479](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/948e4791f49a0626100af8ada29da8b605392566))
+* multi-tariff sync auto-links legacy user-level UUIDs to subscriptions ([dbe247b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/dbe247ba6f8cea2ccb845ceb1cfd87d76d47dc52))
+* notifications include tariff name for multi-subscription clarity ([05d1ae0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/05d1ae0560f63627c17b629d476088ce21398863))
+* parse_bytes now handles IEC units (GiB, MiB, KiB) from API ([1471320](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/147132060659e828b005160003d5bff1a565e280))
+* pass FSM state to _resolve_subscription across all subscription handlers ([90fb0a2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/90fb0a21e227d46ed5624051d8185a1e026b0806))
+* pass sub_id to show_devices_page to fix NameError in multi-tariff ([59d4b35](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/59d4b353a6456fc40682239df441b23bc8d63f6d))
+* persist referral to Redis on /start to prevent loss when user opens miniapp ([6d9bd99](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6d9bd9915cda01d819b4c3db02115777c8cb7500))
+* post-payment keyboard checks all subscriptions instead of LIMIT 1 ([25b853d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/25b853d629f9581a9f7871142751dcb2b1e73d3a))
+* prevent sync from overwriting wrong subscription traffic in multi-tariff mode ([78a7eaf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/78a7eafcb65a175dd8f5ded304138ebd8c47acd8))
+* prevent sync/from-panel cross-subscription data mismatch ([960aa44](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/960aa44b007b454f94403cedf98033c9a2c60dec))
+* promocode system broken in multi-tariff mode ([3cbe09d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3cbe09ddd54bec6568b49fbd2ed961649160d21f))
+* re-fetch subscription after lock_user_for_pricing to prevent selectinload reset ([71082f4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/71082f436c6a49409b84e84a367e6059abea850e))
+* remnawave service uses per-subscription UUID throughout multi-tariff ([afd7b6d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/afd7b6d7ec777fd380b43c77da55d3114ff837d7))
+* RemnaWave sync finds user by Subscription.remnawave_uuid in multi-tariff ([c3c2b81](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c3c2b8137b5b8e656b0368742e55a99c4d6a3ec3))
+* remove unused imports and variables after rebase ([b6cf361](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b6cf361737653f7601515126b2e2d073a8a5ca0f))
+* remove user.subscription setter - use local variable instead ([2f88b07](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f88b07f05cb568c6a6f0bde9c7b7e91d4309d66))
+* remove UUID fallback override in admin_tariffs + restore promo on IntegrityError ([a232d21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a232d21edd9714082a7943f9e23db4241f188d66))
+* rename refresh('subscription') to refresh('subscriptions') in all files ([e99f3d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e99f3d9a374b1ab32bbefd8be2036aa185e50f5c))
+* renewal handlers use _resolve_subscription + store subscription_id in FSM ([87bf65c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/87bf65c8097d270a139402ab5e976b6215735c99))
+* renewal status check, int() safety, daily charge atomicity ([58d899a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/58d899aab89ff41ef86a2c578613a59720fdab31))
+* renumber multi-subscription migrations to avoid conflicts with dev ([5a7b3d5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5a7b3d59627f61b3afc7d23ec08d00d9c07c7f10))
+* resolve MissingGreenlet error on article detail view ([004dac5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/004dac5b7ef76b2b1e98e0ab0f62d9fe7fcbd12b))
+* services use smart subscription selection + per-subscription UUID ([0866c2e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0866c2ea4b3183dc63e5ea88391d83dd03f30428))
+* set is_daily_paused=True when admin cancels/disables daily subscription to prevent auto-resume ([d04f2fc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d04f2fc718d11a4766627fda83bdee3abf7f15ea))
+* show all subscriptions in main menu for multi-tariff mode ([e39c358](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e39c358d5caf00674c8d148757b66d46b15485c2))
+* show subscription picker for traffic/connect buttons with multiple subs ([a39e355](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a39e3554d8b91eac676cf4e3b4cfe6a0dd9caa82))
+* suppress empty reward alerts and clean up referral notifications ([e3d8d21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e3d8d21b662761dca1ffe5938e3ce4d72275be84))
+* tariff purchase shows purchased tariffs and blocks re-buying in multi-tariff ([9644135](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9644135dd7a1c1e951274a73a56ec75fd715fe62))
+* tariff_purchase next() fallbacks use None instead of active_subs[0] in multi-tariff ([72d5bae](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72d5bae531ae04a36fbc44a6803de7f17020f846))
+* test access promo applies to all active subscriptions in multi-tariff ([181ef15](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/181ef1501b31837585958f89631c1aa36b1872a2))
+* transliterate Cyrillic slugs instead of stripping to 'untitled' ([c805cfd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c805cfd6d8335f147991458e42fa8a19121a5126))
+* trial promo extends existing subscription with same tariff ([b8662b8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b8662b8bf6c341f391a25940dea928a043396f04))
+* trial reset in multi-tariff only deletes trial subscriptions, keeps paid ([424fff4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/424fff4ac29e697268eeb57d5b5bacd498c691e8))
+* trial subscription lifecycle — autopay, cleanup on purchase, bonus days ([344852b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/344852b85223b49fc52f1401d63b198e1a8412c5))
+* use '/' instead of empty path in subscription sub-routers ([07ebc43](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/07ebc435cf2544c31e0c55bb543775ffcd252e01))
+* use empty path instead of '/' for multi-tariff list endpoint to avoid 404 ([c8ecec4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c8ecec47a0af59911407d8d5a9d6df3f2afc3fb8))
+* UUID check in servers/tariff_switch, start.py refresh, delegation state passing ([bd46b4c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bd46b4cf6dcd7cd65a42456d741b957a22aa7863))
+* UUID warnings, phantom merge, yookassa validation, contest prize notification ([fe03b58](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fe03b587db96eb365a718e21a0177dd6e6e6a480))
+* validate_and_clean_subscription uses per-subscription UUID in multi-tariff mode, not user-level UUID ([18f31c5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/18f31c565c7c0217ebd2348389466c16dc17fc3f))
+* web API routes use multi-subscription resolution for operations ([a1623d9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a1623d94b119025f59263749eaa727bc910dc467))
+
+
+### Refactoring
+
+* remove dead multi-tariff check in guest purchase activation ([34b5a9a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/34b5a9ab3a0eab8561ddd6930b59b817bc2ef9b4))
+* update remnawave API integration for v2.7.0 ([173cc37](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/173cc374bb8391359d8f54569565f18a82fc28eb))
+
+
+### Documentation
+
+* add Stage 3+4 audit results to multi-tariff review ([6dc5879](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6dc5879ffa7edb77166291fbda9e03fbe532bc2d))
+* update multi-tariff review with Stage 2 full audit results ([40d2ec6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/40d2ec67189064b41774292029a397fde2a1c863))
+
+## [3.42.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.41.0...v3.42.0) (2026-03-23)
+
+
+### New Features
+
+* add managed news categories and tags with DB-backed CRUD ([51392d1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/51392d1918d8e2e94645acfb3a11b8e16776a5d5))
+* add media upload/delete API for news articles ([a0d40ad](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a0d40ad432d858ebfe75485a9597d32e847d5746))
+* add news articles module with admin CRUD and public API ([b932403](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b93240393f739f1243bbbfdd4298b90974b8fa87))
+* enforce single featured news article — unfeature others on toggle/create/update ([b5853ec](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b5853ec3b6769655f8d19914e51fd078ec9edccc))
+* show Platega payment methods inline on main screen ([#2720](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/issues/2720)) ([334db53](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/334db53868ae2f9206fdde97fa575e953a83cbcf))
+
+
+### Bug Fixes
+
+* add explicit File(...) to UploadFile param to fix 422 on media upload ([89bfdc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/89bfdc8ed6bfba48cfcb61083240d5e6e870f49b))
+* add Literal type to SavedMedia and close orphaned PIL Image objects ([ce554cb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ce554cb2a8e606b6060dbf63463e64087a3a7539))
+* add user ID to payment descriptions for all providers and fix tuple bug ([2f19c76](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2f19c76357fe7de1636d65968cb13f784ee47c31))
+* catch DecompressionBombError, hoist MP4 brands to module level ([172924d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/172924df0e1248b27d3f18f6acf23cf115040941))
+* comprehensive html.escape() for all user/admin data in Telegram HTML messages ([9de3490](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9de34900a2a9047ab275c0bbf16fd314eb49a3ec))
+* comprehensive security hardening across payment and API layers ([8175bc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8175bc8bfe56dc564a0783c45226451b695bdbd6))
+* correctly price unlimited traffic (0 GB) in classic subscription mode ([aec04f0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aec04f0085bd9c566bd033b8bb628389ff22bdf6))
+* create uploads subdirectories in Dockerfile for correct permissions ([5ed3780](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5ed3780f830023f7b1940dc96256fd38e3c86f4b))
+* media upload security hardening from 6-agent review ([165d25e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/165d25ef5fc02eecf7c6d703072b6adbe88bfd98))
+* news module security hardening, perf optimizations, bug fixes ([2b91808](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2b91808b0c72381cfb2f4e36eaff69e9102a32ee))
+* phantom user merge on claim failure, referral assignment, account merge hardening ([fad77f8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fad77f8c80a8fdecb0512f0ff91e5ae6d78ec8f3))
+* register categories/tags/media routers before news to avoid route conflict ([d9cda3a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d9cda3a6d67c6249397e3778c1aefc6bdb6d9e4f))
+* reject HEIC as MP4, close UploadFile, narrow exception handling ([7ff73e8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7ff73e8492343be5ed77fad5eea7e730621eac76))
+* remove future annotations breaking UploadFile, harden media URL generation ([0225fa1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0225fa155b7d4f3d1c6572a68651c206b1820db0))
+* replace asyncio.gather with sequential queries on shared session ([3e69efe](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3e69efe5891bbe8869a7feb2320185e14d83dd73))
+* respect per-channel disable_on_leave settings in monitoring service ([958ec48](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/958ec489a2a1d01d19cb6e60f52fb2be56295104))
+* respect X-Forwarded-Proto in media URL generation to prevent mixed content ([fd41009](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fd410096ea7e541d8443ec4336bfd72de63d03d9))
+* restore connected_squads and admin notification on daily subscription resume ([89341ba](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/89341baa6243496d3b24c501e227ed156676c052))
+* simplify 0046 migration downgrade to just drop_table ([015c2da](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/015c2da297e4250ebfa50e32b3c1468c9a2143f3))
+* suppress harmless TelegramBadRequest errors and fix discount promo display ([0fe3c21](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0fe3c217f752ced2e3c3f56b4ab5b4c898ba2d8e))
+* use IF EXISTS in downgrade for FK indexes ([76b1f9b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/76b1f9b036e276646546aa4c89a3fe1d2ee58a40))
+* validate FK existence, add FK indexes, expand video brand whitelist ([f0cdd5d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f0cdd5dc904926b55be390798a71a5427a20949b))
+* validate period_days against tariff in purchase-tariff and auto-purchase ([4660ca5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4660ca5756f5f1ef8033f9202d68612d570ddb1a))
+
+
+### Refactoring
+
+* extract phantom service, replace lightweight merge with execute_merge ([6658af6](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6658af6268c10db170e3eaabc75f857e5c664c3c))
+* simplify referral invite text to single template ([cbe630c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cbe630cab0973d7d71dd72603b114807b237ac84))
+
+## [3.41.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.40.0...v3.41.0) (2026-03-22)
+
+
+### New Features
+
+* add subscription status to referral network graph nodes ([de91d32](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/de91d3282ffa15c0cec60c0d62871d39e7ee4c05))
+* add total subscription revenue to referral network stats ([2bdb764](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2bdb7643f8fd142e99caee0fe989348161377348))
+
+
+### Bug Fixes
+
+* add abs() to all remaining subscription payment sum queries ([1eb4e18](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1eb4e18c1776b2265a48e0b923a0ca4ee057d912))
+* add missing total_subscription_revenue_kopeks in scoped graph early return ([bcc761f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/bcc761f9d3f673bd2b404adf817762058d8e0df4))
+* consider subscription status field in network graph ([454dc93](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/454dc9321bb9405c5ff0ff559ae4ced15533f3af))
+* superadmin role managed exclusively via env config ([e0bedc8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e0bedc8e780a2f91509517110639773e90bb6125))
+* treat expired and limited subscription statuses as inactive in referral network graph ([5ed2f0c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5ed2f0c95842a43ab57220dc05ca346748bd6adb))
+* use abs() for subscription payment amounts in referral network ([056c13b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/056c13bc23e6737f44bbcb802a66b643349f75a9))
+
+
+### Refactoring
+
+* extract _compute_subscription_status shared helper ([8b8f1b9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8b8f1b91f37f829528f785a40e3a9cb98c85e043))
+
+## [3.40.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.39.0...v3.40.0) (2026-03-22)
+
+
+### New Features
+
+* allow inactive tariffs for trial subscription activation ([cce3b0c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cce3b0c13bcbf0b567bd4dcf2670973382e7cab0))
+* custom broadcast buttons and fix home button to use bot menu ([13ea376](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/13ea3768b516337c4e0320120bc60a9acb27a16b))
+
+
+### Bug Fixes
+
+* accept stale Telegram initData to prevent MiniApp auth failures ([4c2cb63](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4c2cb63cf9f71fb392c3723a99e88ca3d02b127d))
+* daily subscription pause not persisting in cabinet and miniapp ([d3c9940](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d3c994083e3b054d02d4911172968c914724d051))
+* handle spurious user.deleted webhooks — preserve active subscriptions and prevent orphaned panel users ([9eab802](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9eab80200006e576967204b52f90bf9866875917))
+* prevent MESSAGE_TOO_LONG in promo groups list ([c307278](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c30727823169159b4b6b61f54897b209ced8dfd2))
+* referral system — self-referral protection, race condition fix, deleted user re-registration ([ed5a92a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ed5a92ab966dac54c15217050eae87f4b05eed62))
+* sanitize email dots in RemnaWave username generation ([6c20858](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6c208581d936f5ab7d6b978baafd50881b8ce9f1))
+* send DISABLED instead of EXPIRED status to RemnaWave API ([79cfcbc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/79cfcbcece3938f2daa83206f96ec1bffd0857e0))
+
+## [3.39.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.38.0...v3.39.0) (2026-03-21)
+
+
+### New Features
+
+* add NaloGO fiscal receipts for code-only gift purchases ([90209eb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/90209ebef1a872665e622124a1898d52eff398e7))
+
+
+### Bug Fixes
+
+* add NaloGO fiscal receipt creation for landing page purchases ([4244962](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/424496233773b4cee4e389a1172e95208b3afeaf))
+* manual admin top-ups missing from sales statistics ([ab43e74](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ab43e74ab7484f8d3517f91e366ea395e1944b99))
+* skip non-JSON payload rows in cryptobot payment index and query ([ba79d03](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ba79d03e389afed972296fe2bc05104aa6b883f3))
+
+## [3.38.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.37.0...v3.38.0) (2026-03-21)
+
+
+### New Features
+
+* add SOCKS proxy support for nalogo (tax service) module ([3c5bf4f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3c5bf4fa22d1cdf144269f4e6ab32a4523c8f1f3))
+
+
+### Bug Fixes
+
+* add diagnostic payload logging in create_user error path ([4990ddf](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4990ddf9e46495b65fc3638ea8d6bed0cbe6b857))
+* retry Remnawave API calls without externalSquadUuid on A039 FK violation ([de00612](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/de006129657ce3dac2b1f2fc0ab1b91e23e44241))
+* sanitize proxy credentials in all nalogo error paths ([3bf3105](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3bf31055e71ff64e6a6d94486bb7f7775ac7dc91))
+
+## [3.37.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.36.1...v3.37.0) (2026-03-21)
+
+
+### New Features
+
+* add SOCKS5 proxy support for Telegram API traffic ([82b6a8b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82b6a8bf707736541b58637b0fc9a84b0c403a6c))
+* broadcast caption validation + landing daily created stats ([d400cd7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d400cd7b49cb18edf8545a5af54009561610218a))
+* expose cabinet_email/password vars in subscription delivered template admin UI ([f82a713](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f82a713110c90494e41f2de9910f5dc60a06962e))
+* include cabinet credentials in subscription delivered email ([fedcf25](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fedcf2569a153ac40699dd5b402208ac86db0fc3))
+* show both bot and cabinet referral links everywhere ([67da390](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/67da3903715e97c0d84d0018efdd74b085ee8720))
+
+
+### Bug Fixes
+
+* default payment_method to BALANCE for bot subscription payments ([226d3f2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/226d3f2766bb0842e5a4aefb1458a9e40389108e))
+* derive income_today from revenue_chart to ensure consistency ([1882909](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1882909b3e60f4959921ae085e909bc91c0756b3))
+* include landing page revenue in dashboard statistics ([c6c1599](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c6c1599e14a8c7033dfa399ff3f2c3ee6d156598))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue ([5f71eaa](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5f71eaa92604faa2c6928994bd32a9c6c8ae7ae5))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue calculations ([13dba5a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/13dba5a303604f8d39e85d1382a4d36225f957ac))
+* include SUBSCRIPTION_PAYMENT in dashboard revenue calculations ([d7f91c8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7f91c83584384ef5d0fc90a28debc722b2db79f))
+* include SUBSCRIPTION_PAYMENT in recent payments today/week totals ([6982d27](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6982d27378d0dbe5c7b37d1491e6c9d0461dffc8))
+* include SUBSCRIPTION_PAYMENT in sales summary and deposits stats ([27ef752](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/27ef75214e73211a68d541f5375ca14275ea86e9))
+* increase landing purchase rate limit from 5 to 30 req/min ([801921f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/801921ff74107daccc17e49a0335c7b133268280))
+* narrow exception handling and fix session leak in gift.py ([3875335](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3875335cd7083115043d22f8726f0d33a225cd10))
+* prevent bootstrap from reactivating revoked superadmin roles ([9dd6b54](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/9dd6b54c6e963d2a842d4ac48c9a463014306ed7))
+* prevent double balance credit on concurrent Platega webhooks ([0e1296e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0e1296e0ea291ee661aa82508d5eb8049ce23cac))
+* prevent double-payment TOCTOU race in all payment providers ([82c79c1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/82c79c130601736cd149350f761dcceacfb7c2db))
+* resolve EmailService stale SMTP config causing NoneType crash on from_email ([2a72dea](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2a72deadd6ac3baea15a8d4ee414d763c16690b0))
+* resolve remaining TOCTOU issues in RioPay, SeverPay and restore paid_at ([afefcc9](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/afefcc9c07a80ecf65871bc2d0fbcfe13ffc24fd))
+
+
+### Refactoring
+
+* centralize Bot instantiation via create_bot() factory ([0a53b85](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0a53b85b8a3193f67e148c0f2bde246cc92f010c))
+
+## [3.36.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.36.0...v3.36.1) (2026-03-20)
+
+
+### Bug Fixes
+
+* handle duplicate admin roles in RBAC bootstrap ([877b1cd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/877b1cde11c462c0cf5692119ca09944476a2fb6))
+* make migration 0042 idempotent for retry_count column ([5faf701](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5faf7015ac043f44366fd2a5e00be19eab76b945))
+
+## [3.36.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.35.0...v3.36.0) (2026-03-20)
+
+
+### New Features
+
+* add media attachment support for admin ticket replies ([69bb399](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/69bb399b63d6e1d761cc5518e6272917fc5a6ae7))
+* add multi-provider recovery, retry_count, amount verification, and indexes ([3d78974](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3d78974af70b360449d9cf634e09a79821cdc7c0))
+* add partner → campaign edges to referral network graph ([01132a7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/01132a7bc77b07eaaaf876c05d639bfed83e5324))
+* add referral network graph visualization admin API ([c08c903](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c08c903e8f94f3730872b19de904ce166ba35b98))
+* add scoped referral network graph with scope selector API ([df086b0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/df086b09c75a9157cdc558fb610b617a2d49deaf))
+* multi-select scope for referral network graph API ([6a4ce3d](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/6a4ce3dd38dc3cf2e9db08322093bfd0b84f1e1c))
+
+
+### Bug Fixes
+
+* address review findings for guest purchase recovery ([57c5c67](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/57c5c679eef987e9bacee1a9d420ac3c0ff69ff7))
+* address review findings for multi-provider recovery ([79c110f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/79c110ff41659ff225164c13690bafc859212d05))
+* allow repeated auto-assignment of promo groups on each purchase ([4a002b7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4a002b7db1bfa8fd1149b0e3dfa469e8912a0e3b))
+* correct revenue calculations in referral network ([c8f4cca](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c8f4cca34053713eb2793bbb82e74cbb9a6f893c))
+* improve referral network query correctness and cleanup ([ac9fcd8](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ac9fcd8d30dd64fdc7363e689e9ffaf03700976e))
+* prevent duplicate promo groups during auto-assignment after purchase ([da7a9cc](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/da7a9cc3c5fd771b932a2bfd154400f6f923a4d1))
+* prevent guest purchases from getting stuck in PENDING/FAILED status ([2781236](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/2781236011942e794949544b9c5422aa8679e5eb))
+* prevent premature commits in promocode promo group operations ([8b26680](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8b2668087b4831c08474846b20591b2158d607fc))
+* propagate exceptions from get_primary_user_promo_group ([3ec9e71](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3ec9e71de7d8d40e969f9ea738455445d04d983a))
+* use 'kassa_ai' base model name for guest metadata patch ([182667e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/182667ecb86f9bbbe87d640865dcbcaadf9e72f6))
+* use base model name for KassaAI guest metadata patch ([b6d4373](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b6d43739337cd2e2cfd61ac33398eb6def5b28b6))
+
+
+### Performance
+
+* add covering indexes for referral network queries ([b5471b7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b5471b7720213c217fc452dc1234a7d3c53447d5))
+
+## [3.35.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.34.1...v3.35.0) (2026-03-18)
+
+
+### New Features
+
+* add user_email to admin payments API response ([7101555](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/7101555da0722d1eacd97f40b6b8c8c3a2327a0c))
+* include manual admin top-ups in sales statistics revenue ([b80eeea](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b80eeea089568c60c20b1ae165b8dbe887bbe378))
+* раздельные топики для админских уведомлений ([e15b18f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e15b18fb41b180e7dd3d65f2f058667be321fe85))
+
+
+### Bug Fixes
+
+* fix Platega and CryptoBot webhook verification ([b40a812](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b40a812f3aa0596bf6c5105008451dd8a17b103f))
+* handle None autopay_days_before in autopayment processing ([f1d4534](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f1d45343e941594d69f71e822ecc9b3a7062f4bf))
+* remove forced white background from custom email template overrides ([cb61014](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cb61014d9c5a89e3aeafb191f1b9826ca1cbf338))
+* undefined currency variable in RioPay payment creation ([5b33534](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5b3353433bc524e3e51f2ae87d26bd162bd9f97b))
+
+## [3.34.1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.34.0...v3.34.1) (2026-03-18)
+
+
+### Bug Fixes
+
+* add null check for subscription in execute_change_devices ([5081deb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5081debee7625954bd7b82f66e09dd58e08e8822))
+* correct CryptoBot webhook signature verification and auto-fill topup amount from cart ([d7ad9d7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7ad9d70330b6ef5599f7a9409cdd16657d61b85))
+* correct RioPay API header case and remove undocumented fields ([1a87d43](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1a87d438fe127a0b62bd6ee59887212869a3cb17))
+* disable quick amount buttons in balance topup ([d0eab3f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d0eab3f7aacf0249ca244f168c96044347c918e3))
+* reset device limit to new tariff base on tariff switch ([aec01ce](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/aec01ce0d4a36da5ddd07b56ca4bd5de04735a0b))
+* sync crypto link from happ.cryptoLink in webhook handlers ([0ceff44](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/0ceff44c30cf11466c4cbe51b520558c51c4af4a))
+
+
+### Refactoring
+
+* remove quick amount buttons feature entirely ([136f29c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/136f29c1eb63778b2b329ed5bf72ab06a4531d0b))
+
+
+### Documentation
+
+* add bot preview screenshot to README ([d7931a2](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/d7931a2afaf272aae74453f2bb6d493593895f67))
+* add cabinet preview screenshot to README ([b032c8f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b032c8f35435ddd592df04d6352097580f5e9837))
+* add icons and list all 14+1 payment providers ([1306c24](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1306c24fa36fd3e812c5bec551a0aca450ca7d2c))
+* add Redis to tech stack ([c14d7ab](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c14d7ab0af2e5dd4f35213b323a97eedcc99af0e))
+* add Redis to tech stack ([e12cc9f](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e12cc9f248764104d538db1daaede9ddd8b77b2d))
+* add WATA partnership block to payments section ([31bdf8a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/31bdf8a0aeba53fcec40358d0a38b8480130a346))
+* increase logo size to 800px ([22e7f15](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/22e7f150b30c35b0419e7923e94c5ebc92c4b61a))
+* redesign README — concise feature showcase, link to docs ([38deb70](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/38deb70f8118d371e36ac92a4417bdb543635fc9))
+* replace header logo with new artwork ([6888822](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/688882237fe3019bb78d5e1d7ad54faf4cd69c09))
+* WATA partnership block with logo and table card ([8d5a002](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/8d5a0029964ba52b40e03ebfe8ab6f4146d3aca9))
+
+## [3.34.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.33.0...v3.34.0) (2026-03-18)
+
+
+### New Features
+
+* добавлен SeverPay в админ-панель и настройки кабинета ([06a00e3](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/06a00e367c303b5426008f38a20393ec4f2e07cd))
+* добавлена интеграция SeverPay для пополнения баланса ([abaf279](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/abaf279533d31994a8a70346627c962b43000c64))
+* поиск платежей в админ-панели с фильтрами и статистикой ([1804c28](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1804c28f0551fbe52883fc36fc4cfcd60d2d6bd6))
+
+
+### Bug Fixes
+
+* remove contains_eager conflicting with selectinload on user relationship ([fddf8ef](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/fddf8ef5ebc8e5176a75a10e92d59165bdabf2e1))
+* добавлен импорт MAX_ALL_TIME_DAYS в admin_payments routes ([ad26832](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/ad268329be45bdd665ce4a6f142e9762a78e55b5))
+* добавлены RioPay и SeverPay в REAL_PAYMENT_METHODS ([f967c29](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f967c29bd7cfe8a66e7e0f492573bb7521fcda22))
+
+## [3.33.0](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.4...v3.33.0) (2026-03-17)
+
+
+### New Features
+
+* add SBP and Card sub-options for KassaAI payment method ([5b722c5](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/5b722c521036befcbbaf6192215f651c2ec9c4fb))
+* add SBP and Card sub-options to kassa_ai payment method ([04419fd](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/04419fdff7dc244eb2c9553ea1501e2de454010b))
+* deep link авторизация в кабинете при блокировке oauth.telegram.org ([322d457](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/322d45765220c854e36ae0b4b862a96d36ae3be8))
+* добавлена поддержка RioPay в кабинете ([3d1fbc7](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3d1fbc70f8add81d4a3561d63dcd46f385bcc6f1))
+* добавлена поддержка RioPay для лендингов и подарков ([04f4e6b](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/04f4e6bf6e9031ef8512a07ab36355111c524319))
+
+
+### Bug Fixes
+
+* add back button to payment amount validation errors ([20eff61](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/20eff6170fb752051022a14fa9d927d59ff1d602))
+* add sync_squads=True to admin tariff change handler ([3f0b24c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3f0b24c1ec82ebfb6fdbc801ed6b493ea09c9a2f))
+* deep link auth security and reliability fixes ([099391e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/099391eb5f24319703f12ae2cb72d93b26164d99))
+* enforce promo group authorization on country/server selection ([641da94](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/641da949a907ade7b870e1a5385fdb71f9e524af))
+* merge phantom users into active accounts on /start ([77f1a76](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/77f1a764d59d68236899ec59c884907d3666d3dd))
+* MissingGreenlet crash after subscription purchase in cabinet ([a80a85c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/a80a85c2a489f397efb4ffb5bd77655420a49adb))
+* MissingGreenlet crash after subscription purchase in cabinet ([1cc687a](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/1cc687ac15ecdf12928e5ce448514c09b6628f65))
+* MissingGreenlet при изменении количества устройств на CLASSIC подписках ([826accb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/826accba519f23a687fcc3d387f727fd31d2a88c))
+* protect external squads from deletion during server sync ([b563796](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/b563796091e83edcc8dfbd6222648b5346f39a9c))
+* review findings — db.commit, isinstance guard, constants, ACTIVE check ([72b5305](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/72b5305b870ae9ecdb2672549b9c153dd8b3f7bc))
+* sub-method enabled check, guest payment provider, silent FSM return ([603b9a1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/603b9a1f4610a5b288d6fba78c98474c439529aa))
+* **subscription:** remove stale extend promo state fields causing NameError ([20a6fa1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/20a6fa1bcf362455623f43838f4ffaaf98b33e76))
+* swap Caddy auth headers — api_key to Authorization, caddy_token to X-Api-Key ([038c34e](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/038c34e52a863d0c5c6993ea785587ba7e0bc61d))
+* sync squads to Remnawave panel on tariff purchase/switch ([c34fdd1](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/c34fdd10a0a22a85a4e29cbf44da2ac5d4a643b3))
+* защита внешних сквадов от удаления при синхронизации серверов ([f84885c](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/f84885cc8aa0c9a70f916076e987284f1f9c3479))
+* исправлен расчёт конверсии в статистике продаж ([3089c17](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/3089c1704b54323b4c2a151d40a5b395a427c658))
+* исправлены проблемы RioPay интеграции после ревью ([4abb8cb](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4abb8cb1a3f21089697199261bcc37e6f6a5c623))
+* миграция Tribute webhook с deprecated user_id на trb_user_id ([9419941](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/94199413c283167edd829b337cf9bec0a5414a54))
+* скрыть плашку верификации email при выключенной верификации ([4966e39](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/4966e39eb9b92967ef92c92ae434ca6cdea80c84))
+
+
+### Refactoring
+
+* deduplicate KassaAI handlers with config dict and shared helpers ([e4bb043](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/e4bb0430fb9cc4f55013767ceda6d1c214bd80a6))
+* move KASSA_AI_SUB_METHODS to service layer, add early enabled checks ([cda2392](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/commit/cda239241122ae1dd02a252b3eadc47453c0c48b))
+
 ## [3.32.4](https://github.com/BEDOLAGA-DEV/remnawave-bedolaga-telegram-bot/compare/v3.32.3...v3.32.4) (2026-03-16)


@@ -19,7 +19,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \

 FROM python:3.13-slim

-ARG VERSION="v3.32.4" # x-release-please-version
+ARG VERSION="v3.45.2" # x-release-please-version
 ARG BUILD_DATE
 ARG VCS_REF

@@ -33,7 +33,8 @@ WORKDIR /app

 COPY --chown=app:app . .

-RUN mkdir -p logs data && chown app:app logs data
+RUN mkdir -p logs data uploads/images uploads/videos uploads/thumbnails && \
+    chown -R app:app logs data uploads

 USER app

@@ -67,6 +67,7 @@ from app.middlewares.blacklist import BlacklistMiddleware
 from app.middlewares.button_stats import ButtonStatsMiddleware
 from app.middlewares.chat_type_filter import ChatTypeFilterMiddleware
 from app.middlewares.context_binding import ContextVarsMiddleware
+from app.middlewares.display_name_restriction import DisplayNameRestrictionMiddleware
 from app.middlewares.global_error import GlobalErrorMiddleware
 from app.middlewares.logging import LoggingMiddleware
 from app.middlewares.maintenance import MaintenanceMiddleware
@@ -96,10 +97,21 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    except Exception as e:
        logger.warning('Кеш не инициализирован', error=e)

-    from aiogram.client.default import DefaultBotProperties
-    from aiogram.enums import ParseMode
+    from app.bot_factory import create_bot

-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
+
+    proxy_url = settings.get_proxy_url()
+    nalogo_proxy_url = settings.get_nalogo_proxy_url()
+
+    if proxy_url or nalogo_proxy_url:
+        from app.utils.proxy import mask_proxy_url
+
+        if proxy_url:
+            logger.info('Proxy configured', proxy_url=mask_proxy_url(proxy_url))
+        if nalogo_proxy_url:
+            source = 'NALOGO_PROXY_URL' if settings.NALOGO_PROXY_URL else 'PROXY_URL (fallback)'
+            logger.info('Nalogo proxy configured', proxy_url=mask_proxy_url(nalogo_proxy_url), source=source)

    maintenance_service.set_bot(bot)
    logger.info('Бот установлен в maintenance_service')
@@ -122,11 +134,11 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    chat_type_filter = ChatTypeFilterMiddleware()
    dp.message.middleware(chat_type_filter)
    dp.callback_query.middleware(chat_type_filter)
+    dp.message.middleware(LoggingMiddleware())
+    dp.callback_query.middleware(LoggingMiddleware())
    dp.message.middleware(GlobalErrorMiddleware())
    dp.callback_query.middleware(GlobalErrorMiddleware())
    dp.pre_checkout_query.middleware(GlobalErrorMiddleware())
-    dp.message.middleware(LoggingMiddleware())
-    dp.callback_query.middleware(LoggingMiddleware())
    dp.message.middleware(MaintenanceMiddleware())
    dp.callback_query.middleware(MaintenanceMiddleware())
    blacklist_middleware = BlacklistMiddleware()
@@ -151,8 +163,12 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
    dp.message.middleware(AuthMiddleware())
    dp.callback_query.middleware(AuthMiddleware())
    dp.pre_checkout_query.middleware(AuthMiddleware())
+    display_name_restriction = DisplayNameRestrictionMiddleware()
+    dp.message.middleware(display_name_restriction)
+    dp.callback_query.middleware(display_name_restriction)
    dp.message.middleware(SubscriptionStatusMiddleware())
    dp.callback_query.middleware(SubscriptionStatusMiddleware())
+    dp.pre_checkout_query.middleware(SubscriptionStatusMiddleware())
    start.register_handlers(dp)
    menu.register_handlers(dp)
    subscription.register_handlers(dp)
@@ -0,0 +1,20 @@
+"""Factory for creating Bot instances with proxy support."""
+
+from aiogram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import ParseMode
+
+from app.config import settings
+
+
+def create_bot(token: str | None = None, **kwargs) -> Bot:
+    """Create a Bot instance with SOCKS5 proxy session if PROXY_URL is configured."""
+    proxy_url = settings.get_proxy_url()
+    session = None
+    if proxy_url:
+        from aiogram.client.session.aiohttp import AiohttpSession
+
+        session = AiohttpSession(proxy=proxy_url)
+
+    kwargs.setdefault('default', DefaultBotProperties(parse_mode=ParseMode.HTML))
+    return Bot(token=token or settings.BOT_TOKEN, session=session, **kwargs)
@@ -49,7 +49,17 @@ def validate_telegram_login_widget(data: dict[str, Any], max_age_seconds: int =
        auth_time = datetime.fromtimestamp(int(auth_date), tz=UTC)
        age = (datetime.now(UTC) - auth_time).total_seconds()
        if age > max_age_seconds or age < -_MAX_CLOCK_SKEW_SECONDS:
+            logger.warning(
+                'Telegram widget auth rejected: too old',
+                age_hours=round(age / 3600, 1),
+                max_age_hours=round(max_age_seconds / 3600, 1),
+            )
            return False
+        if age > 86400:
+            logger.info(
+                'Telegram widget auth accepted with stale auth_date',
+                age_hours=round(age / 3600, 1),
+            )
    except (ValueError, TypeError, OSError):
        return False

@@ -96,7 +106,17 @@ def validate_telegram_init_data(init_data: str, max_age_seconds: int = 86400) ->
            auth_time = datetime.fromtimestamp(int(auth_date), tz=UTC)
            age = (datetime.now(UTC) - auth_time).total_seconds()
            if age > max_age_seconds or age < -_MAX_CLOCK_SKEW_SECONDS:
+                logger.warning(
+                    'Telegram initData rejected: too old',
+                    age_hours=round(age / 3600, 1),
+                    max_age_hours=round(max_age_seconds / 3600, 1),
+                )
                return None
+            if age > 86400:
+                logger.info(
+                    'Telegram initData accepted with stale auth_date (Telegram caching bug)',
+                    age_hours=round(age / 3600, 1),
+                )
        except (ValueError, TypeError, OSError):
            return None

@@ -13,6 +13,10 @@ from .admin_channels import router as admin_channels_router
 from .admin_email_templates import router as admin_email_templates_router
 from .admin_landings import router as admin_landings_router
 from .admin_menu_layout import router as admin_menu_layout_router
+from .admin_news import router as admin_news_router
+from .admin_news_categories import router as admin_news_categories_router
+from .admin_news_media import router as admin_news_media_router
+from .admin_news_tags import router as admin_news_tags_router
 from .admin_partners import router as admin_partners_router
 from .admin_payment_methods import router as admin_payment_methods_router
 from .admin_payments import router as admin_payments_router
@@ -20,6 +24,7 @@ from .admin_pinned_messages import router as admin_pinned_messages_router
 from .admin_policies import router as admin_policies_router
 from .admin_promo_offers import router as admin_promo_offers_router
 from .admin_promocodes import promo_groups_router as admin_promo_groups_router, router as admin_promocodes_router
+from .admin_referral_network import router as admin_referral_network_router
 from .admin_remnawave import router as admin_remnawave_router
 from .admin_roles import router as admin_roles_router
 from .admin_sales_stats import router as admin_sales_stats_router
@@ -41,6 +46,7 @@ from .gift import router as gift_router
 from .info import router as info_router
 from .landing import router as landing_router
 from .media import router as media_router
+from .news import router as news_router
 from .notifications import router as notifications_router
 from .oauth import router as oauth_router
 from .partner_application import router as partner_application_router
@@ -49,6 +55,7 @@ from .promo import router as promo_router
 from .promocode import router as promocode_router
 from .referral import router as referral_router
 from .subscription import router as subscription_router
+from .subscription_modules.multi_tariff import router as multi_tariff_subscription_router
 from .ticket_notifications import (
    admin_router as admin_ticket_notifications_router,
    router as ticket_notifications_router,
@@ -60,7 +67,7 @@ from .withdrawal import router as withdrawal_router


 # Main cabinet router
-router = APIRouter(prefix='/cabinet', tags=['Cabinet'])
+router = APIRouter(prefix='/cabinet', tags=['Cabinet'], redirect_slashes=False)

 # Include all sub-routers
 router.include_router(auth_router)
@@ -68,6 +75,7 @@ router.include_router(oauth_router)
 router.include_router(account_linking_router)
 router.include_router(merge_router)
 router.include_router(subscription_router)
+router.include_router(multi_tariff_subscription_router)
 router.include_router(balance_router)
 router.include_router(referral_router)
 router.include_router(partner_application_router)
@@ -84,6 +92,7 @@ router.include_router(info_router)
 router.include_router(branding_router)
 router.include_router(landing_router)
 router.include_router(media_router)
+router.include_router(news_router)

 # Wheel routes
 router.include_router(wheel_router)
@@ -99,6 +108,7 @@ router.include_router(admin_wheel_router)
 router.include_router(admin_tariffs_router)
 router.include_router(admin_servers_router)
 router.include_router(admin_stats_router)
+router.include_router(admin_referral_network_router)
 router.include_router(admin_sales_stats_router)
 router.include_router(admin_ban_system_router)
 router.include_router(admin_broadcasts_router)
@@ -124,6 +134,12 @@ router.include_router(admin_apps_router)
 router.include_router(admin_roles_router)
 router.include_router(admin_policies_router)
 router.include_router(admin_audit_log_router)
+# Categories/tags/media routers MUST be before the main news router
+# to avoid /admin/news/{article_id} catching /admin/news/categories etc.
+router.include_router(admin_news_categories_router)
+router.include_router(admin_news_tags_router)
+router.include_router(admin_news_media_router)
+router.include_router(admin_news_router)

 # WebSocket route
 router.include_router(websocket_router)
@@ -487,7 +487,8 @@ async def link_telegram(

    if request.init_data:
        # Mini App flow: validate initData
-        user_data = validate_telegram_init_data(request.init_data)
+        # Generous max_age: Telegram Desktop/iOS cache initData with stale auth_date
+        user_data = validate_telegram_init_data(request.init_data, max_age_seconds=86400 * 30)
        if not user_data or not user_data.get('id'):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
@@ -560,7 +561,8 @@ async def link_telegram(
        if request.photo_url is not None:
            widget_data['photo_url'] = request.photo_url

-        if not validate_telegram_login_widget(widget_data):
+        # Generous max_age: Telegram caches auth data with stale auth_date
+        if not validate_telegram_login_widget(widget_data, max_age_seconds=86400 * 30):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail='Invalid or expired Telegram Login Widget data',
@@ -411,6 +411,13 @@ async def create_broadcast(

    media_payload = request.media

+    # Validate caption length for media messages (Telegram limit: 1024 chars)
+    if media_payload and len(message_text) > 1024:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f'Текст слишком длинный для сообщения с медиа. Максимум 1024 символов, сейчас {len(message_text)}. Сократите текст или уберите медиафайл.',
+        )
+
    # Create broadcast record
    broadcast = BroadcastHistory(
        target_type=request.target,
@@ -446,6 +453,7 @@ async def create_broadcast(
        selected_buttons=request.selected_buttons,
        media=media_config,
        initiator_name=admin.username or f'Admin #{admin.id}',
+        custom_buttons=[btn.model_dump() for btn in request.custom_buttons] if request.custom_buttons else None,
    )

    # Start broadcast
@@ -644,6 +652,7 @@ async def create_combined_broadcast(
            selected_buttons=request.selected_buttons,
            media=media_config,
            initiator_name=admin_name,
+            custom_buttons=[btn.model_dump() for btn in request.custom_buttons] if request.custom_buttons else None,
        )

        await broadcast_service.start_broadcast(broadcast.id, telegram_config)
@@ -312,7 +312,7 @@ TEMPLATE_TYPES = [
            'zh': '通过落地页成功付款后发送给买家的邮件',
            'ua': 'Лист покупцю після успішної оплати через лендінг',
        },
-        'context_vars': ['tariff_name', 'period_days', 'cabinet_url'],
+        'context_vars': ['tariff_name', 'period_days', 'cabinet_url', 'cabinet_email', 'cabinet_password'],
    },
    {
        'type': 'guest_activation_required',
@@ -425,6 +425,8 @@ SAMPLE_CONTEXTS: dict[str, dict[str, Any]] = {
        'tariff_name': 'Premium',
        'period_days': 30,
        'cabinet_url': 'https://example.com/cabinet',
+        'cabinet_email': 'user@example.com',
+        'cabinet_password': 'SecurePass123',
    },
    'guest_activation_required': {
        'tariff_name': 'Premium',
@@ -670,8 +672,8 @@ async def preview_template(
    language = data.language if data.language in AVAILABLE_LANGUAGES else 'ru'

    if data.body_html:
-        # Preview custom content wrapped in base template
-        rendered_html = templates_instance._get_base_template(data.body_html, language)
+        # Preview custom content — auto-detects styled vs simple HTML
+        rendered_html = templates_instance._wrap_override_template(data.body_html, language)
        subject = data.subject or notification_type
    else:
        # Preview default template
@@ -483,6 +483,7 @@ class OrderRequest(BaseModel):

 class LandingDailyStat(BaseModel):
    date: str  # YYYY-MM-DD
+    created: int = 0
    purchases: int
    revenue_kopeks: int
    gifts: int
@@ -844,17 +845,35 @@ async def get_landing_stats(
    )
    daily_rows = {str(r.day): r for r in daily_result.all()}

+    # Created per day (all statuses, by created_at)
+    day_created_utc = func.date(func.timezone('UTC', GuestPurchase.created_at))
+    created_result = await db.execute(
+        select(
+            day_created_utc.label('day'),
+            func.count(GuestPurchase.id).label('created'),
+        )
+        .where(
+            GuestPurchase.landing_id == landing_id,
+            GuestPurchase.created_at >= cutoff,
+        )
+        .group_by(day_created_utc)
+        .order_by(day_created_utc)
+    )
+    created_rows = {str(r.day): r.created for r in created_result.all()}
+
    # Fill missing days with zeros
    today = now.date()
    daily_stats: list[LandingDailyStat] = []
    for i in range(_STATS_PERIOD_DAYS, -1, -1):
        day = today - timedelta(days=i)
        day_str = day.isoformat()
+        day_created = created_rows.get(day_str, 0)
        if day_str in daily_rows:
            r = daily_rows[day_str]
            daily_stats.append(
                LandingDailyStat(
                    date=day_str,
+                    created=day_created,
                    purchases=r.purchases,
                    revenue_kopeks=r.revenue_kopeks,
                    gifts=r.gifts,
@@ -864,6 +883,7 @@ async def get_landing_stats(
            daily_stats.append(
                LandingDailyStat(
                    date=day_str,
+                    created=day_created,
                    purchases=0,
                    revenue_kopeks=0,
                    gifts=0,
@@ -897,7 +917,7 @@ async def get_landing_stats(
    ]

    return LandingStatsResponse(
-        total_purchases=total_successful,
+        total_purchases=total_created,
        total_revenue_kopeks=total_revenue_kopeks,
        total_gifts=total_gifts,
        total_regular=total_regular,
@@ -0,0 +1,343 @@
+"""Admin routes for managing news articles in cabinet."""
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news import (
+    create_news_article,
+    delete_news_article,
+    get_all_news,
+    get_all_news_count,
+    get_news_article_by_id,
+    unfeature_all_news,
+    update_news_article,
+)
+from app.database.crud.news_categories import get_category_by_id
+from app.database.crud.news_tags import get_tag_by_id
+from app.database.models import NewsArticle, User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news import (
+    NewsArticleListItem,
+    NewsArticleResponse,
+    NewsCreateRequest,
+    NewsListResponse,
+    NewsToggleResponse,
+    NewsUpdateRequest,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news', tags=['Cabinet Admin News'])
+
+
+def _article_to_detail(article: NewsArticle) -> dict[str, Any]:
+    """Convert NewsArticle ORM instance to full detail dict.
+
+    Expects the ``author`` relationship to be eagerly loaded.
+    """
+    author_name: str | None = None
+    if article.author:
+        author_name = article.author.first_name or article.author.username or f'#{article.author.id}'
+
+    return {
+        'id': article.id,
+        'title': article.title,
+        'slug': article.slug,
+        'content': article.content,
+        'excerpt': article.excerpt,
+        'category': article.category,
+        'category_color': article.category_color,
+        'tag': article.tag,
+        'category_id': article.category_id,
+        'tag_id': article.tag_id,
+        'featured_image_url': article.featured_image_url,
+        'is_published': article.is_published,
+        'is_featured': article.is_featured,
+        'published_at': article.published_at,
+        'read_time_minutes': article.read_time_minutes,
+        'views_count': article.views_count,
+        'author_name': author_name,
+        'created_at': article.created_at,
+        'updated_at': article.updated_at,
+    }
+
+
+@router.get('', response_model=NewsListResponse)
+async def list_all_news(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+    limit: int = Query(50, ge=1, le=200),
+    offset: int = Query(0, ge=0),
+) -> NewsListResponse:
+    """Get all news articles (admin view, includes unpublished)."""
+    try:
+        articles = await get_all_news(db, limit=limit, offset=offset)
+        total = await get_all_news_count(db)
+
+        items = [NewsArticleListItem.model_validate(a) for a in articles]
+
+        return NewsListResponse(items=items, total=total)
+    except HTTPException:
+        raise
+    except Exception:
+        logger.exception('Failed to list all news')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load news articles',
+        )
+
+
+@router.get('/{article_id}', response_model=NewsArticleResponse)
+async def get_article_detail(
+    article_id: int,
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Get a single news article by ID (admin view)."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.post('', response_model=NewsArticleResponse, status_code=status.HTTP_201_CREATED)
+async def create_article(
+    request: NewsCreateRequest,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Create a new news article."""
+    try:
+        # Resolve category from FK -- sync legacy string fields from the managed entity
+        category_name = request.category
+        category_color = request.category_color
+        if request.category_id is not None:
+            cat = await get_category_by_id(db, request.category_id)
+            if not cat:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Category with id={request.category_id} not found',
+                )
+            category_name = cat.name
+            category_color = cat.color
+
+        # Resolve tag from FK -- sync legacy string field from the managed entity
+        tag_name = request.tag
+        if request.tag_id is not None:
+            tag_obj = await get_tag_by_id(db, request.tag_id)
+            if not tag_obj:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Tag with id={request.tag_id} not found',
+                )
+            tag_name = tag_obj.name
+
+        if request.is_featured:
+            await unfeature_all_news(db)
+        article = await create_news_article(
+            db,
+            title=request.title,
+            slug=request.slug,
+            content=request.content,
+            excerpt=request.excerpt,
+            category=category_name,
+            category_color=category_color,
+            tag=tag_name,
+            category_id=request.category_id,
+            tag_id=request.tag_id,
+            featured_image_url=request.featured_image_url,
+            is_published=request.is_published,
+            is_featured=request.is_featured,
+            read_time_minutes=request.read_time_minutes,
+            created_by=admin.id,
+        )
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='An article with this slug already exists',
+        )
+    except Exception:
+        logger.exception('Failed to create news article')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to create article',
+        )
+
+    # Reload with author relationship
+    article = await get_news_article_by_id(db, article.id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to reload article after creation',
+        )
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.put('/{article_id}', response_model=NewsArticleResponse)
+async def update_article(
+    article_id: int,
+    request: NewsUpdateRequest,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Update an existing news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        update_data = request.model_dump(exclude_unset=True)
+
+        # Resolve category from FK -- sync legacy string fields from the managed entity
+        if 'category_id' in update_data and update_data['category_id'] is not None:
+            cat = await get_category_by_id(db, update_data['category_id'])
+            if not cat:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Category with id={update_data["category_id"]} not found',
+                )
+            update_data['category'] = cat.name
+            update_data['category_color'] = cat.color
+
+        # Resolve tag from FK -- sync legacy string field from the managed entity
+        if 'tag_id' in update_data and update_data['tag_id'] is not None:
+            tag_obj = await get_tag_by_id(db, update_data['tag_id'])
+            if not tag_obj:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail=f'Tag with id={update_data["tag_id"]} not found',
+                )
+            update_data['tag'] = tag_obj.name
+
+        if update_data.get('is_featured'):
+            await unfeature_all_news(db)
+        article = await update_news_article(db, article, **update_data)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='An article with this slug already exists',
+        )
+    except Exception:
+        logger.exception('Failed to update news article', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to update article',
+        )
+
+    # Reload with author relationship (update used bulk UPDATE, author not populated)
+    article = await get_news_article_by_id(db, article.id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to reload article after update',
+        )
+    return NewsArticleResponse(**_article_to_detail(article))
+
+
+@router.delete('/{article_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_article(
+    article_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        await delete_news_article(db, article)
+    except Exception:
+        logger.exception('Failed to delete news article', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to delete article',
+        )
+
+
+@router.post('/{article_id}/publish', response_model=NewsToggleResponse)
+async def toggle_publish(
+    article_id: int,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsToggleResponse:
+    """Toggle the published status of a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    new_published = not article.is_published
+
+    update_kwargs: dict[str, Any] = {'is_published': new_published}
+    # Auto-set published_at on first publish
+    if new_published and article.published_at is None:
+        update_kwargs['published_at'] = datetime.now(UTC)
+
+    try:
+        article = await update_news_article(db, article, **update_kwargs)
+        return NewsToggleResponse(
+            id=article.id,
+            is_published=article.is_published,
+            is_featured=article.is_featured,
+            published_at=article.published_at,
+        )
+    except Exception:
+        logger.exception('Failed to toggle publish', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to toggle publish status',
+        )
+
+
+@router.post('/{article_id}/feature', response_model=NewsToggleResponse)
+async def toggle_featured(
+    article_id: int,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsToggleResponse:
+    """Toggle the featured status of a news article."""
+    article = await get_news_article_by_id(db, article_id)
+    if not article:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    try:
+        new_featured = not article.is_featured
+        # Only one article can be featured at a time — unfeature all others first
+        if new_featured:
+            await unfeature_all_news(db)
+        article = await update_news_article(db, article, is_featured=new_featured)
+        return NewsToggleResponse(
+            id=article.id,
+            is_published=article.is_published,
+            is_featured=article.is_featured,
+            published_at=article.published_at,
+        )
+    except Exception:
+        logger.exception('Failed to toggle featured', article_id=article_id)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to toggle featured status',
+        )
@@ -0,0 +1,90 @@
+"""Admin routes for managing news categories."""
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news_categories import (
+    create_category,
+    delete_category,
+    get_all_categories,
+    get_category_by_id,
+    update_category,
+)
+from app.database.models import User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news_categories import NewsCategoryCreate, NewsCategoryResponse, NewsCategoryUpdate
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news/categories', tags=['Cabinet Admin News Categories'])
+
+
+@router.get('', response_model=list[NewsCategoryResponse])
+async def list_categories(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[NewsCategoryResponse]:
+    """Get all news categories."""
+    categories = await get_all_categories(db)
+    return [NewsCategoryResponse.model_validate(c) for c in categories]
+
+
+@router.post('', response_model=NewsCategoryResponse, status_code=status.HTTP_201_CREATED)
+async def create_new_category(
+    request: NewsCategoryCreate,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsCategoryResponse:
+    """Create a new news category."""
+    try:
+        category = await create_category(db, name=request.name, color=request.color)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Category already exists',
+        )
+    return NewsCategoryResponse.model_validate(category)
+
+
+@router.put('/{category_id}', response_model=NewsCategoryResponse)
+async def update_existing_category(
+    category_id: int,
+    request: NewsCategoryUpdate,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsCategoryResponse:
+    """Update an existing news category."""
+    category = await get_category_by_id(db, category_id)
+    if not category:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Category not found',
+        )
+    try:
+        category = await update_category(db, category, **request.model_dump(exclude_unset=True))
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Category name already exists',
+        )
+    return NewsCategoryResponse.model_validate(category)
+
+
+@router.delete('/{category_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_category(
+    category_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news category. Articles using it will have category_id set to NULL."""
+    category = await get_category_by_id(db, category_id)
+    if not category:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Category not found',
+        )
+    await delete_category(db, category)
@@ -0,0 +1,157 @@
+"""Admin routes for managing news article media (images/videos)."""
+
+import asyncio
+import re
+
+import structlog
+from fastapi import APIRouter, Depends, File, HTTPException, Request, UploadFile, status
+from PIL import Image as PILImage
+
+from app.config import settings
+from app.database.models import User
+from app.services.news_media_service import (
+    SavedMedia,
+    delete_media_file,
+    detect_file_type,
+    ensure_upload_dirs,
+    save_image,
+    save_video,
+)
+
+from ..dependencies import require_permission
+from ..schemas.news_media import NewsMediaUploadResponse
+
+
+logger = structlog.get_logger(__name__)
+
+_BYTES_PER_MB = 1024 * 1024
+
+# Only allow UUID-hex filenames with expected extensions (path traversal defense-in-depth).
+# thumb_ prefix is NOT allowed — thumbnails are cleaned up automatically when the main file is deleted.
+_SAFE_FILENAME_RE = re.compile(r'^[0-9a-f]{32}\.(jpg|mp4|webm)$')
+
+router = APIRouter(prefix='/admin/news/media', tags=['Cabinet Admin News Media'])
+
+
+_ALLOWED_SCHEMES = frozenset({'http', 'https'})
+
+
+def _build_media_url(request: Request, relative_path: str) -> str:
+    """Build a full URL for a media file, respecting reverse proxy headers."""
+    proto = request.headers.get('X-Forwarded-Proto', request.url.scheme).split(',')[0].strip()
+    if proto not in _ALLOWED_SCHEMES:
+        proto = 'https'
+    host = request.headers.get('X-Forwarded-Host', request.headers.get('Host', request.url.netloc))
+    host = host.split(',')[0].strip()
+    return f'{proto}://{host}/uploads/{relative_path}'
+
+
+def _build_response(request: Request, saved: SavedMedia) -> NewsMediaUploadResponse:
+    """Convert SavedMedia to API response with full URLs."""
+    thumbnail_url = _build_media_url(request, saved.thumbnail_path) if saved.thumbnail_path else None
+
+    return NewsMediaUploadResponse(
+        url=_build_media_url(request, saved.relative_path),
+        thumbnail_url=thumbnail_url,
+        media_type=saved.media_type,
+        filename=saved.filename,
+        size_bytes=saved.size_bytes,
+        width=saved.width,
+        height=saved.height,
+    )
+
+
+@router.post('/upload', response_model=NewsMediaUploadResponse, status_code=status.HTTP_201_CREATED)
+async def upload_media(
+    request: Request,
+    file: UploadFile = File(...),
+    admin: User = Depends(require_permission('news:edit')),
+) -> NewsMediaUploadResponse:
+    """Upload an image or video for a news article."""
+    # Read with a hard budget to prevent memory exhaustion from huge uploads.
+    # Read slightly over the max allowed size so we can detect oversized files.
+    absolute_max_bytes = settings.MEDIA_MAX_VIDEO_SIZE_MB * _BYTES_PER_MB + 1
+    data = await file.read(absolute_max_bytes)
+    await file.close()
+    if not data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Empty file',
+        )
+
+    if len(data) >= absolute_max_bytes:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f'File too large. Absolute maximum: {settings.MEDIA_MAX_VIDEO_SIZE_MB} MB',
+        )
+
+    # Detect type from magic bytes
+    try:
+        media_type, _ext = detect_file_type(data)
+    except ValueError:
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail='Unsupported file type. Allowed: JPEG, PNG, WebP, MP4, WebM',
+        ) from None
+
+    # Enforce per-type size limits
+    max_size_mb = settings.MEDIA_MAX_IMAGE_SIZE_MB if media_type == 'image' else settings.MEDIA_MAX_VIDEO_SIZE_MB
+    if len(data) > max_size_mb * _BYTES_PER_MB:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail=f'File too large. Maximum size for {media_type}: {max_size_mb} MB',
+        )
+
+    upload_path = settings.get_media_upload_path()
+    await asyncio.to_thread(ensure_upload_dirs, upload_path)
+
+    try:
+        if media_type == 'image':
+            saved = await save_image(
+                data,
+                upload_path,
+                max_dim=settings.MEDIA_IMAGE_MAX_DIMENSION,
+                quality=settings.MEDIA_JPEG_QUALITY,
+            )
+        else:
+            saved = await save_video(data, upload_path)
+    except (ValueError, OSError, PILImage.DecompressionBombError) as exc:
+        logger.warning('Failed to save uploaded media', media_type=media_type, error=str(exc))
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail='Failed to process uploaded file',
+        ) from None
+
+    logger.info(
+        'Media uploaded',
+        filename=saved.filename,
+        media_type=saved.media_type,
+        size_bytes=saved.size_bytes,
+        admin_id=admin.id,
+    )
+
+    return _build_response(request, saved)
+
+
+@router.delete('/{filename}', status_code=status.HTTP_204_NO_CONTENT)
+async def delete_media(
+    filename: str,
+    admin: User = Depends(require_permission('news:delete')),
+) -> None:
+    """Delete a previously uploaded media file."""
+    if not _SAFE_FILENAME_RE.match(filename):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid filename',
+        )
+
+    upload_path = settings.get_media_upload_path()
+
+    deleted = await asyncio.to_thread(delete_media_file, filename, upload_path)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='File not found',
+        )
+
+    logger.info('Media deleted', filename=filename, admin_id=admin.id)
@@ -0,0 +1,90 @@
+"""Admin routes for managing news tags."""
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news_tags import (
+    create_tag,
+    delete_tag,
+    get_all_tags,
+    get_tag_by_id,
+    update_tag,
+)
+from app.database.models import User
+
+from ..dependencies import get_cabinet_db, require_permission
+from ..schemas.news_tags import NewsTagCreate, NewsTagResponse, NewsTagUpdate
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/admin/news/tags', tags=['Cabinet Admin News Tags'])
+
+
+@router.get('', response_model=list[NewsTagResponse])
+async def list_tags(
+    admin: User = Depends(require_permission('news:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[NewsTagResponse]:
+    """Get all news tags."""
+    tags = await get_all_tags(db)
+    return [NewsTagResponse.model_validate(t) for t in tags]
+
+
+@router.post('', response_model=NewsTagResponse, status_code=status.HTTP_201_CREATED)
+async def create_new_tag(
+    request: NewsTagCreate,
+    admin: User = Depends(require_permission('news:create')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsTagResponse:
+    """Create a new news tag."""
+    try:
+        tag = await create_tag(db, name=request.name, color=request.color)
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Tag already exists',
+        )
+    return NewsTagResponse.model_validate(tag)
+
+
+@router.put('/{tag_id}', response_model=NewsTagResponse)
+async def update_existing_tag(
+    tag_id: int,
+    request: NewsTagUpdate,
+    admin: User = Depends(require_permission('news:edit')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsTagResponse:
+    """Update an existing news tag."""
+    tag = await get_tag_by_id(db, tag_id)
+    if not tag:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tag not found',
+        )
+    try:
+        tag = await update_tag(db, tag, **request.model_dump(exclude_unset=True))
+    except IntegrityError:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail='Tag name already exists',
+        )
+    return NewsTagResponse.model_validate(tag)
+
+
+@router.delete('/{tag_id}', status_code=status.HTTP_204_NO_CONTENT)
+async def remove_tag(
+    tag_id: int,
+    admin: User = Depends(require_permission('news:delete')),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> None:
+    """Delete a news tag. Articles using it will have tag_id set to NULL."""
+    tag = await get_tag_by_id(db, tag_id)
+    if not tag:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tag not found',
+        )
+    await delete_tag(db, tag)
@@ -227,8 +227,7 @@ async def approve_application(

    # Notify user about approval
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.config import settings
        from app.services.notification_delivery_service import notification_delivery_service

@@ -240,7 +239,7 @@ async def approve_application(
                tg_message = (
                    f'✅ Ваша заявка на партнёрство одобрена!\nКомиссия: {request.commission_percent}%{comment_text}'
                )
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                try:
                    await notification_delivery_service.notify_partner_approved(
                        user=user,
@@ -280,8 +279,7 @@ async def reject_application(

    # Notify user about rejection
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.config import settings
        from app.services.notification_delivery_service import notification_delivery_service

@@ -291,7 +289,7 @@ async def reject_application(
            if user:
                comment_text = f'\nПричина: {request.comment}' if request.comment else ''
                tg_message = f'❌ Ваша заявка на партнёрство отклонена.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                try:
                    await notification_delivery_service.notify_partner_rejected(
                        user=user,
@@ -1,18 +1,23 @@
 """Admin routes for payment verification in cabinet."""

 import math
-from datetime import datetime
+from datetime import UTC, datetime, timedelta

 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import PaymentMethod, User
+from app.services.payment_search_service import (
+    MAX_ALL_TIME_DAYS,
+    PeriodPreset,
+    SearchParams,
+    StatusFilter,
+    search_payments,
+    search_payments_stats,
+)
 from app.services.payment_service import PaymentService
 from app.services.payment_verification_service import (
    SUPPORTED_MANUAL_CHECK_METHODS,
@@ -54,6 +59,7 @@ class PendingPaymentResponse(BaseModel):
    user_id: int | None = None
    user_telegram_id: int | None = None
    user_username: str | None = None
+    user_email: str | None = None

    class Config:
        from_attributes = True
@@ -87,6 +93,16 @@ class PaymentsStatsResponse(BaseModel):
    by_method: dict


+class SearchStatsResponse(BaseModel):
+    """Statistics for payment search results."""
+
+    total: int
+    pending: int
+    paid: int
+    cancelled: int
+    by_method: dict
+
+
 # ============ Helper functions ============


@@ -241,6 +257,8 @@ def _get_payment_url(record: PendingPayment) -> str | None:
    elif record.method == PaymentMethod.CLOUDPAYMENTS or record.method == PaymentMethod.FREEKASSA:
        payment_url = getattr(payment, 'payment_url', None) or payment_url

+    if payment_url and not payment_url.startswith(('https://', 'http://')):
+        return None
    return payment_url


@@ -265,6 +283,7 @@ def _record_to_response(record: PendingPayment) -> PendingPaymentResponse:
        user_id=record.user.id if record.user else None,
        user_telegram_id=record.user.telegram_id if record.user else None,
        user_username=record.user.username if record.user else None,
+        user_email=record.user.email if record.user else None,
    )


@@ -329,6 +348,140 @@ async def get_payments_stats(
    )


+@router.get('/search', response_model=PendingPaymentListResponse)
+async def search_payments_endpoint(
+    search: str | None = Query(
+        None, max_length=256, description='Search query (invoice, @username, telegram_id, email)'
+    ),
+    status_filter: str = Query('all', description='Status filter: all, pending, paid, cancelled'),
+    method_filter: str | None = Query(None, description='Filter by payment method'),
+    period: str = Query('24h', description='Period preset: 24h, 7d, 30d, all'),
+    date_from: datetime | None = Query(None, description='Custom range start (ISO 8601)'),
+    date_to: datetime | None = Query(None, description='Custom range end (ISO 8601)'),
+    page: int = Query(1, ge=1, description='Page number'),
+    per_page: int = Query(20, ge=1, le=100, description='Items per page'),
+    admin: User = Depends(require_permission('payments:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Search payments across all providers with filters."""
+    try:
+        parsed_status = StatusFilter(status_filter)
+    except ValueError:
+        parsed_status = StatusFilter.ALL
+
+    try:
+        parsed_period = PeriodPreset(period)
+    except ValueError:
+        parsed_period = PeriodPreset.H24
+
+    parsed_method: PaymentMethod | None = None
+    if method_filter:
+        try:
+            parsed_method = PaymentMethod(method_filter)
+        except ValueError:
+            pass
+
+    # Ensure custom dates are timezone-aware
+    if date_from is not None and date_from.tzinfo is None:
+        date_from = date_from.replace(tzinfo=UTC)
+    if date_to is not None and date_to.tzinfo is None:
+        date_to = date_to.replace(tzinfo=UTC)
+
+    # Clamp custom dates to safety limit
+    min_allowed = datetime.now(UTC) - timedelta(days=MAX_ALL_TIME_DAYS)
+    if date_from is not None and date_from < min_allowed:
+        date_from = min_allowed
+    if date_from is not None and date_to is not None and date_from > date_to:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail='date_from must be before date_to')
+
+    params = SearchParams(
+        search=search.strip() if search else None,
+        status_filter=parsed_status,
+        method_filter=parsed_method,
+        period=parsed_period,
+        date_from=date_from,
+        date_to=date_to,
+        page=page,
+        per_page=per_page,
+    )
+
+    page_items, total = await search_payments(db, params)
+    pages = math.ceil(total / per_page) if total > 0 else 1
+    items = [_record_to_response(p) for p in page_items]
+
+    return PendingPaymentListResponse(
+        items=items,
+        total=total,
+        page=page,
+        per_page=per_page,
+        pages=pages,
+    )
+
+
+@router.get('/search/stats', response_model=SearchStatsResponse)
+async def search_payments_stats_endpoint(
+    search: str | None = Query(
+        None, max_length=256, description='Search query (invoice, @username, telegram_id, email)'
+    ),
+    status_filter: str = Query('all', description='Status filter: all, pending, paid, cancelled'),
+    method_filter: str | None = Query(None, description='Filter by payment method'),
+    period: str = Query('24h', description='Period preset: 24h, 7d, 30d, all'),
+    date_from: datetime | None = Query(None, description='Custom range start (ISO 8601)'),
+    date_to: datetime | None = Query(None, description='Custom range end (ISO 8601)'),
+    admin: User = Depends(require_permission('payments:read')),
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Get aggregated statistics for payment search results."""
+    try:
+        parsed_status = StatusFilter(status_filter)
+    except ValueError:
+        parsed_status = StatusFilter.ALL
+
+    try:
+        parsed_period = PeriodPreset(period)
+    except ValueError:
+        parsed_period = PeriodPreset.H24
+
+    parsed_method: PaymentMethod | None = None
+    if method_filter:
+        try:
+            parsed_method = PaymentMethod(method_filter)
+        except ValueError:
+            pass
+
+    # Ensure custom dates are timezone-aware
+    if date_from is not None and date_from.tzinfo is None:
+        date_from = date_from.replace(tzinfo=UTC)
+    if date_to is not None and date_to.tzinfo is None:
+        date_to = date_to.replace(tzinfo=UTC)
+
+    # Clamp custom dates to safety limit
+    min_allowed = datetime.now(UTC) - timedelta(days=MAX_ALL_TIME_DAYS)
+    if date_from is not None and date_from < min_allowed:
+        date_from = min_allowed
+    if date_from is not None and date_to is not None and date_from > date_to:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail='date_from must be before date_to')
+
+    params = SearchParams(
+        search=search.strip() if search else None,
+        status_filter=parsed_status,
+        method_filter=parsed_method,
+        period=parsed_period,
+        date_from=date_from,
+        date_to=date_to,
+    )
+
+    stats = await search_payments_stats(db, params)
+
+    return SearchStatsResponse(
+        total=stats.total,
+        pending=stats.pending,
+        paid=stats.paid,
+        cancelled=stats.cancelled,
+        by_method=stats.by_method or {},
+    )
+
+
@router.get('/{method}/{payment_id}', response_model=PendingPaymentResponse)
 async def get_pending_payment_details(
    method: str,
@@ -342,7 +495,7 @@ async def get_pending_payment_details(
    except ValueError:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f'Invalid payment method: {method}',
+            detail='Invalid payment method',
        )

    record = await get_payment_record(db, payment_method, payment_id)
@@ -369,7 +522,7 @@ async def check_payment_status(
    except ValueError:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f'Invalid payment method: {method}',
+            detail='Invalid payment method',
        )

    # Get current record
@@ -394,7 +547,7 @@ async def check_payment_status(
    old_is_paid = record.is_paid

    # Run manual check
-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
    try:
        payment_service = PaymentService(bot=bot)
        updated = await run_manual_check(db, payment_method, payment_id, payment_service)
@@ -5,13 +5,11 @@ from datetime import UTC, datetime

 import structlog
 from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import PinnedMessage, User
 from app.services.pinned_message_service import (
    broadcast_pinned_message,
@@ -77,10 +75,7 @@ _cached_bot: Bot | None = None
 def _get_bot() -> Bot:
    global _cached_bot
    if _cached_bot is None:
-        _cached_bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        _cached_bot = create_bot()
    return _cached_bot


@@ -4,19 +4,17 @@ from __future__ import annotations

 import asyncio
 from datetime import datetime
-from typing import Any
+from typing import Any, ClassVar

 import structlog
 from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from fastapi import APIRouter, Depends, HTTPException, Query, status
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.crud.discount_offer import (
    count_discount_offers,
    list_discount_offers,
@@ -130,6 +128,20 @@ class PromoOfferBroadcastRequest(BaseModel):
    message_text: str | None = Field(None, description='Custom message text (HTML)')
    button_text: str | None = Field(None, description='Button text')

+    _TARGET_ALIASES: ClassVar[dict[str, str]] = {
+        'no_sub': 'no',
+        'all_users': 'all',
+        'active_subscribers': 'active',
+        'trial_users': 'trial',
+    }
+
+    @validator('target')
+    def normalize_target(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        normalized = value.strip().lower()
+        return cls._TARGET_ALIASES.get(normalized, normalized)
+

 class PromoOfferBroadcastResponse(BaseModel):
    created_offers: int
@@ -369,10 +381,7 @@ async def list_offers(

 def _get_bot() -> Bot:
    """Create bot instance for sending notifications."""
-    return Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    return create_bot()


 def _build_default_promo_message(
@@ -28,6 +28,7 @@ from app.database.crud.promocode import (
    get_promocodes_list,
    update_promocode,
 )
+from app.database.crud.tariff import get_tariff_by_id
 from app.database.models import PromoCode, PromoCodeType, PromoCodeUse, PromoGroup, User

 from ..dependencies import get_cabinet_db, require_permission
@@ -55,6 +56,8 @@ class PromoCodeResponse(BaseModel):
    valid_from: datetime
    valid_until: datetime | None = None
    promo_group_id: int | None = None
+    tariff_id: int | None = None
+    tariff_name: str | None = None
    created_by: int | None = None
    created_at: datetime
    updated_at: datetime
@@ -93,6 +96,7 @@ class PromoCodeCreateRequest(BaseModel):
    is_active: bool = True
    first_purchase_only: bool = False
    promo_group_id: int | None = None
+    tariff_id: int | None = None


 class PromoCodeUpdateRequest(BaseModel):
@@ -106,6 +110,7 @@ class PromoCodeUpdateRequest(BaseModel):
    is_active: bool | None = None
    first_purchase_only: bool | None = None
    promo_group_id: int | None = None
+    tariff_id: int | None = None


 # ============== PromoGroup Schemas ==============
@@ -168,7 +173,12 @@ def _normalize_datetime(value: datetime | None) -> datetime | None:
    return value


-def _serialize_promocode(promocode: PromoCode) -> PromoCodeResponse:
+async def _serialize_promocode(db: AsyncSession, promocode: PromoCode) -> PromoCodeResponse:
+    tariff_name = None
+    if promocode.tariff_id:
+        tariff = await get_tariff_by_id(db, promocode.tariff_id)
+        tariff_name = tariff.name if tariff else None
+
    promo_type = PromoCodeType(promocode.type)
    return PromoCodeResponse(
        id=promocode.id,
@@ -186,6 +196,8 @@ def _serialize_promocode(promocode: PromoCode) -> PromoCodeResponse:
        valid_from=promocode.valid_from,
        valid_until=promocode.valid_until,
        promo_group_id=promocode.promo_group_id,
+        tariff_id=promocode.tariff_id,
+        tariff_name=tariff_name,
        created_by=promocode.created_by,
        created_at=promocode.created_at,
        updated_at=promocode.updated_at,
@@ -315,8 +327,9 @@ async def list_promocodes(
    total = await get_promocodes_count(db, is_active=is_active) or 0
    promocodes = await get_promocodes_list(db, offset=offset, limit=limit, is_active=is_active)

+    serialized = [await _serialize_promocode(db, p) for p in promocodes]
    return PromoCodeListResponse(
-        items=[_serialize_promocode(promocode) for promocode in promocodes],
+        items=serialized,
        total=int(total),
        limit=limit,
        offset=offset,
@@ -335,7 +348,7 @@ async def get_promocode(
        raise HTTPException(status.HTTP_404_NOT_FOUND, 'Promo code not found')

    stats = await get_promocode_statistics(db, promocode_id)
-    base = _serialize_promocode(promocode)
+    base = await _serialize_promocode(db, promocode)
    recent_uses = [_serialize_recent_use(use) for use in stats.get('recent_uses', [])]

    return PromoCodeDetailResponse(
@@ -388,11 +401,13 @@ async def create_promocode_endpoint(
        update_fields['first_purchase_only'] = payload.first_purchase_only
    if payload.promo_group_id is not None:
        update_fields['promo_group_id'] = payload.promo_group_id
+    if payload.tariff_id is not None:
+        update_fields['tariff_id'] = payload.tariff_id

    if update_fields:
        promocode = await update_promocode(db, promocode, **update_fields)

-    return _serialize_promocode(promocode)
+    return await _serialize_promocode(db, promocode)


@router.patch('/{promocode_id}', response_model=PromoCodeResponse)
@@ -446,11 +461,14 @@ async def update_promocode_endpoint(
    if payload.promo_group_id is not None:
        updates['promo_group_id'] = payload.promo_group_id

+    if payload.tariff_id is not None:
+        updates['tariff_id'] = payload.tariff_id if payload.tariff_id != 0 else None
+
    if not updates:
-        return _serialize_promocode(promocode)
+        return await _serialize_promocode(db, promocode)

    promocode = await update_promocode(db, promocode, **updates)
-    return _serialize_promocode(promocode)
+    return await _serialize_promocode(db, promocode)


@router.delete(
@@ -5,6 +5,7 @@ from typing import Any

 import structlog
 from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession

 from app.database.crud.server_squad import (
@@ -129,22 +130,22 @@ def _serialize_node(node_data: dict[str, Any]) -> NodeInfo:
        is_disabled=bool(node_data.get('is_disabled')),
        is_node_online=bool(node_data.get('is_node_online')),
        is_xray_running=bool(node_data.get('is_xray_running')),
-        users_online=node_data.get('users_online'),
+        users_online=node_data.get('users_online', 0),
        traffic_used_bytes=node_data.get('traffic_used_bytes'),
        traffic_limit_bytes=node_data.get('traffic_limit_bytes'),
        last_status_change=_parse_datetime(node_data.get('last_status_change')),
        last_status_message=node_data.get('last_status_message'),
-        xray_uptime=node_data.get('xray_uptime'),
+        xray_uptime=node_data.get('xray_uptime', 0) or 0,
        is_traffic_tracking_active=bool(node_data.get('is_traffic_tracking_active', False)),
        traffic_reset_day=node_data.get('traffic_reset_day'),
        notify_percent=node_data.get('notify_percent'),
        consumption_multiplier=float(node_data.get('consumption_multiplier', 1.0)),
-        cpu_count=node_data.get('cpu_count'),
-        cpu_model=node_data.get('cpu_model'),
-        total_ram=node_data.get('total_ram'),
        created_at=_parse_datetime(node_data.get('created_at')),
        updated_at=_parse_datetime(node_data.get('updated_at')),
        provider_uuid=node_data.get('provider_uuid'),
+        versions=node_data.get('versions'),
+        system=node_data.get('system'),
+        active_plugin_uuid=node_data.get('active_plugin_uuid'),
    )


@@ -208,11 +209,9 @@ async def get_system_statistics(
        users_by_status=stats.get('users_by_status', {}),
        server_info=ServerInfo(
            cpu_cores=server_data.get('cpu_cores', 0),
-            cpu_physical_cores=server_data.get('cpu_physical_cores', 0),
            memory_total=server_data.get('memory_total', 0),
            memory_used=server_data.get('memory_used', 0),
            memory_free=server_data.get('memory_free', 0),
-            memory_available=server_data.get('memory_available', 0),
            uptime_seconds=server_data.get('uptime_seconds', 0),
        ),
        bandwidth=Bandwidth(
@@ -397,15 +396,21 @@ async def perform_node_action(
    )


+class RestartAllNodesPayload(BaseModel):
+    force_restart: bool = False
+
+
@router.post('/nodes/restart-all', response_model=NodeActionResponse)
 async def restart_all_nodes(
+    payload: RestartAllNodesPayload | None = None,
    admin: User = Depends(require_permission('remnawave:manage')),
 ) -> NodeActionResponse:
    """Restart all nodes."""
    service = _get_service()
    _ensure_configured(service)

-    success = await service.restart_all_nodes()
+    force = payload.force_restart if payload else False
+    success = await service.restart_all_nodes(force_restart=force)

    if success:
        logger.info('Admin restarted all nodes', telegram_id=admin.telegram_id)
@@ -4,12 +4,13 @@ from __future__ import annotations

 from datetime import datetime

+import sqlalchemy as sa
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession

-from app.database.crud.rbac import AdminRoleCRUD, UserRoleCRUD
+from app.database.crud.rbac import SUPERADMIN_LEVEL, AdminRoleCRUD, UserRoleCRUD
 from app.database.models import User
 from app.services.permission_service import PERMISSION_REGISTRY, get_all_permissions

@@ -129,21 +130,26 @@ async def _role_to_response(db: AsyncSession, role) -> RoleResponse:


 async def _get_admin_level(db: AsyncSession, admin: User) -> int:
-    """Get the maximum role level of the current admin.
+    """Get the effective management level of the current admin.

-    Legacy config-based admins (ADMIN_IDS) get superadmin level (999+1=1000)
-    so they can manage all roles including level 999.
+    Superadmin-tier users (DB level 999 or legacy ADMIN_IDS) are promoted to
+    level 1000 so they can manage peer Superadmins.  Without this, the ``>=``
+    hierarchy guard would block 999-vs-999 operations.
    """
    from app.config import settings

    _perms, _names, max_level = await UserRoleCRUD.get_user_permissions(db, admin.id)

+    # DB-assigned Superadmins can manage peers
+    if max_level >= SUPERADMIN_LEVEL:
+        max_level = SUPERADMIN_LEVEL + 1
+
    # Legacy config-based admins always get the highest level
    if settings.is_admin(
        telegram_id=admin.telegram_id,
        email=admin.email if admin.email_verified else None,
    ):
-        max_level = max(max_level, 1000)
+        max_level = max(max_level, SUPERADMIN_LEVEL + 1)

    return max_level

@@ -339,6 +345,15 @@ async def update_role(

    update_data = payload.model_dump(exclude_unset=True)

+    # System roles: only permissions can be extended, block is_active/level changes
+    if role.is_system:
+        blocked = {'is_active', 'level'} & update_data.keys()
+        if blocked:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f'Cannot change {", ".join(sorted(blocked))} on a system role',
+            )
+
    # Validate level change
    if 'level' in update_data and update_data['level'] >= admin_level:
        raise HTTPException(
@@ -426,6 +441,14 @@ async def assign_role(
            detail='Role not found',
        )

+    # Superadmin role is managed exclusively via ADMIN_IDS/ADMIN_EMAILS env config
+    if role.level >= SUPERADMIN_LEVEL:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Superadmin role is managed via ADMIN_IDS/ADMIN_EMAILS environment variables. '
+            'Add the user there and restart the bot.',
+        )
+
    admin_level = await _get_admin_level(db, admin)

    # Cannot assign a role with level >= own level
@@ -483,13 +506,11 @@ async def revoke_role(
    admin: User = Depends(require_permission('roles:assign')),
    db: AsyncSession = Depends(get_cabinet_db),
 ):
-    """Revoke a role assignment. Cannot remove the last superadmin."""
-    from sqlalchemy import select as sa_select
-
+    """Revoke a role assignment. Superadmin roles are managed via env config."""
    from app.database.models import UserRole

-    # Load the assignment to check hierarchy
-    result = await db.execute(sa_select(UserRole).where(UserRole.id == assignment_id))
+    # Lock the assignment row (FOR UPDATE held until commit)
+    result = await db.execute(sa.select(UserRole).where(UserRole.id == assignment_id).with_for_update())
    user_role = result.scalar_one_or_none()
    if not user_role:
        raise HTTPException(
@@ -504,6 +525,14 @@ async def revoke_role(
            detail='Associated role not found',
        )

+    # Superadmin role is managed exclusively via env config
+    if role.level >= SUPERADMIN_LEVEL:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Superadmin role is managed via ADMIN_IDS/ADMIN_EMAILS environment variables. '
+            'Remove the user from env and restart the bot.',
+        )
+
    admin_level = await _get_admin_level(db, admin)

    # Cannot revoke a role at or above own level
@@ -513,23 +542,9 @@ async def revoke_role(
            detail='Cannot revoke a role at or above your own level',
        )

-    # Protect last superadmin (level 999)
-    superadmin_level = 999
-    if role.level == superadmin_level:
-        superadmin_count = await UserRoleCRUD.get_superadmin_count(db)
-        if superadmin_count <= 1:
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail='Cannot remove the last superadmin',
-            )
-
-    revoked = await UserRoleCRUD.revoke_role(db, assignment_id)
-    if not revoked:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='Failed to revoke role',
-        )
-
+    # Revoke directly on the locked object (avoid CRUD re-fetch without FOR UPDATE)
+    user_role.is_active = False
+    await db.flush()
    await db.commit()

    logger.info(
@@ -539,4 +554,5 @@ async def revoke_role(
        target_user_id=user_role.user_id,
        role_name=role.name,
    )
+
    return {'message': 'Role revoked', 'assignment_id': assignment_id}
@@ -10,6 +10,7 @@ from sqlalchemy.ext.asyncio import AsyncSession

 from app.database.crud.transaction import REAL_PAYMENT_METHODS
 from app.database.models import (
+    PaymentMethod,
    Subscription,
    SubscriptionConversion,
    SubscriptionStatus,
@@ -87,6 +88,7 @@ class SalesSummary(BaseModel):
    """Summary stats for the top cards."""

    total_revenue_kopeks: int
+    manual_topup_kopeks: int
    active_subscriptions: int
    active_trials: int
    new_trials: int
@@ -110,11 +112,11 @@ async def get_sales_summary(
    try:
        period_start, period_end = _parse_period(days, start_date, end_date)

-        # Total revenue (deposits with real payment methods)
+        # Total revenue (deposits + direct subscription payments with real payment methods)
        revenue_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                    Transaction.is_completed == True,
                    Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
                    Transaction.created_at >= period_start,
@@ -124,6 +126,20 @@ async def get_sales_summary(
        )
        total_revenue = revenue_result.scalar() or 0

+        # Manual top-ups by admins
+        manual_topup_result = await db.execute(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
+                and_(
+                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.is_completed == True,
+                    Transaction.payment_method == PaymentMethod.MANUAL.value,
+                    Transaction.created_at >= period_start,
+                    Transaction.created_at <= period_end,
+                )
+            )
+        )
+        manual_topup = manual_topup_result.scalar() or 0
+
        # Consolidated subscription counts: active paid, active trial, new trials in period
        sub_counts_result = await db.execute(
            select(
@@ -170,6 +186,7 @@ async def get_sales_summary(
        new_trials = row.new_trials or 0

        # Trial-to-paid conversion in period
+        # Method 1: SubscriptionConversion records (only created by some purchase flows)
        conversions_result = await db.execute(
            select(func.count(SubscriptionConversion.id)).where(
                and_(
@@ -178,9 +195,29 @@ async def get_sales_summary(
                )
            )
        )
-        conversions = conversions_result.scalar() or 0
-        # Cap at 100%: conversions from previous periods can exceed current new_trials
-        conversion_rate = min(round((conversions / new_trials * 100), 1), 100.0) if new_trials > 0 else 0.0
+        conversion_records = conversions_result.scalar() or 0
+
+        # Method 2: Users registered in period who have paid (catches all purchase flows)
+        converted_users_result = await db.execute(
+            select(func.count(User.id)).where(
+                and_(
+                    User.created_at >= period_start,
+                    User.created_at <= period_end,
+                    User.has_had_paid_subscription.is_(True),
+                )
+            )
+        )
+        converted_users = converted_users_result.scalar() or 0
+
+        # Use the higher count to catch conversions from all purchase flows
+        conversions = max(conversion_records, converted_users)
+
+        # new_trials only counts REMAINING trials (is_trial=True), but converted users
+        # had is_trial flipped to False. Add conversions back to get total trial starters.
+        total_trial_starters = new_trials + conversions
+        conversion_rate = (
+            min(round((conversions / total_trial_starters * 100), 1), 100.0) if total_trial_starters > 0 else 0.0
+        )

        # Renewals count
        renewals_subquery = (
@@ -209,7 +246,7 @@ async def get_sales_summary(

        # Add-on revenue
        addon_revenue_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                and_(
                    Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
                    Transaction.is_completed == True,
@@ -219,10 +256,11 @@ async def get_sales_summary(
                )
            )
        )
-        addon_revenue = abs(addon_revenue_result.scalar() or 0)
+        addon_revenue = addon_revenue_result.scalar() or 0

        return SalesSummary(
-            total_revenue_kopeks=total_revenue,
+            total_revenue_kopeks=total_revenue + manual_topup,
+            manual_topup_kopeks=manual_topup,
            active_subscriptions=active_subs,
            active_trials=active_trials,
            new_trials=new_trials,
@@ -290,6 +328,7 @@ async def get_trials_stats(
        )
        total_trials = total_result.scalar() or 0

+        # Conversion: SubscriptionConversion records + fallback to has_had_paid_subscription
        conversions_result = await db.execute(
            select(func.count(SubscriptionConversion.id)).where(
                and_(
@@ -298,9 +337,25 @@ async def get_trials_stats(
                )
            )
        )
-        conversions = conversions_result.scalar() or 0
-        # Cap at 100%: conversions from previous periods can exceed current period trials
-        conversion_rate = min(round((conversions / total_trials * 100), 1), 100.0) if total_trials > 0 else 0.0
+        conversion_records = conversions_result.scalar() or 0
+
+        converted_users_result = await db.execute(
+            select(func.count(User.id)).where(
+                and_(
+                    User.created_at >= period_start,
+                    User.created_at <= period_end,
+                    User.has_had_paid_subscription.is_(True),
+                )
+            )
+        )
+        converted_users = converted_users_result.scalar() or 0
+        conversions = max(conversion_records, converted_users)
+
+        # total_trials only counts remaining is_trial=True; add conversions for total starters
+        total_trial_starters = total_trials + conversions
+        conversion_rate = (
+            min(round((conversions / total_trial_starters * 100), 1), 100.0) if total_trial_starters > 0 else 0.0
+        )

        avg_duration_result = await db.execute(
            select(func.avg(SubscriptionConversion.trial_duration_days)).where(
@@ -1022,10 +1077,11 @@ async def get_deposits_stats(
    try:
        period_start, period_end = _parse_period(days, start_date, end_date)

+        methods_with_manual = [*REAL_PAYMENT_METHODS, PaymentMethod.MANUAL.value]
        base_filter = and_(
-            Transaction.type == TransactionType.DEPOSIT.value,
+            Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
            Transaction.is_completed == True,
-            Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
+            Transaction.payment_method.in_(methods_with_manual),
            Transaction.created_at >= period_start,
            Transaction.created_at <= period_end,
        )
@@ -1033,7 +1089,7 @@ async def get_deposits_stats(
        totals_result = await db.execute(
            select(
                func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
            ).where(base_filter)
        )
        totals = totals_result.one()
@@ -1045,11 +1101,11 @@ async def get_deposits_stats(
            select(
                Transaction.payment_method.label('method'),
                func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
            )
            .where(base_filter)
            .group_by(Transaction.payment_method)
-            .order_by(func.sum(Transaction.amount_kopeks).desc())
+            .order_by(func.sum(func.abs(Transaction.amount_kopeks)).desc())
        )
        by_method = [
            DepositByMethodItem(method=row.method or 'unknown', count=row.count, amount_kopeks=row.amount)
@@ -1060,7 +1116,7 @@ async def get_deposits_stats(
            select(
                func.date(Transaction.created_at).label('date'),
                func.count(Transaction.id).label('count'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
            )
            .where(base_filter)
            .group_by(func.date(Transaction.created_at))
@@ -1076,12 +1132,12 @@ async def get_deposits_stats(
        ]

        # Daily deposits grouped by payment method
-        # base_filter already excludes NULLs via .in_(REAL_PAYMENT_METHODS), no coalesce needed
+        # base_filter already excludes NULLs via .in_(methods_with_manual), no coalesce needed
        daily_by_method_query = await db.execute(
            select(
                func.date(Transaction.created_at).label('date'),
                Transaction.payment_method.label('method'),
-                func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount'),
+                func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0).label('amount'),
            )
            .where(base_filter)
            .group_by(func.date(Transaction.created_at), Transaction.payment_method)
@@ -3,6 +3,7 @@
 import sys
 import time
 from datetime import UTC, datetime, timedelta
+from typing import Any

 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
@@ -49,15 +50,11 @@ class NodeStatus(BaseModel):
    is_disabled: bool
    users_online: int
    traffic_used_bytes: int | None = None
-    uptime: str | None = None
-    xray_version: str | None = None
-    node_version: str | None = None
    last_status_message: str | None = None
-    xray_uptime: str | None = None
+    xray_uptime: int = 0
    is_xray_running: bool | None = None
-    cpu_count: int | None = None
-    cpu_model: str | None = None
-    total_ram: str | None = None
+    versions: dict[str, str] | None = None
+    system: dict[str, Any] | None = None
    country_code: str | None = None


@@ -275,6 +272,14 @@ async def get_dashboard_stats(
        # Get tariff statistics
        tariff_stats = await _get_tariff_stats(db)

+        # Derive income_today from revenue_chart to ensure consistency with chart
+        today_str = now.date().isoformat()
+        income_today_from_chart = sum(
+            item.get('amount_kopeks', 0) for item in revenue_data if str(item.get('date', '')) == today_str
+        )
+        # Use chart-derived value if available, otherwise fall back to trans_stats
+        income_today_kopeks = income_today_from_chart or trans_stats.get('today', {}).get('income_kopeks', 0)
+
        # Build response
        return DashboardStats(
            nodes=nodes_data,
@@ -290,8 +295,8 @@ async def get_dashboard_stats(
                trial_to_paid_conversion=sub_stats.get('trial_to_paid_conversion', 0.0),
            ),
            financial=FinancialStats(
-                income_today_kopeks=trans_stats.get('today', {}).get('income_kopeks', 0),
-                income_today_rubles=trans_stats.get('today', {}).get('income_kopeks', 0) / 100,
+                income_today_kopeks=income_today_kopeks,
+                income_today_rubles=income_today_kopeks / 100,
                income_month_kopeks=trans_stats.get('totals', {}).get('income_kopeks', 0),
                income_month_rubles=trans_stats.get('totals', {}).get('income_kopeks', 0) / 100,
                income_total_kopeks=all_time_stats.get('totals', {}).get('income_kopeks', 0),
@@ -461,15 +466,11 @@ async def _get_nodes_overview() -> NodesOverview:
                is_disabled=n.get('is_disabled', False),
                users_online=n.get('users_online', 0) or 0,
                traffic_used_bytes=n.get('traffic_used_bytes'),
-                uptime=n.get('uptime'),
-                xray_version=n.get('xray_version'),
-                node_version=n.get('node_version'),
                last_status_message=n.get('last_status_message'),
-                xray_uptime=n.get('xray_uptime'),
+                xray_uptime=n.get('xray_uptime', 0) or 0,
                is_xray_running=n.get('is_xray_running'),
-                cpu_count=n.get('cpu_count'),
-                cpu_model=n.get('cpu_model'),
-                total_ram=n.get('total_ram'),
+                versions=n.get('versions'),
+                system=n.get('system'),
                country_code=n.get('country_code'),
            )
            for n in nodes
@@ -926,9 +927,9 @@ async def get_recent_payments(
        total_count = total_count_result.scalar() or 0

        today_total_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                    Transaction.is_completed == True,
                    Transaction.created_at >= today_start,
                    Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
@@ -938,9 +939,9 @@ async def get_recent_payments(
        total_today = today_total_result.scalar() or 0

        week_total_result = await db.execute(
-            select(func.coalesce(func.sum(Transaction.amount_kopeks), 0)).where(
+            select(func.coalesce(func.sum(func.abs(Transaction.amount_kopeks)), 0)).where(
                and_(
-                    Transaction.type == TransactionType.DEPOSIT.value,
+                    Transaction.type.in_([TransactionType.DEPOSIT.value, TransactionType.SUBSCRIPTION_PAYMENT.value]),
                    Transaction.is_completed == True,
                    Transaction.created_at >= week_ago,
                    Transaction.payment_method.in_(REAL_PAYMENT_METHODS),
@@ -8,6 +8,7 @@ from sqlalchemy import and_, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload

+from app.config import settings
 from app.database.crud.server_squad import get_all_server_squads
 from app.database.crud.tariff import (
    create_tariff,
@@ -656,7 +657,11 @@ async def _background_sync_squads(tariff_id: int, admin_id: int) -> None:

                async def _sync_one(sub: Subscription) -> None:
                    nonlocal updated, failed
-                    remnawave_uuid = sub.user.remnawave_uuid if sub.user else None
+                    remnawave_uuid = (
+                        getattr(sub, 'remnawave_uuid', None)
+                        if settings.is_multi_tariff_enabled()
+                        else (sub.user.remnawave_uuid if sub.user else None)
+                    )
                    if not remnawave_uuid:
                        return
                    async with semaphore:
@@ -767,7 +772,11 @@ async def sync_tariff_squads(
                skipped_count += 1
                return 'skipped'

-            remnawave_uuid = sub.user.remnawave_uuid if sub.user else None
+            remnawave_uuid = (
+                getattr(sub, 'remnawave_uuid', None)
+                if settings.is_multi_tariff_enabled()
+                else (sub.user.remnawave_uuid if sub.user else None)
+            )
            if not remnawave_uuid:
                skipped_count += 1
                return 'skipped'
@@ -5,7 +5,7 @@ from datetime import UTC, datetime

 import structlog
 from fastapi import APIRouter, Depends, HTTPException, Query, status
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from sqlalchemy import desc, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
@@ -90,6 +90,19 @@ class AdminReplyRequest(BaseModel):
    """Admin reply to ticket."""

    message: str = Field(..., min_length=1, max_length=4000, description='Reply message')
+    media_type: str | None = Field(None, description='Media type: photo, video, or document')
+    media_file_id: str | None = Field(None, max_length=255, description='Telegram file_id from media upload')
+    media_caption: str | None = Field(None, max_length=1000, description='Caption for media')
+
+    @model_validator(mode='after')
+    def validate_media_fields(self) -> 'AdminReplyRequest':
+        if self.media_file_id and not self.media_type:
+            raise ValueError('media_type is required when media_file_id is provided')
+        if self.media_type and not self.media_file_id:
+            raise ValueError('media_file_id is required when media_type is provided')
+        if self.media_type and self.media_type not in {'photo', 'video', 'document'}:
+            raise ValueError('media_type must be one of: photo, video, document')
+        return self


 class AdminStatusUpdateRequest(BaseModel):
@@ -443,11 +456,16 @@ async def reply_to_ticket(
        )

    # Create admin message
+    has_media = bool(request.media_file_id)
    message = TicketMessage(
        ticket_id=ticket.id,
        user_id=ticket.user_id,
        message_text=request.message,
        is_from_admin=True,
+        has_media=has_media,
+        media_type=request.media_type if has_media else None,
+        media_file_id=request.media_file_id if has_media else None,
+        media_caption=request.media_caption if has_media else None,
        created_at=datetime.now(UTC),
    )
    db.add(message)
@@ -461,14 +479,9 @@ async def reply_to_ticket(

    # Try to notify user via Telegram
    try:
-        from aiogram import Bot
-        from aiogram.client.default import DefaultBotProperties
-        from aiogram.enums import ParseMode
+        from app.bot_factory import create_bot

-        bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        bot = create_bot()
        try:
            from app.handlers.admin.tickets import notify_user_about_ticket_reply

@@ -7,16 +7,13 @@ import time
 from datetime import UTC, datetime, timedelta

 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.types import BufferedInputFile
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import and_, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.config import settings
+from app.bot_factory import create_bot
 from app.database.models import Subscription, Transaction, TransactionType, User
 from app.services.remnawave_service import RemnaWaveService

@@ -24,6 +21,8 @@ from ..dependencies import get_cabinet_db, require_permission
 from ..schemas.traffic import (
    ExportCsvRequest,
    ExportCsvResponse,
+    SubscriptionEnrichmentInfo,
+    SubscriptionTrafficInfo,
    TrafficEnrichmentResponse,
    TrafficNodeInfo,
    TrafficUsageResponse,
@@ -159,15 +158,42 @@ def _compute_date_range(period_days: int) -> tuple[str, str]:


 async def _load_user_map(db: AsyncSession) -> dict[str, User]:
-    """Load all users with remnawave_uuid, eagerly loading subscription + tariff."""
-    stmt = (
+    """Load all users with remnawave_uuid, eagerly loading subscription + tariff.
+
+    In multi-tariff mode UUIDs live on Subscription rows, not on User.
+    Both sources are merged so the caller gets a complete uuid → User map.
+    """
+    from app.config import settings
+
+    # Build user map from both user-level and subscription-level UUIDs
+    user_map: dict[str, User] = {}
+
+    # Legacy: user-level UUIDs
+    stmt_users = (
        select(User)
        .where(User.remnawave_uuid.isnot(None))
-        .options(selectinload(User.subscription).selectinload(Subscription.tariff))
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
    )
-    result = await db.execute(stmt)
-    users = result.scalars().all()
-    return {u.remnawave_uuid: u for u in users if u.remnawave_uuid}
+    result_users = await db.execute(stmt_users)
+    users = result_users.scalars().all()
+    for u in users:
+        if u.remnawave_uuid:
+            user_map[u.remnawave_uuid] = u
+
+    # Multi-tariff: subscription-level UUIDs
+    if settings.is_multi_tariff_enabled():
+        stmt_subs = (
+            select(Subscription)
+            .where(Subscription.remnawave_uuid.isnot(None))
+            .options(selectinload(Subscription.user).selectinload(User.subscriptions).selectinload(Subscription.tariff))
+        )
+        result_subs = await db.execute(stmt_subs)
+        subs = result_subs.scalars().all()
+        for sub in subs:
+            if sub.remnawave_uuid and sub.user and sub.remnawave_uuid not in user_map:
+                user_map[sub.remnawave_uuid] = sub.user
+
+    return user_map


 def _build_traffic_items(
@@ -205,19 +231,23 @@ def _build_traffic_items(
            ):
                continue

-        sub = user.subscription
+        subs = getattr(user, 'subscriptions', None) or []
+
+        # Primary subscription for backward-compat top-level fields
+        primary_sub = next((s for s in subs if s.is_active), subs[0] if subs else None)
        tariff_name = None
        subscription_status = None
        traffic_limit_gb = 0.0
        device_limit = 1

-        if sub:
-            subscription_status = _get_status(sub)
-            traffic_limit_gb = float(sub.traffic_limit_gb or 0)
-            device_limit = sub.device_limit or 1
-            if sub.tariff:
-                tariff_name = sub.tariff.name
+        if primary_sub:
+            subscription_status = _get_status(primary_sub)
+            traffic_limit_gb = float(primary_sub.traffic_limit_gb or 0)
+            device_limit = primary_sub.device_limit or 1
+            if primary_sub.tariff:
+                tariff_name = primary_sub.tariff.name

+        # Filtering uses primary sub values (keeps existing filter semantics)
        if tariff_filter is not None:
            if (tariff_name or '') not in tariff_filter:
                continue
@@ -232,6 +262,18 @@ def _build_traffic_items(

        total_bytes = sum(traffic.values())

+        # Build per-subscription detail list for multi-subscription display
+        subscriptions_traffic = [
+            SubscriptionTrafficInfo(
+                subscription_id=sub.id,
+                tariff_name=sub.tariff.name if sub.tariff else None,
+                status=_get_status(sub),
+                traffic_limit_gb=float(sub.traffic_limit_gb or 0),
+                device_limit=sub.device_limit or 1,
+            )
+            for sub in subs
+        ]
+
        items.append(
            UserTrafficItem(
                user_id=user.id,
@@ -245,6 +287,7 @@ def _build_traffic_items(
                device_limit=device_limit,
                node_traffic=traffic,
                total_bytes=total_bytes,
+                subscriptions=subscriptions_traffic,
            )
        )

@@ -308,15 +351,21 @@ async def get_traffic_usage(
    # Collect all available tariff names (before filtering)
    available_tariffs = sorted(
        {
-            u.subscription.tariff.name
+            sub.tariff.name
            for u in user_map.values()
-            if u.subscription and u.subscription.tariff and u.subscription.tariff.name
+            for sub in (getattr(u, 'subscriptions', None) or [])
+            if sub.tariff and sub.tariff.name
        }
    )

    # Collect all available statuses (before filtering)
    available_statuses = sorted(
-        {_get_status(sub) for u in user_map.values() if (sub := u.subscription) and _get_status(sub)}
+        {
+            _get_status(sub)
+            for u in user_map.values()
+            for sub in (getattr(u, 'subscriptions', None) or [])
+            if _get_status(sub)
+        }
    )

    # Parse tariff filter
@@ -469,27 +518,42 @@ async def _build_enrichment(db: AsyncSession, user_map: dict[str, User]) -> dict
    enrichment: dict[int, UserTrafficEnrichment] = {}
    for uuid, user in user_map.items():
        uid = user.id
-        sub = user.subscription
+        subs_list = getattr(user, 'subscriptions', None) or []
+
+        # Primary subscription for backward-compat top-level date fields
+        primary_sub = next((s for s in subs_list if s.is_active), subs_list[0] if subs_list else None)

        start_date = None
        end_date = None
-        if sub:
-            if sub.start_date:
-                start_date = sub.start_date.isoformat()
-            if sub.end_date:
-                end_date = sub.end_date.isoformat()
+        if primary_sub:
+            if primary_sub.start_date:
+                start_date = primary_sub.start_date.isoformat()
+            if primary_sub.end_date:
+                end_date = primary_sub.end_date.isoformat()

        last_node_name = None
        last_uuid = last_node_uuid_by_user.get(uid)
        if last_uuid:
            last_node_name = node_uuid_to_name.get(last_uuid)

+        # Build per-subscription enrichment list for multi-subscription display
+        subscriptions_enrichment = [
+            SubscriptionEnrichmentInfo(
+                subscription_id=sub.id,
+                tariff_name=sub.tariff.name if sub.tariff else None,
+                start_date=sub.start_date.isoformat() if sub.start_date else None,
+                end_date=sub.end_date.isoformat() if sub.end_date else None,
+            )
+            for sub in subs_list
+        ]
+
        enrichment[uid] = UserTrafficEnrichment(
            devices_connected=devices_by_user.get(uid, 0),
            total_spent_kopeks=spending_map.get(uid, 0),
            subscription_start_date=start_date,
            subscription_end_date=end_date,
            last_node_name=last_node_name,
+            subscriptions=subscriptions_enrichment,
        )

    return enrichment
@@ -680,10 +744,7 @@ async def export_traffic_csv(
    filename = f'traffic_usage_{period_label}_{timestamp}.csv'

    try:
-        bot = Bot(
-            token=settings.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-        )
+        bot = create_bot()
        async with bot:
            await bot.send_document(
                chat_id=admin.telegram_id,
@@ -199,8 +199,7 @@ async def approve_withdrawal(

    # Notify user about approval
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.config import settings
        from app.services.notification_delivery_service import notification_delivery_service

@@ -211,7 +210,7 @@ async def approve_withdrawal(
                formatted_amount = settings.format_price(withdrawal.amount_kopeks)
                comment_text = f'\n{request.comment}' if request.comment else ''
                tg_message = f'✅ Ваш запрос на вывод {formatted_amount} одобрен.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                try:
                    await notification_delivery_service.notify_withdrawal_approved(
                        user=user,
@@ -251,8 +250,7 @@ async def reject_withdrawal(

    # Notify user about rejection
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.config import settings
        from app.services.notification_delivery_service import notification_delivery_service

@@ -263,7 +261,7 @@ async def reject_withdrawal(
                formatted_amount = settings.format_price(withdrawal.amount_kopeks)
                comment_text = f'\nПричина: {request.comment}' if request.comment else ''
                tg_message = f'❌ Ваш запрос на вывод {formatted_amount} отклонён.{comment_text}'
-                bot = Bot(token=settings.BOT_TOKEN)
+                bot = create_bot()
                try:
                    await notification_delivery_service.notify_withdrawal_rejected(
                        user=user,
@@ -28,10 +28,16 @@ from app.database.crud.user import (
    set_email_change_pending,
    verify_and_apply_email_change,
 )
-from app.database.models import CabinetRefreshToken, User
+from app.database.models import CabinetRefreshToken, User, UserStatus
 from app.services.campaign_service import AdvertisingCampaignService
 from app.services.disposable_email_service import disposable_email_service
 from app.services.referral_service import process_referral_registration
+from app.services.web_auth_service import (
+    WEB_AUTH_TOKEN_TTL,
+    consume_web_auth_token,
+    create_web_auth_token,
+    poll_web_auth_token,
+)
 from app.utils.cache import RateLimitCache, TokenReplayCache
 from app.utils.timezone import panel_datetime_to_utc

@@ -55,12 +61,15 @@ from ..auth.email_verification import (
    is_token_expired,
 )
 from ..auth.jwt_handler import get_refresh_token_expires_at
+from ..auth.merge_service import create_merge_token
 from ..dependencies import get_cabinet_db, get_current_cabinet_user
 from ..ip_utils import get_client_ip
 from ..schemas.auth import (
    AuthResponse,
    AutoLoginRequest,
    CampaignBonusInfo,
+    DeepLinkPollRequest,
+    DeepLinkTokenResponse,
    EmailChangeRequest,
    EmailChangeResponse,
    EmailChangeVerifyRequest,
@@ -188,12 +197,10 @@ async def _process_campaign_bonus(
            user.referred_by_id = campaign.partner_user_id
            await db.flush()
            try:
-                from aiogram import Bot
-                from aiogram.client.default import DefaultBotProperties
-                from aiogram.enums import ParseMode
+                from app.bot_factory import create_bot

-                bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-                await process_referral_registration(db, user.id, campaign.partner_user_id, bot=bot)
+                async with create_bot() as bot:
+                    await process_referral_registration(db, user.id, campaign.partner_user_id, bot=bot)
                logger.info(
                    'Referral set from campaign partner',
                    user_id=user.id,
@@ -233,11 +240,39 @@ async def _process_referral_code(
    db: AsyncSession,
    user: User,
    referral_code: str | None,
+    *,
+    is_new_user: bool = False,
 ) -> None:
-    """Set referred_by_id for user if referral_code is valid. Never raises."""
-    if not referral_code or user.referred_by_id:
+    """Process referral for a newly created user. Never raises.
+
+    Only applies to new users (is_new_user=True). Existing users cannot be
+    assigned a referrer — same logic as the bot /start handler.
+
+    Handles two cases:
+    - referred_by_id already set by create_user() → fire registration event
+    - referred_by_id not set (resolution failed earlier) → resolve, set, fire
+    """
+    if not referral_code or not is_new_user:
        return
    try:
+        from app.bot_factory import create_bot
+
+        # Lock user row to prevent concurrent referral application (TOCTOU race)
+        await db.execute(select(User).where(User.id == user.id).with_for_update())
+        await db.refresh(user)
+
+        # Case 1: referred_by_id already set by create_user() — just fire the event
+        if user.referred_by_id:
+            async with create_bot() as bot:
+                await process_referral_registration(db, user.id, user.referred_by_id, bot=bot)
+            logger.info(
+                'Referral registration processed for pre-set referrer',
+                user_id=user.id,
+                referrer_id=user.referred_by_id,
+            )
+            return
+
+        # Case 2: referred_by_id not set — resolve referral code and set it
        referrer = await get_user_by_referral_code(db, referral_code)
        if not referrer:
            return
@@ -247,12 +282,9 @@ async def _process_referral_code(
            return
        user.referred_by_id = referrer.id
        await db.flush()
-        from aiogram import Bot
-        from aiogram.client.default import DefaultBotProperties
-        from aiogram.enums import ParseMode

-        bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-        await process_referral_registration(db, user.id, referrer.id, bot=bot)
+        async with create_bot() as bot:
+            await process_referral_registration(db, user.id, referrer.id, bot=bot)
        logger.info('Referral applied from code', user_id=user.id, referrer_id=referrer.id, referral_code=referral_code)
    except Exception as e:
        logger.error('Failed to process referral code', error=e, referral_code=referral_code)
@@ -283,94 +315,123 @@ async def _sync_subscription_from_panel_by_email(db: AsyncSession, user: User) -
                logger.debug('No subscription found in panel for email', email=user.email)
                return

-            # Take first user if multiple found
-            panel_user = panel_users[0]
-            logger.info('Found subscription in panel for email', email=user.email, uuid=panel_user.uuid)
-
-            # Check if another user already owns this remnawave_uuid
-            from app.database.crud.user import get_user_by_remnawave_uuid
-
-            existing_owner = await get_user_by_remnawave_uuid(db, panel_user.uuid)
-            if existing_owner and existing_owner.id != user.id:
-                logger.warning(
-                    'Panel UUID already belongs to another user, skipping sync',
-                    email=user.email,
-                    panel_uuid=panel_user.uuid,
-                    existing_owner_id=existing_owner.id,
-                )
-                return
-
-            # Link user to panel
-            user.remnawave_uuid = panel_user.uuid
-
-            # Create or update subscription
-            from app.database.crud.subscription import get_subscription_by_user_id
+            # In multi-tariff mode, sync ALL panel users (each = one subscription)
+            # In single-tariff mode, process only the first
+            from app.database.crud.subscription import get_active_subscriptions_by_user_id, get_subscription_by_user_id
            from app.database.models import Subscription, SubscriptionStatus

-            existing_sub = await get_subscription_by_user_id(db, user.id)
+            panel_users_to_sync = panel_users if settings.is_multi_tariff_enabled() else panel_users[:1]

-            # Parse panel data — panel returns local time with misleading +00:00 offset
-            expire_at = panel_datetime_to_utc(panel_user.expire_at)
-            traffic_limit_gb = panel_user.traffic_limit_bytes // (1024**3) if panel_user.traffic_limit_bytes > 0 else 0
-            traffic_used_gb = panel_user.used_traffic_bytes / (1024**3) if panel_user.used_traffic_bytes > 0 else 0
+            for panel_user in panel_users_to_sync:
+                logger.info('Syncing panel subscription for email', email=user.email, uuid=panel_user.uuid)

-            # Extract squad UUIDs from active_internal_squads
-            connected_squads = [s.get('uuid', '') for s in (panel_user.active_internal_squads or []) if s.get('uuid')]
+                # Check if another user already owns this remnawave_uuid
+                if settings.is_multi_tariff_enabled():
+                    from sqlalchemy import select as _select

-            # Device limit from panel
-            device_limit = panel_user.hwid_device_limit or 0
+                    from app.database.models import Subscription as _Subscription

-            # Determine status — expire_at is now naive UTC
-            current_time = datetime.now(UTC)
+                    _sub_result = await db.execute(
+                        _select(_Subscription).where(_Subscription.remnawave_uuid == panel_user.uuid)
+                    )
+                    _existing_sub = _sub_result.scalar_one_or_none()
+                    if _existing_sub and _existing_sub.user_id != user.id:
+                        logger.warning(
+                            'Panel UUID already owned by another user subscription, skipping',
+                            email=user.email,
+                            panel_uuid=panel_user.uuid,
+                            existing_owner_id=_existing_sub.user_id,
+                        )
+                        continue
+                else:
+                    from app.database.crud.user import get_user_by_remnawave_uuid

-            if panel_user.status.value == 'ACTIVE' and expire_at > current_time:
-                sub_status = SubscriptionStatus.ACTIVE
-            elif expire_at <= current_time:
-                sub_status = SubscriptionStatus.EXPIRED
-            else:
-                sub_status = SubscriptionStatus.DISABLED
+                    existing_owner = await get_user_by_remnawave_uuid(db, panel_user.uuid)
+                    if existing_owner and existing_owner.id != user.id:
+                        logger.warning(
+                            'Panel UUID already belongs to another user, skipping',
+                            email=user.email,
+                            panel_uuid=panel_user.uuid,
+                            existing_owner_id=existing_owner.id,
+                        )
+                        continue

-            if existing_sub:
-                # Update existing subscription (expire_at already naive UTC)
-                existing_sub.end_date = expire_at
-                existing_sub.traffic_limit_gb = traffic_limit_gb
-                existing_sub.traffic_used_gb = traffic_used_gb
-                existing_sub.status = sub_status.value
-                existing_sub.remnawave_short_uuid = panel_user.short_uuid
-                existing_sub.subscription_url = panel_user.subscription_url
-                existing_sub.subscription_crypto_link = panel_user.happ_crypto_link
-                existing_sub.connected_squads = connected_squads
-                existing_sub.device_limit = device_limit
-                existing_sub.is_trial = False  # Panel subscription is not trial
-                logger.info(
-                    'Updated subscription for email user squads: devices',
-                    email=user.email,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
-                )
-            else:
-                # Create new subscription (expire_at and current_time already naive UTC)
-                new_sub = Subscription(
-                    user_id=user.id,
-                    start_date=current_time,
-                    end_date=expire_at,
-                    traffic_limit_gb=traffic_limit_gb,
-                    traffic_used_gb=traffic_used_gb,
-                    status=sub_status.value,
-                    is_trial=False,
-                    remnawave_short_uuid=panel_user.short_uuid,
-                    subscription_url=panel_user.subscription_url,
-                    subscription_crypto_link=panel_user.happ_crypto_link,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
-                )
-                db.add(new_sub)
-                logger.info(
-                    'Created subscription for email user squads: devices',
-                    email=user.email,
-                    connected_squads=connected_squads,
-                    device_limit=device_limit,
+                # Link user to panel (only in single-tariff mode)
+                if not settings.is_multi_tariff_enabled():
+                    user.remnawave_uuid = panel_user.uuid
+
+                # Find existing subscription
+                if settings.is_multi_tariff_enabled():
+                    active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+                    existing_sub = next(
+                        (s for s in active_subs if s.remnawave_uuid == panel_user.uuid),
+                        None,
+                    )
+                else:
+                    existing_sub = await get_subscription_by_user_id(db, user.id)
+
+                # Parse panel data
+                expire_at = panel_datetime_to_utc(panel_user.expire_at)
+                traffic_limit_gb = (
+                    panel_user.traffic_limit_bytes // (1024**3) if panel_user.traffic_limit_bytes > 0 else 0
                )
+                traffic_used_gb = panel_user.used_traffic_bytes / (1024**3) if panel_user.used_traffic_bytes > 0 else 0
+                connected_squads = [
+                    s.get('uuid', '') for s in (panel_user.active_internal_squads or []) if s.get('uuid')
+                ]
+                device_limit = panel_user.hwid_device_limit or 0
+
+                # Determine status
+                current_time = datetime.now(UTC)
+                if panel_user.status.value == 'ACTIVE' and expire_at > current_time:
+                    sub_status = SubscriptionStatus.ACTIVE
+                elif expire_at <= current_time:
+                    sub_status = SubscriptionStatus.EXPIRED
+                else:
+                    sub_status = SubscriptionStatus.DISABLED
+
+                if existing_sub:
+                    existing_sub.end_date = expire_at
+                    existing_sub.traffic_limit_gb = traffic_limit_gb
+                    existing_sub.traffic_used_gb = traffic_used_gb
+                    existing_sub.status = sub_status.value
+                    existing_sub.remnawave_short_uuid = panel_user.short_uuid
+                    existing_sub.subscription_url = panel_user.subscription_url
+                    existing_sub.subscription_crypto_link = panel_user.happ_crypto_link
+                    existing_sub.connected_squads = connected_squads
+                    existing_sub.device_limit = device_limit
+                    existing_sub.is_trial = False
+                    logger.info(
+                        'Updated subscription for email user',
+                        email=user.email,
+                        uuid=panel_user.uuid,
+                    )
+                else:
+                    from app.database.crud.subscription import generate_unique_short_id
+
+                    _short_id = await generate_unique_short_id(db)
+                    new_sub = Subscription(
+                        user_id=user.id,
+                        start_date=current_time,
+                        end_date=expire_at,
+                        traffic_limit_gb=traffic_limit_gb,
+                        traffic_used_gb=traffic_used_gb,
+                        status=sub_status.value,
+                        is_trial=False,
+                        remnawave_uuid=panel_user.uuid if settings.is_multi_tariff_enabled() else None,
+                        remnawave_short_id=_short_id,
+                        remnawave_short_uuid=panel_user.short_uuid,
+                        subscription_url=panel_user.subscription_url,
+                        subscription_crypto_link=panel_user.happ_crypto_link,
+                        connected_squads=connected_squads,
+                        device_limit=device_limit,
+                    )
+                    db.add(new_sub)
+                    logger.info(
+                        'Created subscription for email user',
+                        email=user.email,
+                        uuid=panel_user.uuid,
+                    )

            await db.commit()

@@ -400,7 +461,11 @@ async def auth_telegram(
            detail='Too many requests',
            headers={'Retry-After': '60'},
        )
-    user_data = validate_telegram_init_data(request.init_data)
+    # Telegram Desktop/iOS cache initData with stale auth_date (known Telegram bug:
+    # https://github.com/telegramdesktop/tdesktop/issues/28303).
+    # Use generous max_age: HMAC signature proves authenticity,
+    # JWT tokens handle actual session expiration after login.
+    user_data = validate_telegram_init_data(request.init_data, max_age_seconds=86400 * 30)

    if not user_data:
        raise HTTPException(
@@ -429,10 +494,35 @@ async def auth_telegram(
        try:
            referrer = await get_user_by_referral_code(db, request.referral_code)
            if referrer:
-                referrer_id = referrer.id
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == telegram_id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=telegram_id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
        except Exception as e:
            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)

+    # Fallback: check Redis for pending referral from /start (user opened cabinet before completing bot registration)
+    if not referrer_id and not user and telegram_id:
+        try:
+            from app.services.referral_service import get_pending_referral
+
+            pending = await get_pending_referral(telegram_id)
+            if pending and pending.get('referrer_id'):
+                referrer_id = pending['referrer_id']
+                logger.info(
+                    'Resolved referral from Redis pending_referral (cabinet)',
+                    telegram_id=telegram_id,
+                    referrer_id=referrer_id,
+                )
+        except Exception as e:
+            logger.warning('Failed to check pending referral', error=e)
+
+    is_new_user = not user
    if not user:
        # Create new user from Telegram initData
        logger.info('Creating new user from cabinet (initData): telegram_id', telegram_id=telegram_id)
@@ -461,7 +551,7 @@ async def auth_telegram(
        if updated:
            logger.info('User profile updated from initData', user_id=user.id)

-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='User account is not active',
@@ -476,8 +566,17 @@ async def auth_telegram(
    # Store refresh token
    await _store_refresh_token(db, user.id, response.refresh_token)

-    # Process referral code (before campaign bonus, which may also set referrer)
-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful user creation with referral
+    if referrer_id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(telegram_id)
+        except Exception:
+            pass

    # Process campaign bonus
    response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
@@ -510,7 +609,8 @@ async def auth_telegram_widget(

    widget_data = request.model_dump(exclude={'campaign_slug', 'referral_code'})

-    if not validate_telegram_login_widget(widget_data):
+    # Generous max_age: Telegram caches auth data with stale auth_date
+    if not validate_telegram_login_widget(widget_data, max_age_seconds=86400 * 30):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail='Invalid or expired Telegram authentication data',
@@ -524,10 +624,19 @@ async def auth_telegram_widget(
        try:
            referrer = await get_user_by_referral_code(db, request.referral_code)
            if referrer:
-                referrer_id = referrer.id
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == request.id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=request.id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
        except Exception as e:
            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)

+    is_new_user = not user
    if not user:
        # Create new user from Telegram data
        logger.info(
@@ -544,7 +653,7 @@ async def auth_telegram_widget(
        )
        logger.info('User created successfully: id=, telegram_id', user_id=user.id, telegram_id=user.telegram_id)

-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='User account is not active',
@@ -564,8 +673,17 @@ async def auth_telegram_widget(
    response = await _create_auth_response(user, db)
    await _store_refresh_token(db, user.id, response.refresh_token)

-    # Process referral code (before campaign bonus, which may also set referrer)
-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful registration
+    if referrer_id and request.id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(request.id)
+        except Exception:
+            pass

    # Process campaign bonus
    response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
@@ -656,10 +774,19 @@ async def auth_telegram_oidc(
        try:
            referrer = await get_user_by_referral_code(db, request.referral_code)
            if referrer:
-                referrer_id = referrer.id
-        except (ValueError, LookupError) as e:
-            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=str(e))
+                # Self-referral protection by telegram_id (user doesn't exist yet, can't compare user.id)
+                if referrer.telegram_id and referrer.telegram_id == telegram_id:
+                    logger.warning(
+                        'Self-referral attempt blocked via telegram_id',
+                        telegram_id=telegram_id,
+                        referral_code=request.referral_code,
+                    )
+                else:
+                    referrer_id = referrer.id
+        except Exception as e:
+            logger.warning('Failed to resolve referral code', referral_code=request.referral_code, error=e)

+    is_new_user = not user
    if not user:
        logger.info('Creating new user from cabinet OIDC', telegram_id=telegram_id, username=username)
        user = await create_user(
@@ -673,7 +800,7 @@ async def auth_telegram_oidc(
        )
        logger.info('User created successfully', user_id=user.id, telegram_id=user.telegram_id)

-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='User account is not active',
@@ -693,7 +820,17 @@ async def auth_telegram_oidc(
    response = await _create_auth_response(user, db)
    await _store_refresh_token(db, user.id, response.refresh_token)

-    await _process_referral_code(db, user, request.referral_code)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
+    await _process_referral_code(db, user, request.referral_code, is_new_user=is_new_user)
+
+    # Clear Redis pending referral after successful registration
+    if referrer_id and telegram_id:
+        try:
+            from app.services.referral_service import clear_pending_referral
+
+            await clear_pending_referral(telegram_id)
+        except Exception:
+            pass

    response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
    if response.campaign_bonus:
@@ -705,6 +842,7 @@ async def auth_telegram_oidc(
@router.post('/email/register')
 async def register_email(
    request: EmailRegisterRequest,
+    raw_request: Request,
    user: User = Depends(get_current_cabinet_user),
    db: AsyncSession = Depends(get_cabinet_db),
 ):
@@ -713,7 +851,24 @@ async def register_email(

    Requires valid JWT token from Telegram authentication.
    Sends verification email to the provided address.
+    If the email belongs to another active user, offers account merge.
    """
+    # Rate limit
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'email_register', limit=5, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    # Check if user already has a verified email — block before doing anything else
+    if user.email and user.email_verified:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='You already have a verified email',
+        )
+
    # Check for disposable email
    if disposable_email_service.is_disposable(request.email):
        raise HTTPException(
@@ -721,21 +876,38 @@ async def register_email(
            detail='Disposable email addresses are not allowed',
        )

-    # Check if email already exists (case-insensitive)
+    # Check if email already exists (case-insensitive, exclude deleted users)
    email_lower = (request.email or '').strip().lower()
-    existing_user = await db.execute(select(User).where(func.lower(User.email) == email_lower))
-    if existing_user.scalar_one_or_none():
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='This email is already registered',
+    existing_result = await db.execute(
+        select(User).where(
+            func.lower(User.email) == email_lower,
+            User.status != UserStatus.DELETED.value,
        )
-
-    # Check if user already has email
-    if user.email and user.email_verified:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail='You already have a verified email',
+    )
+    existing_email_user = existing_result.scalar_one_or_none()
+    if existing_email_user:
+        if existing_email_user.id == user.id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='This email is already linked to your account',
+            )
+        # Offer account merge instead of blocking
+        logger.info(
+            'Email register conflict: email already linked to another user, offering merge',
+            current_user_id=user.id,
+            existing_user_id=existing_email_user.id,
        )
+        merge_token = await create_merge_token(
+            primary_user_id=user.id,
+            secondary_user_id=existing_email_user.id,
+            provider='email',
+            provider_id=email_lower,
+        )
+        return {
+            'message': 'Account merge required',
+            'merge_required': True,
+            'merge_token': merge_token,
+        }

    # Update user
    user.email = request.email
@@ -886,6 +1058,11 @@ async def register_email_standalone(
        user.email_verified_at = datetime.now(UTC)
        await db.commit()
        logger.info('Email auto-verified (test or verification disabled)', email=request.email, user_id=user.id)
+        # Sync existing panel subscription (same as manual verification flow)
+        try:
+            await _sync_subscription_from_panel_by_email(db, user)
+        except Exception:
+            logger.warning('Failed to sync panel subscription after auto-verify', user_id=user.id, exc_info=True)
    else:
        # Сгенерировать токен верификации
        verification_token = generate_verification_token()
@@ -929,12 +1106,10 @@ async def register_email_standalone(
    # Обработать реферальную регистрацию (если есть реферер)
    if referrer:
        try:
-            from aiogram import Bot
-            from aiogram.client.default import DefaultBotProperties
-            from aiogram.enums import ParseMode
+            from app.bot_factory import create_bot

-            bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
-            await process_referral_registration(db, user.id, referrer.id, bot=bot)
+            async with create_bot() as bot:
+                await process_referral_registration(db, user.id, referrer.id, bot=bot)
            logger.info(
                'Processed referral registration: user_id=, referrer_id', user_id=user.id, referrer_id=referrer.id
            )
@@ -1143,7 +1318,7 @@ async def login_email(
            detail='Please verify your email first',
        )

-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='User account is not active',
@@ -1292,7 +1467,7 @@ async def auto_login(
            detail='User not found',
        )

-    if user.status != 'active':
+    if user.status != UserStatus.ACTIVE.value:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='Account is deactivated',
@@ -1674,3 +1849,130 @@ async def get_email_change_status(
        'new_email': user.email_change_new,
        'expires_at': user.email_change_expires.isoformat() if user.email_change_expires else None,
    }
+
+
+# --- Deep link auth (fallback when oauth.telegram.org is blocked) ---
+
+
+@router.post('/deeplink/request', response_model=DeepLinkTokenResponse)
+async def request_deep_link_token(
+    raw_request: Request,
+):
+    """Generate a one-time deep link auth token.
+
+    Frontend shows t.me/{bot}?start=webauth_{token} to the user.
+    No auth required (user is not logged in yet).
+    """
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'deeplink_request', limit=10, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    try:
+        token = await create_web_auth_token()
+    except RuntimeError:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail='Service temporarily unavailable',
+        )
+
+    bot_username = settings.get_bot_username()
+    if not bot_username:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail='Bot not configured',
+        )
+
+    return DeepLinkTokenResponse(
+        token=token,
+        bot_username=bot_username,
+        expires_in=WEB_AUTH_TOKEN_TTL,
+    )
+
+
+@router.post('/deeplink/poll', response_model=AuthResponse)
+async def poll_deep_link_token(
+    request: DeepLinkPollRequest,
+    raw_request: Request,
+    db: AsyncSession = Depends(get_cabinet_db),
+):
+    """Poll for deep link auth completion.
+
+    Returns 202 if still pending, AuthResponse if completed, 410 if expired.
+    """
+    client_ip = get_client_ip(raw_request)
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'deeplink_poll', limit=60, window=60, fail_closed=True):
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail='Too many requests',
+            headers={'Retry-After': '60'},
+        )
+
+    data = await poll_web_auth_token(request.token)
+
+    if data is None:
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Token expired or not found',
+        )
+
+    if data.get('status') == 'pending':
+        raise HTTPException(
+            status_code=status.HTTP_202_ACCEPTED,
+            detail='Waiting for confirmation',
+        )
+
+    if data.get('status') != 'linked':
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Invalid token state',
+        )
+
+    # Token is linked - consume it atomically
+    consumed = await consume_web_auth_token(request.token)
+    if not consumed:
+        raise HTTPException(
+            status_code=status.HTTP_410_GONE,
+            detail='Token already consumed',
+        )
+
+    user_id = consumed.get('user_id')
+    if not user_id:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Invalid token data',
+        )
+
+    user = await get_user_by_id(db, int(user_id))
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail='User not found',
+        )
+
+    if user.status != UserStatus.ACTIVE.value:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Account is deactivated',
+        )
+
+    user.cabinet_last_login = datetime.now(UTC)
+    await db.commit()
+
+    response = await _create_auth_response(user, db)
+    await _store_refresh_token(db, user.id, response.refresh_token, device_info='deep_link')
+
+    # Deep link auth is always for existing users — referral code not applicable
+    # (kept for campaign bonus processing only)
+
+    # Process campaign bonus
+    response.campaign_bonus = await _process_campaign_bonus(db, user, request.campaign_slug)
+    if response.campaign_bonus:
+        response.user = _user_to_response(user)
+
+    logger.info('Deep link auth successful', user_id=user.id, telegram_id=user.telegram_id)
+
+    return response
@@ -4,15 +4,12 @@ import math
 import time
 from decimal import ROUND_HALF_UP, Decimal, InvalidOperation

-import httpx
 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy import desc, func, select
 from sqlalchemy.ext.asyncio import AsyncSession

+from app.bot_factory import create_bot
 from app.config import settings
 from app.database.crud.saved_payment_method import (
    deactivate_payment_method,
@@ -272,50 +269,37 @@ async def create_stars_invoice(

    # Create invoice through Telegram Bot API
    try:
-        bot_token = settings.BOT_TOKEN
-        api_url = f'https://api.telegram.org/bot{bot_token}/createInvoiceLink'
+        from aiogram.exceptions import TelegramAPIError
+        from aiogram.types import LabeledPrice

-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                api_url,
-                json={
-                    'title': 'Пополнение баланса VPN',
-                    'description': f'Пополнение баланса на {normalized_kopeks / 100:.2f} ₽ ({stars_amount} ⭐)',
-                    'payload': payload,
-                    'provider_token': '',  # Empty for Stars
-                    'currency': 'XTR',
-                    'prices': [{'label': 'Пополнение баланса', 'amount': stars_amount}],
-                },
+        async with create_bot() as bot:
+            invoice_url = await bot.create_invoice_link(
+                title='Пополнение баланса VPN',
+                description=f'Пополнение баланса на {normalized_kopeks / 100:.2f} ₽ ({stars_amount} ⭐)',
+                payload=payload,
+                provider_token='',
+                currency='XTR',
+                prices=[LabeledPrice(label='Пополнение баланса', amount=stars_amount)],
            )

-            result = response.json()
+        logger.info(
+            'Created Stars invoice for balance top-up: user=, amount= kopeks, stars',
+            user_id=user.id,
+            amount_kopeks=request.amount_kopeks,
+            stars_amount=stars_amount,
+        )

-            if not result.get('ok'):
-                logger.error('Telegram API error', result=result)
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail='Failed to create Stars invoice',
-                )
+        return StarsInvoiceResponse(
+            invoice_url=invoice_url,
+            stars_amount=stars_amount,
+            amount_kopeks=normalized_kopeks,
+        )

-            invoice_url = result['result']
-            logger.info(
-                'Created Stars invoice for balance top-up: user=, amount= kopeks, stars',
-                user_id=user.id,
-                amount_kopeks=request.amount_kopeks,
-                stars_amount=stars_amount,
-            )
-
-            return StarsInvoiceResponse(
-                invoice_url=invoice_url,
-                stars_amount=stars_amount,
-                amount_kopeks=normalized_kopeks,
-            )
-
-    except httpx.HTTPError as e:
-        logger.error('HTTP error creating Stars invoice', error=e)
+    except TelegramAPIError as e:
+        logger.error('Error creating Stars invoice', error=e)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail='Failed to connect to Telegram API',
+            detail='Failed to create Stars invoice',
        )


@@ -376,7 +360,7 @@ async def create_topup(
            option = (request.payment_option or '').strip().lower()
            # Use description with telegram_id for tax receipts
            description = settings.get_balance_payment_description(
-                request.amount_kopeks, telegram_user_id=user.telegram_id
+                request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
            )
            if option == 'sbp':
                result = await payment_service.create_yookassa_sbp_payment(
@@ -439,7 +423,7 @@ async def create_topup(
                amount_usd=amount_usd,
                asset=settings.CRYPTOBOT_DEFAULT_ASSET,
                description=settings.get_balance_payment_description(
-                    request.amount_kopeks, telegram_user_id=user.telegram_id
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
                ),
                payload=f'cabinet_topup_{user.id}_{request.amount_kopeks}',
            )
@@ -500,7 +484,7 @@ async def create_topup(
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
                description=settings.get_balance_payment_description(
-                    request.amount_kopeks, telegram_user_id=user.telegram_id
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                payment_method_code=method_code,
@@ -529,7 +513,9 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                return_url=cabinet_return_url,
                success_url=cabinet_success_url,
@@ -556,7 +542,9 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
            )

@@ -586,8 +574,11 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                payment_method=option,
            )

            if result:
@@ -626,7 +617,9 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                return_url=cabinet_success_url,
                failed_url=cabinet_failed_url,
@@ -653,7 +646,9 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                telegram_id=user.telegram_id,
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
                return_url=cabinet_success_url,
@@ -681,7 +676,9 @@ async def create_topup(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
            )

@@ -701,14 +698,22 @@ async def create_topup(
                    detail='KassaAI payment method is unavailable',
                )

+            # Use payment_option to select sbp or card
+            KASSA_AI_OPTION_MAP = {'sbp': 44, 'card': 36, 'sberpay': 43}
+            option = (request.payment_option or '').strip().lower()
+            ps_id = KASSA_AI_OPTION_MAP.get(option)  # None = use env default
+
            payment_service = PaymentService()
            result = await payment_service.create_kassa_ai_payment(
                db=db,
                user_id=user.id,
                amount_kopeks=request.amount_kopeks,
-                description=settings.get_balance_payment_description(request.amount_kopeks),
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
                email=getattr(user, 'email', None),
                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                payment_system_id=ps_id,
            )

            if result and result.get('payment_url'):
@@ -720,6 +725,35 @@ async def create_topup(
                    detail='Failed to create KassaAI payment',
                )

+        elif request.payment_method == 'riopay':
+            if not settings.is_riopay_enabled():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='RioPay payment method is unavailable',
+                )
+
+            payment_service = PaymentService()
+            result = await payment_service.create_riopay_payment(
+                db=db,
+                user_id=user.id,
+                amount_kopeks=request.amount_kopeks,
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
+                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                success_url=cabinet_success_url,
+                fail_url=cabinet_failed_url,
+            )
+
+            if result and result.get('payment_url'):
+                payment_url = result.get('payment_url')
+                payment_id = str(result.get('local_payment_id') or result.get('riopay_order_id') or 'pending')
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail='Failed to create RioPay payment',
+                )
+
        elif request.payment_method == 'tribute':
            if not settings.TRIBUTE_ENABLED or not settings.TRIBUTE_DONATE_LINK:
                raise HTTPException(
@@ -731,6 +765,35 @@ async def create_topup(
            payment_url = f'{settings.TRIBUTE_DONATE_LINK}&user_id={user_identifier}'
            payment_id = f'tribute_{user_identifier}_{request.amount_kopeks}'

+        elif request.payment_method == 'severpay':
+            if not settings.is_severpay_enabled():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='SeverPay payment method is unavailable',
+                )
+
+            payment_service = PaymentService()
+            result = await payment_service.create_severpay_payment(
+                db=db,
+                user_id=user.id,
+                amount_kopeks=request.amount_kopeks,
+                description=settings.get_balance_payment_description(
+                    request.amount_kopeks, telegram_user_id=user.telegram_id, user_db_id=user.id
+                ),
+                email=getattr(user, 'email', None),
+                language=getattr(user, 'language', None) or settings.DEFAULT_LANGUAGE,
+                return_url=cabinet_success_url,
+            )
+
+            if result and result.get('payment_url'):
+                payment_url = result.get('payment_url')
+                payment_id = str(result.get('local_payment_id') or result.get('order_id') or 'pending')
+            else:
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail='Failed to create SeverPay payment',
+                )
+
        else:
            # For other payment methods, redirect to bot
            raise HTTPException(
@@ -871,6 +934,17 @@ def _get_status_info(record: PendingPayment) -> tuple[str, str]:
        }
        return mapping.get(status, ('❓', 'Неизвестно'))

+    if record.method == PaymentMethod.RIOPAY:
+        mapping = {
+            'pending': ('⏳', 'Ожидает оплаты'),
+            'success': ('✅', 'Оплачено'),
+            'failed': ('❌', 'Ошибка'),
+            'canceled': ('❌', 'Отменено'),
+            'expired': ('⌛', 'Истёк'),
+            'amount_mismatch': ('⚠️', 'Несовпадение суммы'),
+        }
+        return mapping.get(status, ('❓', 'Неизвестно'))
+
    return '❓', 'Неизвестно'


@@ -901,6 +975,8 @@ def _is_checkable(record: PendingPayment) -> bool:
        return status in {'pending', 'created', 'processing'}
    if record.method == PaymentMethod.KASSA_AI:
        return status in {'pending', 'created', 'processing'}
+    if record.method == PaymentMethod.RIOPAY:
+        return status in {'pending'}
    return False


@@ -924,7 +1000,12 @@ def _get_payment_url(record: PendingPayment) -> str | None:
        )
    elif record.method == PaymentMethod.PLATEGA:
        payment_url = getattr(payment, 'redirect_url', None) or payment_url
-    elif record.method in (PaymentMethod.CLOUDPAYMENTS, PaymentMethod.FREEKASSA, PaymentMethod.KASSA_AI):
+    elif record.method in (
+        PaymentMethod.CLOUDPAYMENTS,
+        PaymentMethod.FREEKASSA,
+        PaymentMethod.KASSA_AI,
+        PaymentMethod.RIOPAY,
+    ):
        payment_url = getattr(payment, 'payment_url', None) or payment_url

    return payment_url
@@ -1013,6 +1094,7 @@ async def get_latest_payment_by_method(
        MulenPayPayment,
        Pal24Payment,
        PlategaPayment,
+        RioPayPayment,
        WataPayment,
        YooKassaPayment,
    )
@@ -1028,6 +1110,7 @@ async def get_latest_payment_by_method(
        PaymentMethod.CLOUDPAYMENTS: CloudPaymentsPayment,
        PaymentMethod.FREEKASSA: FreekassaPayment,
        PaymentMethod.KASSA_AI: KassaAiPayment,
+        PaymentMethod.RIOPAY: RioPayPayment,
    }

    model = model_map.get(payment_method)
@@ -1149,7 +1232,7 @@ async def check_payment_status(
    old_is_paid = record.is_paid

    # Run manual check
-    bot = Bot(token=settings.BOT_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    bot = create_bot()
    try:
        payment_service = PaymentService(bot=bot)
        updated = await run_manual_check(db, payment_method, payment_id, payment_service)
@@ -244,6 +244,7 @@ class EmailAuthEnabledResponse(BaseModel):
    """Email auth enabled setting."""

    enabled: bool = True
+    verification_enabled: bool = True


 class EmailAuthEnabledUpdate(BaseModel):
@@ -838,10 +839,16 @@ async def get_email_auth_enabled(

    if email_auth_value is not None:
        enabled = email_auth_value.lower() == 'true'
-        return EmailAuthEnabledResponse(enabled=enabled)
+        return EmailAuthEnabledResponse(
+            enabled=enabled,
+            verification_enabled=settings.is_cabinet_email_verification_enabled(),
+        )

    # Default: check config setting
-    return EmailAuthEnabledResponse(enabled=settings.is_cabinet_email_auth_enabled())
+    return EmailAuthEnabledResponse(
+        enabled=settings.is_cabinet_email_auth_enabled(),
+        verification_enabled=settings.is_cabinet_email_verification_enabled(),
+    )


@router.patch('/email-auth', response_model=EmailAuthEnabledResponse)
@@ -855,7 +862,10 @@ async def update_email_auth_enabled(

    logger.info('Admin set email auth enabled', telegram_id=admin.telegram_id, enabled=payload.enabled)

-    return EmailAuthEnabledResponse(enabled=payload.enabled)
+    return EmailAuthEnabledResponse(
+        enabled=payload.enabled,
+        verification_enabled=settings.is_cabinet_email_verification_enabled(),
+    )


 # ============ Telegram Widget Config Routes ============
@@ -9,14 +9,28 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession

+from app.config import settings
 from app.database.crud.contest import (
    create_attempt,
    get_active_rounds,
    get_attempt,
    increment_winner_count,
 )
-from app.database.crud.subscription import get_subscription_by_user_id
+from app.database.crud.subscription import get_active_subscriptions_by_user_id, get_subscription_by_user_id
 from app.database.models import SubscriptionStatus, User
+
+
+async def _resolve_subscription_for_prize(db, user_id: int):
+    """Resolve best subscription for applying contest prize (days/traffic)."""
+    if settings.is_multi_tariff_enabled():
+        active_subs = await get_active_subscriptions_by_user_id(db, user_id)
+        # Prefer non-daily with most days left
+        non_daily = [s for s in active_subs if not (s.tariff and getattr(s.tariff, 'is_daily', False))]
+        eligible = non_daily or active_subs
+        return max(eligible, key=lambda s: s.days_left) if eligible else None
+    return await get_subscription_by_user_id(db, user_id)
+
+
 from app.services.contest_rotation_service import (
    GAME_ANAGRAM,
    GAME_BLITZ,
@@ -98,7 +112,7 @@ async def _award_prize(db: AsyncSession, user_id: int, prize_type: str, prize_va
        except ValueError:
            return 'Error: invalid prize value'

-        subscription = await get_subscription_by_user_id(db, user_id)
+        subscription = await _resolve_subscription_for_prize(db, user_id)
        if not subscription:
            return 'Error: subscription not found'

@@ -151,7 +165,7 @@ async def get_contests_count(
    db: AsyncSession = Depends(get_cabinet_db),
 ):
    """Get count of contests available for the user."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)

    if not _user_allowed(subscription):
        return ContestsCountResponse(count=0)
@@ -183,7 +197,7 @@ async def get_contests(
    db: AsyncSession = Depends(get_cabinet_db),
 ):
    """Get list of available contests/games."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)

    if not _user_allowed(subscription):
        raise HTTPException(
@@ -230,7 +244,7 @@ async def get_contest_game(
    db: AsyncSession = Depends(get_cabinet_db),
 ):
    """Get game data for a specific contest round."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)

    if not _user_allowed(subscription):
        raise HTTPException(
@@ -350,7 +364,7 @@ async def submit_contest_answer(
    db: AsyncSession = Depends(get_cabinet_db),
 ):
    """Submit answer for a contest round."""
-    subscription = await get_subscription_by_user_id(db, user.id)
+    subscription = await _resolve_subscription_for_prize(db, user.id)

    if not _user_allowed(subscription):
        raise HTTPException(
@@ -306,9 +306,9 @@ async def create_gift_purchase(
        else:
            # 2) Fall back to Bot API (works for public usernames the bot has seen)
            try:
-                from aiogram import Bot
+                from app.bot_factory import create_bot

-                async with Bot(token=settings.BOT_TOKEN) as bot:
+                async with create_bot() as bot:
                    chat = await asyncio.wait_for(bot.get_chat(chat_id=f'@{tg_username}'), timeout=5.0)
                    pre_resolved_telegram_id = chat.id
            except Exception:
@@ -371,19 +371,23 @@ async def create_gift_purchase(
        # Stars payments need a Bot instance to create invoice links
        bot = None
        if body.payment_method == 'telegram_stars':
-            from aiogram import Bot
+            from app.bot_factory import create_bot

-            bot = Bot(token=settings.BOT_TOKEN)
+            bot = create_bot()

-        payment_service = PaymentService(bot=bot)
-        payment_result = await payment_service.create_guest_payment(
-            db=db,
-            amount_kopeks=price_kopeks,
-            payment_method=body.payment_method,
-            description=f'Gift: {tariff.name} ({body.period_days}d)',
-            purchase_token=purchase.token,
-            return_url=return_url,
-        )
+        try:
+            payment_service = PaymentService(bot=bot)
+            payment_result = await payment_service.create_guest_payment(
+                db=db,
+                amount_kopeks=price_kopeks,
+                payment_method=body.payment_method,
+                description=f'Gift: {tariff.name} ({body.period_days}d)',
+                purchase_token=purchase.token,
+                return_url=return_url,
+            )
+        finally:
+            if bot:
+                await bot.session.close()

        if payment_result is None:
            await db.rollback()
@@ -421,8 +425,8 @@ async def create_gift_purchase(
            warning=recipient_warning,
        )

-    # Balance mode
-    if user.balance_kopeks < price_kopeks:
+    # Balance mode (skip for 100% discount)
+    if price_kopeks > 0 and user.balance_kopeks < price_kopeks:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail='Insufficient balance',
@@ -720,7 +724,7 @@ async def activate_gift_by_code(
        raise HTTPException(status_code=status.HTTP_429_TOO_MANY_REQUESTS, detail='Too many requests')

    code = body.code.strip()
-    if code.upper().startswith('GIFT-'):
+    if code.upper().startswith('GIFT-') or code.upper().startswith('GIFT_'):
        code = code[5:]

    if len(code) < 8:
@@ -550,7 +550,7 @@ async def create_landing_purchase(
    No authentication required.
    """
    client_ip = get_client_ip(raw_request)
-    if await RateLimitCache.is_ip_rate_limited(client_ip, 'landing_purchase', limit=5, window=60, fail_closed=True):
+    if await RateLimitCache.is_ip_rate_limited(client_ip, 'landing_purchase', limit=30, window=60, fail_closed=True):
        raise HTTPException(
            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
            detail='Too many purchase attempts, please try again later',
@@ -3,13 +3,11 @@
 import mimetypes

 import structlog
-from aiogram import Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
 from aiogram.types import BufferedInputFile
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, Response, UploadFile, status
 from pydantic import BaseModel

+from app.bot_factory import create_bot
 from app.config import settings
 from app.database.models import User

@@ -98,10 +96,7 @@ async def upload_media(
    target_chat_id = _resolve_target_chat_id()
    upload = BufferedInputFile(file_bytes, filename=file.filename or 'upload')

-    bot = Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    bot = create_bot()

    try:
        if media_type_normalized == 'photo':
@@ -158,10 +153,7 @@ async def download_media(
    Download media file by file_id.
    Used to display images/documents in ticket messages.
    """
-    bot = Bot(
-        token=settings.BOT_TOKEN,
-        default=DefaultBotProperties(parse_mode=ParseMode.HTML),
-    )
+    bot = create_bot()

    try:
        file = await bot.get_file(file_id)
@@ -0,0 +1,177 @@
+"""Public news routes for cabinet - user-facing news/blog section."""
+
+import time
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Path, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.news import (
+    get_news_article_by_slug,
+    get_news_categories,
+    get_published_news,
+    get_published_news_count,
+    increment_views,
+)
+from app.database.models import NewsArticle, User
+
+from ..dependencies import get_cabinet_db, get_current_cabinet_user
+from ..schemas.news import (
+    NewsArticleListItem,
+    NewsArticleResponse,
+    NewsListResponse,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+# Slug constraint: alphanumeric, hyphens, underscores, max 500 chars
+_SLUG_MAX_LENGTH: int = 500
+_SLUG_PATTERN: str = r'^[a-zA-Z0-9_-]+$'
+
+# --- View counter deduplication ---
+# In-memory TTL cache to prevent a single user from inflating view counts.
+# Key: (user_id, article_id), Value: timestamp of last counted view.
+# Views from the same user on the same article within _VIEW_DEDUP_SECONDS are ignored.
+_VIEW_DEDUP_SECONDS: int = 300  # 5 minutes
+_VIEW_DEDUP_MAX_SIZE: int = 10_000  # max entries before eviction
+_view_dedup_cache: dict[tuple[int, int], float] = {}
+
+
+def _should_count_view(user_id: int, article_id: int) -> bool:
+    """Return True if this view should be counted (not a duplicate within TTL)."""
+    now = time.monotonic()
+    key = (user_id, article_id)
+    last_seen = _view_dedup_cache.get(key)
+
+    if last_seen is not None and (now - last_seen) < _VIEW_DEDUP_SECONDS:
+        return False
+
+    # Evict stale entries if cache grows too large
+    if len(_view_dedup_cache) >= _VIEW_DEDUP_MAX_SIZE:
+        cutoff = now - _VIEW_DEDUP_SECONDS
+        stale_keys = [k for k, v in _view_dedup_cache.items() if v < cutoff]
+        for k in stale_keys:
+            del _view_dedup_cache[k]
+
+    _view_dedup_cache[key] = now
+    return True
+
+
+router = APIRouter(prefix='/news', tags=['Cabinet News'])
+
+
+def _article_to_response(article: NewsArticle, *, include_content: bool = True) -> dict[str, Any]:
+    """Convert NewsArticle ORM instance to response dict.
+
+    ``author_name`` is only resolved when ``include_content=True`` (single-article
+    detail view) because the author relationship is not eagerly loaded for list
+    queries -- accessing it there would trigger a lazy-load or raise
+    ``MissingGreenlet`` in async context.
+    """
+    data: dict[str, Any] = {
+        'id': article.id,
+        'title': article.title,
+        'slug': article.slug,
+        'excerpt': article.excerpt,
+        'category': article.category,
+        'category_color': article.category_color,
+        'tag': article.tag,
+        'featured_image_url': article.featured_image_url,
+        'is_published': article.is_published,
+        'is_featured': article.is_featured,
+        'published_at': article.published_at,
+        'read_time_minutes': article.read_time_minutes,
+        'views_count': article.views_count,
+    }
+
+    if include_content:
+        author_name: str | None = None
+        if article.author:
+            author_name = article.author.first_name or article.author.username or f'#{article.author.id}'
+        data['content'] = article.content
+        data['author_name'] = author_name
+        data['created_at'] = article.created_at
+        data['updated_at'] = article.updated_at
+
+    return data
+
+
+# NOTE: /categories MUST be declared before /{slug} to avoid route conflict
+@router.get('/categories', response_model=list[str])
+async def list_categories(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> list[str]:
+    """Get list of distinct news categories."""
+    try:
+        return await get_news_categories(db)
+    except Exception:
+        logger.exception('Failed to get news categories')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load categories',
+        )
+
+
+@router.get('', response_model=NewsListResponse)
+async def list_published_news(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    category: str | None = Query(None, max_length=100),
+    limit: int = Query(20, ge=1, le=100),
+    offset: int = Query(0, ge=0),
+) -> NewsListResponse:
+    """Get paginated list of published news articles.
+
+    SQLAlchemy AsyncSession does not support concurrent operations, so
+    queries run sequentially.
+    """
+    try:
+        articles = await get_published_news(db, category=category, limit=limit, offset=offset)
+        total = await get_published_news_count(db, category=category)
+        categories = await get_news_categories(db)
+
+        items = [NewsArticleListItem(**_article_to_response(a, include_content=False)) for a in articles]
+
+        return NewsListResponse(items=items, total=total, categories=categories)
+    except HTTPException:
+        raise
+    except Exception:
+        logger.exception('Failed to list published news')
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to load news',
+        )
+
+
+@router.get('/{slug}', response_model=NewsArticleResponse)
+async def get_article_by_slug(
+    slug: str = Path(..., max_length=_SLUG_MAX_LENGTH, pattern=_SLUG_PATTERN),
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> NewsArticleResponse:
+    """Get a single published news article by slug. Increments view count."""
+    article = await get_news_article_by_slug(db, slug)
+
+    if not article or not article.is_published:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Article not found',
+        )
+
+    # Build response dict while session attributes are still loaded.
+    # increment_views() calls db.commit() which expires all ORM attributes;
+    # accessing them afterwards triggers lazy-load → MissingGreenlet in async.
+    response_data = _article_to_response(article, include_content=True)
+
+    # Increment views with per-user deduplication (5-min TTL).
+    if _should_count_view(user.id, article.id):
+        try:
+            new_count = await increment_views(db, article.id)
+            response_data['views_count'] = new_count
+        except Exception:
+            logger.warning('Failed to increment views', article_id=article.id)
+
+    return NewsArticleResponse(**response_data)
@@ -40,6 +40,8 @@ async def _finalize_oauth_login(
    provider: str,
    campaign_slug: str | None = None,
    referral_code: str | None = None,
+    *,
+    is_new_user: bool = False,
 ) -> AuthResponse:
    """Update last login, create tokens, store refresh token."""
    user.cabinet_last_login = datetime.now(UTC)
@@ -47,10 +49,10 @@ async def _finalize_oauth_login(
    auth_response = await _create_auth_response(user, db)
    await _store_refresh_token(db, user.id, auth_response.refresh_token, device_info=f'oauth:{provider}')

-    # Process referral code (before campaign bonus, which may also set referrer)
+    # Process referral code (only for new users — existing users cannot be assigned a referrer)
    from .auth import _process_referral_code, _user_to_response

-    await _process_referral_code(db, user, referral_code)
+    await _process_referral_code(db, user, referral_code, is_new_user=is_new_user)

    auth_response.campaign_bonus = await _process_campaign_bonus(db, user, campaign_slug)
    if auth_response.campaign_bonus:
@@ -232,4 +234,19 @@ async def oauth_callback(
        referred_by_id=referrer_id,
    )
    logger.info('New OAuth user created', provider=provider, user_id=user.id)
-    return await _finalize_oauth_login(db, user, provider, request.campaign_slug, request.referral_code)
+
+    # Commit user before panel sync (sync does its own commit/rollback)
+    await db.commit()
+
+    # Sync existing panel subscriptions by email (if verified)
+    if user_info.email and user_info.email_verified:
+        try:
+            from app.cabinet.routes.auth import _sync_subscription_from_panel_by_email
+
+            await _sync_subscription_from_panel_by_email(db, user)
+        except Exception:
+            logger.warning('Failed to sync panel subscription for new OAuth user', user_id=user.id, exc_info=True)
+
+    return await _finalize_oauth_login(
+        db, user, provider, request.campaign_slug, request.referral_code, is_new_user=True
+    )
@@ -178,12 +178,11 @@ async def apply_for_partner(

    # Уведомляем админов о новой заявке
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.services.admin_notification_service import AdminNotificationService

        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
-            bot = Bot(token=settings.BOT_TOKEN)
+            bot = create_bot()
            try:
                notification_service = AdminNotificationService(bot)
                await notification_service.send_partner_application_notification(
@@ -309,7 +309,7 @@ async def claim_promo_offer(

    # Handle test access offers
    if effect_type == 'test_access':
-        await db.refresh(user, ['subscription'])
+        await db.refresh(user, ['subscriptions'])
        success, newly_added, expires_at, error_code = await promo_offer_service.grant_test_access(
            db,
            user,
@@ -20,6 +20,7 @@ class PromocodeActivateRequest(BaseModel):
    """Request to activate a promo code."""

    code: str = Field(..., min_length=1, max_length=50, description='Promo code to activate')
+    subscription_id: int | None = Field(None, description='Subscription ID for multi-tariff promo codes')


 class PromocodeActivateResponse(BaseModel):
@@ -41,7 +42,7 @@ class PromocodeDeactivateResponse(BaseModel):
    discount_percent: int = 0


-@router.post('/activate', response_model=PromocodeActivateResponse)
+@router.post('/activate')
 async def activate_promocode(
    request: PromocodeActivateRequest,
    user: User = Depends(get_current_cabinet_user),
@@ -50,7 +51,17 @@ async def activate_promocode(
    """Activate a promo code for the current user."""
    promocode_service = PromoCodeService()

-    result = await promocode_service.activate_promocode(db=db, user_id=user.id, code=request.code.strip())
+    result = await promocode_service.activate_promocode(
+        db=db, user_id=user.id, code=request.code.strip(), subscription_id=request.subscription_id
+    )
+
+    if result.get('error') == 'select_subscription':
+        return {
+            'success': False,
+            'error': 'select_subscription',
+            'eligible_subscriptions': result.get('eligible_subscriptions', []),
+            'code': result.get('code', request.code.strip()),
+        }

    if result['success']:
        balance_before_rubles = result.get('balance_before_kopeks', 0) / 100
@@ -68,10 +79,13 @@ async def activate_promocode(
    error_messages = {
        'not_found': 'Promo code not found',
        'expired': 'Promo code has expired',
+        'inactive': 'Promo code is deactivated',
+        'not_yet_valid': 'Promo code is not yet active',
        'used': 'Promo code has been fully used',
        'already_used_by_user': 'You have already used this promo code',
        'active_discount_exists': 'You already have an active discount. Deactivate it first via /deactivate-discount',
        'no_subscription_for_days': 'This promo code requires an active or expired subscription',
+        'subscription_not_found': 'Subscription not found',
        'not_first_purchase': 'This promo code is only available for first purchase',
        'daily_limit': 'Too many promo code activations today',
        'user_not_found': 'User not found',
@@ -92,14 +92,8 @@ async def get_referral_info(
    available_balance = min(user.balance_kopeks, referral_entitlement)

    # Build referral links
-    referral_link = settings.get_referral_link(user.referral_code) if user.referral_code else ''
-    bot_username = settings.get_bot_username()
-    bot_referral_link = ''
-    if user.referral_code and bot_username:
-        from urllib.parse import quote
-
-        safe_code = quote(user.referral_code, safe='')
-        bot_referral_link = f'https://t.me/{bot_username}?start={safe_code}'
+    referral_link = (settings.get_cabinet_referral_link(user.referral_code) or '') if user.referral_code else ''
+    bot_referral_link = settings.get_bot_referral_link(user.referral_code) if user.referral_code else ''

    return ReferralInfoResponse(
        referral_code=user.referral_code or '',
@@ -125,7 +119,11 @@ async def get_referral_list(
 ):
    """Get list of invited users."""
    # Base query with eager loading of subscription relationship
-    query = select(User).options(selectinload(User.subscription)).where(User.referred_by_id == user.id)
+    query = (
+        select(User)
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
+        .where(User.referred_by_id == user.id)
+    )

    # Get total count
    count_query = select(func.count()).select_from(User).where(User.referred_by_id == user.id)
@@ -145,7 +143,7 @@ async def get_referral_list(
            username=r.username,
            first_name=r.first_name,
            created_at=r.created_at,
-            has_subscription=r.subscription is not None,
+            has_subscription=bool(getattr(r, 'subscriptions', None)),
            has_paid=r.has_had_paid_subscription,
        )
        for r in referrals
@@ -0,0 +1,30 @@
+"""Subscription sub-modules for cabinet API.
+
+Each module contains a subset of endpoints from the original monolithic subscription.py.
+The main subscription.py includes all sub-routers for backward compatibility.
+"""
+
+from .autopay import router as autopay_router
+from .daily import router as daily_router
+from .devices import router as devices_router
+from .multi_tariff import router as multi_tariff_router
+from .purchase import router as purchase_router
+from .renewal import router as renewal_router
+from .servers import router as servers_router
+from .status import router as status_router
+from .tariff_switch import router as tariff_switch_router
+from .traffic import router as traffic_router
+
+
+__all__ = [
+    'autopay_router',
+    'daily_router',
+    'devices_router',
+    'multi_tariff_router',
+    'purchase_router',
+    'renewal_router',
+    'servers_router',
+    'status_router',
+    'tariff_switch_router',
+    'traffic_router',
+]
@@ -0,0 +1,78 @@
+"""Autopay settings endpoint.
+
+PATCH /subscription/autopay
+"""
+
+from __future__ import annotations
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import AutopayUpdateRequest
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.patch('/autopay')
+async def update_autopay(
+    request: AutopayUpdateRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Update autopay settings."""
+    from .helpers import resolve_subscription
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if request.enabled:
+        # Classic subscriptions cannot use autopay when tariff mode is enabled
+        from app.config import settings
+
+        if settings.is_tariffs_mode() and not subscription.tariff_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for classic subscriptions. Please purchase a tariff.',
+            )
+
+        # Триальные подписки — пробник, автопродление не имеет смысла
+        if subscription.is_trial:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for trial subscriptions',
+            )
+
+        # Суточные подписки имеют свой механизм продления (DailySubscriptionService),
+        # глобальный autopay для них запрещён
+        await db.refresh(subscription, ['tariff'])
+        if subscription.tariff and getattr(subscription.tariff, 'is_daily', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Autopay is not available for daily subscriptions',
+            )
+
+    subscription.autopay_enabled = request.enabled
+
+    if request.days_before is not None:
+        subscription.autopay_days_before = request.days_before
+
+    await db.commit()
+
+    return {
+        'message': 'Autopay settings updated',
+        'autopay_enabled': subscription.autopay_enabled,
+        'autopay_days_before': subscription.autopay_days_before,
+    }
@@ -0,0 +1,183 @@
+"""Daily subscription management endpoints.
+
+POST /subscription/pause
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import User
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from .helpers import resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.post('/pause')
+async def toggle_subscription_pause(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Toggle pause/resume for daily subscription."""
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    tariff_id = getattr(subscription, 'tariff_id', None)
+    if not tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Subscription has no tariff',
+        )
+
+    tariff = await get_tariff_by_id(db, tariff_id)
+    if not tariff or not getattr(tariff, 'is_daily', False):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Pause is only available for daily tariffs',
+        )
+
+    # Determine current state
+    from app.database.models import SubscriptionStatus
+
+    is_currently_paused = getattr(subscription, 'is_daily_paused', False)
+    was_disabled = subscription.status in (
+        SubscriptionStatus.DISABLED.value,
+        SubscriptionStatus.EXPIRED.value,
+        SubscriptionStatus.LIMITED.value,
+    )
+
+    # System-DISABLED subs (insufficient balance) should always be treated as needing resume,
+    # even if is_daily_paused is False (it's set by the system, not the user)
+    if was_disabled and not is_currently_paused:
+        new_paused_state = False  # Force resume path
+    else:
+        new_paused_state = not is_currently_paused
+
+    raw_daily_price = getattr(tariff, 'daily_price_kopeks', 0)
+
+    # Lock user BEFORE discount computation to prevent TOCTOU on promo group
+    # IMPORTANT: must happen BEFORE modifying subscription — lock_user_for_pricing
+    # reloads subscriptions via selectinload which resets in-memory changes
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Re-fetch subscription after lock (selectinload may have replaced the ORM object)
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        raise HTTPException(status_code=404, detail='Subscription not found after lock')
+
+    subscription.is_daily_paused = new_paused_state
+
+    # Apply group discount to daily price (consistent with DailySubscriptionService and miniapp resume)
+    from app.services.pricing_engine import PricingEngine
+
+    promo_group = PricingEngine.resolve_promo_group(user)
+    daily_group_pct = promo_group.get_discount_percent('period', 1) if promo_group else 0
+    daily_price = (
+        PricingEngine.apply_discount(raw_daily_price, daily_group_pct) if daily_group_pct > 0 else raw_daily_price
+    )
+
+    # If resuming, check balance and charge
+    if not new_paused_state:
+        if daily_price > 0 and user.balance_kopeks < daily_price:
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail={
+                    'code': 'insufficient_balance',
+                    'message': 'Insufficient balance to resume daily subscription',
+                    'required': daily_price,
+                    'balance': user.balance_kopeks,
+                },
+            )
+
+        # Charge daily fee FIRST, then restore ACTIVE status
+        if was_disabled:
+            if daily_price > 0:
+                from app.database.crud.user import subtract_user_balance
+
+                deducted = await subtract_user_balance(
+                    db,
+                    user,
+                    daily_price,
+                    f'Суточная оплата тарифа «{tariff.name}» (возобновление)',
+                    mark_as_paid_subscription=True,
+                )
+                if not deducted:
+                    raise HTTPException(
+                        status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                        detail={
+                            'code': 'insufficient_balance',
+                            'message': 'Balance deduction failed',
+                            'required': daily_price,
+                            'balance': user.balance_kopeks,
+                        },
+                    )
+
+                from app.database.crud.transaction import create_transaction
+                from app.database.models import TransactionType
+
+                try:
+                    await create_transaction(
+                        db=db,
+                        user_id=user.id,
+                        type=TransactionType.SUBSCRIPTION_PAYMENT,
+                        amount_kopeks=daily_price,
+                        description=f'Суточная оплата тарифа «{tariff.name}» (возобновление)',
+                    )
+                except Exception as exc:
+                    logger.warning('Failed to create resume transaction', error=exc)
+
+            # Balance deducted successfully — now activate
+            subscription.status = SubscriptionStatus.ACTIVE.value
+            subscription.last_daily_charge_at = datetime.now(UTC)
+            subscription.end_date = datetime.now(UTC) + timedelta(days=1)
+
+    await db.commit()
+    await db.refresh(subscription)
+    await db.refresh(user)
+
+    # Sync with RemnaWave only when resuming from DISABLED state
+    if not new_paused_state and was_disabled:
+        try:
+            subscription_service = SubscriptionService()
+            await subscription_service.create_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=False,
+                reset_reason=None,
+            )
+        except Exception as e:
+            logger.error('Error syncing RemnaWave user on resume', error=e)
+
+    if new_paused_state:
+        message = 'Daily subscription paused'
+    else:
+        message = 'Daily subscription resumed'
+
+    return {
+        'success': True,
+        'message': message,
+        'is_paused': new_paused_state,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }
@@ -0,0 +1,234 @@
+"""Shared helper functions for subscription modules."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+import structlog
+
+from app.config import settings
+
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import Subscription, User
+
+from ...schemas.subscription import (
+    ServerInfo,
+    SubscriptionResponse,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def resolve_subscription(
+    db: AsyncSession,
+    user: User,
+    subscription_id: int | None,
+) -> Subscription | None:
+    """Resolve target subscription: by ID in multi-tariff mode, or legacy fallback.
+
+    Args:
+        db: Database session.
+        user: Current user.
+        subscription_id: Optional subscription ID (from query param).
+
+    Returns:
+        Target Subscription or None if not found.
+
+    Raises:
+        HTTPException: If subscription_id provided but not found for this user.
+    """
+    from fastapi import HTTPException
+
+    from app.database.crud.subscription import get_subscription_by_id_for_user
+
+    if subscription_id and settings.is_multi_tariff_enabled():
+        subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+        if not subscription:
+            raise HTTPException(status_code=404, detail='Subscription not found')
+        return subscription
+
+    if settings.is_multi_tariff_enabled() and not subscription_id:
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id
+
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        if active_subs:
+            non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            pool = non_daily or active_subs
+            return max(pool, key=lambda s: s.days_left)
+        return None
+
+    await db.refresh(user, ['subscriptions'])
+    return user.subscription
+
+
+def _get_addon_discount_percent(
+    user: User | None,
+    category: str,
+    period_days_hint: int | None = None,
+) -> int:
+    """Get addon discount percent for user — delegates to PricingEngine."""
+    from app.services.pricing_engine import PricingEngine
+
+    return PricingEngine.get_addon_discount_percent(user, category, period_days_hint)
+
+
+def _apply_addon_discount(
+    user: User,
+    category: str,
+    amount: int,
+    period_days: int | None = None,
+) -> dict[str, int]:
+    """Apply addon discount to amount.
+
+    Returns dict with keys: discounted, discount, percent
+    """
+    from app.utils.pricing_utils import apply_percentage_discount
+
+    percent = _get_addon_discount_percent(user, category, period_days)
+    if percent <= 0 or amount <= 0:
+        return {'discounted': amount, 'discount': 0, 'percent': 0}
+
+    discounted_amount, discount_value = apply_percentage_discount(amount, percent)
+    return {
+        'discounted': discounted_amount,
+        'discount': discount_value,
+        'percent': percent,
+    }
+
+
+def _subscription_to_response(
+    subscription: Subscription,
+    servers: list[ServerInfo] | None = None,
+    tariff_name: str | None = None,
+    traffic_purchases: list[dict[str, Any]] | None = None,
+    user: User | None = None,
+) -> SubscriptionResponse:
+    """Convert Subscription model to response."""
+    now = datetime.now(UTC)
+
+    # Use actual_status property for correct status (same as bot uses)
+    actual_status = subscription.actual_status
+    is_expired = actual_status == 'expired'
+    is_active = actual_status in ('active', 'trial')
+    is_limited = actual_status == 'limited'
+
+    # Calculate time remaining
+    days_left = 0
+    hours_left = 0
+    minutes_left = 0
+    time_left_display = ''
+
+    if subscription.end_date and not is_expired:
+        time_delta = subscription.end_date - now
+        total_seconds = max(0, int(time_delta.total_seconds()))
+
+        days_left = total_seconds // 86400  # 86400 seconds in a day
+        remaining_seconds = total_seconds % 86400
+        hours_left = remaining_seconds // 3600
+        minutes_left = (remaining_seconds % 3600) // 60
+
+        # Create human-readable display
+        if days_left > 0:
+            time_left_display = f'{days_left}d {hours_left}h'
+        elif hours_left > 0:
+            time_left_display = f'{hours_left}h {minutes_left}m'
+        elif minutes_left > 0:
+            time_left_display = f'{minutes_left}m'
+        else:
+            time_left_display = '0m'
+    else:
+        time_left_display = '0m'
+
+    traffic_limit_gb = subscription.traffic_limit_gb or 0
+    traffic_used_gb = subscription.traffic_used_gb or 0.0
+
+    if traffic_limit_gb > 0:
+        traffic_used_percent = min(100, (traffic_used_gb / traffic_limit_gb) * 100)
+    else:
+        traffic_used_percent = 0
+
+    # Check if this is a daily tariff
+    is_daily_paused = getattr(subscription, 'is_daily_paused', False) or False
+    tariff_id = getattr(subscription, 'tariff_id', None)
+
+    # Use subscription's is_daily_tariff property if available
+    is_daily = False
+    daily_price_kopeks = None
+
+    if hasattr(subscription, 'is_daily_tariff'):
+        is_daily = subscription.is_daily_tariff
+    elif tariff_id and hasattr(subscription, 'tariff') and subscription.tariff:
+        is_daily = getattr(subscription.tariff, 'is_daily', False)
+
+    # Get daily_price_kopeks, tariff_name, traffic_reset_mode from tariff
+    traffic_reset_mode = None
+    if tariff_id and hasattr(subscription, 'tariff') and subscription.tariff:
+        daily_price_kopeks = getattr(subscription.tariff, 'daily_price_kopeks', None)
+        # Применяем скидку промогруппы + promo-offer для отображения
+        if daily_price_kopeks and daily_price_kopeks > 0 and user:
+            from app.services.pricing_engine import PricingEngine
+            from app.utils.promo_offer import get_user_active_promo_discount_percent
+
+            _promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+            _group_pct = _promo_group.get_discount_percent('period', 1) if _promo_group else 0
+            _offer_pct = get_user_active_promo_discount_percent(user)
+            if _group_pct > 0 or _offer_pct > 0:
+                daily_price_kopeks, _, _ = PricingEngine.apply_stacked_discounts(
+                    daily_price_kopeks, _group_pct, _offer_pct
+                )
+        if not tariff_name:  # Only set if not passed as parameter
+            tariff_name = getattr(subscription.tariff, 'name', None)
+        traffic_reset_mode = (
+            getattr(subscription.tariff, 'traffic_reset_mode', None) or settings.DEFAULT_TRAFFIC_RESET_STRATEGY
+        )
+
+    # Calculate next daily charge time (24 hours after last charge)
+    next_daily_charge_at = None
+    if is_daily and not is_daily_paused:
+        last_charge = getattr(subscription, 'last_daily_charge_at', None)
+        if last_charge:
+            next_charge = last_charge + timedelta(days=1)
+            # Если время списания уже прошло — не показываем (DailySubscriptionService обработает)
+            if next_charge > datetime.now(UTC):
+                next_daily_charge_at = next_charge
+
+    # Проверяем настройку скрытия ссылки (скрывается только текст, кнопки работают)
+    hide_link = settings.should_hide_subscription_link()
+
+    return SubscriptionResponse(
+        id=subscription.id,
+        status=actual_status,  # Use actual_status instead of raw status
+        is_trial=subscription.is_trial or actual_status == 'trial',
+        start_date=subscription.start_date,
+        end_date=subscription.end_date,
+        days_left=days_left,
+        hours_left=hours_left,
+        minutes_left=minutes_left,
+        time_left_display=time_left_display,
+        traffic_limit_gb=traffic_limit_gb,
+        traffic_used_gb=round(traffic_used_gb, 2),
+        traffic_used_percent=round(traffic_used_percent, 1),
+        device_limit=subscription.device_limit or 0,
+        connected_squads=subscription.connected_squads or [],
+        servers=servers or [],
+        autopay_enabled=subscription.autopay_enabled or False,
+        autopay_days_before=subscription.autopay_days_before or 3,
+        subscription_url=subscription.subscription_url,
+        hide_subscription_link=hide_link,
+        is_active=is_active,
+        is_expired=is_expired,
+        is_limited=is_limited,
+        traffic_purchases=traffic_purchases or [],
+        is_daily=is_daily,
+        is_daily_paused=is_daily_paused,
+        daily_price_kopeks=daily_price_kopeks,
+        next_daily_charge_at=next_daily_charge_at,
+        tariff_id=tariff_id,
+        tariff_name=tariff_name,
+        traffic_reset_mode=traffic_reset_mode,
+    )
@@ -0,0 +1,156 @@
+"""Multi-tariff subscription endpoints for cabinet API.
+
+GET /subscriptions — list all user subscriptions (multi-tariff)
+GET /subscriptions/{id} — get specific subscription details
+"""
+
+from __future__ import annotations
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.subscription import (
+    decrement_subscription_server_counts,
+    get_all_subscriptions_by_user_id,
+    get_subscription_by_id_for_user,
+)
+from app.database.models import SubscriptionStatus, User
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix='/subscriptions', tags=['Cabinet Multi-Tariff'], redirect_slashes=False)
+
+
+class SubscriptionListItem(BaseModel):
+    id: int
+    status: str
+    tariff_id: int | None = None
+    tariff_name: str | None = None
+    traffic_limit_gb: int = 0
+    traffic_used_gb: float = 0.0
+    device_limit: int = 1
+    end_date: str | None = None
+    subscription_url: str | None = None
+    subscription_crypto_link: str | None = None
+    is_trial: bool = False
+    is_daily: bool = False
+    is_daily_paused: bool = False
+    autopay_enabled: bool = False
+    connected_squads: list[str] | None = None
+
+
+class SubscriptionsListResponse(BaseModel):
+    subscriptions: list[SubscriptionListItem]
+    multi_tariff_enabled: bool
+
+
+def _subscription_to_list_item(sub) -> SubscriptionListItem:
+    tariff_name = None
+    if sub.tariff:
+        tariff_name = sub.tariff.name
+
+    return SubscriptionListItem(
+        id=sub.id,
+        status=sub.actual_status,
+        tariff_id=sub.tariff_id,
+        tariff_name=tariff_name,
+        traffic_limit_gb=sub.traffic_limit_gb or 0,
+        traffic_used_gb=sub.traffic_used_gb or 0.0,
+        device_limit=sub.device_limit or 1,
+        end_date=sub.end_date.isoformat() if sub.end_date else None,
+        subscription_url=sub.subscription_url,
+        subscription_crypto_link=sub.subscription_crypto_link,
+        is_trial=sub.is_trial or False,
+        is_daily=bool(sub.tariff and getattr(sub.tariff, 'is_daily', False)),
+        is_daily_paused=bool(getattr(sub, 'is_daily_paused', False)),
+        autopay_enabled=sub.autopay_enabled or False,
+        connected_squads=sub.connected_squads,
+    )
+
+
+@router.get('', response_model=SubscriptionsListResponse)
+async def list_subscriptions(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> SubscriptionsListResponse:
+    """List all user subscriptions. Returns all subscriptions regardless of multi-tariff mode."""
+    subscriptions = await get_all_subscriptions_by_user_id(db, user.id)
+    items = [_subscription_to_list_item(sub) for sub in subscriptions]
+    return SubscriptionsListResponse(
+        subscriptions=items,
+        multi_tariff_enabled=settings.is_multi_tariff_enabled(),
+    )
+
+
+@router.get('/{subscription_id}', response_model=SubscriptionListItem)
+async def get_subscription_detail(
+    subscription_id: int,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> SubscriptionListItem:
+    """Get specific subscription details with ownership check."""
+    subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription not found',
+        )
+    return _subscription_to_list_item(subscription)
+
+
+@router.delete('/{subscription_id}')
+async def delete_subscription(
+    subscription_id: int,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+) -> dict:
+    """Delete an expired/disabled subscription. Active subscriptions cannot be deleted."""
+    subscription = await get_subscription_by_id_for_user(db, subscription_id, user.id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription not found',
+        )
+
+    # Only expired/disabled subscriptions can be deleted
+    deletable_statuses = {
+        SubscriptionStatus.EXPIRED.value,
+        SubscriptionStatus.DISABLED.value,
+    }
+    if getattr(subscription, 'actual_status', subscription.status) not in deletable_statuses:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Only expired or disabled subscriptions can be deleted',
+        )
+
+    # Delete from RemnaWave panel (stops webhooks / phantom notifications)
+    if subscription.remnawave_uuid:
+        try:
+            from app.services.subscription_service import SubscriptionService
+
+            service = SubscriptionService()
+            await service.delete_remnawave_user(subscription.remnawave_uuid)
+        except Exception as e:
+            logger.warning('Failed to delete RemnaWave user on subscription delete', error=e)
+
+    # Decrement server counts
+    await decrement_subscription_server_counts(db, subscription)
+
+    # Delete the subscription
+    await db.delete(subscription)
+    await db.commit()
+
+    logger.info(
+        'Subscription deleted by user',
+        subscription_id=subscription_id,
+        user_id=user.id,
+        tariff_id=subscription.tariff_id,
+    )
+
+    return {'message': 'Subscription deleted'}
@@ -0,0 +1,269 @@
+"""Subscription renewal endpoints.
+
+GET /subscription/renewal-options
+POST /subscription/renew
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import PaymentMethod, SubscriptionStatus, User
+from app.services.pricing_engine import pricing_engine
+from app.services.subscription_renewal_service import (
+    SubscriptionRenewalChargeError,
+    SubscriptionRenewalService,
+)
+from app.services.user_cart_service import user_cart_service
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    RenewalOptionResponse,
+    RenewalRequest,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/renewal-options', response_model=list[RenewalOptionResponse])
+async def get_renewal_options(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Get available subscription renewal options with prices."""
+    from .helpers import resolve_subscription
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        return []
+
+    # Classic subscriptions cannot be renewed when tariff mode is enabled
+    if settings.is_tariffs_mode() and not subscription.tariff_id:
+        return []
+
+    _non_renewable = {SubscriptionStatus.DISABLED.value, SubscriptionStatus.PENDING.value}
+    _actual_status = getattr(subscription, 'actual_status', subscription.status)
+    if _actual_status in _non_renewable:
+        return []
+
+    # Determine available periods
+    if subscription.tariff_id and subscription.tariff and subscription.tariff.period_prices:
+        periods = sorted(int(k) for k in subscription.tariff.period_prices.keys())
+    else:
+        periods = settings.get_available_renewal_periods()
+
+    options = []
+
+    for period in periods:
+        pricing = await pricing_engine.calculate_renewal_price(db, subscription, period, user=user)
+
+        if pricing.final_total <= 0 and pricing.original_total <= 0:
+            continue
+
+        original_price = pricing.original_total
+        combined_discount = 0
+        if original_price > 0 and original_price != pricing.final_total:
+            combined_discount = int((original_price - pricing.final_total) * 100 / original_price)
+
+        options.append(
+            RenewalOptionResponse(
+                period_days=period,
+                price_kopeks=pricing.final_total,
+                price_rubles=pricing.final_total / 100,
+                discount_percent=combined_discount,
+                original_price_kopeks=original_price if combined_discount > 0 else None,
+            )
+        )
+
+    return options
+
+
+@router.post('/renew')
+async def renew_subscription(
+    request: RenewalRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Renew subscription (pay from balance)."""
+    if getattr(user, 'restriction_subscription', False):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Subscription renewal is restricted for this account',
+        )
+
+    # Support subscription_id from both query param and body (backward compat)
+    from .helpers import resolve_subscription
+
+    _sub_id = subscription_id or request.subscription_id
+    subscription = await resolve_subscription(db, user, _sub_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    # Classic subscriptions cannot be renewed when tariff mode is enabled
+    if settings.is_tariffs_mode() and not subscription.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Classic subscriptions cannot be renewed. Please purchase a tariff.',
+        )
+
+    _non_renewable = {SubscriptionStatus.DISABLED.value, SubscriptionStatus.PENDING.value}
+    _actual_status = getattr(subscription, 'actual_status', subscription.status)
+    if _actual_status in _non_renewable:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f'Cannot renew subscription with status: {_actual_status}',
+        )
+
+    if subscription.tariff_id and subscription.tariff and subscription.tariff.period_prices:
+        available_periods = [int(p) for p in subscription.tariff.period_prices.keys()]
+    else:
+        available_periods = settings.get_available_renewal_periods()
+
+    if request.period_days not in available_periods:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Selected renewal period is not available',
+        )
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Unified pricing via PricingEngine
+    pricing = await pricing_engine.calculate_renewal_price(
+        db,
+        subscription,
+        request.period_days,
+        user=user,
+    )
+    price_kopeks = pricing.final_total
+    promo_offer_discount_value = pricing.promo_offer_discount
+    promo_offer_discount_percent = pricing.breakdown.get('offer_discount_pct', 0)
+
+    if price_kopeks <= 0 and pricing.original_total <= 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid renewal period',
+        )
+
+    original_price_kopeks = pricing.original_total
+    discount_percent = 0
+    if original_price_kopeks > 0 and original_price_kopeks != price_kopeks:
+        discount_percent = int((original_price_kopeks - price_kopeks) * 100 / original_price_kopeks)
+
+    tariff = subscription.tariff if subscription.tariff_id else None
+
+    # Check balance (skip for 100% discount)
+    if price_kopeks > 0 and user.balance_kopeks < price_kopeks:
+        missing = price_kopeks - user.balance_kopeks
+
+        # Get tariff info for cart
+        tariff_id = subscription.tariff_id
+        tariff_name = None
+        tariff_traffic_limit_gb = None
+        tariff_allowed_squads = None
+
+        if tariff_id:
+            tariff = await get_tariff_by_id(db, tariff_id)
+            if tariff:
+                tariff_name = tariff.name
+                tariff_traffic_limit_gb = tariff.traffic_limit_gb
+                tariff_allowed_squads = tariff.allowed_squads or []
+
+        # Save cart for auto-purchase after balance top-up
+        cart_data: dict[str, Any] = {
+            'cart_mode': 'extend',
+            'subscription_id': subscription.id,
+            'tariff_id': tariff_id,
+            'period_days': request.period_days,
+            'total_price': price_kopeks,
+            'user_id': user.id,
+            'saved_cart': True,
+            'missing_amount': missing,
+            'return_to_cart': True,
+            'description': f'Продление подписки на {request.period_days} дней'
+            + (f' ({tariff_name})' if tariff_name else ''),
+            'discount_percent': discount_percent,
+            'consume_promo_offer': promo_offer_discount_value > 0,
+            'source': 'cabinet',
+        }
+
+        # Add subscription parameters for auto-purchase
+        if tariff_id:
+            cart_data['traffic_limit_gb'] = tariff_traffic_limit_gb
+            # Сохраняем актуальный device_limit подписки (включая докупленные устройства)
+            cart_data['device_limit'] = subscription.device_limit
+            cart_data['allowed_squads'] = tariff_allowed_squads
+        else:
+            # Classic mode: сохраняем текущие параметры подписки для корректной автопокупки
+            cart_data['device_limit'] = subscription.device_limit
+            cart_data['traffic_limit_gb'] = subscription.traffic_limit_gb
+
+        try:
+            await user_cart_service.save_user_cart(user.id, cart_data)
+            logger.info('Cart saved for auto-renewal (cabinet) user', user_id=user.id)
+        except Exception as e:
+            logger.error('Error saving cart for auto-renewal (cabinet)', error=e)
+
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': f'Недостаточно средств. Не хватает {settings.format_price(missing)}',
+                'missing_amount': missing,
+                'cart_saved': True,
+                'cart_mode': 'extend',
+            },
+        )
+
+    # Centralized renewal: balance deduction, extension, RemnaWave sync, admin notification,
+    # server price recording, and compensating refund on failure.
+    renewal_description = f'Продление подписки на {request.period_days} дней' + (f' ({tariff.name})' if tariff else '')
+    renewal_service = SubscriptionRenewalService()
+
+    try:
+        result = await renewal_service.finalize(
+            db,
+            user,
+            subscription,
+            pricing,
+            description=renewal_description,
+            payment_method=PaymentMethod.BALANCE,
+        )
+    except SubscriptionRenewalChargeError:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': 'Недостаточно средств (concurrent check)',
+            },
+        )
+
+    response: dict[str, Any] = {
+        'message': 'Subscription renewed successfully',
+        'new_end_date': result.subscription.end_date.isoformat(),
+        'amount_paid_kopeks': price_kopeks,
+    }
+
+    # Add discount info to response
+    if promo_offer_discount_value > 0:
+        response['promo_discount_percent'] = promo_offer_discount_percent
+        response['promo_discount_amount_kopeks'] = promo_offer_discount_value
+        response['original_price_kopeks'] = original_price_kopeks
+
+    return response
@@ -0,0 +1,261 @@
+"""Server/country management endpoints.
+
+GET /subscription/countries
+POST /subscription/countries
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from .helpers import resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/countries')
+async def get_available_countries(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get available countries/servers for the user."""
+    from app.database.crud.server_squad import get_available_server_squads
+    from app.utils.pricing_utils import apply_percentage_discount, calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    promo_group_id = user.promo_group_id
+    available_servers = await get_available_server_squads(db, promo_group_id=promo_group_id)
+
+    connected_squads = []
+    days_left = 0
+    if subscription:
+        connected_squads = subscription.connected_squads or []
+        if subscription.end_date:
+            delta = subscription.end_date - datetime.now(UTC)
+            days_left = max(0, delta.days)
+
+    # Get discount from promo group via PricingEngine (respects apply_discounts_to_addons flag)
+    from app.services.pricing_engine import PricingEngine
+
+    servers_discount_percent = PricingEngine.get_addon_discount_percent(user, 'servers', None)
+
+    countries = []
+    for server in available_servers:
+        base_price = server.price_kopeks
+
+        # Apply discount
+        if servers_discount_percent > 0:
+            discounted_price, _ = apply_percentage_discount(base_price, servers_discount_percent)
+        else:
+            discounted_price = base_price
+
+        # Calculate prorated price if subscription exists
+        prorated_price = discounted_price
+        if subscription and subscription.end_date:
+            prorated_price, _ = calculate_prorated_price(
+                discounted_price,
+                subscription.end_date,
+            )
+
+        countries.append(
+            {
+                'uuid': server.squad_uuid,
+                'name': server.display_name,
+                'country_code': server.country_code,
+                'base_price_kopeks': base_price,
+                'price_kopeks': prorated_price,  # Prorated price with discount
+                'price_per_month_kopeks': discounted_price,  # Monthly price with discount
+                'price_rubles': prorated_price / 100,
+                'is_available': server.is_available and not server.is_full,
+                'is_connected': server.squad_uuid in connected_squads,
+                'has_discount': servers_discount_percent > 0,
+                'discount_percent': servers_discount_percent,
+            }
+        )
+
+    return {
+        'countries': countries,
+        'connected_count': len(connected_squads),
+        'has_subscription': subscription is not None,
+        'days_left': days_left,
+        'discount_percent': servers_discount_percent,
+    }
+
+
+@router.post('/countries')
+async def update_countries(
+    request: dict[str, Any],
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Update subscription countries/servers."""
+    from app.database.crud.server_squad import add_user_to_servers, get_available_server_squads, get_server_ids_by_uuids
+    from app.database.crud.subscription import add_subscription_servers
+    from app.database.crud.transaction import create_transaction
+    from app.database.crud.user import subtract_user_balance
+    from app.database.models import TransactionType
+    from app.utils.pricing_utils import apply_percentage_discount, calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Country management is not available for trial subscriptions',
+        )
+
+    selected_countries = request.get('countries', [])
+    if not selected_countries:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='At least one country must be selected',
+        )
+
+    current_countries = subscription.connected_squads or []
+    promo_group_id = user.promo_group_id
+
+    available_servers = await get_available_server_squads(db, promo_group_id=promo_group_id)
+    allowed_country_ids = {server.squad_uuid for server in available_servers}
+
+    # Validate selected countries
+    for country_uuid in selected_countries:
+        if country_uuid not in allowed_country_ids:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Country {country_uuid} is not available',
+            )
+
+    added = [c for c in selected_countries if c not in current_countries]
+    removed = [c for c in current_countries if c not in selected_countries]
+
+    if not added and not removed:
+        return {
+            'message': 'No changes detected',
+            'connected_squads': current_countries,
+        }
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Calculate cost for added servers
+    total_cost = 0
+    added_names = []
+    removed_names = []
+
+    from app.services.pricing_engine import PricingEngine
+
+    servers_discount_percent = PricingEngine.get_addon_discount_percent(user, 'servers', None)
+
+    added_server_prices = []
+
+    for server in available_servers:
+        if server.squad_uuid in added:
+            server_price_per_month = server.price_kopeks
+            if servers_discount_percent > 0:
+                discounted_per_month, _ = apply_percentage_discount(
+                    server_price_per_month,
+                    servers_discount_percent,
+                )
+            else:
+                discounted_per_month = server_price_per_month
+
+            charged_price, charged_days = calculate_prorated_price(
+                discounted_per_month,
+                subscription.end_date,
+            )
+
+            total_cost += charged_price
+            added_names.append(server.display_name)
+            added_server_prices.append(charged_price)
+
+        if server.squad_uuid in removed:
+            removed_names.append(server.display_name)
+
+    # Check balance
+    if total_cost > 0 and user.balance_kopeks < total_cost:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail=f'Insufficient balance. Need {total_cost / 100:.2f} RUB, have {user.balance_kopeks / 100:.2f} RUB',
+        )
+
+    # Deduct balance and update subscription
+    if added and total_cost > 0:
+        success = await subtract_user_balance(db, user, total_cost, f'Adding countries: {", ".join(added_names)}')
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=total_cost,
+            description=f'Adding countries to subscription: {", ".join(added_names)}',
+        )
+
+    # Add servers to subscription
+    if added:
+        added_server_ids = await get_server_ids_by_uuids(db, added)
+        if added_server_ids:
+            await add_subscription_servers(db, subscription, added_server_ids, added_server_prices)
+            try:
+                await add_user_to_servers(db, added_server_ids)
+            except Exception as e:
+                logger.error('Ошибка обновления счётчика серверов', error=e)
+
+    # Update connected squads
+    subscription.connected_squads = selected_countries
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Sync with RemnaWave
+    try:
+        from app.config import settings
+
+        subscription_service = SubscriptionService()
+        _has_panel = (
+            getattr(subscription, 'remnawave_uuid', None)
+            if settings.is_multi_tariff_enabled()
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _has_panel:
+            await subscription_service.update_remnawave_user(db, subscription, sync_squads=True)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync countries with RemnaWave', error=e)
+
+    await db.refresh(subscription)
+
+    return {
+        'message': 'Countries updated successfully',
+        'added': added_names,
+        'removed': removed_names,
+        'amount_paid_kopeks': total_cost,
+        'connected_squads': subscription.connected_squads,
+    }
@@ -0,0 +1,526 @@
+"""Subscription status endpoints.
+
+GET /subscription — subscription info
+GET /subscription/connection-link
+GET /subscription/happ-downloads
+GET /subscription/app-config
+"""
+
+from __future__ import annotations
+
+import base64
+import re
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.models import ServerSquad, User
+from app.services.remnawave_service import RemnaWaveService
+from app.services.system_settings_service import bot_configuration_service
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    ServerInfo,
+    SubscriptionStatusResponse,
+)
+from .helpers import _subscription_to_response, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/info', response_model=SubscriptionStatusResponse)
+async def get_subscription(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+):
+    """Get current user's subscription details."""
+    # Reload user from current session to get fresh data
+    # (user object is from different session in get_current_cabinet_user)
+    from app.database.crud.user import get_user_by_id
+
+    fresh_user = await get_user_by_id(db, user.id)
+
+    if not fresh_user:
+        return SubscriptionStatusResponse(has_subscription=False, subscription=None)
+
+    subscription = await resolve_subscription(db, fresh_user, subscription_id)
+
+    if not subscription:
+        # Return 200 with has_subscription: false instead of 404
+        return SubscriptionStatusResponse(has_subscription=False, subscription=None)
+
+    # Load tariff for daily subscription check and tariff name
+    tariff_name = None
+    if subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if tariff:
+            subscription.tariff = tariff
+            tariff_name = tariff.name
+
+    # Fetch server names for connected squads
+    servers: list[ServerInfo] = []
+    connected_squads = subscription.connected_squads or []
+    if connected_squads:
+        result = await db.execute(select(ServerSquad).where(ServerSquad.squad_uuid.in_(connected_squads)))
+        server_squads = result.scalars().all()
+        servers = [
+            ServerInfo(uuid=sq.squad_uuid, name=sq.display_name, country_code=sq.country_code) for sq in server_squads
+        ]
+
+    # Fetch traffic purchases (monthly packages)
+    traffic_purchases_data = []
+    from app.database.models import TrafficPurchase
+
+    now = datetime.now(UTC)
+    purchases_query = (
+        select(TrafficPurchase)
+        .where(TrafficPurchase.subscription_id == subscription.id)
+        .where(TrafficPurchase.expires_at > now)
+        .order_by(TrafficPurchase.expires_at.asc())
+    )
+    purchases_result = await db.execute(purchases_query)
+    purchases = purchases_result.scalars().all()
+
+    for purchase in purchases:
+        time_remaining = purchase.expires_at - now
+        days_remaining = max(0, int(time_remaining.total_seconds() / 86400))
+        total_duration_seconds = (purchase.expires_at - purchase.created_at).total_seconds()
+        elapsed_seconds = (now - purchase.created_at).total_seconds()
+        progress_percent = min(
+            100.0, max(0.0, (elapsed_seconds / total_duration_seconds * 100) if total_duration_seconds > 0 else 0)
+        )
+
+        traffic_purchases_data.append(
+            {
+                'id': purchase.id,
+                'traffic_gb': purchase.traffic_gb,
+                'expires_at': purchase.expires_at,
+                'created_at': purchase.created_at,
+                'days_remaining': days_remaining,
+                'progress_percent': round(progress_percent, 1),
+            }
+        )
+
+    subscription_data = _subscription_to_response(
+        subscription, servers, tariff_name, traffic_purchases_data, user=fresh_user
+    )
+    return SubscriptionStatusResponse(has_subscription=True, subscription=subscription_data)
+
+
+# ============ Connection Link ============
+
+
+@router.get('/connection-link')
+async def get_connection_link(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get subscription connection link and instructions."""
+    from app.utils.subscription_utils import (
+        convert_subscription_link_to_happ_scheme,
+        get_display_subscription_link,
+        get_happ_cryptolink_redirect_link,
+    )
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    subscription_url = subscription.subscription_url
+    if not subscription_url:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Subscription link not yet generated',
+        )
+
+    display_link = get_display_subscription_link(subscription)
+    happ_redirect = get_happ_cryptolink_redirect_link(subscription_url) if settings.is_happ_cryptolink_mode() else None
+    happ_scheme_link = (
+        convert_subscription_link_to_happ_scheme(subscription_url) if settings.is_happ_cryptolink_mode() else None
+    )
+
+    connect_mode = settings.CONNECT_BUTTON_MODE
+    hide_subscription_link = settings.should_hide_subscription_link()
+
+    return {
+        'subscription_url': subscription_url if not hide_subscription_link else None,
+        'display_link': display_link if not hide_subscription_link else None,
+        'happ_redirect_link': happ_redirect,
+        'happ_scheme_link': happ_scheme_link,
+        'connect_mode': connect_mode,
+        'hide_link': hide_subscription_link,
+        'instructions': {
+            'steps': [
+                'Copy the subscription link',
+                'Open your VPN application',
+                "Find 'Add subscription' or 'Import' option",
+                'Paste the copied link',
+            ]
+        },
+    }
+
+
+# ============ hApp Downloads ============
+
+
+@router.get('/happ-downloads')
+async def get_happ_downloads(
+    user: User = Depends(get_current_cabinet_user),
+) -> dict[str, Any]:
+    """Get hApp download links for different platforms."""
+    platforms = {
+        'ios': {
+            'name': 'iOS (iPhone/iPad)',
+            'icon': '🍎',
+            'link': settings.get_happ_download_link('ios'),
+        },
+        'android': {
+            'name': 'Android',
+            'icon': '🤖',
+            'link': settings.get_happ_download_link('android'),
+        },
+        'macos': {
+            'name': 'macOS',
+            'icon': '🖥️',
+            'link': settings.get_happ_download_link('macos'),
+        },
+        'windows': {
+            'name': 'Windows',
+            'icon': '💻',
+            'link': settings.get_happ_download_link('windows'),
+        },
+    }
+
+    # Filter out platforms without links
+    available_platforms = {k: v for k, v in platforms.items() if v['link']}
+
+    return {
+        'platforms': available_platforms,
+        'happ_enabled': bool(available_platforms),
+    }
+
+
+# ============ App Config for Connection ============
+
+
+def _get_remnawave_config_uuid() -> str | None:
+    """Get RemnaWave config UUID from system settings or env."""
+    try:
+        return bot_configuration_service.get_current_value('CABINET_REMNA_SUB_CONFIG')
+    except Exception:
+        return settings.CABINET_REMNA_SUB_CONFIG
+
+
+def _extract_scheme_from_buttons(buttons: list[dict[str, Any]]) -> tuple[str, bool]:
+    """Extract URL scheme from buttons list.
+
+    Returns:
+        Tuple of (scheme, uses_crypto_link).
+        uses_crypto_link=True when the template is {{HAPP_CRYPT4_LINK}},
+        meaning subscription_crypto_link should be used as payload.
+    """
+    for btn in buttons:
+        if not isinstance(btn, dict):
+            continue
+        link = btn.get('link', '') or btn.get('url', '') or btn.get('buttonLink', '')
+        if not link:
+            continue
+        link_upper = link.upper()
+
+        # Check for {{HAPP_CRYPT4_LINK}} -- uses crypto link as payload
+        if '{{HAPP_CRYPT4_LINK}}' in link_upper or 'HAPP_CRYPT4_LINK' in link_upper:
+            scheme = re.sub(r'\{\{HAPP_CRYPT4_LINK\}\}', '', link, flags=re.IGNORECASE)
+            if scheme and '://' in scheme:
+                return scheme, True
+
+        # Check for {{SUBSCRIPTION_LINK}} -- uses plain subscription_url as payload
+        if '{{SUBSCRIPTION_LINK}}' in link_upper or 'SUBSCRIPTION_LINK' in link_upper:
+            scheme = re.sub(r'\{\{SUBSCRIPTION_LINK\}\}', '', link, flags=re.IGNORECASE)
+            if scheme and '://' in scheme:
+                return scheme, False
+
+        # Also check for type="subscriptionLink" buttons with custom schemes
+        btn_type = btn.get('type', '')
+        if btn_type == 'subscriptionLink' and '://' in link and not link.startswith('http'):
+            scheme = link.split('{{')[0] if '{{' in link else link
+            if scheme and '://' in scheme:
+                return scheme, False
+    return '', False
+
+
+def _get_url_scheme_for_app(app: dict[str, Any]) -> tuple[str, bool]:
+    """Get URL scheme for app - from config, buttons, or fallback by name.
+
+    Returns:
+        Tuple of (scheme, uses_crypto_link).
+        uses_crypto_link=True means the app template uses {{HAPP_CRYPT4_LINK}},
+        so subscription_crypto_link should be used as the deep link payload.
+    """
+    # 1. Check urlScheme field (cabinet format stores usesCryptoLink alongside)
+    scheme = str(app.get('urlScheme', '')).strip()
+    if scheme:
+        uses_crypto = bool(app.get('usesCryptoLink', False))
+        return scheme, uses_crypto
+
+    # 2. Extract from buttons in blocks (RemnaWave format)
+    blocks = app.get('blocks', [])
+    for block in blocks:
+        if not isinstance(block, dict):
+            continue
+        buttons = block.get('buttons', [])
+        scheme, uses_crypto = _extract_scheme_from_buttons(buttons)
+        if scheme:
+            return scheme, uses_crypto
+
+    # 3. Check buttons directly in app (alternative structure)
+    direct_buttons = app.get('buttons', [])
+    if direct_buttons:
+        scheme, uses_crypto = _extract_scheme_from_buttons(direct_buttons)
+        if scheme:
+            return scheme, uses_crypto
+
+    # No scheme found
+    logger.debug(
+        '_get_url_scheme_for_app: No scheme found for app has blocks: has buttons: has urlScheme',
+        get=app.get('name'),
+        get_2=bool(app.get('blocks')),
+        get_3=bool(app.get('buttons')),
+        get_4=bool(app.get('urlScheme')),
+    )
+    return '', False
+
+
+async def _load_app_config_async() -> dict[str, Any] | None:
+    """Load app config from RemnaWave API (if configured).
+
+    Returns None when no Remnawave config is set or API fails.
+    """
+    remnawave_uuid = _get_remnawave_config_uuid()
+
+    if remnawave_uuid:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                config = await api.get_subscription_page_config(remnawave_uuid)
+                if config and config.config:
+                    logger.debug('Loaded app config from RemnaWave', remnawave_uuid=remnawave_uuid)
+                    raw = dict(config.config)
+                    raw['_isRemnawave'] = True
+                    return raw
+        except Exception as e:
+            logger.warning('Failed to load RemnaWave config', error=e)
+
+    return None
+
+
+def _create_deep_link(
+    app: dict[str, Any], subscription_url: str, subscription_crypto_link: str | None = None
+) -> str | None:
+    """Create deep link for app with subscription URL.
+
+    Uses urlScheme from RemnaWave config (e.g. "happ://add/", "v2rayng://install-config?url=")
+    combined with the appropriate payload URL.
+
+    Two Happ schemes exist in RemnaWave:
+      - happ://add/{{SUBSCRIPTION_LINK}}       -> uses plain subscription_url
+      - happ://crypt4/{{HAPP_CRYPT4_LINK}}     -> uses subscription_crypto_link
+    """
+    if not isinstance(app, dict):
+        return None
+
+    if not subscription_url and not subscription_crypto_link:
+        return None
+
+    scheme, uses_crypto = _get_url_scheme_for_app(app)
+    if not scheme:
+        logger.debug('_create_deep_link: no urlScheme for app', get=app.get('name', 'unknown'))
+        return None
+
+    # Pick the correct payload based on which template the app uses
+    if uses_crypto:
+        if not subscription_crypto_link:
+            logger.debug(
+                '_create_deep_link: app requires crypto link but none available', get=app.get('name', 'unknown')
+            )
+            return None
+        payload = subscription_crypto_link
+    else:
+        if not subscription_url:
+            logger.debug(
+                '_create_deep_link: app requires subscription_url but none available', get=app.get('name', 'unknown')
+            )
+            return None
+        payload = subscription_url
+
+    if app.get('isNeedBase64Encoding'):
+        try:
+            payload = base64.b64encode(payload.encode('utf-8')).decode('utf-8')
+        except Exception as e:
+            logger.warning('Failed to encode payload to base64', error=e)
+
+    return f'{scheme}{payload}'
+
+
+def _resolve_button_url(
+    url: str,
+    subscription_url: str | None,
+    subscription_crypto_link: str | None,
+) -> str:
+    """Resolve template variables in button URLs.
+
+    Matches remnawave/subscription-page frontend TemplateEngine:
+    - {{SUBSCRIPTION_LINK}} -> plain subscription URL
+    - {{HAPP_CRYPT3_LINK}} -> crypto link
+    - {{HAPP_CRYPT4_LINK}} -> crypto link
+    """
+    if not url:
+        return url
+    result = url
+    if subscription_url:
+        result = result.replace('{{SUBSCRIPTION_LINK}}', subscription_url)
+    if subscription_crypto_link:
+        result = result.replace('{{HAPP_CRYPT3_LINK}}', subscription_crypto_link)
+        result = result.replace('{{HAPP_CRYPT4_LINK}}', subscription_crypto_link)
+    return result
+
+
+@router.get('/app-config')
+async def get_app_config(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = Query(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Get app configuration for connection with deep links."""
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    subscription_url = None
+    subscription_crypto_link = None
+    if subscription:
+        subscription_url = subscription.subscription_url
+        subscription_crypto_link = subscription.subscription_crypto_link
+
+    # Generate crypto link on the fly if subscription_url exists but crypto link is missing.
+    # This covers synced users where enrich_happ_links was not called.
+    if subscription_url and not subscription_crypto_link:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                encrypted = await api.encrypt_happ_crypto_link(subscription_url)
+                if encrypted:
+                    subscription_crypto_link = encrypted
+                    if subscription:
+                        subscription.subscription_crypto_link = encrypted
+                        await db.commit()
+                        logger.info(
+                            'Generated and saved crypto link for user',
+                            user_id=user.id,
+                        )
+        except Exception as e:
+            logger.debug('Could not generate crypto link', error=e)
+
+    config = await _load_app_config_async()
+
+    if not config:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='App configuration not set up.',
+        )
+
+    config.pop('_isRemnawave', None)
+    hide_link = settings.should_hide_subscription_link()
+
+    # Build platformNames from displayName of each platform
+    platform_names: dict[str, Any] = {}
+    for pk, pd in config.get('platforms', {}).items():
+        if isinstance(pd, dict) and 'displayName' in pd:
+            platform_names[pk] = pd['displayName']
+    fallback_names = {
+        'ios': {'en': 'iPhone/iPad'},
+        'android': {'en': 'Android'},
+        'macos': {'en': 'macOS'},
+        'windows': {'en': 'Windows'},
+        'linux': {'en': 'Linux'},
+        'androidTV': {'en': 'Android TV'},
+        'appleTV': {'en': 'Apple TV'},
+    }
+    for k, v in fallback_names.items():
+        if k not in platform_names:
+            platform_names[k] = v
+
+    # Serve original blocks/svgLibrary enriched with deep links and resolved URLs.
+    platforms: dict[str, Any] = {}
+    for platform_key, platform_data in config.get('platforms', {}).items():
+        if not isinstance(platform_data, dict):
+            continue
+        apps = platform_data.get('apps', [])
+        if not isinstance(apps, list):
+            continue
+
+        enriched_apps = []
+        for app in apps:
+            if not isinstance(app, dict):
+                continue
+
+            # Generate deep link
+            deep_link = None
+            if subscription_url or subscription_crypto_link:
+                deep_link = _create_deep_link(app, subscription_url, subscription_crypto_link)
+            app['deepLink'] = deep_link
+
+            # Resolve templates only for subscriptionLink and copyButton (not external)
+            for block in app.get('blocks', []):
+                if not isinstance(block, dict):
+                    continue
+                for btn in block.get('buttons', []):
+                    if not isinstance(btn, dict):
+                        continue
+                    btn_type = btn.get('type', '')
+                    if btn_type in ('subscriptionLink', 'copyButton'):
+                        url = btn.get('url', '') or btn.get('link', '')
+                        if url and '{{' in url:
+                            resolved = _resolve_button_url(
+                                url,
+                                subscription_url,
+                                subscription_crypto_link,
+                            )
+                            # Only set resolvedUrl if ALL templates were resolved;
+                            # otherwise let the frontend fall through to deepLink/subscriptionUrl
+                            if '{{' not in resolved:
+                                btn['resolvedUrl'] = resolved
+
+            enriched_apps.append(app)
+
+        if enriched_apps:
+            platform_output = {k: v for k, v in platform_data.items() if k != 'apps'}
+            platform_output['apps'] = enriched_apps
+            platforms[platform_key] = platform_output
+
+    return {
+        'isRemnawave': True,
+        'platforms': platforms,
+        'svgLibrary': config.get('svgLibrary', {}),
+        'baseTranslations': config.get('baseTranslations'),
+        'baseSettings': config.get('baseSettings'),
+        'uiConfig': config.get('uiConfig', {}),
+        'platformNames': platform_names,
+        'hasSubscription': bool(subscription_url or subscription_crypto_link),
+        'subscriptionUrl': subscription_url,
+        'subscriptionCryptoLink': subscription_crypto_link,
+        'hideLink': hide_link,
+        'branding': config.get('brandingSettings', {}),
+    }
@@ -0,0 +1,500 @@
+"""Tariff switching endpoints.
+
+POST /subscription/tariff/switch/preview
+POST /subscription/tariff/switch
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.crud.transaction import create_transaction
+from app.database.crud.user import subtract_user_balance
+from app.database.models import PaymentMethod, Subscription, TransactionType, User
+from app.services.pricing_engine import pricing_engine
+from app.services.remnawave_service import RemnaWaveService
+from app.services.subscription_service import SubscriptionService
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import TariffPurchaseRequest
+from .helpers import _subscription_to_response, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.post('/tariff/switch/preview')
+async def preview_tariff_switch(
+    request: TariffPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Preview tariff switch - shows cost calculation."""
+    if not settings.is_tariffs_mode():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Tariffs mode is not enabled',
+        )
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription or not subscription.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='No active subscription with tariff',
+        )
+
+    # Use actual_status for correct status check (handles time-based expiration)
+    actual_status = subscription.actual_status
+    if actual_status == 'expired':
+        # For expired subscriptions, user should purchase a new tariff, not switch
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_expired',
+                'message': 'Subscription is expired. Please purchase a new tariff instead of switching.',
+                'use_purchase_flow': True,
+            },
+        )
+    if actual_status not in ('active', 'trial'):
+        # For disabled/pending subscriptions, block switching with generic error
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_not_active',
+                'message': f'Subscription is not active (status: {actual_status}). Cannot switch tariff.',
+            },
+        )
+
+    current_tariff = await get_tariff_by_id(db, subscription.tariff_id)
+    new_tariff = await get_tariff_by_id(db, request.tariff_id)
+
+    if not new_tariff or not new_tariff.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found or inactive',
+        )
+
+    if subscription.tariff_id == request.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this tariff',
+        )
+
+    # Check tariff availability for user's promo group
+    # Use get_primary_promo_group() for correct promo group resolution
+    promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+    if promo_group is None:
+        promo_group = getattr(user, 'promo_group', None)
+    promo_group_id = promo_group.id if promo_group else None
+    if not new_tariff.is_available_for_promo_group(promo_group_id):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Tariff not available for your promo group',
+        )
+
+    # Calculate remaining days
+    remaining_days = 0
+    if subscription.end_date and subscription.end_date > datetime.now(UTC):
+        delta = subscription.end_date - datetime.now(UTC)
+        remaining_days = max(0, delta.days)
+
+    # Calculate switch cost (PricingEngine handles all cases: periodic<->periodic, daily->periodic, periodic->daily)
+    switch_result = pricing_engine.calculate_tariff_switch_cost(
+        current_tariff,
+        new_tariff,
+        remaining_days,
+        user=user,
+    )
+    upgrade_cost = switch_result.upgrade_cost
+    is_upgrade = switch_result.is_upgrade
+    base_upgrade_cost = switch_result.raw_cost
+    discount_value = switch_result.discount_value
+    period_discount_percent = switch_result.effective_discount_pct
+
+    balance = user.balance_kopeks or 0
+    has_enough = balance >= upgrade_cost
+    missing = max(0, upgrade_cost - balance) if not has_enough else 0
+
+    response: dict[str, Any] = {
+        'can_switch': has_enough,
+        'current_tariff_id': current_tariff.id if current_tariff else None,
+        'current_tariff_name': current_tariff.name if current_tariff else None,
+        'new_tariff_id': new_tariff.id,
+        'new_tariff_name': new_tariff.name,
+        'remaining_days': remaining_days,
+        'upgrade_cost_kopeks': upgrade_cost,
+        'upgrade_cost_label': settings.format_price(upgrade_cost) if upgrade_cost > 0 else 'Бесплатно',
+        'balance_kopeks': balance,
+        'balance_label': settings.format_price(balance),
+        'has_enough_balance': has_enough,
+        'missing_amount_kopeks': missing,
+        'missing_amount_label': settings.format_price(missing) if missing > 0 else '',
+        'is_upgrade': is_upgrade,
+    }
+
+    # Add discount info if applicable
+    if period_discount_percent > 0 and discount_value > 0:
+        response['discount_percent'] = period_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_upgrade_cost_kopeks'] = base_upgrade_cost
+
+    return response
+
+
+@router.post('/tariff/switch')
+async def switch_tariff(
+    request: TariffPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Switch to a different tariff without changing end date."""
+    if not settings.is_tariffs_mode():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Tariffs mode is not enabled',
+        )
+
+    resolved = await resolve_subscription(db, user, subscription_id)
+
+    if not resolved or not resolved.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='No active subscription with tariff',
+        )
+
+    # Guard: prevent switching to a tariff the user already owns (multi-tariff)
+    if settings.is_multi_tariff_enabled() and request.tariff_id:
+        from app.database.crud.subscription import get_subscription_by_user_and_tariff
+
+        existing_target = await get_subscription_by_user_and_tariff(db, user.id, request.tariff_id)
+        if existing_target and existing_target.id != resolved.id:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail='You already have an active subscription for the target tariff',
+            )
+
+    # Lock subscription row to prevent concurrent tariff switches
+    locked_result = await db.execute(
+        select(Subscription)
+        .where(Subscription.id == resolved.id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    subscription = locked_result.scalar_one()
+
+    # Use actual_status for correct status check (handles time-based expiration)
+    actual_status = subscription.actual_status
+    if actual_status == 'expired':
+        # For expired subscriptions, user should purchase a new tariff, not switch
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_expired',
+                'message': 'Subscription is expired. Please purchase a new tariff instead of switching.',
+                'use_purchase_flow': True,
+            },
+        )
+    if actual_status not in ('active', 'trial'):
+        # For disabled/pending subscriptions, block switching with generic error
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                'code': 'subscription_not_active',
+                'message': f'Subscription is not active (status: {actual_status}). Cannot switch tariff.',
+            },
+        )
+
+    current_tariff = await get_tariff_by_id(db, subscription.tariff_id)
+    new_tariff = await get_tariff_by_id(db, request.tariff_id)
+
+    if not new_tariff or not new_tariff.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Tariff not found or inactive',
+        )
+
+    if subscription.tariff_id == request.tariff_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this tariff',
+        )
+
+    # Check tariff availability
+    # Use get_primary_promo_group() for correct promo group resolution
+    promo_group = user.get_primary_promo_group() if hasattr(user, 'get_primary_promo_group') else None
+    if promo_group is None:
+        promo_group = getattr(user, 'promo_group', None)
+    promo_group_id = promo_group.id if promo_group else None
+    if not new_tariff.is_available_for_promo_group(promo_group_id):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Tariff not available',
+        )
+
+    # Lock user BEFORE price computation to prevent TOCTOU on promo offer
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Calculate remaining days
+    remaining_days = 0
+    if subscription.end_date and subscription.end_date > datetime.now(UTC):
+        delta = subscription.end_date - datetime.now(UTC)
+        remaining_days = max(0, delta.days)
+
+    # Calculate cost (PricingEngine handles all cases: periodic<->periodic, daily->periodic, periodic->daily)
+    switch_result = pricing_engine.calculate_tariff_switch_cost(
+        current_tariff,
+        new_tariff,
+        remaining_days,
+        user=user,
+    )
+    upgrade_cost = switch_result.upgrade_cost
+    base_upgrade_cost = switch_result.raw_cost
+    discount_value = switch_result.discount_value
+    period_discount_percent = switch_result.effective_discount_pct
+    new_period_days = switch_result.new_period_days
+
+    # Validate daily price for switching TO daily
+    new_is_daily = getattr(new_tariff, 'is_daily', False)
+    current_is_daily = getattr(current_tariff, 'is_daily', False) if current_tariff else False
+    switching_to_daily = not current_is_daily and new_is_daily
+    switching_from_daily = current_is_daily and not new_is_daily
+
+    if switching_to_daily and (getattr(new_tariff, 'daily_price_kopeks', 0) or 0) <= 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Daily tariff has invalid price',
+        )
+
+    # Charge if upgrade
+    switch_transaction = None
+    if upgrade_cost > 0:
+        if user.balance_kopeks < upgrade_cost:
+            missing = upgrade_cost - user.balance_kopeks
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail={
+                    'code': 'insufficient_funds',
+                    'message': f'Insufficient funds. Missing {settings.format_price(missing)}',
+                    'missing_amount': missing,
+                },
+            )
+
+        if switching_to_daily:
+            description = f"Переход на суточный тариф '{new_tariff.name}'"
+        elif switching_from_daily:
+            description = f"Переход с суточного на тариф '{new_tariff.name}' ({new_period_days} дней)"
+        else:
+            description = f"Переход на тариф '{new_tariff.name}' (доплата за {remaining_days} дней)"
+
+        # Add discount info to description if applicable
+        if period_discount_percent > 0 and discount_value > 0:
+            description += f' (скидка {period_discount_percent}%)'
+
+        success = await subtract_user_balance(
+            db,
+            user,
+            upgrade_cost,
+            description,
+            consume_promo_offer=switch_result.offer_discount_pct > 0,
+            mark_as_paid_subscription=True,
+            commit=False,
+        )
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        # Create transaction (commit=False to keep FOR UPDATE lock held)
+        switch_transaction = await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=upgrade_cost,
+            description=description,
+            payment_method=PaymentMethod.BALANCE,
+            commit=False,
+        )
+    else:
+        # Free switch (downgrade) — record in history
+        description = f"Переход на тариф '{new_tariff.name}'"
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=0,
+            description=description,
+            commit=False,
+        )
+
+    # Update subscription
+    old_tariff_name = current_tariff.name if current_tariff else 'Unknown'
+
+    # Reset device limit to new tariff base (extra purchased devices are not carried over)
+    from app.database.crud.subscription import calc_device_limit_on_tariff_switch
+
+    # Re-load subscription to avoid MissingGreenlet from expired lazy relationship
+    # (subtract_user_balance re-selects User with populate_existing=True which expires relationships)
+    await db.refresh(subscription)
+
+    subscription.tariff_id = new_tariff.id
+    subscription.traffic_limit_gb = new_tariff.traffic_limit_gb
+    subscription.device_limit = calc_device_limit_on_tariff_switch(
+        current_device_limit=subscription.device_limit,
+        old_tariff_device_limit=current_tariff.device_limit if current_tariff else None,
+        new_tariff_device_limit=new_tariff.device_limit,
+        max_device_limit=new_tariff.max_device_limit,
+    )
+    subscription.connected_squads = new_tariff.allowed_squads or []
+
+    # Reset purchased traffic and delete TrafficPurchase records on tariff switch
+    from sqlalchemy import delete as sql_delete
+
+    from app.database.models import TrafficPurchase
+
+    await db.execute(sql_delete(TrafficPurchase).where(TrafficPurchase.subscription_id == subscription.id))
+    subscription.purchased_traffic_gb = 0
+    subscription.traffic_reset_at = None
+
+    if settings.RESET_TRAFFIC_ON_TARIFF_SWITCH:
+        subscription.traffic_used_gb = 0.0
+
+    if switching_to_daily:
+        # Switching TO daily - reset end_date to 1 day, set last_daily_charge_at
+        subscription.end_date = datetime.now(UTC) + timedelta(days=1)
+        subscription.last_daily_charge_at = datetime.now(UTC)
+        subscription.is_daily_paused = False
+    elif switching_from_daily:
+        subscription.end_date = datetime.now(UTC) + timedelta(days=new_period_days)
+        subscription.is_daily_paused = False
+
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Emit deferred side-effects after atomic commit
+    if upgrade_cost > 0 and switch_transaction:
+        from app.database.crud.transaction import emit_transaction_side_effects
+
+        await emit_transaction_side_effects(
+            db,
+            switch_transaction,
+            amount_kopeks=upgrade_cost,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            payment_method=PaymentMethod.BALANCE,
+        )
+
+    # Sync with RemnaWave (optionally reset traffic based on admin setting)
+    should_reset_traffic = settings.RESET_TRAFFIC_ON_TARIFF_SWITCH
+    # Refresh subscription after commit (all objects are expired)
+    await db.refresh(subscription)
+
+    try:
+        subscription_service = SubscriptionService()
+        _has_panel = (
+            getattr(subscription, 'remnawave_uuid', None)
+            if settings.is_multi_tariff_enabled()
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _has_panel:
+            await subscription_service.update_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=should_reset_traffic,
+                reset_reason='смена тарифа',
+                sync_squads=True,
+            )
+        else:
+            await subscription_service.create_remnawave_user(
+                db,
+                subscription,
+                reset_traffic=should_reset_traffic,
+                reset_reason='смена тарифа',
+            )
+    except Exception as e:
+        logger.error('Failed to sync tariff switch with RemnaWave', error=e)
+
+    # Reset all devices on tariff switch
+    devices_reset = False
+    _switch_uuid = (
+        subscription.remnawave_uuid
+        if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+        else user.remnawave_uuid
+    )
+    if _switch_uuid:
+        try:
+            service = RemnaWaveService()
+            async with service.get_api_client() as api:
+                await api.reset_user_devices(_switch_uuid)
+                devices_reset = True
+                logger.info('Reset all devices for user on tariff switch', user_id=user.id)
+        except Exception as e:
+            logger.error('Failed to reset devices on tariff switch', error=e)
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    # Отправляем уведомление админам о смене тарифа
+    try:
+        from aiogram import Bot
+
+        from app.services.admin_notification_service import AdminNotificationService
+
+        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
+            bot = Bot(token=settings.BOT_TOKEN)
+            try:
+                notification_service = AdminNotificationService(bot)
+                await notification_service.send_subscription_purchase_notification(
+                    db=db,
+                    user=user,
+                    subscription=subscription,
+                    transaction=switch_transaction if upgrade_cost > 0 else None,
+                    period_days=remaining_days if remaining_days > 0 else new_period_days,
+                    was_trial_conversion=False,
+                    amount_kopeks=upgrade_cost,
+                    purchase_type='tariff_switch',
+                )
+            finally:
+                await bot.session.close()
+    except Exception as e:
+        logger.error('Failed to send admin notification for tariff switch', error=e)
+
+    # Refresh expired objects after db.commit() in _record_subscription_event
+    await db.refresh(subscription)
+    await db.refresh(user)
+
+    response: dict[str, Any] = {
+        'success': True,
+        'message': f"Switched from '{old_tariff_name}' to '{new_tariff.name}'"
+        + (' (devices reset)' if devices_reset else ''),
+        'subscription': _subscription_to_response(subscription, user=user),
+        'old_tariff_name': old_tariff_name,
+        'new_tariff_id': new_tariff.id,
+        'new_tariff_name': new_tariff.name,
+        'charged_kopeks': upgrade_cost,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }
+
+    # Add discount info if applicable
+    if period_discount_percent > 0 and discount_value > 0:
+        response['discount_percent'] = period_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_charged_kopeks'] = base_upgrade_cost
+
+    return response
@@ -0,0 +1,770 @@
+"""Traffic management endpoints.
+
+GET /subscription/traffic-packages
+POST /subscription/traffic
+PUT /subscription/traffic
+POST /subscription/refresh-traffic
+POST /subscription/traffic/save-cart
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Query as QueryParam, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.tariff import get_tariff_by_id
+from app.database.crud.transaction import create_transaction
+from app.database.crud.user import subtract_user_balance
+from app.database.models import TransactionType, User
+from app.services.pricing_engine import pricing_engine
+from app.services.remnawave_service import RemnaWaveService
+from app.services.subscription_service import SubscriptionService
+from app.services.user_cart_service import user_cart_service
+from app.utils.cache import RateLimitCache, cache, cache_key
+
+from ...dependencies import get_cabinet_db, get_current_cabinet_user
+from ...schemas.subscription import (
+    TrafficPackageResponse,
+    TrafficPurchaseRequest,
+)
+from .helpers import _apply_addon_discount, resolve_subscription
+
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get('/traffic-packages', response_model=list[TrafficPackageResponse])
+async def get_traffic_packages(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """Get available traffic packages."""
+    from app.database.crud.tariff import get_tariff_by_id
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        return []
+
+    # Режим тарифов - берём пакеты из тарифа
+    if settings.is_tariffs_mode() and subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            return []
+
+        # Проверяем, разрешена ли докупка для этого тарифа
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            return []
+
+        # Проверяем безлимит
+        if tariff.traffic_limit_gb == 0:
+            return []
+
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        result = []
+
+        for gb, price in packages.items():
+            if price <= 0:
+                continue
+            result.append(
+                TrafficPackageResponse(
+                    gb=gb,
+                    price_kopeks=price,
+                    price_rubles=price / 100,
+                    is_unlimited=False,
+                )
+            )
+
+        return sorted(result, key=lambda x: x.gb)
+
+    # Classic режим - глобальные настройки
+    if not settings.is_traffic_topup_enabled():
+        return []
+
+    # Проверяем настройку тарифа пользователя (allow_traffic_topup)
+    if subscription.tariff_id:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if tariff and not tariff.allow_traffic_topup:
+            return []
+
+    packages = settings.get_traffic_topup_packages()
+    result = []
+
+    for pkg in packages:
+        if not pkg.get('enabled', True):
+            continue
+        if pkg['price'] <= 0:
+            continue
+
+        result.append(
+            TrafficPackageResponse(
+                gb=pkg['gb'],
+                price_kopeks=pkg['price'],
+                price_rubles=pkg['price'] / 100,
+                is_unlimited=pkg['gb'] == 0,
+            )
+        )
+
+    return result
+
+
+@router.post('/traffic')
+async def purchase_traffic(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """Purchase additional traffic."""
+    if getattr(user, 'restriction_subscription', False):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Subscription purchases are restricted for this account',
+        )
+
+    from app.database.crud.subscription import add_subscription_traffic
+    from app.database.crud.tariff import get_tariff_by_id
+    from app.utils.pricing_utils import calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+    tariff = None
+    base_price_kopeks = 0
+    is_tariff_mode = settings.is_tariffs_mode() and subscription.tariff_id
+
+    # Режим тарифов
+    if is_tariff_mode:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Tariff not found',
+            )
+
+        # Проверяем, разрешена ли докупка
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic top-up is disabled for this tariff',
+            )
+
+        # Проверяем безлимит
+        if tariff.traffic_limit_gb == 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Cannot add traffic to unlimited subscription',
+            )
+
+        # Проверяем лимит докупки
+        max_topup_limit = getattr(tariff, 'max_topup_traffic_gb', 0) or 0
+        if max_topup_limit > 0:
+            current_traffic = subscription.traffic_limit_gb or 0
+            new_traffic = current_traffic + request.gb
+            if new_traffic > max_topup_limit:
+                available_gb = max(0, max_topup_limit - current_traffic)
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f'Traffic limit exceeded. Max: {max_topup_limit} GB, available: {available_gb} GB',
+                )
+
+        # Получаем цену из тарифа
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        if request.gb not in packages:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Traffic package {request.gb}GB is not available',
+            )
+        base_price_kopeks = packages[request.gb]
+        if base_price_kopeks <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Traffic package {request.gb}GB has no price configured',
+            )
+
+    else:
+        # Classic режим
+        if not settings.is_traffic_topup_enabled():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic top-up feature is disabled',
+            )
+
+        # Проверяем настройку тарифа (allow_traffic_topup)
+        if subscription.tariff_id:
+            tariff = await get_tariff_by_id(db, subscription.tariff_id)
+            if tariff and not tariff.allow_traffic_topup:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail='Traffic top-up is not available for your tariff',
+                )
+
+        # Получаем цену из глобальных настроек
+        packages = settings.get_traffic_topup_packages()
+        matching_pkg = next((pkg for pkg in packages if pkg['gb'] == request.gb and pkg.get('enabled', True)), None)
+        if not matching_pkg:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Invalid traffic package',
+            )
+        base_price_kopeks = matching_pkg['price']
+        if base_price_kopeks <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Traffic package has no price configured',
+            )
+
+    # На тарифах пакеты трафика покупаются на 1 месяц (30 дней),
+    # цена в тарифе уже месячная — не умножаем на оставшиеся месяцы подписки.
+    # Пропорциональный расчёт применяем только в классическом режиме.
+    if is_tariff_mode:
+        prorated_price = base_price_kopeks
+        days_charged = 30
+    else:
+        prorated_price, days_charged = calculate_prorated_price(
+            base_price_kopeks,
+            subscription.end_date,
+        )
+
+    # Lock user row to prevent TOCTOU on promo-offer state
+    from app.database.crud.user import lock_user_for_pricing
+
+    user = await lock_user_for_pricing(db, user.id)
+
+    # Apply discount from promo group using proper method
+    period_hint_days = days_charged if days_charged > 0 else 30
+    discount_result = _apply_addon_discount(user, 'traffic', prorated_price, period_hint_days)
+    final_price = discount_result['discounted']
+    traffic_discount_percent = discount_result['percent']
+    discount_value = discount_result['discount']
+
+    # Ensure minimum price after discount (except for 100% discount)
+    if traffic_discount_percent < 100 and final_price > 0:
+        final_price = max(100, final_price)
+
+    # Проверяем баланс
+    if final_price > 0 and user.balance_kopeks < final_price:
+        missing = final_price - user.balance_kopeks
+
+        # Save cart for auto-purchase after balance top-up
+        cart_data = {
+            'cart_mode': 'add_traffic',
+            'subscription_id': subscription.id,
+            'traffic_gb': request.gb,
+            'price_kopeks': final_price,
+            'base_price_kopeks': prorated_price,
+            'discount_percent': traffic_discount_percent,
+            'source': 'cabinet',
+            'description': f'Докупка {request.gb} ГБ трафика',
+        }
+
+        try:
+            await user_cart_service.save_user_cart(user.id, cart_data)
+            logger.info(
+                'Cart saved for traffic purchase (cabinet) user + discount',
+                user_id=user.id,
+                gb=request.gb,
+                traffic_discount_percent=traffic_discount_percent,
+            )
+        except Exception as e:
+            logger.error('Error saving cart for traffic purchase (cabinet)', error=e)
+
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail={
+                'code': 'insufficient_funds',
+                'message': f'Недостаточно средств. Не хватает {settings.format_price(missing)}',
+                'missing_amount': missing,
+                'cart_saved': True,
+                'cart_mode': 'add_traffic',
+            },
+        )
+
+    # Формируем описание
+    if traffic_discount_percent > 0:
+        traffic_description = f'Докупка {request.gb} ГБ трафика (скидка {traffic_discount_percent}%)'
+    else:
+        traffic_description = f'Докупка {request.gb} ГБ трафика'
+
+    # Списываем баланс
+    success = await subtract_user_balance(db, user, final_price, traffic_description)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to charge balance',
+        )
+
+    # Добавляем трафик (add_subscription_traffic обновляет purchased_traffic_gb, traffic_reset_at и коммитит)
+    await add_subscription_traffic(db, subscription, request.gb)
+
+    # Реактивируем подписку если она была DISABLED/EXPIRED (например, после LIMITED/EXPIRED в RemnaWave)
+    from app.database.crud.subscription import reactivate_subscription
+
+    await reactivate_subscription(db, subscription)
+
+    # Синхронизируем с RemnaWave
+    try:
+        subscription_service = SubscriptionService()
+        _panel_uuid = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _panel_uuid:
+            await subscription_service.update_remnawave_user(db, subscription)
+            if subscription.status == 'active':
+                await subscription_service.enable_remnawave_user(_panel_uuid)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync traffic with RemnaWave', error=e)
+
+    # Создаём транзакцию
+    await create_transaction(
+        db=db,
+        user_id=user.id,
+        type=TransactionType.SUBSCRIPTION_PAYMENT,
+        amount_kopeks=final_price,
+        description=traffic_description,
+    )
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    # Отправляем уведомление админам
+    try:
+        from aiogram import Bot
+
+        from app.services.admin_notification_service import AdminNotificationService
+
+        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
+            bot = Bot(token=settings.BOT_TOKEN)
+            try:
+                notification_service = AdminNotificationService(bot)
+                old_traffic = subscription.traffic_limit_gb - request.gb
+                await notification_service.send_subscription_update_notification(
+                    db=db,
+                    user=user,
+                    subscription=subscription,
+                    update_type='traffic',
+                    old_value=old_traffic,
+                    new_value=subscription.traffic_limit_gb,
+                    price_paid=final_price,
+                )
+            finally:
+                await bot.session.close()
+    except Exception as e:
+        logger.error('Failed to send admin notification for traffic purchase', error=e)
+
+    response: dict[str, Any] = {
+        'success': True,
+        'message': 'Traffic purchased successfully',
+        'gb_added': request.gb,
+        'new_traffic_limit_gb': subscription.traffic_limit_gb,
+        'amount_paid_kopeks': final_price,
+        'new_balance_kopeks': user.balance_kopeks,
+    }
+
+    if traffic_discount_percent > 0:
+        response['discount_percent'] = traffic_discount_percent
+        response['discount_kopeks'] = discount_value
+        response['base_price_kopeks'] = prorated_price
+
+    return response
+
+
+@router.post('/traffic/save-cart')
+async def save_traffic_cart(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, bool]:
+    """Save cart for traffic purchase (for insufficient balance flow)."""
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='У вас нет активной подписки',
+        )
+
+    if subscription.status not in ['active', 'trial']:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Ваша подписка неактивна',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Докупка трафика недоступна на пробном периоде',
+        )
+
+    if subscription.traffic_limit_gb == 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='У вас уже безлимитный трафик',
+        )
+
+    # Get traffic price from tariff or settings
+    tariff = None
+    base_price_kopeks = 0
+    is_tariff_mode = settings.is_tariffs_mode() and subscription.tariff_id
+
+    if is_tariff_mode:
+        tariff = await get_tariff_by_id(db, subscription.tariff_id)
+        if not tariff:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail='Тариф не найден',
+            )
+
+        if not getattr(tariff, 'traffic_topup_enabled', False):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Докупка трафика недоступна на вашем тарифе',
+            )
+
+        packages = tariff.get_traffic_topup_packages() if hasattr(tariff, 'get_traffic_topup_packages') else {}
+        if request.gb not in packages:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f'Пакет трафика {request.gb} ГБ недоступен',
+            )
+        base_price_kopeks = packages[request.gb]
+    else:
+        if not settings.is_traffic_topup_enabled():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Докупка трафика отключена',
+            )
+
+        packages = settings.get_traffic_topup_packages()
+        matching_pkg = next((pkg for pkg in packages if pkg['gb'] == request.gb and pkg.get('enabled', True)), None)
+        if not matching_pkg:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail='Недоступный пакет трафика',
+            )
+        base_price_kopeks = matching_pkg['price']
+
+    # Calculate prorated price (days-based), then apply discount
+    from app.utils.pricing_utils import calculate_prorated_price as _calc_prorated
+
+    now = datetime.now(UTC)
+    days_left = max(1, (subscription.end_date - now).days)
+    prorated_price, _ = _calc_prorated(
+        base_price_kopeks,
+        subscription.end_date,
+    )
+    discount_result = _apply_addon_discount(user, 'traffic', prorated_price, days_left)
+    final_price = discount_result['discounted']
+    traffic_discount_percent = discount_result['percent']
+
+    # Save cart for auto-purchase after balance top-up
+    cart_data = {
+        'cart_mode': 'add_traffic',
+        'subscription_id': subscription.id,
+        'traffic_gb': request.gb,
+        'price_kopeks': final_price,
+        'base_price_kopeks': base_price_kopeks,
+        'discount_percent': traffic_discount_percent,
+        'source': 'cabinet',
+        'description': f'Докупка {request.gb} ГБ трафика',
+    }
+    await user_cart_service.save_user_cart(user.id, cart_data)
+    logger.info('Cart saved for traffic purchase (cabinet save-cart) user +', user_id=user.id, gb=request.gb)
+
+    return {'success': True, 'cart_saved': True}
+
+
+# ============ Traffic Switch (Change Traffic Package) ============
+
+
+@router.put('/traffic')
+async def switch_traffic_package(
+    request: TrafficPurchaseRequest,
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+) -> dict[str, Any]:
+    """Switch to a different traffic package (change limit)."""
+    from app.utils.pricing_utils import calculate_prorated_price
+
+    subscription = await resolve_subscription(db, user, subscription_id)
+
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No subscription found',
+        )
+
+    if subscription.is_trial:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Traffic management is only available for paid subscriptions',
+        )
+
+    current_traffic = subscription.traffic_limit_gb or 0
+    new_traffic = request.gb
+
+    if current_traffic == new_traffic:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Already on this traffic package',
+        )
+
+    # Get available packages
+    packages = settings.get_traffic_packages()
+    current_pkg = next((p for p in packages if p['gb'] == current_traffic and p.get('enabled', True)), None)
+    new_pkg = next((p for p in packages if p['gb'] == new_traffic and p.get('enabled', True)), None)
+
+    if not new_pkg:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid traffic package',
+        )
+
+    # Calculate price difference (only charge for upgrade)
+    current_price = current_pkg['price'] if current_pkg else 0
+    new_price = new_pkg['price']
+
+    if new_price > current_price:
+        # Upgrade - charge difference
+        price_diff = new_price - current_price
+
+        # Lock user row to prevent TOCTOU on promo-offer state
+        from app.database.crud.user import lock_user_for_pricing
+
+        user = await lock_user_for_pricing(db, user.id)
+
+        # Apply promo discount via PricingEngine
+        price_diff, _discount_val, traffic_discount_percent = pricing_engine.calculate_traffic_discount(
+            price_diff,
+            user,
+        )
+
+        # Prorated calculation
+        final_price, days_charged = calculate_prorated_price(price_diff, subscription.end_date)
+
+        if final_price > 0 and user.balance_kopeks < final_price:
+            raise HTTPException(
+                status_code=status.HTTP_402_PAYMENT_REQUIRED,
+                detail=f'Insufficient balance. Need {final_price / 100:.2f} RUB',
+            )
+
+        # Charge balance
+        description = f'Traffic upgrade from {current_traffic}GB to {new_traffic}GB'
+        success = await subtract_user_balance(db, user, final_price, description)
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail='Failed to charge balance',
+            )
+
+        # Create transaction
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=final_price,
+            description=description,
+        )
+
+        charged = final_price
+    else:
+        # Downgrade - no charge, no refund
+        charged = 0
+
+    # Update subscription — delete TrafficPurchase records before resetting purchased_traffic_gb
+    from sqlalchemy import delete as sql_delete
+
+    from app.database.models import TrafficPurchase
+
+    await db.execute(sql_delete(TrafficPurchase).where(TrafficPurchase.subscription_id == subscription.id))
+    subscription.traffic_limit_gb = new_traffic
+    subscription.purchased_traffic_gb = 0  # Reset purchased traffic on switch
+    subscription.traffic_reset_at = None  # Reset traffic reset date
+    subscription.updated_at = datetime.now(UTC)
+    await db.commit()
+
+    # Sync with RemnaWave
+    try:
+        subscription_service = SubscriptionService()
+        _panel_uuid2 = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else getattr(user, 'remnawave_uuid', None)
+        )
+        if _panel_uuid2:
+            await subscription_service.update_remnawave_user(db, subscription)
+        else:
+            await subscription_service.create_remnawave_user(db, subscription)
+    except Exception as e:
+        logger.error('Failed to sync traffic switch with RemnaWave', error=e)
+
+    await db.refresh(user)
+    await db.refresh(subscription)
+
+    return {
+        'success': True,
+        'message': f'Traffic changed from {current_traffic}GB to {new_traffic}GB',
+        'old_traffic_gb': current_traffic,
+        'new_traffic_gb': new_traffic,
+        'charged_kopeks': charged,
+        'balance_kopeks': user.balance_kopeks,
+        'balance_label': settings.format_price(user.balance_kopeks),
+    }
+
+
+# ============ Traffic Refresh ============
+
+# Rate limit: 1 request per 60 seconds per user
+TRAFFIC_REFRESH_RATE_LIMIT = 1
+TRAFFIC_REFRESH_RATE_WINDOW = 60  # seconds
+TRAFFIC_CACHE_TTL = 60  # Cache traffic data for 60 seconds
+
+
+@router.post('/refresh-traffic')
+async def refresh_traffic(
+    user: User = Depends(get_current_cabinet_user),
+    db: AsyncSession = Depends(get_cabinet_db),
+    subscription_id: int | None = QueryParam(None, description='Subscription ID for multi-tariff'),
+):
+    """
+    Refresh traffic usage from RemnaWave panel.
+    Rate limited to 1 request per 60 seconds.
+    """
+    subscription = await resolve_subscription(db, user, subscription_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='No active subscription',
+        )
+
+    # Use per-subscription key when subscription_id is available so that refreshing
+    # Sub B is not blocked by a previous refresh of Sub A (multi-tariff mode).
+    cache_suffix = f'{user.id}_{subscription_id}' if subscription_id is not None else str(user.id)
+
+    # Check rate limit
+    is_limited = await RateLimitCache.is_rate_limited(
+        cache_suffix,
+        'traffic_refresh',
+        TRAFFIC_REFRESH_RATE_LIMIT,
+        TRAFFIC_REFRESH_RATE_WINDOW,
+    )
+
+    if is_limited:
+        # Check if we have cached data
+        traffic_cache_key = cache_key('traffic', cache_suffix)
+        cached_data = await cache.get(traffic_cache_key)
+
+        if cached_data:
+            return {
+                'success': True,
+                'cached': True,
+                'rate_limited': True,
+                'retry_after_seconds': TRAFFIC_REFRESH_RATE_WINDOW,
+                **cached_data,
+            }
+
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail=f'Rate limited. Try again in {TRAFFIC_REFRESH_RATE_WINDOW} seconds.',
+            headers={'Retry-After': str(TRAFFIC_REFRESH_RATE_WINDOW)},
+        )
+
+    # Fetch traffic from RemnaWave
+    try:
+        remnawave_service = RemnaWaveService()
+
+        # Resolve panel UUID for traffic lookup
+        _traffic_uuid = (
+            subscription.remnawave_uuid
+            if settings.is_multi_tariff_enabled() and subscription.remnawave_uuid
+            else user.remnawave_uuid
+        )
+        if user.telegram_id and not settings.is_multi_tariff_enabled():
+            traffic_stats = await remnawave_service.get_user_traffic_stats(user.telegram_id)
+        elif _traffic_uuid:
+            traffic_stats = await remnawave_service.get_user_traffic_stats_by_uuid(_traffic_uuid)
+        else:
+            traffic_stats = None
+
+        if not traffic_stats:
+            # Return current database values if RemnaWave unavailable
+            traffic_data = {
+                'traffic_used_bytes': int((subscription.traffic_used_gb or 0) * (1024**3)),
+                'traffic_used_gb': round(subscription.traffic_used_gb or 0, 2),
+                'traffic_limit_bytes': int((subscription.traffic_limit_gb or 0) * (1024**3)),
+                'traffic_limit_gb': subscription.traffic_limit_gb or 0,
+                'traffic_used_percent': round(
+                    ((subscription.traffic_used_gb or 0) / (subscription.traffic_limit_gb or 1)) * 100
+                    if subscription.traffic_limit_gb
+                    else 0,
+                    1,
+                ),
+                'is_unlimited': (subscription.traffic_limit_gb or 0) == 0,
+            }
+            return {
+                'success': True,
+                'cached': False,
+                'source': 'database',
+                **traffic_data,
+            }
+
+        # Update subscription with fresh data
+        used_gb = traffic_stats.get('used_traffic_gb', 0)
+        if abs((subscription.traffic_used_gb or 0) - used_gb) > 0.01:
+            subscription.traffic_used_gb = used_gb
+            subscription.updated_at = datetime.now(UTC)
+            await db.commit()
+
+        # Calculate percentage
+        limit_gb = subscription.traffic_limit_gb or 0
+        if limit_gb > 0:
+            percent = min(100, (used_gb / limit_gb) * 100)
+        else:
+            percent = 0
+
+        traffic_data = {
+            'traffic_used_bytes': traffic_stats.get('used_traffic_bytes', 0),
+            'traffic_used_gb': round(used_gb, 2),
+            'traffic_limit_bytes': traffic_stats.get('traffic_limit_bytes', 0),
+            'traffic_limit_gb': limit_gb,
+            'traffic_used_percent': round(percent, 1),
+            'is_unlimited': limit_gb == 0,
+            'lifetime_used_bytes': traffic_stats.get('lifetime_used_traffic_bytes', 0),
+            'lifetime_used_gb': round(traffic_stats.get('lifetime_used_traffic_gb', 0), 2),
+        }
+
+        # Cache the result
+        traffic_cache_key = cache_key('traffic', cache_suffix)
+        await cache.set(traffic_cache_key, traffic_data, TRAFFIC_CACHE_TTL)
+
+        return {
+            'success': True,
+            'cached': False,
+            'source': 'remnawave',
+            **traffic_data,
+        }
+
+    except Exception as e:
+        logger.error('Error refreshing traffic for user', user_id=user.id, error=e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail='Failed to refresh traffic data',
+        )
@@ -317,7 +317,8 @@ async def notify_user_balance_change(

 async def notify_user_subscription_activated(
    user_id: int,
-    expires_at: str,
+    subscription_id: int | None = None,
+    expires_at: str = '',
    tariff_name: str = '',
 ) -> None:
    """Уведомить пользователя об активации подписки."""
@@ -325,6 +326,7 @@ async def notify_user_subscription_activated(
        user_id,
        {
            'type': 'subscription.activated',
+            'subscription_id': subscription_id,
            'expires_at': expires_at,
            'tariff_name': tariff_name,
        },
@@ -359,7 +361,8 @@ async def notify_user_subscription_expired(user_id: int) -> None:

 async def notify_user_subscription_renewed(
    user_id: int,
-    new_expires_at: str,
+    subscription_id: int | None = None,
+    new_expires_at: str = '',
    amount_kopeks: int = 0,
 ) -> None:
    """Уведомить пользователя о продлении подписки."""
@@ -367,6 +370,7 @@ async def notify_user_subscription_renewed(
        user_id,
        {
            'type': 'subscription.renewed',
+            'subscription_id': subscription_id,
            'new_expires_at': new_expires_at,
            'amount_kopeks': amount_kopeks,
            'amount_rubles': amount_kopeks / 100,
@@ -5,7 +5,6 @@ API роуты колеса удачи для пользователей.
 import math
 import time

-import httpx
 import structlog
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
@@ -50,10 +49,22 @@ async def get_wheel_config(
    # Проверяем доступность
    availability = await wheel_service.check_availability(db, user)

-    # Проверяем наличие подписки
-    from app.database.crud.subscription import get_subscription_by_user_id
+    # Проверяем наличие подписки (multi-tariff aware)
+    if settings.is_multi_tariff_enabled():
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id

-    subscription = await get_subscription_by_user_id(db, user.id)
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        # Check if user has any active subscription for wheel access
+        if active_subs:
+            _non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            _pool = _non_daily or active_subs
+            subscription = max(_pool, key=lambda s: s.days_left)
+        else:
+            subscription = None
+    else:
+        from app.database.crud.subscription import get_subscription_by_user_id
+
+        subscription = await get_subscription_by_user_id(db, user.id)
    has_subscription = subscription is not None and subscription.is_active

    prizes_display = [
@@ -67,6 +78,14 @@ async def get_wheel_config(
        for p in prizes
    ]

+    # Build eligible subscriptions for frontend picker
+    eligible_subs_display = None
+    if availability.eligible_subscriptions:
+        eligible_subs_display = [
+            {'id': s.id, 'tariff_name': s.tariff_name, 'days_left': s.days_left}
+            for s in availability.eligible_subscriptions
+        ]
+
    return WheelConfigResponse(
        is_enabled=config.is_enabled,
        name=config.name,
@@ -84,6 +103,7 @@ async def get_wheel_config(
        user_balance_kopeks=availability.user_balance_kopeks,
        required_balance_kopeks=availability.required_balance_kopeks,
        has_subscription=has_subscription,
+        eligible_subscriptions=eligible_subs_display,
    )


@@ -115,7 +135,7 @@ async def spin_wheel(
    db: AsyncSession = Depends(get_cabinet_db),
 ):
    """Крутить колесо удачи."""
-    result = await wheel_service.spin(db, user, request.payment_type.value)
+    result = await wheel_service.spin(db, user, request.payment_type.value, subscription_id=request.subscription_id)

    if not result.success:
        # Возвращаем ошибку в теле ответа, а не HTTP exception
@@ -220,10 +240,22 @@ async def create_stars_invoice(
            detail='Оплата Stars не включена',
        )

-    # Проверяем наличие активной подписки
-    from app.database.crud.subscription import get_subscription_by_user_id
+    # Проверяем наличие активной подписки (multi-tariff aware)
+    if settings.is_multi_tariff_enabled():
+        from app.database.crud.subscription import get_active_subscriptions_by_user_id

-    subscription = await get_subscription_by_user_id(db, user.id)
+        active_subs = await get_active_subscriptions_by_user_id(db, user.id)
+        # Check if user has any active subscription for Stars invoice
+        if active_subs:
+            _non_daily = [s for s in active_subs if not getattr(s, 'is_daily_tariff', False)]
+            _pool = _non_daily or active_subs
+            subscription = max(_pool, key=lambda s: s.days_left)
+        else:
+            subscription = None
+    else:
+        from app.database.crud.subscription import get_subscription_by_user_id
+
+        subscription = await get_subscription_by_user_id(db, user.id)
    if not subscription or not subscription.is_active:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
@@ -251,44 +283,31 @@ async def create_stars_invoice(

    # Создаем invoice через Telegram Bot API
    try:
-        bot_token = settings.BOT_TOKEN
-        api_url = f'https://api.telegram.org/bot{bot_token}/createInvoiceLink'
+        from aiogram.exceptions import TelegramAPIError
+        from aiogram.types import LabeledPrice

-        async with httpx.AsyncClient() as client:
-            response = await client.post(
-                api_url,
-                json={
-                    'title': 'Колесо удачи',
-                    'description': f'Спин колеса удачи ({stars_amount} ⭐)',
-                    'payload': payload,
-                    'provider_token': '',  # Пустой для Stars
-                    'currency': 'XTR',
-                    'prices': [{'label': 'Спин колеса', 'amount': stars_amount}],
-                },
+        from app.bot_factory import create_bot
+
+        async with create_bot() as bot:
+            invoice_url = await bot.create_invoice_link(
+                title='Колесо удачи',
+                description=f'Спин колеса удачи ({stars_amount} ⭐)',
+                payload=payload,
+                provider_token='',
+                currency='XTR',
+                prices=[LabeledPrice(label='Спин колеса', amount=stars_amount)],
            )

-            result = response.json()
+        logger.info('Created Stars invoice for wheel spin: user=, stars', user_id=user.id, stars_amount=stars_amount)

-            if not result.get('ok'):
-                logger.error('Telegram API error', result=result)
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail='Ошибка создания инвойса',
-                )
+        return StarsInvoiceResponse(
+            invoice_url=invoice_url,
+            stars_amount=stars_amount,
+        )

-            invoice_url = result['result']
-            logger.info(
-                'Created Stars invoice for wheel spin: user=, stars', user_id=user.id, stars_amount=stars_amount
-            )
-
-            return StarsInvoiceResponse(
-                invoice_url=invoice_url,
-                stars_amount=stars_amount,
-            )
-
-    except httpx.HTTPError as e:
-        logger.error('HTTP error creating invoice', error=e)
+    except TelegramAPIError as e:
+        logger.error('Error creating invoice', error=e)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail='Ошибка соединения с Telegram',
+            detail='Ошибка создания инвойса',
        )
@@ -70,12 +70,11 @@ async def create_withdrawal(

    # Уведомляем админов о запросе на вывод
    try:
-        from aiogram import Bot
-
+        from app.bot_factory import create_bot
        from app.services.admin_notification_service import AdminNotificationService

        if getattr(settings, 'ADMIN_NOTIFICATIONS_ENABLED', False) and settings.BOT_TOKEN:
-            bot = Bot(token=settings.BOT_TOKEN)
+            bot = create_bot()
            try:
                notification_service = AdminNotificationService(bot)
                await notification_service.send_withdrawal_request_notification(
@@ -187,3 +187,28 @@ class EmailChangeResponse(BaseModel):
    message: str = Field(..., description='Success message')
    new_email: str = Field(..., description='New email address pending verification')
    expires_in_minutes: int = Field(..., description='Code expiration time in minutes')
+
+
+class DeepLinkTokenResponse(BaseModel):
+    """Response with deep link auth token."""
+
+    token: str = Field(..., description='One-time auth token')
+    bot_username: str = Field(..., description='Bot username for deep link')
+    expires_in: int = Field(..., description='Token TTL in seconds')
+
+
+class DeepLinkPollRequest(BaseModel):
+    """Request to poll deep link auth status.
+
+    Deep link auth is always for existing bot users — referral codes are not applicable here.
+    Only campaign_slug is supported (campaign bonus can apply to existing users).
+    """
+
+    token: str = Field(..., min_length=16, max_length=128, description='Deep link auth token')
+    campaign_slug: str | None = Field(
+        None,
+        min_length=1,
+        max_length=64,
+        pattern=r'^[a-zA-Z0-9_-]+$',
+        description='Campaign slug captured from cabinet URL',
+    )
@@ -3,7 +3,7 @@
 from datetime import datetime
 from typing import Literal

-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator


 # ============ Channel Types ============
@@ -75,6 +75,27 @@ class BroadcastButtonsResponse(BaseModel):
    buttons: list[BroadcastButton]


+class CustomBroadcastButton(BaseModel):
+    """Custom button for broadcast message."""
+
+    label: str = Field(..., min_length=1, max_length=64)
+    action_type: Literal['callback', 'url'] = 'callback'
+    action_value: str = Field(..., min_length=1, max_length=256)
+
+    @field_validator('action_value')
+    @classmethod
+    def validate_action_value(cls, v: str, info) -> str:
+        action_type = info.data.get('action_type', 'callback')
+        if action_type == 'url':
+            if not v.startswith(('https://', 'tg://')):
+                raise ValueError('URL must start with https:// or tg://')
+        elif action_type == 'callback':
+            # Telegram API limits callback_data to 64 bytes
+            if len(v.encode('utf-8')) > 64:
+                raise ValueError('Callback data must be at most 64 bytes')
+        return v
+
+
 # ============ Media ============


@@ -95,6 +116,7 @@ class BroadcastCreateRequest(BaseModel):
    target: str
    message_text: str = Field(..., min_length=1, max_length=4000)
    selected_buttons: list[str] = Field(default_factory=lambda: ['home'])
+    custom_buttons: list[CustomBroadcastButton] = Field(default_factory=list, max_length=10)
    media: BroadcastMediaRequest | None = None


@@ -187,6 +209,7 @@ class CombinedBroadcastCreateRequest(BaseModel):
    # Telegram-specific fields
    message_text: str | None = Field(default=None, max_length=4000)
    selected_buttons: list[str] = Field(default_factory=lambda: ['home'])
+    custom_buttons: list[CustomBroadcastButton] = Field(default_factory=list, max_length=10)
    media: BroadcastMediaRequest | None = None

    # Email-specific fields
@@ -0,0 +1,332 @@
+"""Schemas for news articles in cabinet.
+
+Security notes:
+- featured_image_url is validated to only accept http/https schemes.
+- category_color is validated as a strict hex color (#RGB, #RRGGBB, etc.).
+- Slug is sanitized to only allow [a-zA-Z0-9_-].
+- Content is server-side sanitized to strip <script>, event handlers, and
+  dangerous URI schemes as a defense-in-depth measure. The frontend also
+  sanitizes via DOMPurify, but server-side sanitization protects against
+  alternative consumers (mobile apps, RSS, email digests) and compromised
+  frontends.
+"""
+
+import re
+from datetime import datetime
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+
+# Pre-compiled regex for hex color validation (reused across validators)
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+# Pre-compiled regex for collapsing repeated hyphens in slugs
+_MULTI_HYPHEN_RE: re.Pattern[str] = re.compile(r'-+')
+
+# Maximum slug length (matches DB column constraint)
+_MAX_SLUG_LENGTH: int = 500
+
+# Allowed URL schemes for user-supplied URLs (featured_image_url)
+_SAFE_URL_SCHEMES: frozenset[str] = frozenset({'http', 'https'})
+
+# Cyrillic-to-Latin transliteration map for slug generation
+_TRANSLIT_MAP: dict[str, str] = {
+    'а': 'a',
+    'б': 'b',
+    'в': 'v',
+    'г': 'g',
+    'д': 'd',
+    'е': 'e',
+    'ё': 'yo',
+    'ж': 'zh',
+    'з': 'z',
+    'и': 'i',
+    'й': 'y',
+    'к': 'k',
+    'л': 'l',
+    'м': 'm',
+    'н': 'n',
+    'о': 'o',
+    'п': 'p',
+    'р': 'r',
+    'с': 's',
+    'т': 't',
+    'у': 'u',
+    'ф': 'f',
+    'х': 'kh',
+    'ц': 'ts',
+    'ч': 'ch',
+    'ш': 'sh',
+    'щ': 'shch',
+    'ъ': '',
+    'ы': 'y',
+    'ь': '',
+    'э': 'e',
+    'ю': 'yu',
+    'я': 'ya',
+}
+
+
+def _slugify(title: str) -> str:
+    """Generate a URL-safe slug from a title, transliterating Cyrillic."""
+    slug = title.lower()
+    result: list[str] = []
+    for ch in slug:
+        if ch in _TRANSLIT_MAP:
+            result.append(_TRANSLIT_MAP[ch])
+        elif ch.isascii() and (ch.isalnum() or ch in '-_'):
+            result.append(ch)
+        elif ch == ' ':
+            result.append('-')
+    slug = ''.join(result)
+    slug = _MULTI_HYPHEN_RE.sub('-', slug).strip('-')
+    return slug[:_MAX_SLUG_LENGTH] or 'untitled'
+
+
+def _validate_hex_color(v: str) -> str:
+    """Validate a hex color string. Raises ValueError on invalid input."""
+    if not _HEX_COLOR_RE.match(v):
+        msg = 'category_color must be a valid hex color (e.g. #00e5a0)'
+        raise ValueError(msg)
+    return v
+
+
+def _validate_safe_url(v: str) -> str:
+    """Validate that a URL uses http or https scheme only.
+
+    Prevents javascript:, data:, vbscript:, and other dangerous URI schemes
+    from being stored in the database and later rendered in <img> or <a> tags.
+    """
+    try:
+        parsed = urlparse(v)
+    except Exception:
+        msg = 'Invalid URL format'
+        raise ValueError(msg)
+
+    if parsed.scheme not in _SAFE_URL_SCHEMES:
+        msg = f'URL scheme must be http or https, got: {parsed.scheme!r}'
+        raise ValueError(msg)
+
+    if not parsed.netloc:
+        msg = 'URL must have a valid host'
+        raise ValueError(msg)
+
+    return v
+
+
+# --- Server-side HTML content sanitization ---
+# Pre-compiled patterns for stripping the most dangerous HTML constructs.
+# This is a defense-in-depth measure: the frontend also sanitizes via DOMPurify.
+# Uses regex rather than a full HTML parser to avoid adding a new dependency.
+# Strips: <script>, <style>, <object>, <embed>, <applet>, <base>, <form>,
+# <link>, <meta> tags and all on* event handler attributes.
+_DANGEROUS_TAGS_RE: re.Pattern[str] = re.compile(
+    r'<\s*/?\s*(script|style|object|embed|applet|base|form|link(?:\s)|meta)\b[^>]*>',
+    re.IGNORECASE | re.DOTALL,
+)
+# Match on* event handler attributes, e.g. onclick="...", onerror='...'
+_EVENT_HANDLER_RE: re.Pattern[str] = re.compile(
+    r'\s+on[a-z]+\s*=\s*(?:"[^"]*"|\'[^\']*\'|[^\s>]+)',
+    re.IGNORECASE,
+)
+# Match javascript:, vbscript:, data: in href/src attributes
+_DANGEROUS_URI_RE: re.Pattern[str] = re.compile(
+    r'((?:href|src)\s*=\s*["\'])\s*(javascript|vbscript|data)\s*:',
+    re.IGNORECASE,
+)
+
+
+def _sanitize_html_content(html: str) -> str:
+    """Strip dangerous HTML constructs from article content.
+
+    This is NOT a replacement for DOMPurify on the frontend. It is a
+    defense-in-depth layer that removes the most obvious XSS vectors
+    at the storage boundary. A full HTML sanitizer (nh3, bleach) would
+    be stronger, but this avoids adding a new dependency.
+    """
+    if not html:
+        return html
+
+    # 1. Remove dangerous tags and their content
+    result = _DANGEROUS_TAGS_RE.sub('', html)
+
+    # Also strip <script>...</script> content (tag + body)
+    result = re.sub(r'<script\b[^>]*>[\s\S]*?</script>', '', result, flags=re.IGNORECASE)
+    result = re.sub(r'<style\b[^>]*>[\s\S]*?</style>', '', result, flags=re.IGNORECASE)
+
+    # 2. Remove event handler attributes
+    result = _EVENT_HANDLER_RE.sub('', result)
+
+    # 3. Neutralize dangerous URI schemes in href/src
+    result = _DANGEROUS_URI_RE.sub(r'\1about:', result)
+
+    return result
+
+
+class NewsArticleResponse(BaseModel):
+    """Full news article response (detail view)."""
+
+    id: int
+    title: str
+    slug: str
+    content: str
+    excerpt: str | None
+    category: str
+    category_color: str
+    tag: str | None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None
+    read_time_minutes: int
+    views_count: int
+    author_name: str | None = None
+    created_at: datetime
+    updated_at: datetime | None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NewsArticleListItem(BaseModel):
+    """Compact news article for list views."""
+
+    id: int
+    title: str
+    slug: str
+    excerpt: str | None
+    category: str
+    category_color: str
+    tag: str | None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None
+    read_time_minutes: int
+    views_count: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class NewsListResponse(BaseModel):
+    """Paginated list of news articles."""
+
+    items: list[NewsArticleListItem]
+    total: int
+    categories: list[str] = Field(default_factory=list)
+
+
+class NewsCreateRequest(BaseModel):
+    """Request to create a news article."""
+
+    title: str = Field(..., min_length=1, max_length=500)
+    slug: str | None = Field(None, min_length=1, max_length=500)
+    content: str = Field(default='', max_length=500_000)
+    excerpt: str | None = Field(None, max_length=1000)
+    category: str = Field(..., min_length=1, max_length=100)
+    category_color: str = Field(default='#00e5a0', max_length=20)
+    tag: str | None = Field(None, max_length=50)
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None = Field(None, max_length=2000)
+    is_published: bool = False
+    is_featured: bool = False
+    read_time_minutes: int = Field(default=1, ge=1, le=60)
+
+    @field_validator('content')
+    @classmethod
+    def sanitize_content(cls, v: str) -> str:
+        """Strip dangerous HTML from article content (defense-in-depth)."""
+        return _sanitize_html_content(v)
+
+    @field_validator('category_color')
+    @classmethod
+    def validate_hex_color(cls, v: str) -> str:
+        return _validate_hex_color(v)
+
+    @field_validator('featured_image_url')
+    @classmethod
+    def validate_featured_image_url(cls, v: str | None) -> str | None:
+        """Reject javascript:, data:, and other dangerous URL schemes."""
+        if v is not None:
+            return _validate_safe_url(v)
+        return v
+
+    @model_validator(mode='before')
+    @classmethod
+    def auto_generate_slug(cls, data: dict) -> dict:  # type: ignore[type-arg]
+        """Generate slug from title when not explicitly provided."""
+        if isinstance(data, dict) and not data.get('slug'):
+            title = data.get('title', '')
+            data['slug'] = _slugify(title) if isinstance(title, str) else 'untitled'
+        return data
+
+    @field_validator('slug')
+    @classmethod
+    def sanitize_slug(cls, v: str | None) -> str | None:
+        """Ensure slug contains only URL-safe characters, transliterating Cyrillic."""
+        if v is not None:
+            return _slugify(v)
+        return v
+
+
+class NewsUpdateRequest(BaseModel):
+    """Request to update a news article."""
+
+    title: str | None = Field(None, min_length=1, max_length=500)
+    slug: str | None = Field(None, min_length=1, max_length=500)
+    content: str | None = Field(None, max_length=500_000)
+    excerpt: str | None = None
+    category: str | None = Field(None, min_length=1, max_length=100)
+    category_color: str | None = Field(None, max_length=20)
+    tag: str | None = None
+    category_id: int | None = None
+    tag_id: int | None = None
+    featured_image_url: str | None = Field(None, max_length=2000)
+    is_published: bool | None = None
+    is_featured: bool | None = None
+    read_time_minutes: int | None = Field(None, ge=1, le=60)
+
+    @field_validator('content')
+    @classmethod
+    def sanitize_content(cls, v: str | None) -> str | None:
+        """Strip dangerous HTML from article content (defense-in-depth)."""
+        if v is not None:
+            return _sanitize_html_content(v)
+        return v
+
+    @field_validator('category_color')
+    @classmethod
+    def validate_hex_color(cls, v: str | None) -> str | None:
+        if v is not None:
+            return _validate_hex_color(v)
+        return v
+
+    @field_validator('featured_image_url')
+    @classmethod
+    def validate_featured_image_url(cls, v: str | None) -> str | None:
+        """Reject javascript:, data:, and other dangerous URL schemes."""
+        if v is not None:
+            return _validate_safe_url(v)
+        return v
+
+    @field_validator('slug')
+    @classmethod
+    def sanitize_slug(cls, v: str | None) -> str | None:
+        """Ensure slug contains only URL-safe characters, transliterating Cyrillic."""
+        if v is not None:
+            return _slugify(v)
+        return v
+
+
+class NewsToggleResponse(BaseModel):
+    """Response after toggling publish/featured status."""
+
+    id: int
+    is_published: bool
+    is_featured: bool
+    published_at: datetime | None
@@ -0,0 +1,48 @@
+"""Schemas for news categories."""
+
+import re
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+
+class NewsCategoryCreate(BaseModel):
+    """Request to create a news category."""
+
+    name: str = Field(..., min_length=1, max_length=100)
+    color: str = Field(default='#00e5a0', max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str) -> str:
+        if not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsCategoryUpdate(BaseModel):
+    """Request to update a news category."""
+
+    name: str | None = Field(None, min_length=1, max_length=100)
+    color: str | None = Field(None, max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str | None) -> str | None:
+        if v is not None and not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsCategoryResponse(BaseModel):
+    """News category response."""
+
+    id: int
+    name: str
+    color: str
+
+    model_config = ConfigDict(from_attributes=True)
@@ -0,0 +1,17 @@
+"""Schemas for news media upload responses."""
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class NewsMediaUploadResponse(BaseModel):
+    """Response returned after a successful media upload."""
+
+    url: str
+    thumbnail_url: str | None = None
+    media_type: Literal['image', 'video']
+    filename: str
+    size_bytes: int
+    width: int | None = None
+    height: int | None = None
@@ -0,0 +1,48 @@
+"""Schemas for news tags."""
+
+import re
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+_HEX_COLOR_RE: re.Pattern[str] = re.compile(r'^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$')
+
+
+class NewsTagCreate(BaseModel):
+    """Request to create a news tag."""
+
+    name: str = Field(..., min_length=1, max_length=50)
+    color: str = Field(default='#94a3b8', max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str) -> str:
+        if not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsTagUpdate(BaseModel):
+    """Request to update a news tag."""
+
+    name: str | None = Field(None, min_length=1, max_length=50)
+    color: str | None = Field(None, max_length=20)
+
+    @field_validator('color')
+    @classmethod
+    def validate_color(cls, v: str | None) -> str | None:
+        if v is not None and not _HEX_COLOR_RE.match(v):
+            msg = 'Invalid hex color'
+            raise ValueError(msg)
+        return v
+
+
+class NewsTagResponse(BaseModel):
+    """News tag response."""
+
+    id: int
+    name: str
+    color: str
+
+    model_config = ConfigDict(from_attributes=True)
@@ -47,11 +47,9 @@ class ServerInfo(BaseModel):
    """Server hardware info."""

    cpu_cores: int
-    cpu_physical_cores: int
    memory_total: int
    memory_used: int
    memory_free: int
-    memory_available: int
    uptime_seconds: int


@@ -108,22 +106,22 @@ class NodeInfo(BaseModel):
    is_disabled: bool
    is_node_online: bool
    is_xray_running: bool
-    users_online: int | None = None
+    users_online: int = 0
    traffic_used_bytes: int | None = None
    traffic_limit_bytes: int | None = None
    last_status_change: datetime | None = None
    last_status_message: str | None = None
-    xray_uptime: str | None = None
+    xray_uptime: int = 0
    is_traffic_tracking_active: bool = False
    traffic_reset_day: int | None = None
    notify_percent: int | None = None
    consumption_multiplier: float = 1.0
-    cpu_count: int | None = None
-    cpu_model: str | None = None
-    total_ram: str | None = None
    created_at: datetime | None = None
    updated_at: datetime | None = None
    provider_uuid: str | None = None
+    versions: dict[str, str] | None = None
+    system: dict[str, Any] | None = None
+    active_plugin_uuid: str | None = None


 class NodesListResponse(BaseModel):
@@ -88,6 +88,10 @@ class RenewalRequest(BaseModel):
    """Request to renew subscription."""

    period_days: int = Field(..., ge=1, le=3650, description='Renewal period in days')
+    subscription_id: int | None = Field(
+        default=None,
+        description='ID of subscription to renew (required in multi-tariff mode)',
+    )


 class TrafficPackageResponse(BaseModel):
@@ -112,7 +112,7 @@ class TariffDetailResponse(BaseModel):
    is_daily: bool = False
    daily_price_kopeks: int = 0
    # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
    # Внешний сквад RemnaWave
    external_squad_uuid: str | None = None
    # Показывать в подарках
@@ -170,7 +170,7 @@ class TariffCreateRequest(BaseModel):
    is_daily: bool = False
    daily_price_kopeks: int = Field(0, ge=0)
    # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
    # Внешний сквад RemnaWave
    external_squad_uuid: str | None = Field(None, pattern=UUID_PATTERN)
    # Показывать в подарках
@@ -211,7 +211,7 @@ class TariffUpdateRequest(BaseModel):
    is_daily: bool | None = None
    daily_price_kopeks: int | None = Field(None, ge=0)
    # Режим сброса трафика
-    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
    # Внешний сквад RemnaWave
    external_squad_uuid: str | None = Field(None, pattern=UUID_PATTERN)
    # Показывать в подарках
@@ -9,18 +9,31 @@ class TrafficNodeInfo(BaseModel):
    country_code: str


+class SubscriptionTrafficInfo(BaseModel):
+    """Per-subscription traffic metadata for multi-subscription display."""
+
+    subscription_id: int
+    tariff_name: str | None
+    status: str | None
+    traffic_limit_gb: float
+    device_limit: int
+
+
 class UserTrafficItem(BaseModel):
    user_id: int
    telegram_id: int | None
    username: str | None
    email: str | None
    full_name: str
+    # Primary subscription fields (backward compat — reflect the active/first sub)
    tariff_name: str | None
    subscription_status: str | None
    traffic_limit_gb: float
    device_limit: int
    node_traffic: dict[str, int]  # {node_uuid: total_bytes}
    total_bytes: int
+    # All subscriptions for multi-subscription display
+    subscriptions: list[SubscriptionTrafficInfo] = Field(default_factory=list)


 class TrafficUsageResponse(BaseModel):
@@ -34,12 +47,24 @@ class TrafficUsageResponse(BaseModel):
    available_statuses: list[str]


+class SubscriptionEnrichmentInfo(BaseModel):
+    """Per-subscription enrichment (dates) for multi-subscription display."""
+
+    subscription_id: int
+    tariff_name: str | None
+    start_date: str | None
+    end_date: str | None
+
+
 class UserTrafficEnrichment(BaseModel):
    devices_connected: int = 0
    total_spent_kopeks: int = 0
+    # Primary subscription dates (backward compat — reflect the active/first sub)
    subscription_start_date: str | None = None
    subscription_end_date: str | None = None
    last_node_name: str | None = None
+    # All subscriptions for multi-subscription display
+    subscriptions: list[SubscriptionEnrichmentInfo] = Field(default_factory=list)


 class TrafficEnrichmentResponse(BaseModel):
@@ -177,9 +177,12 @@ class UserDetailResponse(BaseModel):
    last_activity: datetime | None = None
    cabinet_last_login: datetime | None = None

-    # Subscription
+    # Subscription (legacy single, kept for backward compat)
    subscription: UserSubscriptionInfo | None = None

+    # All subscriptions (multi-tariff)
+    subscriptions: list[UserSubscriptionInfo] = []
+
    # Promo group
    promo_group: UserPromoGroupInfo | None = None

@@ -285,6 +288,9 @@ class UpdateSubscriptionRequest(BaseModel):
        ..., description='Action: extend, shorten, set_end_date, change_tariff, set_traffic, toggle_autopay, cancel'
    )

+    # Target subscription (required in multi-tariff mode for non-create actions)
+    subscription_id: int | None = Field(None, description='Subscription ID to target (multi-tariff)')
+
    # For extend action
    days: int | None = Field(None, ge=1, le=3650, description='Days to extend')

@@ -387,6 +393,37 @@ class UpdateReferralCommissionResponse(BaseModel):
    message: str


+class AssignReferrerRequest(BaseModel):
+    """Request to manually assign a referrer to a user."""
+
+    referrer_id: int = Field(..., gt=0, description='ID of the referrer user')
+
+
+class AssignReferrerResponse(BaseModel):
+    """Response after referrer assignment."""
+
+    success: bool
+    old_referrer_id: int | None = None
+    new_referrer_id: int | None = None
+    message: str
+
+
+class RemoveReferrerResponse(BaseModel):
+    """Response after removing a user's referrer."""
+
+    success: bool
+    old_referrer_id: int | None = None
+    message: str
+
+
+class RemoveReferralResponse(BaseModel):
+    """Response after removing a specific referral from a user."""
+
+    success: bool
+    removed_user_id: int
+    message: str
+
+
 class DeviceInfo(BaseModel):
    """Individual device info."""

@@ -608,6 +645,10 @@ class PanelSyncStatusResponse(BaseModel):
    remnawave_uuid: str | None = None
    last_sync: datetime | None = None

+    # Multi-tariff context
+    subscription_id: int | None = None
+    subscription_tariff_name: str | None = None
+
    # Bot data
    bot_subscription_status: str | None = None
    bot_subscription_end_date: datetime | None = None
@@ -61,6 +61,7 @@ class WheelConfigResponse(BaseModel):
    user_balance_kopeks: int = 0
    required_balance_kopeks: int = 0
    has_subscription: bool = False
+    eligible_subscriptions: list[dict] | None = None


 class SpinAvailabilityResponse(BaseModel):
@@ -81,6 +82,7 @@ class SpinRequest(BaseModel):
    """Запрос на спин."""

    payment_type: WheelPaymentType
+    subscription_id: int | None = None


 class SpinResultResponse(BaseModel):
@@ -17,14 +17,33 @@ logger = structlog.get_logger(__name__)
 class EmailService:
    """Service for sending emails via SMTP."""

-    def __init__(self):
-        self.host = settings.SMTP_HOST
-        self.port = settings.SMTP_PORT
-        self.user = settings.SMTP_USER
-        self.password = settings.SMTP_PASSWORD
-        self.from_email = settings.get_smtp_from_email()
-        self.from_name = settings.SMTP_FROM_NAME
-        self.use_tls = settings.SMTP_USE_TLS
+    @property
+    def host(self) -> str | None:
+        return settings.SMTP_HOST
+
+    @property
+    def port(self) -> int:
+        return settings.SMTP_PORT
+
+    @property
+    def user(self) -> str | None:
+        return settings.SMTP_USER
+
+    @property
+    def password(self) -> str | None:
+        return settings.SMTP_PASSWORD
+
+    @property
+    def from_email(self) -> str | None:
+        return settings.get_smtp_from_email()
+
+    @property
+    def from_name(self) -> str:
+        return settings.SMTP_FROM_NAME
+
+    @property
+    def use_tls(self) -> bool:
+        return settings.SMTP_USE_TLS

    def is_configured(self) -> bool:
        """Check if SMTP is properly configured."""
@@ -71,6 +90,11 @@ class EmailService:
            logger.warning('SMTP is not configured, cannot send email')
            return False

+        sender_email = self.from_email
+        if not sender_email or '@' not in sender_email:
+            logger.error('Invalid or missing SMTP from_email, cannot send email', from_email=sender_email)
+            return False
+
        # Defensive: strip newlines to prevent header injection
        to_email = to_email.strip().replace('\n', '').replace('\r', '')
        subject = subject.replace('\n', '').replace('\r', '')
@@ -79,11 +103,11 @@ class EmailService:
            msg = MIMEMultipart('alternative')
            msg['Subject'] = subject
            safe_from_name = self.from_name.replace('\n', '').replace('\r', '') if self.from_name else ''
-            safe_from_email = self.from_email.replace('\n', '').replace('\r', '') if self.from_email else ''
+            safe_from_email = sender_email.replace('\n', '').replace('\r', '')
            msg['From'] = f'{safe_from_name} <{safe_from_email}>'
            msg['To'] = to_email
            msg['Date'] = formatdate(localtime=False)
-            msg['Message-ID'] = make_msgid(domain=self.from_email.split('@')[-1])
+            msg['Message-ID'] = make_msgid(domain=safe_from_email.split('@')[-1])

            # Plain text version
            if body_text is None:
@@ -103,7 +127,7 @@ class EmailService:
            msg.attach(part2)

            with self._get_smtp_connection() as smtp:
-                smtp.sendmail(self.from_email, to_email, msg.as_string())
+                smtp.sendmail(safe_from_email, to_email, msg.as_string())

            logger.info('Email sent successfully to', to_email=to_email)
            return True
@@ -198,7 +198,7 @@ async def get_rendered_override(
        for key, value in context.items():
            body_html = body_html.replace(f'{{{key}}}', html.escape(str(value)))

-    rendered = templates._get_base_template(body_html, language)
+    rendered = templates._wrap_override_template(body_html, language)
    subject = override['subject']

    # Also substitute in subject
@@ -74,6 +74,39 @@ class EmailNotificationTemplates:

        return template_func(language, context)

+    def _wrap_override_template(self, content: str, language: str = 'ru') -> str:
+        """Wrap override template content appropriately based on its structure.
+
+        Three-tier detection:
+        1. Full HTML document (<!DOCTYPE or <html>) — return as-is, no wrapping
+        2. Styled content (has <style> tag or background CSS) — minimal HTML wrapper
+           without forced colors, headers, or footers
+        3. Simple HTML fragment — wrap with base template (header, footer, white bg)
+           for backward compatibility
+        """
+        content_stripped = content.strip()
+        content_lower = content_stripped.lower()
+
+        # Tier 1: Full HTML document — return as-is
+        if content_lower.startswith('<!doctype') or content_lower.startswith('<html'):
+            return content_stripped
+
+        # Tier 2: Styled content — minimal wrapper without forced styling
+        if '<style' in content_lower or 'background' in content_lower:
+            return f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body style="margin: 0; padding: 0;">
+    {content}
+</body>
+</html>"""
+
+        # Tier 3: Simple HTML fragment — use base template for structure
+        return self._get_base_template(content, language)
+
    def _get_base_template(self, content: str, language: str = 'ru') -> str:
        """Wrap content in base HTML template."""
        footer_texts = {
@@ -318,18 +351,26 @@ class EmailNotificationTemplates:
        """Template for subscription expiring notification."""
        days_left = context.get('days_left', 0)
        expires_at = context.get('expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_zh = f'<p>套餐: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_ua = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''

        subjects = {
-            'ru': f'Подписка истекает через {days_left} дн.',
-            'en': f'Subscription expires in {days_left} day(s)',
+            'ru': f'Подписка{tariff_suffix_ru} истекает через {days_left} дн.',
+            'en': f'Subscription{tariff_suffix_en} expires in {days_left} day(s)',
            'zh': f'订阅将在 {days_left} 天后到期',
-            'ua': f'Підписка закінчується через {days_left} дн.',
+            'ua': f'Підписка{tariff_suffix_ru} закінчується через {days_left} дн.',
        }

        bodies = {
            'ru': f"""
                <h2>Подписка скоро истекает</h2>
                <div class="highlight warning">
+                    {tariff_line_ru}
                    <p>Ваша подписка истекает через <strong>{days_left}</strong> дн.</p>
                    <p>Дата истечения: <strong>{expires_at}</strong></p>
                </div>
@@ -339,6 +380,7 @@ class EmailNotificationTemplates:
            'en': f"""
                <h2>Subscription Expiring Soon</h2>
                <div class="highlight warning">
+                    {tariff_line_en}
                    <p>Your subscription expires in <strong>{days_left}</strong> day(s).</p>
                    <p>Expiration date: <strong>{expires_at}</strong></p>
                </div>
@@ -348,6 +390,7 @@ class EmailNotificationTemplates:
            'zh': f"""
                <h2>订阅即将到期</h2>
                <div class="highlight warning">
+                    {tariff_line_zh}
                    <p>您的订阅将在 <strong>{days_left}</strong> 天后到期。</p>
                    <p>到期日期: <strong>{expires_at}</strong></p>
                </div>
@@ -357,6 +400,7 @@ class EmailNotificationTemplates:
            'ua': f"""
                <h2>Підписка скоро закінчується</h2>
                <div class="highlight warning">
+                    {tariff_line_ua}
                    <p>Ваша підписка закінчується через <strong>{days_left}</strong> дн.</p>
                    <p>Дата закінчення: <strong>{expires_at}</strong></p>
                </div>
@@ -372,17 +416,26 @@ class EmailNotificationTemplates:

    def _subscription_expired_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
        """Template for subscription expired notification."""
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_zh = f'<p>套餐: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_ua = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+
        subjects = {
-            'ru': 'Подписка истекла',
-            'en': 'Subscription Expired',
+            'ru': f'Подписка{tariff_suffix_ru} истекла',
+            'en': f'Subscription{tariff_suffix_en} Expired',
            'zh': '订阅已到期',
-            'ua': 'Підписка закінчилась',
+            'ua': f'Підписка{tariff_suffix_ru} закінчилась',
        }

        bodies = {
            'ru': f"""
                <h2>Подписка истекла</h2>
                <div class="highlight danger">
+                    {tariff_line_ru}
                    <p>Ваша подписка истекла. Доступ к VPN отключён.</p>
                </div>
                <p>Оформите новую подписку, чтобы продолжить использование сервиса.</p>
@@ -391,6 +444,7 @@ class EmailNotificationTemplates:
            'en': f"""
                <h2>Subscription Expired</h2>
                <div class="highlight danger">
+                    {tariff_line_en}
                    <p>Your subscription has expired. VPN access has been disabled.</p>
                </div>
                <p>Purchase a new subscription to continue using our service.</p>
@@ -399,6 +453,7 @@ class EmailNotificationTemplates:
            'zh': f"""
                <h2>订阅已到期</h2>
                <div class="highlight danger">
+                    {tariff_line_zh}
                    <p>您的订阅已到期。VPN访问已被禁用。</p>
                </div>
                <p>请购买新订阅以继续使用我们的服务。</p>
@@ -407,6 +462,7 @@ class EmailNotificationTemplates:
            'ua': f"""
                <h2>Підписка закінчилась</h2>
                <div class="highlight danger">
+                    {tariff_line_ua}
                    <p>Ваша підписка закінчилась. Доступ до VPN вимкнено.</p>
                </div>
                <p>Оформіть нову підписку, щоб продовжити використання сервісу.</p>
@@ -422,18 +478,24 @@ class EmailNotificationTemplates:
    def _subscription_renewed_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
        """Template for subscription renewed notification."""
        new_expires_at = context.get('new_expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''

        subjects = {
-            'ru': 'Подписка продлена',
-            'en': 'Subscription Renewed',
+            'ru': f'Подписка{tariff_suffix_ru} продлена',
+            'en': f'Subscription{tariff_suffix_en} Renewed',
            'zh': '订阅已续订',
-            'ua': 'Підписку продовжено',
+            'ua': f'Підписку{tariff_suffix_ru} продовжено',
        }

        bodies = {
            'ru': f"""
                <h2>Подписка успешно продлена!</h2>
                <div class="highlight success">
+                    {tariff_line_ru}
                    <p>Ваша подписка была успешно продлена.</p>
                    <p>Новая дата истечения: <strong>{new_expires_at}</strong></p>
                </div>
@@ -443,6 +505,7 @@ class EmailNotificationTemplates:
            'en': f"""
                <h2>Subscription Successfully Renewed!</h2>
                <div class="highlight success">
+                    {tariff_line_en}
                    <p>Your subscription has been successfully renewed.</p>
                    <p>New expiration date: <strong>{new_expires_at}</strong></p>
                </div>
@@ -459,18 +522,24 @@ class EmailNotificationTemplates:
    def _subscription_activated_template(self, language: str, context: dict[str, Any]) -> dict[str, str]:
        """Template for subscription activated notification."""
        expires_at = context.get('expires_at', '')
+        tariff_name = html.escape(context.get('tariff_name', ''))
+        tariff_suffix_ru = f' «{tariff_name}»' if tariff_name else ''
+        tariff_suffix_en = f' "{tariff_name}"' if tariff_name else ''
+        tariff_line_ru = f'<p>Тариф: <strong>{tariff_name}</strong></p>' if tariff_name else ''
+        tariff_line_en = f'<p>Plan: <strong>{tariff_name}</strong></p>' if tariff_name else ''

        subjects = {
-            'ru': 'Подписка активирована',
-            'en': 'Subscription Activated',
+            'ru': f'Подписка{tariff_suffix_ru} активирована',
+            'en': f'Subscription{tariff_suffix_en} Activated',
            'zh': '订阅已激活',
-            'ua': 'Підписку активовано',
+            'ua': f'Підписку{tariff_suffix_ru} активовано',
        }

        bodies = {
            'ru': f"""
                <h2>Подписка активирована!</h2>
                <div class="highlight success">
+                    {tariff_line_ru}
                    <p>Ваша VPN подписка успешно активирована.</p>
                    <p>Действует до: <strong>{expires_at}</strong></p>
                </div>
@@ -480,6 +549,7 @@ class EmailNotificationTemplates:
            'en': f"""
                <h2>Subscription Activated!</h2>
                <div class="highlight success">
+                    {tariff_line_en}
                    <p>Your VPN subscription has been successfully activated.</p>
                    <p>Valid until: <strong>{expires_at}</strong></p>
                </div>
@@ -1340,6 +1410,8 @@ class EmailNotificationTemplates:
        tariff_name = html.escape(context.get('tariff_name', ''))
        period_days = context.get('period_days', 0)
        cabinet_url = html.escape(context.get('cabinet_url', ''))
+        cabinet_email = html.escape(context.get('cabinet_email', ''))
+        cabinet_password = context.get('cabinet_password', '')

        subjects = {
            'ru': 'Ваша VPN подписка готова',
@@ -1349,6 +1421,66 @@ class EmailNotificationTemplates:
            'fa': 'اشتراک VPN شما آماده است',
        }

+        creds_block_ru = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Данные для входа в личный кабинет:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Пароль:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_en = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Your cabinet login credentials:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Password:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_zh = (
+            f"""
+                <div class="highlight">
+                    <p><strong>个人中心登录信息：</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>密码:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_ua = (
+            f"""
+                <div class="highlight">
+                    <p><strong>Дані для входу в особистий кабінет:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>Пароль:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
+        creds_block_fa = (
+            f"""
+                <div class="highlight">
+                    <p><strong>اطلاعات ورود به پنل کاربری:</strong></p>
+                    <p><strong>Email:</strong> <code>{cabinet_email}</code></p>
+                    <p><strong>رمز عبور:</strong> <code>{cabinet_password}</code></p>
+                </div>
+        """
+            if cabinet_password
+            else ''
+        )
+
        bodies = {
            'ru': f"""
                <h2>Ваша VPN подписка готова!</h2>
@@ -1356,6 +1488,7 @@ class EmailNotificationTemplates:
                    <p>Тариф: <strong>{tariff_name}</strong></p>
                    <p>Период: <strong>{period_days} дней</strong></p>
                </div>
+                {creds_block_ru}
                <p>Подписка активирована в вашем личном кабинете.</p>
                <p style="text-align: center;"><a href="{cabinet_url}" class="button">Перейти в личный кабинет</a></p>
            """,
@@ -1365,6 +1498,7 @@ class EmailNotificationTemplates:
                    <p>Plan: <strong>{tariff_name}</strong></p>
                    <p>Period: <strong>{period_days} days</strong></p>
                </div>
+                {creds_block_en}
                <p>Your subscription has been activated in your cabinet.</p>
                <p style="text-align: center;"><a href="{cabinet_url}" class="button">Go to Cabinet</a></p>
            """,
@@ -1374,6 +1508,7 @@ class EmailNotificationTemplates:
                    <p>套餐: <strong>{tariff_name}</strong></p>
                    <p>期限: <strong>{period_days} 天</strong></p>
                </div>
+                {creds_block_zh}
                <p>订阅已在您的个人中心激活。</p>
                <p style="text-align: center;"><a href="{cabinet_url}" class="button">前往个人中心</a></p>
            """,
@@ -1383,6 +1518,7 @@ class EmailNotificationTemplates:
                    <p>Тариф: <strong>{tariff_name}</strong></p>
                    <p>Період: <strong>{period_days} днів</strong></p>
                </div>
+                {creds_block_ua}
                <p>Підписка активована у вашому особистому кабінеті.</p>
                <p style="text-align: center;"><a href="{cabinet_url}" class="button">Перейти до кабінету</a></p>
            """,
@@ -1392,6 +1528,7 @@ class EmailNotificationTemplates:
                    <p>طرح: <strong>{tariff_name}</strong></p>
                    <p>مدت: <strong>{period_days} روز</strong></p>
                </div>
+                {creds_block_fa}
                <p>اشتراک شما در پنل کاربری فعال شده است.</p>
                <p style="text-align: center;"><a href="{cabinet_url}" class="button">رفتن به پنل کاربری</a></p>
            """,
@@ -7,7 +7,7 @@ from collections import defaultdict
 from datetime import time
 from pathlib import Path
 from typing import Literal
-from urllib.parse import urlparse
+from urllib.parse import quote as _url_quote, urlparse
 from zoneinfo import ZoneInfo

 import structlog
@@ -56,6 +56,17 @@ class Settings(BaseSettings):
    ADMIN_NOTIFICATIONS_TICKET_TOPIC_ID: int | None = None
    ADMIN_NOTIFICATIONS_NALOG_TOPIC_ID: int | None = None

+    # Раздельные топики для уведомлений (если не задано — fallback на ADMIN_NOTIFICATIONS_TOPIC_ID)
+    ADMIN_NOTIFICATIONS_PURCHASES_TOPIC_ID: int | None = None  # Покупки подписок
+    ADMIN_NOTIFICATIONS_RENEWALS_TOPIC_ID: int | None = None  # Продления
+    ADMIN_NOTIFICATIONS_TRIALS_TOPIC_ID: int | None = None  # Триалы
+    ADMIN_NOTIFICATIONS_BALANCE_TOPIC_ID: int | None = None  # Пополнение баланса
+    ADMIN_NOTIFICATIONS_ADDONS_TOPIC_ID: int | None = None  # Докупка трафика/устройств/серверов
+    ADMIN_NOTIFICATIONS_INFRASTRUCTURE_TOPIC_ID: int | None = None  # Ноды, техработы, статус панели
+    ADMIN_NOTIFICATIONS_ERRORS_TOPIC_ID: int | None = None  # Ошибки бота
+    ADMIN_NOTIFICATIONS_PROMO_TOPIC_ID: int | None = None  # Промокоды, кампании, промогруппы
+    ADMIN_NOTIFICATIONS_PARTNERS_TOPIC_ID: int | None = None  # Партнёрки, выводы, админ-действия
+
    # Настройки очереди чеков NaloGO
    NALOGO_QUEUE_CHECK_INTERVAL: int = 300  # Интервал проверки очереди (секунды)
    NALOGO_QUEUE_RECEIPT_DELAY: int = 3  # Задержка между отправкой чеков (секунды)
@@ -107,6 +118,7 @@ class Settings(BaseSettings):
    REMNAWAVE_WEBHOOK_ENABLED: bool = False
    REMNAWAVE_WEBHOOK_PATH: str = '/remnawave-webhook'
    REMNAWAVE_WEBHOOK_SECRET: str | None = None  # HMAC-SHA256 shared secret (min 32 chars)
+    REMNAWAVE_WEBHOOK_NOTIFY_NODE_CONNECTION_STATUS: bool = True

    # Webhook user notification toggles (what Telegram messages users receive from webhook events)
    WEBHOOK_NOTIFY_USER_ENABLED: bool = True
@@ -121,6 +133,7 @@ class Settings(BaseSettings):
    WEBHOOK_NOTIFY_NOT_CONNECTED: bool = True
    WEBHOOK_NOTIFY_BANDWIDTH_THRESHOLD: bool = True
    WEBHOOK_NOTIFY_DEVICES: bool = True
+    WEBHOOK_NOTIFY_TORRENT_DETECTED: bool = True

    TRIAL_DURATION_DAYS: int = 3
    TRIAL_TRAFFIC_LIMIT_GB: int = 10
@@ -196,6 +209,11 @@ class Settings(BaseSettings):
    # - tariffs: режим тарифов (готовые пакеты с фиксированными параметрами)
    SALES_MODE: str = 'tariffs'

+    # Multi-tariff mode: allows users to purchase multiple tariffs simultaneously
+    # Only works when SALES_MODE='tariffs'
+    MULTI_TARIFF_ENABLED: bool = False
+    MAX_ACTIVE_SUBSCRIPTIONS: int = 10
+
    # ID тарифа для триала в режиме тарифов (0 = использовать стандартные настройки триала)
    # Если указан ID тарифа, параметры триала берутся из тарифа (traffic_limit_gb, device_limit, allowed_squads)
    # Длительность триала всё равно берётся из TRIAL_DURATION_DAYS
@@ -353,10 +371,9 @@ class Settings(BaseSettings):
    YOOKASSA_TRUSTED_PROXY_NETWORKS: str = ''
    YOOKASSA_MIN_AMOUNT_KOPEKS: int = 5000
    YOOKASSA_MAX_AMOUNT_KOPEKS: int = 1000000
-    YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED: bool = False
    YOOKASSA_RECURRENT_ENABLED: bool = False
    YOOKASSA_RECURRENT_REQUIRED: bool = False
-    DISABLE_TOPUP_BUTTONS: bool = False
+    YOOKASSA_TEST_MODE: bool = False
    SUPPORT_TOPUP_ENABLED: bool = True
    PAYMENT_VERIFICATION_AUTO_CHECK_ENABLED: bool = False
    PAYMENT_VERIFICATION_AUTO_CHECK_INTERVAL_MINUTES: int = 10
@@ -366,6 +383,7 @@ class Settings(BaseSettings):
    NALOGO_PASSWORD: str | None = None
    NALOGO_DEVICE_ID: str | None = None
    NALOGO_STORAGE_PATH: str = './nalogo_tokens.json'
+    NALOGO_PROXY_URL: str | None = None  # SOCKS proxy for nalog.ru; falls back to PROXY_URL if not set

    AUTO_PURCHASE_AFTER_TOPUP_ENABLED: bool = False

@@ -450,7 +468,8 @@ class Settings(BaseSettings):
    PLATEGA_RETURN_URL: str | None = None
    PLATEGA_FAILED_URL: str | None = None
    PLATEGA_CURRENCY: str = 'RUB'
-    PLATEGA_ACTIVE_METHODS: str = '2,10,11,12,13'
+    PLATEGA_ACTIVE_METHODS: str = '2,11,12,13'
+    PLATEGA_INLINE_METHODS: bool = True
    PLATEGA_MIN_AMOUNT_KOPEKS: int = 10000
    PLATEGA_MAX_AMOUNT_KOPEKS: int = 100000000
    PLATEGA_WEBHOOK_PATH: str = '/platega-webhook'
@@ -535,6 +554,13 @@ class Settings(BaseSettings):
    KASSA_AI_WEBHOOK_PORT: int = 8089
    # Способ оплаты: 44 = СБП (QR код), 36 = Карты РФ, 43 = SberPay
    KASSA_AI_PAYMENT_SYSTEM_ID: int = 44
+    # Раздельные методы оплаты KassaAI (отображаются как отдельные кнопки)
+    KASSA_AI_SBP_ENABLED: bool = False  # СБП — payment_system_id=44
+    KASSA_AI_SBP_DISPLAY_NAME: str = 'СБП (KassaAI)'
+    KASSA_AI_CARD_ENABLED: bool = False  # Карты РФ — payment_system_id=36
+    KASSA_AI_CARD_DISPLAY_NAME: str = 'Карта (KassaAI)'
+    KASSA_AI_SBERPAY_ENABLED: bool = False  # SberPay — payment_system_id=43
+    KASSA_AI_SBERPAY_DISPLAY_NAME: str = 'SberPay (KassaAI)'

    # RioPay (api.riopay.online) v2.0.1
    RIOPAY_ENABLED: bool = False
@@ -548,12 +574,31 @@ class Settings(BaseSettings):
    RIOPAY_SUCCESS_URL: str | None = None
    RIOPAY_FAIL_URL: str | None = None

+    # SeverPay (severpay.io)
+    SEVERPAY_ENABLED: bool = False
+    SEVERPAY_MID: int | None = None  # Merchant ID
+    SEVERPAY_TOKEN: str | None = None  # Secret token for HMAC-SHA256
+    SEVERPAY_DISPLAY_NAME: str = 'SeverPay'
+    SEVERPAY_CURRENCY: str = 'RUB'
+    SEVERPAY_MIN_AMOUNT_KOPEKS: int = 10000  # 100₽
+    SEVERPAY_MAX_AMOUNT_KOPEKS: int = 10000000  # 100 000₽
+    SEVERPAY_WEBHOOK_PATH: str = '/severpay-webhook'
+    SEVERPAY_RETURN_URL: str | None = None
+    SEVERPAY_LIFETIME: int = 1440  # minutes, 30-4320
+
    MAIN_MENU_MODE: str = 'default'  # 'default' | 'cabinet'
    # Стиль кнопок Cabinet: primary (синий), success (зелёный), danger (красный), '' (по умолчанию для каждой секции)
    CABINET_BUTTON_STYLE: str = ''
    CONNECT_BUTTON_MODE: str = 'miniapp_subscription'
    MINIAPP_CUSTOM_URL: str = ''
    MINIAPP_STATIC_PATH: str = 'miniapp'
+
+    # Media upload settings (news article images/videos)
+    MEDIA_UPLOAD_DIR: str = './uploads'
+    MEDIA_MAX_IMAGE_SIZE_MB: int = 10
+    MEDIA_MAX_VIDEO_SIZE_MB: int = 50
+    MEDIA_IMAGE_MAX_DIMENSION: int = 2048
+    MEDIA_JPEG_QUALITY: int = 85
    MINIAPP_PURCHASE_URL: str = ''
    MINIAPP_SERVICE_NAME_EN: str = 'Bedolaga VPN'
    MINIAPP_SERVICE_NAME_RU: str = 'Bedolaga VPN'
@@ -776,6 +821,27 @@ class Settings(BaseSettings):
    BAN_SYSTEM_API_TOKEN: str | None = None
    BAN_SYSTEM_REQUEST_TIMEOUT: int = 30

+    # SOCKS5 proxy for routing bot traffic to Telegram API
+    # Format: socks5://user:password@host:port or socks5://host:port
+    PROXY_URL: str | None = None
+
+    @field_validator('PROXY_URL', 'NALOGO_PROXY_URL', mode='before')
+    @classmethod
+    def validate_proxy_url(cls, value: str | None) -> str | None:
+        if not value:
+            return None
+        from urllib.parse import urlparse
+
+        parsed = urlparse(value)
+        if parsed.scheme not in ('socks5', 'socks5h', 'socks4'):
+            raise ValueError(
+                f'Proxy URL must use socks5://, socks5h://, or socks4:// scheme, got: {parsed.scheme!r}. '
+                'HTTP proxies are not supported for security reasons.'
+            )
+        if not parsed.hostname:
+            raise ValueError('Proxy URL must contain a hostname')
+        return value
+
    @field_validator('MAIN_MENU_MODE', mode='before')
    @classmethod
    def normalize_main_menu_mode(cls, value: str | None) -> str:
@@ -902,6 +968,17 @@ class Settings(BaseSettings):
        """Проверяет, используется ли SQLite"""
        return 'sqlite' in self.get_database_url()

+    def get_proxy_url(self) -> str | None:
+        """Return SOCKS5 proxy URL or None."""
+        return self.PROXY_URL if self.PROXY_URL else None
+
+    def get_nalogo_proxy_url(self) -> str | None:
+        """Return SOCKS proxy URL for nalogo or None.
+
+        Uses NALOGO_PROXY_URL if set, otherwise falls back to PROXY_URL.
+        """
+        return self.NALOGO_PROXY_URL or self.PROXY_URL
+
    def is_admin(self, telegram_id: int | None = None, email: str | None = None) -> bool:
        """
        Check if user is admin by telegram_id or email.
@@ -1073,12 +1150,17 @@ class Settings(BaseSettings):
        username_clean = (username or '').lstrip('@')
        full_name_value = full_name or ''

+        # Remnawave разрешает только буквы, цифры, подчёркивания и дефисы
+        def _sanitize(value: str) -> str:
+            result = re.sub(r'[^0-9A-Za-z_-]+', '_', value)
+            return re.sub(r'_+', '_', result).strip('_-')
+
        # Для email-пользователей формируем уникальный identifier
        if telegram_id:
            identifier = str(telegram_id)
        elif email:
-            email_prefix = email.split('@')[0][:10]
-            identifier = f'email_{email_prefix}_{user_id}' if user_id else f'email_{email_prefix}'
+            email_prefix = _sanitize(email.split('@')[0][:10])
+            identifier = _sanitize(f'email_{email_prefix}_{user_id}' if user_id else f'email_{email_prefix}')
        elif user_id:
            identifier = f'id_{user_id}'
        else:
@@ -1092,20 +1174,18 @@ class Settings(BaseSettings):
                'username_clean': username_clean,
                'telegram_id': str(telegram_id) if telegram_id else identifier,
                'identifier': identifier,
-                'email': email.split('@')[0] if email else '',
+                'email': _sanitize(email.split('@')[0]) if email else '',
                'user_id': str(user_id) if user_id else '',
            },
        )

        raw_username = template.format_map(values).strip()
-        # Remnawave разрешает только буквы, цифры, подчёркивания и дефисы
-        sanitized_username = re.sub(r'[^0-9A-Za-z_-]+', '_', raw_username)
-        sanitized_username = re.sub(r'_+', '_', sanitized_username).strip('_-')
+        sanitized_username = _sanitize(raw_username)

        if not sanitized_username:
-            sanitized_username = f'user_{identifier}'
+            sanitized_username = _sanitize(f'user_{identifier}')

-        return sanitized_username[:36]
+        return sanitized_username[:36].strip('_-') or 'user'

    @staticmethod
    def parse_daily_time_list(raw_value: str | None) -> list[time]:
@@ -1237,10 +1317,6 @@ class Settings(BaseSettings):

        return bool(value)

-    def is_quick_amount_buttons_enabled(self) -> bool:
-        """Показывать ли кнопки быстрого выбора суммы пополнения."""
-        return self.YOOKASSA_QUICK_AMOUNT_SELECTION_ENABLED and not self.DISABLE_TOPUP_BUTTONS
-
    def get_available_languages(self) -> list[str]:
        defaults = ['ru', 'en', 'ua', 'zh', 'fa']

@@ -1417,24 +1493,44 @@ class Settings(BaseSettings):

    _CABINET_URL_DEFAULT = 'https://example.com/cabinet'

+    def _encode_referral_code(self, referral_code: str) -> str:
+        """Validate and URL-encode a referral code."""
+        if not referral_code:
+            raise ValueError('referral_code must not be empty or None')
+        return _url_quote(referral_code, safe='')
+
+    def _normalized_cabinet_url(self) -> str | None:
+        """Return normalized cabinet URL, or None if not configured."""
+        cabinet_url = (self.CABINET_URL or '').strip().rstrip('/')
+        if not cabinet_url or cabinet_url == self._CABINET_URL_DEFAULT:
+            return None
+        return cabinet_url
+
    def get_referral_link(self, referral_code: str, bot_username: str | None = None) -> str:
        """Build a referral link pointing to the web cabinet.

        Falls back to a Telegram bot deep link when CABINET_URL is not configured.
        """
-        from urllib.parse import quote
+        cabinet_link = self.get_cabinet_referral_link(referral_code)
+        if cabinet_link:
+            return cabinet_link
+        return self.get_bot_referral_link(referral_code, bot_username)

-        if not referral_code:
-            raise ValueError('referral_code must not be empty or None')
-
-        safe_code = quote(referral_code, safe='')
-        cabinet_url = (self.CABINET_URL or '').strip().rstrip('/')
-        if cabinet_url and cabinet_url != self._CABINET_URL_DEFAULT:
-            sep = '&' if '?' in cabinet_url else '?'
-            return f'{cabinet_url}{sep}ref={safe_code}'
+    def get_bot_referral_link(self, referral_code: str, bot_username: str | None = None) -> str:
+        """Always return the Telegram bot deep link for a referral code."""
+        safe_code = self._encode_referral_code(referral_code)
        username = bot_username or self.get_bot_username() or 'bot'
        return f'https://t.me/{username}?start={safe_code}'

+    def get_cabinet_referral_link(self, referral_code: str) -> str | None:
+        """Return the cabinet referral link, or None if cabinet is not configured."""
+        cabinet_url = self._normalized_cabinet_url()
+        if not cabinet_url:
+            return None
+        safe_code = self._encode_referral_code(referral_code)
+        sep = '&' if '?' in cabinet_url else '?'
+        return f'{cabinet_url}{sep}ref={safe_code}'
+
    def is_deep_links_enabled(self) -> bool:
        return self.ENABLE_DEEP_LINKS

@@ -1588,6 +1684,14 @@ class Settings(BaseSettings):
    def get_disabled_mode_device_limit(self) -> int | None:
        return self.get_devices_selection_disabled_amount()

+    def is_multi_tariff_enabled(self) -> bool:
+        """Проверяет, включен ли мультитарифный режим."""
+        return self.MULTI_TARIFF_ENABLED and self.SALES_MODE == 'tariffs'
+
+    def get_max_active_subscriptions(self) -> int:
+        """Максимальное число одновременных подписок (>1 только в multi-tariff)."""
+        return self.MAX_ACTIVE_SUBSCRIPTIONS if self.is_multi_tariff_enabled() else 1
+
    def is_tariffs_mode(self) -> bool:
        """Проверяет, включен ли режим продаж 'Тарифы'."""
        return self.SALES_MODE == 'tariffs'
@@ -1738,7 +1842,7 @@ class Settings(BaseSettings):
            except ValueError:
                logger.warning('Некорректный код метода Platega', part=part)
                continue
-            if method_code in {2, 10, 11, 12, 13} and method_code not in seen:
+            if method_code in {2, 11, 12, 13} and method_code not in seen:
                methods.append(method_code)
                seen.add(method_code)

@@ -1751,8 +1855,7 @@ class Settings(BaseSettings):
    def get_platega_method_definitions() -> dict[int, dict[str, str]]:
        return {
            2: {'name': 'СБП (QR)', 'title': '🏦 СБП (QR)'},
-            10: {'name': 'Банковские карты (RUB)', 'title': '💳 Карты (RUB)'},
-            11: {'name': 'Банковские карты', 'title': '💳 Банковские карты'},
+            11: {'name': 'Карты (RUB)', 'title': '💳 Карты (RUB)'},
            12: {'name': 'Международные карты', 'title': '🌍 Международные карты'},
            13: {'name': 'Криптовалюта', 'title': '🪙 Криптовалюта'},
        }
@@ -1850,6 +1953,46 @@ class Settings(BaseSettings):
    def get_riopay_display_name_html(self) -> str:
        return html.escape(self.get_riopay_display_name())

+    def is_severpay_enabled(self) -> bool:
+        return self.SEVERPAY_ENABLED and self.SEVERPAY_MID is not None and self.SEVERPAY_TOKEN is not None
+
+    def get_severpay_display_name(self) -> str:
+        name = (self.SEVERPAY_DISPLAY_NAME or '').strip()
+        return name if name else 'SeverPay'
+
+    def get_severpay_display_name_html(self) -> str:
+        return html.escape(self.get_severpay_display_name())
+
+    def is_kassa_ai_sbp_enabled(self) -> bool:
+        return self.KASSA_AI_SBP_ENABLED and self.is_kassa_ai_enabled()
+
+    def get_kassa_ai_sbp_display_name(self) -> str:
+        name = (self.KASSA_AI_SBP_DISPLAY_NAME or '').strip()
+        return name if name else 'СБП (KassaAI)'
+
+    def get_kassa_ai_sbp_display_name_html(self) -> str:
+        return html.escape(self.get_kassa_ai_sbp_display_name())
+
+    def is_kassa_ai_card_enabled(self) -> bool:
+        return self.KASSA_AI_CARD_ENABLED and self.is_kassa_ai_enabled()
+
+    def get_kassa_ai_card_display_name(self) -> str:
+        name = (self.KASSA_AI_CARD_DISPLAY_NAME or '').strip()
+        return name if name else 'Карта (KassaAI)'
+
+    def get_kassa_ai_card_display_name_html(self) -> str:
+        return html.escape(self.get_kassa_ai_card_display_name())
+
+    def is_kassa_ai_sberpay_enabled(self) -> bool:
+        return self.KASSA_AI_SBERPAY_ENABLED and self.is_kassa_ai_enabled()
+
+    def get_kassa_ai_sberpay_display_name(self) -> str:
+        name = (self.KASSA_AI_SBERPAY_DISPLAY_NAME or '').strip()
+        return name if name else 'SberPay (KassaAI)'
+
+    def get_kassa_ai_sberpay_display_name_html(self) -> str:
+        return html.escape(self.get_kassa_ai_sberpay_display_name())
+
    def is_payment_verification_auto_check_enabled(self) -> bool:
        return self.PAYMENT_VERIFICATION_AUTO_CHECK_ENABLED

@@ -2098,13 +2241,17 @@ class Settings(BaseSettings):
        except (ValueError, AttributeError):
            return [30, 60, 90, 180, 360]

-    def get_balance_payment_description(self, amount_kopeks: int, telegram_user_id: int | None = None) -> str:
+    def get_balance_payment_description(
+        self, amount_kopeks: int, telegram_user_id: int | None = None, user_db_id: int | None = None
+    ) -> str:
        # Базовое описание
        description = f'{self.PAYMENT_BALANCE_DESCRIPTION} на {self.format_price(amount_kopeks)}'

-        # Если передан user_id, добавляем его
+        # Добавляем идентификатор пользователя (TG ID приоритет, fallback на DB ID)
        if telegram_user_id is not None:
            description += f' (ID {telegram_user_id})'
+        elif user_db_id is not None:
+            description += f' (U{user_db_id})'

        # Формируем финальную строку по шаблону
        return self.PAYMENT_BALANCE_TEMPLATE.format(service_name=self.PAYMENT_SERVICE_NAME, description=description)
@@ -2517,6 +2664,9 @@ class Settings(BaseSettings):
            raw_path = 'miniapp'
        return Path(raw_path)

+    def get_media_upload_path(self) -> Path:
+        return Path(self.MEDIA_UPLOAD_DIR)
+
    # Cabinet methods
    def is_cabinet_enabled(self) -> bool:
        return bool(self.CABINET_ENABLED)
@@ -67,8 +67,24 @@ async def get_cryptobot_payment_by_id(db: AsyncSession, payment_id: int) -> Cryp
    return result.scalar_one_or_none()


+async def get_cryptobot_payment_by_invoice_id_for_update(db: AsyncSession, invoice_id: str) -> CryptoBotPayment | None:
+    result = await db.execute(
+        select(CryptoBotPayment)
+        .options(selectinload(CryptoBotPayment.user))
+        .where(CryptoBotPayment.invoice_id == invoice_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    return result.scalar_one_or_none()
+
+
 async def get_cryptobot_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> CryptoBotPayment | None:
-    result = await db.execute(select(CryptoBotPayment).where(CryptoBotPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(CryptoBotPayment)
+        .where(CryptoBotPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -63,7 +63,12 @@ async def get_freekassa_payment_by_id(db: AsyncSession, payment_id: int) -> Free


 async def get_freekassa_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> FreekassaPayment | None:
-    result = await db.execute(select(FreekassaPayment).where(FreekassaPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(FreekassaPayment)
+        .where(FreekassaPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -65,7 +65,12 @@ async def get_kassa_ai_payment_by_id(db: AsyncSession, payment_id: int) -> Kassa


 async def get_kassa_ai_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> KassaAiPayment | None:
-    result = await db.execute(select(KassaAiPayment).where(KassaAiPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(KassaAiPayment)
+        .where(KassaAiPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -58,7 +58,12 @@ async def get_mulenpay_payment_by_local_id(db: AsyncSession, payment_id: int) ->


 async def get_mulenpay_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> MulenPayPayment | None:
-    result = await db.execute(select(MulenPayPayment).where(MulenPayPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(MulenPayPayment)
+        .where(MulenPayPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -0,0 +1,288 @@
+"""CRUD operations for news articles."""
+
+from datetime import UTC, datetime
+from typing import Any
+
+import structlog
+from sqlalchemy import delete, func, nullslast, select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import NewsArticle
+
+
+logger = structlog.get_logger(__name__)
+
+# Fields that can be set via update_news_article
+_ALLOWED_UPDATE_FIELDS: frozenset[str] = frozenset(
+    {
+        'title',
+        'slug',
+        'content',
+        'excerpt',
+        'category',
+        'category_color',
+        'tag',
+        'category_id',
+        'tag_id',
+        'featured_image_url',
+        'is_published',
+        'is_featured',
+        'published_at',
+        'read_time_minutes',
+    }
+)
+
+# Fields that can be explicitly set to None
+_NULLABLE_UPDATE_FIELDS: frozenset[str] = frozenset(
+    {
+        'excerpt',
+        'tag',
+        'category_id',
+        'tag_id',
+        'featured_image_url',
+        'published_at',
+    }
+)
+
+
+async def create_news_article(
+    db: AsyncSession,
+    *,
+    title: str,
+    slug: str,
+    content: str = '',
+    excerpt: str | None = None,
+    category: str = '',
+    category_color: str = '#00e5a0',
+    tag: str | None = None,
+    category_id: int | None = None,
+    tag_id: int | None = None,
+    featured_image_url: str | None = None,
+    is_published: bool = False,
+    is_featured: bool = False,
+    published_at: datetime | None = None,
+    read_time_minutes: int = 1,
+    created_by: int | None = None,
+) -> NewsArticle:
+    """Create a new news article.
+
+    Raises:
+        IntegrityError: if slug is not unique (caller must handle).
+    """
+    # Auto-set published_at when publishing without explicit date
+    if is_published and published_at is None:
+        published_at = datetime.now(UTC)
+
+    article = NewsArticle(
+        title=title,
+        slug=slug,
+        content=content,
+        excerpt=excerpt,
+        category=category,
+        category_color=category_color,
+        tag=tag,
+        category_id=category_id,
+        tag_id=tag_id,
+        featured_image_url=featured_image_url,
+        is_published=is_published,
+        is_featured=is_featured,
+        published_at=published_at,
+        read_time_minutes=read_time_minutes,
+        created_by=created_by,
+    )
+
+    db.add(article)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(article)
+
+    logger.info(
+        'Created news article',
+        article_id=article.id,
+        slug=article.slug,
+        is_published=article.is_published,
+    )
+    return article
+
+
+async def get_news_article_by_id(db: AsyncSession, article_id: int) -> NewsArticle | None:
+    """Get a news article by ID with author, category, and tag relationships."""
+    result = await db.execute(
+        select(NewsArticle)
+        .options(
+            selectinload(NewsArticle.author),
+            selectinload(NewsArticle.category_obj),
+            selectinload(NewsArticle.tag_obj),
+        )
+        .where(NewsArticle.id == article_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_news_article_by_slug(db: AsyncSession, slug: str) -> NewsArticle | None:
+    """Get a news article by slug with author, category, and tag relationships."""
+    result = await db.execute(
+        select(NewsArticle)
+        .options(
+            selectinload(NewsArticle.author),
+            selectinload(NewsArticle.category_obj),
+            selectinload(NewsArticle.tag_obj),
+        )
+        .where(NewsArticle.slug == slug)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_published_news(
+    db: AsyncSession,
+    *,
+    category: str | None = None,
+    limit: int = 20,
+    offset: int = 0,
+) -> list[NewsArticle]:
+    """Get published news articles, ordered by published_at descending.
+
+    Does NOT load the author relationship -- list views do not need it.
+    """
+    stmt = select(NewsArticle).where(NewsArticle.is_published.is_(True))
+    if category:
+        stmt = stmt.where(NewsArticle.category == category)
+
+    # NULLs last so articles without published_at don't float to the top in DESC
+    stmt = stmt.order_by(nullslast(NewsArticle.published_at.desc())).offset(offset).limit(limit)
+
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_published_news_count(
+    db: AsyncSession,
+    *,
+    category: str | None = None,
+) -> int:
+    """Get count of published news articles, optionally filtered by category."""
+    stmt = select(func.count(NewsArticle.id)).where(NewsArticle.is_published.is_(True))
+    if category:
+        stmt = stmt.where(NewsArticle.category == category)
+
+    result = await db.execute(stmt)
+    return result.scalar_one() or 0
+
+
+async def get_all_news(
+    db: AsyncSession,
+    *,
+    limit: int = 50,
+    offset: int = 0,
+) -> list[NewsArticle]:
+    """Get all news articles (admin), ordered by created_at descending."""
+    stmt = select(NewsArticle).order_by(NewsArticle.created_at.desc()).offset(offset).limit(limit)
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
+async def get_all_news_count(db: AsyncSession) -> int:
+    """Get total count of all news articles."""
+    result = await db.execute(select(func.count(NewsArticle.id)))
+    return result.scalar_one() or 0
+
+
+async def get_news_categories(db: AsyncSession) -> list[str]:
+    """Get distinct categories from published articles."""
+    result = await db.execute(
+        select(NewsArticle.category)
+        .where(NewsArticle.is_published.is_(True))
+        .where(NewsArticle.category != '')
+        .distinct()
+        .order_by(NewsArticle.category)
+    )
+    return list(result.scalars().all())
+
+
+async def unfeature_all_news(db: AsyncSession) -> None:
+    """Remove featured flag from all articles (so only one can be featured).
+
+    Does NOT commit. The caller must commit the session to persist this change.
+    This is intentional — the caller should commit both this operation and the
+    subsequent feature operation atomically.
+    """
+    await db.execute(update(NewsArticle).where(NewsArticle.is_featured.is_(True)).values(is_featured=False))
+
+
+async def update_news_article(
+    db: AsyncSession,
+    article: NewsArticle,
+    **kwargs: Any,
+) -> NewsArticle:
+    """Update a news article. Only whitelisted fields are applied.
+
+    Raises:
+        IntegrityError: if slug conflicts with another article (caller must handle).
+    """
+    update_data: dict[str, Any] = {}
+    for key, value in kwargs.items():
+        if key not in _ALLOWED_UPDATE_FIELDS:
+            continue
+        if value is None and key not in _NULLABLE_UPDATE_FIELDS:
+            continue
+        update_data[key] = value
+
+    # Auto-set published_at when transitioning to published
+    if update_data.get('is_published') and not article.is_published and not update_data.get('published_at'):
+        if article.published_at is None:
+            update_data['published_at'] = datetime.now(UTC)
+
+    if not update_data:
+        return article
+
+    update_data['updated_at'] = datetime.now(UTC)
+
+    await db.execute(update(NewsArticle).where(NewsArticle.id == article.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(article)
+
+    logger.info(
+        'Updated news article',
+        article_id=article.id,
+        slug=article.slug,
+        updated_fields=list(update_data.keys()),
+    )
+    return article
+
+
+async def delete_news_article(db: AsyncSession, article: NewsArticle) -> None:
+    """Delete a news article."""
+    # Capture fields before commit expires the ORM instance attributes
+    article_id = article.id
+    article_slug = article.slug
+
+    await db.execute(delete(NewsArticle).where(NewsArticle.id == article_id))
+    await db.commit()
+
+    logger.info('Deleted news article', article_id=article_id, slug=article_slug)
+
+
+async def increment_views(db: AsyncSession, article_id: int) -> int:
+    """Atomically increment the views counter and return the new count.
+
+    Uses UPDATE … RETURNING so the caller can patch the ORM instance directly
+    without issuing a second SELECT (db.refresh).
+    """
+    result = await db.execute(
+        update(NewsArticle)
+        .where(NewsArticle.id == article_id)
+        .values(views_count=NewsArticle.views_count + 1)
+        .returning(NewsArticle.views_count)
+    )
+    await db.commit()
+    row = result.fetchone()
+    return row[0] if row else 0
@@ -0,0 +1,87 @@
+"""CRUD operations for news categories."""
+
+import structlog
+from sqlalchemy import select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import NewsArticle, NewsCategory
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def get_all_categories(db: AsyncSession) -> list[NewsCategory]:
+    """Get all news categories ordered by name."""
+    result = await db.execute(select(NewsCategory).order_by(NewsCategory.name))
+    return list(result.scalars().all())
+
+
+async def get_category_by_id(db: AsyncSession, category_id: int) -> NewsCategory | None:
+    """Get a single news category by primary key."""
+    result = await db.execute(select(NewsCategory).where(NewsCategory.id == category_id))
+    return result.scalar_one_or_none()
+
+
+async def create_category(db: AsyncSession, *, name: str, color: str = '#00e5a0') -> NewsCategory:
+    """Create a new news category.
+
+    Raises:
+        IntegrityError: if a category with the same name already exists (caller must handle).
+    """
+    category = NewsCategory(name=name.strip(), color=color)
+    db.add(category)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(category)
+    logger.info('Created news category', category_id=category.id, name=category.name)
+    return category
+
+
+async def update_category(
+    db: AsyncSession,
+    category: NewsCategory,
+    **kwargs: str | None,
+) -> NewsCategory:
+    """Update an existing news category.
+
+    Supported kwargs: name, color.
+
+    Raises:
+        IntegrityError: if the new name conflicts with an existing category.
+    """
+    update_data: dict[str, str] = {}
+    if 'name' in kwargs and kwargs['name'] is not None:
+        update_data['name'] = kwargs['name'].strip()
+    if 'color' in kwargs and kwargs['color'] is not None:
+        update_data['color'] = kwargs['color']
+
+    if not update_data:
+        return category
+
+    await db.execute(update(NewsCategory).where(NewsCategory.id == category.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(category)
+    logger.info('Updated news category', category_id=category.id, updated_fields=list(update_data.keys()))
+    return category
+
+
+async def delete_category(db: AsyncSession, category: NewsCategory) -> None:
+    """Delete a news category and clear category fields from all linked articles."""
+    cat_id, cat_name = category.id, category.name
+    # Clear legacy string fields on articles that reference this category
+    await db.execute(
+        update(NewsArticle)
+        .where(NewsArticle.category_id == cat_id)
+        .values(category='', category_color='#00e5a0', category_id=None)
+    )
+    await db.delete(category)
+    await db.commit()
+    logger.info('Deleted news category', category_id=cat_id, name=cat_name)
@@ -0,0 +1,83 @@
+"""CRUD operations for news tags."""
+
+import structlog
+from sqlalchemy import select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import NewsArticle, NewsTag
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def get_all_tags(db: AsyncSession) -> list[NewsTag]:
+    """Get all news tags ordered by name."""
+    result = await db.execute(select(NewsTag).order_by(NewsTag.name))
+    return list(result.scalars().all())
+
+
+async def get_tag_by_id(db: AsyncSession, tag_id: int) -> NewsTag | None:
+    """Get a single news tag by primary key."""
+    result = await db.execute(select(NewsTag).where(NewsTag.id == tag_id))
+    return result.scalar_one_or_none()
+
+
+async def create_tag(db: AsyncSession, *, name: str, color: str = '#94a3b8') -> NewsTag:
+    """Create a new news tag.
+
+    Raises:
+        IntegrityError: if a tag with the same name already exists (caller must handle).
+    """
+    tag = NewsTag(name=name.strip(), color=color)
+    db.add(tag)
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(tag)
+    logger.info('Created news tag', tag_id=tag.id, name=tag.name)
+    return tag
+
+
+async def update_tag(
+    db: AsyncSession,
+    tag: NewsTag,
+    **kwargs: str | None,
+) -> NewsTag:
+    """Update an existing news tag.
+
+    Supported kwargs: name, color.
+
+    Raises:
+        IntegrityError: if the new name conflicts with an existing tag.
+    """
+    update_data: dict[str, str] = {}
+    if 'name' in kwargs and kwargs['name'] is not None:
+        update_data['name'] = kwargs['name'].strip()
+    if 'color' in kwargs and kwargs['color'] is not None:
+        update_data['color'] = kwargs['color']
+
+    if not update_data:
+        return tag
+
+    await db.execute(update(NewsTag).where(NewsTag.id == tag.id).values(**update_data))
+    try:
+        await db.commit()
+    except IntegrityError:
+        await db.rollback()
+        raise
+    await db.refresh(tag)
+    logger.info('Updated news tag', tag_id=tag.id, updated_fields=list(update_data.keys()))
+    return tag
+
+
+async def delete_tag(db: AsyncSession, tag: NewsTag) -> None:
+    """Delete a news tag and clear tag fields from all linked articles."""
+    tag_id, tag_name = tag.id, tag.name
+    # Clear legacy string field on articles that reference this tag
+    await db.execute(update(NewsArticle).where(NewsArticle.tag_id == tag_id).values(tag=None, tag_id=None))
+    await db.delete(tag)
+    await db.commit()
+    logger.info('Deleted news tag', tag_id=tag_id, name=tag_name)
@@ -34,6 +34,8 @@ async def record_notification(
    subscription_id: int,
    notification_type: str,
    days_before: int | None = None,
+    *,
+    commit: bool = True,
 ) -> None:
    already_exists = await notification_sent(db, user_id, subscription_id, notification_type, days_before)
    if already_exists:
@@ -45,7 +47,8 @@ async def record_notification(
        days_before=days_before,
    )
    db.add(notification)
-    await db.commit()
+    if commit:
+        await db.commit()


 async def clear_notifications(db: AsyncSession, subscription_id: int, *, commit: bool = True) -> None:
@@ -58,6 +61,8 @@ async def clear_notification_by_type(
    db: AsyncSession,
    subscription_id: int,
    notification_type: str,
+    *,
+    commit: bool = True,
 ) -> None:
    await db.execute(
        delete(SentNotification).where(
@@ -65,4 +70,5 @@ async def clear_notification_by_type(
            SentNotification.notification_type == notification_type,
        )
    )
-    await db.commit()
+    if commit:
+        await db.commit()
@@ -67,7 +67,12 @@ async def get_pal24_payment_by_id(db: AsyncSession, payment_id: int) -> Pal24Pay


 async def get_pal24_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> Pal24Payment | None:
-    result = await db.execute(select(Pal24Payment).where(Pal24Payment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(Pal24Payment)
+        .where(Pal24Payment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -71,7 +71,12 @@ async def get_platega_payment_by_id(db: AsyncSession, payment_id: int) -> Plateg


 async def get_platega_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> PlategaPayment | None:
-    result = await db.execute(select(PlategaPayment).where(PlategaPayment.id == payment_id).with_for_update())
+    result = await db.execute(
+        select(PlategaPayment)
+        .where(PlategaPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
    return result.scalar_one_or_none()


@@ -3,7 +3,7 @@ from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

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


 def _normalize_period_discounts(period_discounts: dict[int, int] | None) -> dict[int, int]:
@@ -259,7 +259,7 @@ async def get_promo_group_members(
 ) -> list[User]:
    result = await db.execute(
        select(User)
-        .options(selectinload(User.subscription))
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
        .where(User.promo_group_id == group_id)
        .order_by(User.created_at.desc())
        .offset(offset)
@@ -38,8 +38,8 @@ _POLICY_UPDATABLE_FIELDS = frozenset(
    }
 )

-# Superadmin level constant
-_SUPERADMIN_LEVEL = 999
+# Superadmin level constant — single source of truth, imported by admin_roles and bootstrap
+SUPERADMIN_LEVEL = 999


 class AdminRoleCRUD:
@@ -240,21 +240,6 @@ class UserRoleCRUD:
        logger.info('Assigned role to user', user_role_id=user_role.id, user_id=user_id, role_id=role_id)
        return user_role

-    @staticmethod
-    async def revoke_role(db: AsyncSession, user_role_id: int) -> bool:
-        """Soft-revoke: set is_active=False. Returns False if not found."""
-        result = await db.execute(select(UserRole).where(UserRole.id == user_role_id))
-        user_role = result.scalar_one_or_none()
-        if not user_role:
-            return False
-
-        user_role.is_active = False
-        await db.flush()
-        logger.info(
-            'Revoked user role', user_role_id=user_role_id, user_id=user_role.user_id, role_id=user_role.role_id
-        )
-        return True
-
    @staticmethod
    async def get_all_admins(
        db: AsyncSession,
@@ -296,14 +281,16 @@ class UserRoleCRUD:

    @staticmethod
    async def get_superadmin_count(db: AsyncSession) -> int:
-        """Count users with an active role at superadmin level (999)."""
+        """Count users with an active, non-expired role at superadmin level (999)."""
+        now = datetime.now(UTC)
        result = await db.execute(
            select(func.count(func.distinct(UserRole.user_id)))
            .join(AdminRole, UserRole.role_id == AdminRole.id)
            .where(
                UserRole.is_active.is_(True),
                AdminRole.is_active.is_(True),
-                AdminRole.level == _SUPERADMIN_LEVEL,
+                AdminRole.level == SUPERADMIN_LEVEL,
+                or_(UserRole.expires_at.is_(None), UserRole.expires_at > now),
            )
        )
        return result.scalar() or 0
@@ -15,7 +15,7 @@ logger = structlog.get_logger(__name__)
 async def create_riopay_payment(
    db: AsyncSession,
    *,
-    user_id: int,
+    user_id: int | None,
    order_id: str,
    amount_kopeks: int,
    currency: str = 'RUB',
@@ -66,6 +66,17 @@ async def get_riopay_payment_by_id(db: AsyncSession, payment_id: int) -> RioPayP
    return result.scalar_one_or_none()


+async def get_riopay_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> RioPayPayment | None:
+    """Получает платеж по ID с блокировкой FOR UPDATE (для защиты от TOCTOU race)."""
+    result = await db.execute(
+        select(RioPayPayment)
+        .where(RioPayPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    return result.scalar_one_or_none()
+
+
 async def update_riopay_payment_status(
    db: AsyncSession,
    payment: RioPayPayment,
@@ -317,7 +317,17 @@ async def sync_with_remnawave(db: AsyncSession, remnawave_squads: list[dict]) ->
            )
            created += 1

-    removed_servers = [server for uuid, server in existing_servers.items() if uuid not in remnawave_uuids]
+    # Protect external squads referenced by tariffs from being removed during sync
+    tariff_ext_uuids_result = await db.execute(
+        select(Tariff.external_squad_uuid).where(Tariff.external_squad_uuid.isnot(None))
+    )
+    protected_uuids = {row[0] for row in tariff_ext_uuids_result.fetchall()}
+
+    removed_servers = [
+        server
+        for uuid, server in existing_servers.items()
+        if uuid not in remnawave_uuids and uuid not in protected_uuids
+    ]

    if removed_servers:
        removed_ids = [server.id for server in removed_servers]
@@ -420,7 +430,7 @@ async def get_server_connected_users(db: AsyncSession, server_id: int) -> list[U
            ),
        )
        .where(or_(*connection_filters))
-        .options(selectinload(User.subscription))
+        .options(selectinload(User.subscriptions).selectinload(Subscription.tariff))
        .order_by(User.id)
    )

@@ -0,0 +1,162 @@
+"""CRUD операции для платежей SeverPay."""
+
+from datetime import UTC, datetime
+
+import structlog
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import SeverPayPayment
+
+
+logger = structlog.get_logger(__name__)
+
+
+async def create_severpay_payment(
+    db: AsyncSession,
+    *,
+    user_id: int | None,
+    order_id: str,
+    amount_kopeks: int,
+    currency: str = 'RUB',
+    description: str | None = None,
+    payment_url: str | None = None,
+    payment_method: str | None = None,
+    severpay_id: str | None = None,
+    severpay_uid: str | None = None,
+    expires_at: datetime | None = None,
+    metadata_json: dict | None = None,
+) -> SeverPayPayment:
+    """Создает запись о платеже SeverPay."""
+    payment = SeverPayPayment(
+        user_id=user_id,
+        order_id=order_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        description=description,
+        payment_url=payment_url,
+        payment_method=payment_method,
+        severpay_id=severpay_id,
+        severpay_uid=severpay_uid,
+        expires_at=expires_at,
+        metadata_json=metadata_json,
+        status='pending',
+        is_paid=False,
+    )
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+    logger.info('Создан платеж SeverPay', order_id=order_id, user_id=user_id)
+    return payment
+
+
+async def get_severpay_payment_by_order_id(db: AsyncSession, order_id: str) -> SeverPayPayment | None:
+    """Получает платеж по order_id (internal)."""
+    result = await db.execute(select(SeverPayPayment).where(SeverPayPayment.order_id == order_id))
+    return result.scalar_one_or_none()
+
+
+async def get_severpay_payment_by_severpay_id(db: AsyncSession, severpay_id: str) -> SeverPayPayment | None:
+    """Получает платеж по ID от SeverPay."""
+    result = await db.execute(select(SeverPayPayment).where(SeverPayPayment.severpay_id == severpay_id))
+    return result.scalar_one_or_none()
+
+
+async def get_severpay_payment_by_id(db: AsyncSession, payment_id: int) -> SeverPayPayment | None:
+    """Получает платеж по ID."""
+    result = await db.execute(select(SeverPayPayment).where(SeverPayPayment.id == payment_id))
+    return result.scalar_one_or_none()
+
+
+async def get_severpay_payment_by_id_for_update(db: AsyncSession, payment_id: int) -> SeverPayPayment | None:
+    """Получает платеж по ID с блокировкой FOR UPDATE."""
+    result = await db.execute(
+        select(SeverPayPayment)
+        .where(SeverPayPayment.id == payment_id)
+        .with_for_update()
+        .execution_options(populate_existing=True)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_severpay_payment_status(
+    db: AsyncSession,
+    payment: SeverPayPayment,
+    *,
+    status: str,
+    is_paid: bool | None = None,
+    severpay_id: str | None = None,
+    severpay_uid: str | None = None,
+    payment_method: str | None = None,
+    callback_payload: dict | None = None,
+    transaction_id: int | None = None,
+) -> SeverPayPayment:
+    """Обновляет статус платежа."""
+    payment.status = status
+    payment.updated_at = datetime.now(UTC)
+
+    if is_paid is not None:
+        payment.is_paid = is_paid
+        if is_paid:
+            payment.paid_at = datetime.now(UTC)
+    if severpay_id is not None:
+        payment.severpay_id = severpay_id
+    if severpay_uid is not None:
+        payment.severpay_uid = severpay_uid
+    if payment_method is not None:
+        payment.payment_method = payment_method
+    if callback_payload is not None:
+        payment.callback_payload = callback_payload
+    if transaction_id is not None:
+        payment.transaction_id = transaction_id
+
+    await db.commit()
+    await db.refresh(payment)
+    logger.info(
+        'Обновлен статус платежа SeverPay',
+        order_id=payment.order_id,
+        status=status,
+        is_paid=payment.is_paid,
+    )
+    return payment
+
+
+async def get_pending_severpay_payments(db: AsyncSession, user_id: int) -> list[SeverPayPayment]:
+    """Получает незавершенные платежи пользователя."""
+    result = await db.execute(
+        select(SeverPayPayment).where(
+            SeverPayPayment.user_id == user_id,
+            SeverPayPayment.status == 'pending',
+            SeverPayPayment.is_paid == False,
+        )
+    )
+    return list(result.scalars().all())
+
+
+async def get_expired_pending_severpay_payments(
+    db: AsyncSession,
+) -> list[SeverPayPayment]:
+    """Получает просроченные платежи в статусе pending."""
+    now = datetime.now(UTC)
+    result = await db.execute(
+        select(SeverPayPayment).where(
+            SeverPayPayment.status == 'pending',
+            SeverPayPayment.is_paid == False,
+            SeverPayPayment.expires_at < now,
+        )
+    )
+    return list(result.scalars().all())
+
+
+async def link_severpay_payment_to_transaction(
+    db: AsyncSession,
+    *,
+    payment: SeverPayPayment,
+    transaction_id: int,
+) -> SeverPayPayment:
+    """Связывает платеж с транзакцией."""
+    payment.transaction_id = transaction_id
+    payment.updated_at = datetime.now(UTC)
+    await db.flush()
+    await db.refresh(payment)
+    return payment
@@ -1,8 +1,9 @@
+import secrets
 from collections.abc import Iterable
 from datetime import UTC, datetime, timedelta

 import structlog
-from sqlalchemy import and_, delete, func, select
+from sqlalchemy import and_, case, delete, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 from sqlalchemy.orm.exc import StaleDataError
@@ -23,6 +24,18 @@ from app.utils.timezone import format_local_datetime

 logger = structlog.get_logger(__name__)

+
+async def generate_unique_short_id(db: AsyncSession, max_attempts: int = 10) -> str:
+    """Generate a unique remnawave_short_id (6 hex chars) with collision check."""
+    for _ in range(max_attempts):
+        short_id = secrets.token_hex(3)
+        existing = await db.execute(select(Subscription.id).where(Subscription.remnawave_short_id == short_id).limit(1))
+        if existing.scalar_one_or_none() is None:
+            return short_id
+    # Fallback: 8 chars for extra entropy
+    return secrets.token_hex(4)
+
+
 _WEBHOOK_GUARD_SECONDS = 60


@@ -40,23 +53,18 @@ def calc_device_limit_on_tariff_switch(
    new_tariff_device_limit: int | None,
    max_device_limit: int | None = None,
 ) -> int:
-    """Calculate device_limit preserving extra purchased devices when switching tariffs.
+    """Calculate device_limit when switching tariffs.

-    Extra devices = current_device_limit - old_tariff_device_limit (clamped to 0).
-    Result = new_tariff_device_limit + extra_devices, capped at max_device_limit.
+    Resets to new tariff base device limit — previously purchased
+    extra devices are NOT carried over.  Capped at max_device_limit.
    """
-    old_base = old_tariff_device_limit if old_tariff_device_limit is not None else 0
-    current = current_device_limit if current_device_limit is not None else old_base
-    extra = max(0, current - old_base)
-
    new_base = new_tariff_device_limit if new_tariff_device_limit is not None else 1
-    total = new_base + extra

    effective_max = max_device_limit or (settings.MAX_DEVICES_LIMIT if settings.MAX_DEVICES_LIMIT > 0 else None)
-    if effective_max and total > effective_max:
-        total = effective_max
+    if effective_max and new_base > effective_max:
+        new_base = effective_max

-    return total
+    return new_base


 def is_active_paid_subscription(subscription: Subscription | None) -> bool:
@@ -72,6 +80,14 @@ def is_active_paid_subscription(subscription: Subscription | None) -> bool:


 async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Subscription | None:
+    """Get primary subscription for user.
+
+    Returns the first active/trial subscription, or the most recently created one.
+    Multi-tariff compatible: prioritizes active subscriptions.
+    For multi-tariff operations on a specific subscription, use get_subscription_by_id_for_user().
+    """
+    from app.database.models import SubscriptionStatus
+
    result = await db.execute(
        select(Subscription)
        .options(
@@ -79,7 +95,16 @@ async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Subscri
            selectinload(Subscription.tariff),
        )
        .where(Subscription.user_id == user_id)
-        .order_by(Subscription.created_at.desc())
+        .order_by(
+            # Active/trial subscriptions first, then by end_date (most remaining time)
+            case(
+                (Subscription.status == SubscriptionStatus.ACTIVE.value, 0),
+                (Subscription.status == SubscriptionStatus.TRIAL.value, 1),
+                else_=2,
+            ),
+            Subscription.end_date.desc().nulls_last(),
+            Subscription.created_at.desc(),
+        )
        .limit(1)
    )
    subscription = result.scalar_one_or_none()
@@ -140,7 +165,17 @@ async def create_trial_subscription(
    end_date = datetime.now(UTC) + timedelta(days=duration_days)

    # Check for existing PENDING trial subscription (retry after failed payment)
-    existing = await get_subscription_by_user_id(db, user_id)
+    # In multi-tariff mode, only reuse a subscription for the SAME tariff to avoid
+    # overwriting a paid subscription for a different tariff.
+    existing = None
+    if settings.is_multi_tariff_enabled() and tariff_id:
+        for sub in await get_active_subscriptions_by_user_id(db, user_id):
+            if sub.tariff_id == tariff_id:
+                existing = sub
+                break
+    else:
+        existing = await get_subscription_by_user_id(db, user_id)
+
    if existing and existing.is_trial and existing.status == SubscriptionStatus.PENDING.value:
        existing.status = SubscriptionStatus.ACTIVE.value
        existing.start_date = datetime.now(UTC)
@@ -149,6 +184,8 @@ async def create_trial_subscription(
        existing.device_limit = device_limit
        existing.connected_squads = final_squads
        existing.tariff_id = tariff_id
+        if not existing.remnawave_short_id:
+            existing.remnawave_short_id = await generate_unique_short_id(db)
        await db.commit()
        await db.refresh(existing)
        logger.info(
@@ -156,6 +193,8 @@ async def create_trial_subscription(
        )
        return existing

+    short_id = await generate_unique_short_id(db)
+
    subscription = Subscription(
        user_id=user_id,
        status=SubscriptionStatus.ACTIVE.value,
@@ -165,9 +204,10 @@ async def create_trial_subscription(
        traffic_limit_gb=traffic_limit_gb,
        device_limit=device_limit,
        connected_squads=final_squads,
-        autopay_enabled=settings.is_autopay_enabled_by_default(),
+        autopay_enabled=False,
        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
        tariff_id=tariff_id,
+        remnawave_short_id=short_id,
    )

    db.add(subscription)
@@ -235,6 +275,8 @@ async def create_paid_subscription(
        except Exception as error:
            logger.error('❌ Не удалось получить fallback сквад', user_id=user_id, error=error)

+    short_id = await generate_unique_short_id(db)
+
    subscription = Subscription(
        user_id=user_id,
        status=SubscriptionStatus.ACTIVE.value,
@@ -247,6 +289,7 @@ async def create_paid_subscription(
        autopay_enabled=settings.is_autopay_enabled_by_default(),
        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
        tariff_id=tariff_id,
+        remnawave_short_id=short_id,
    )

    db.add(subscription)
@@ -256,6 +299,20 @@ async def create_paid_subscription(
    else:
        await db.flush()

+    # Kill all trial subscriptions when creating a paid subscription
+    # Trial = probe, must die on any paid purchase (regardless of path: bot, cabinet, webhook)
+    if not is_trial:
+        try:
+            killed = await deactivate_user_trial_subscriptions(db, user_id, exclude_subscription_id=subscription.id)
+            if killed:
+                logger.info(
+                    'Deactivated trial subscriptions on paid purchase',
+                    user_id=user_id,
+                    killed_count=len(killed),
+                )
+        except Exception as trial_err:
+            logger.warning('Failed to deactivate trials on paid purchase', error=trial_err)
+
    logger.info(
        '💎 Создана платная подписка для пользователя ID: статус',
        user_id=user_id,
@@ -642,6 +699,21 @@ async def extend_subscription(

    await clear_notifications(db, subscription.id, commit=commit)

+    # Kill other trial subscriptions if this extension converts trial to paid
+    if not subscription.is_trial and days > 0:
+        try:
+            killed = await deactivate_user_trial_subscriptions(
+                db, subscription.user_id, exclude_subscription_id=subscription.id
+            )
+            if killed:
+                logger.info(
+                    'Deactivated trial subscriptions on extend',
+                    user_id=subscription.user_id,
+                    killed_count=len(killed),
+                )
+        except Exception as trial_err:
+            logger.warning('Failed to deactivate trials on extend', error=trial_err)
+
    logger.info('✅ Подписка продлена до', end_date=subscription.end_date)
    logger.info('📊 Новые параметры: статус=, окончание', status=subscription.status, end_date=subscription.end_date)

@@ -699,6 +771,7 @@ async def add_subscription_devices(db: AsyncSession, subscription: Subscription,
    locked_result = await db.execute(
        select(Subscription)
        .where(Subscription.id == subscription.id)
+        .options(selectinload(Subscription.tariff))
        .with_for_update()
        .execution_options(populate_existing=True)
    )
@@ -717,6 +790,18 @@ async def add_subscription_devices(db: AsyncSession, subscription: Subscription,
        )
        new_limit = max_devices

+    # Check tariff max device limit
+    tariff_max = subscription.tariff.max_device_limit if subscription.tariff else None
+    if tariff_max is not None and tariff_max > 0 and new_limit > tariff_max:
+        logger.warning(
+            '📱 Попытка превысить лимит устройств тарифа',
+            user_id=subscription.user_id,
+            current=subscription.device_limit,
+            requested=devices,
+            tariff_max_devices=tariff_max,
+        )
+        new_limit = tariff_max
+
    subscription.device_limit = new_limit
    subscription.updated_at = datetime.now(UTC)

@@ -817,10 +902,11 @@ async def decrement_subscription_server_counts(


 async def update_subscription_autopay(
-    db: AsyncSession, subscription: Subscription, enabled: bool, days_before: int = 3
+    db: AsyncSession, subscription: Subscription, enabled: bool, days_before: int | None = None
 ) -> Subscription:
    subscription.autopay_enabled = enabled
-    subscription.autopay_days_before = days_before
+    if days_before is not None:
+        subscription.autopay_days_before = days_before
    subscription.updated_at = datetime.now(UTC)

    await db.commit()
@@ -831,18 +917,19 @@ async def update_subscription_autopay(
    return subscription


-async def deactivate_subscription(db: AsyncSession, subscription: Subscription) -> Subscription:
+async def deactivate_subscription(db: AsyncSession, subscription: Subscription, *, commit: bool = True) -> Subscription:
    subscription.status = SubscriptionStatus.DISABLED.value
    subscription.updated_at = datetime.now(UTC)

-    await db.commit()
-    await db.refresh(subscription)
+    if commit:
+        await db.commit()
+        await db.refresh(subscription)

    logger.info('❌ Подписка пользователя деактивирована', user_id=subscription.user_id)
    return subscription


-async def reactivate_subscription(db: AsyncSession, subscription: Subscription) -> Subscription:
+async def reactivate_subscription(db: AsyncSession, subscription: Subscription, *, commit: bool = True) -> Subscription:
    """Реактивация подписки (например, после повторной подписки на канал или докупки трафика).

    Активирует если подписка была DISABLED или EXPIRED и ещё не истекла по времени.
@@ -866,8 +953,9 @@ async def reactivate_subscription(db: AsyncSession, subscription: Subscription)
    subscription.status = SubscriptionStatus.ACTIVE.value
    subscription.updated_at = now

-    await db.commit()
-    await db.refresh(subscription)
+    if commit:
+        await db.commit()
+        await db.refresh(subscription)

    logger.info(
        '✅ Подписка реактивирована',
@@ -1361,6 +1449,7 @@ async def create_subscription_no_commit(
    if connected_squads is None:
        connected_squads = []

+    short_id = await generate_unique_short_id(db)
    subscription = Subscription(
        user_id=user_id,
        status=status,
@@ -1371,6 +1460,7 @@ async def create_subscription_no_commit(
        device_limit=device_limit,
        connected_squads=connected_squads,
        remnawave_short_uuid=remnawave_short_uuid,
+        remnawave_short_id=short_id,
        subscription_url=subscription_url,
        subscription_crypto_link=subscription_crypto_link,
        autopay_enabled=(settings.is_autopay_enabled_by_default() if autopay_enabled is None else autopay_enabled),
@@ -1411,6 +1501,7 @@ async def create_subscription(
    if connected_squads is None:
        connected_squads = []

+    short_id = await generate_unique_short_id(db)
    subscription = Subscription(
        user_id=user_id,
        status=status,
@@ -1421,6 +1512,7 @@ async def create_subscription(
        device_limit=device_limit,
        connected_squads=connected_squads,
        remnawave_short_uuid=remnawave_short_uuid,
+        remnawave_short_id=short_id,
        subscription_url=subscription_url,
        subscription_crypto_link=subscription_crypto_link,
        autopay_enabled=(settings.is_autopay_enabled_by_default() if autopay_enabled is None else autopay_enabled),
@@ -1447,6 +1539,7 @@ async def create_pending_subscription(
    payment_method: str = 'pending',
    total_price_kopeks: int = 0,
    is_trial: bool = False,
+    tariff_id: int | None = None,
 ) -> Subscription:
    """Creates a pending subscription that will be activated after payment.

@@ -1457,7 +1550,23 @@ async def create_pending_subscription(
    current_time = datetime.now(UTC)
    end_date = current_time + timedelta(days=duration_days)

-    existing_subscription = await get_subscription_by_user_id(db, user_id)
+    if settings.is_multi_tariff_enabled() and tariff_id:
+        active_subs = await get_active_subscriptions_by_user_id(db, user_id)
+        existing_subscription = next((s for s in active_subs if s.tariff_id == tariff_id), None)
+        if not existing_subscription:
+            # Also check non-active subs for this tariff
+            result = await db.execute(
+                select(Subscription)
+                .where(
+                    Subscription.user_id == user_id,
+                    Subscription.tariff_id == tariff_id,
+                )
+                .order_by(Subscription.created_at.desc())
+                .limit(1)
+            )
+            existing_subscription = result.scalar_one_or_none()
+    else:
+        existing_subscription = await get_subscription_by_user_id(db, user_id)

    if existing_subscription:
        if (
@@ -1480,6 +1589,8 @@ async def create_pending_subscription(
        existing_subscription.connected_squads = connected_squads or []
        existing_subscription.traffic_used_gb = 0.0
        existing_subscription.updated_at = current_time
+        if tariff_id is not None:
+            existing_subscription.tariff_id = tariff_id

        await db.commit()
        await db.refresh(existing_subscription)
@@ -1493,6 +1604,7 @@ async def create_pending_subscription(
        )
        return existing_subscription

+    short_id = await generate_unique_short_id(db)
    subscription = Subscription(
        user_id=user_id,
        status=SubscriptionStatus.PENDING.value,
@@ -1502,8 +1614,10 @@ async def create_pending_subscription(
        traffic_limit_gb=traffic_limit_gb,
        device_limit=device_limit,
        connected_squads=connected_squads or [],
+        tariff_id=tariff_id,
        autopay_enabled=settings.is_autopay_enabled_by_default(),
        autopay_days_before=settings.DEFAULT_AUTOPAY_DAYS_BEFORE,
+        remnawave_short_id=short_id,
    )

    db.add(subscription)
@@ -1531,6 +1645,7 @@ async def create_pending_trial_subscription(
    connected_squads: list[str] = None,
    payment_method: str = 'pending',
    total_price_kopeks: int = 0,
+    tariff_id: int | None = None,
 ) -> Subscription:
    """Creates a pending trial subscription. Wrapper for create_pending_subscription with is_trial=True."""
    return await create_pending_subscription(
@@ -1543,18 +1658,34 @@ async def create_pending_trial_subscription(
        payment_method=payment_method,
        total_price_kopeks=total_price_kopeks,
        is_trial=True,
+        tariff_id=tariff_id,
    )


-async def activate_pending_subscription(db: AsyncSession, user_id: int, period_days: int = None) -> Subscription | None:
+async def activate_pending_subscription(
+    db: AsyncSession,
+    user_id: int,
+    period_days: int = None,
+    subscription_id: int | None = None,
+) -> Subscription | None:
    """Активирует pending подписку пользователя, меняя её статус на ACTIVE."""
-    logger.info('Активация pending подписки: пользователь период дней', user_id=user_id, period_days=period_days)
+    logger.info(
+        'Активация pending подписки: пользователь период дней',
+        user_id=user_id,
+        period_days=period_days,
+        subscription_id=subscription_id,
+    )
+
+    # Находим pending подписку пользователя (последнюю созданную при наличии нескольких)
+    conditions = [
+        Subscription.user_id == user_id,
+        Subscription.status == SubscriptionStatus.PENDING.value,
+    ]
+    if subscription_id is not None:
+        conditions.append(Subscription.id == subscription_id)

-    # Находим pending подписку пользователя
    result = await db.execute(
-        select(Subscription).where(
-            and_(Subscription.user_id == user_id, Subscription.status == SubscriptionStatus.PENDING.value)
-        )
+        select(Subscription).where(and_(*conditions)).order_by(Subscription.created_at.desc()).limit(1)
    )
    pending_subscription = result.scalar_one_or_none()

@@ -1865,6 +1996,8 @@ async def update_daily_charge_time(
    db: AsyncSession,
    subscription: Subscription,
    charge_time: datetime = None,
+    *,
+    commit: bool = True,
 ) -> Subscription:
    """Обновляет время последнего суточного списания и продлевает подписку на 1 день."""
    now = charge_time or datetime.now(UTC)
@@ -1876,8 +2009,11 @@ async def update_daily_charge_time(
        subscription.end_date = new_end_date
        logger.info('📅 Продлена подписка до', subscription_id=subscription.id, new_end_date=new_end_date)

-    await db.commit()
-    await db.refresh(subscription)
+    if commit:
+        await db.commit()
+        await db.refresh(subscription)
+    else:
+        await db.flush()

    return subscription

@@ -1934,3 +2070,164 @@ async def toggle_daily_subscription_pause(
    if subscription.is_daily_paused:
        return await resume_daily_subscription(db, subscription)
    return await pause_daily_subscription(db, subscription)
+
+
+# ── Multi-tariff CRUD functions ──────────────────────────────────────────────
+
+
+async def get_active_subscriptions_by_user_id(db: AsyncSession, user_id: int) -> list[Subscription]:
+    """Get all active/trial/limited subscriptions for a user.
+
+    Includes LIMITED status because those subscriptions still have time remaining
+    (just ran out of traffic) and should be treated as "alive" for renewal,
+    duplicate prevention, and display purposes.
+    """
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.tariff),
+        )
+        .where(
+            Subscription.user_id == user_id,
+            Subscription.status.in_(
+                [
+                    SubscriptionStatus.ACTIVE.value,
+                    SubscriptionStatus.TRIAL.value,
+                    SubscriptionStatus.LIMITED.value,
+                ]
+            ),
+        )
+        .order_by(Subscription.created_at.desc())
+    )
+    return list(result.scalars().all())
+
+
+async def get_subscription_by_id_for_user(db: AsyncSession, subscription_id: int, user_id: int) -> Subscription | None:
+    """Get subscription by ID with ownership check (IDOR protection)."""
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.tariff),
+        )
+        .where(
+            Subscription.id == subscription_id,
+            Subscription.user_id == user_id,
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_subscription_by_id(db: AsyncSession, subscription_id: int) -> Subscription | None:
+    """Get subscription by ID (admin use only, no ownership check)."""
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.tariff),
+        )
+        .where(Subscription.id == subscription_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_subscription_by_user_and_tariff(db: AsyncSession, user_id: int, tariff_id: int) -> Subscription | None:
+    """Get active/trial/limited subscription for a specific user+tariff combination.
+
+    Includes LIMITED status because those subscriptions still have time remaining
+    (just ran out of traffic) and should be extended rather than duplicated.
+    """
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.tariff),
+        )
+        .where(
+            Subscription.user_id == user_id,
+            Subscription.tariff_id == tariff_id,
+            Subscription.status.in_(
+                [
+                    SubscriptionStatus.ACTIVE.value,
+                    SubscriptionStatus.TRIAL.value,
+                    SubscriptionStatus.LIMITED.value,
+                ]
+            ),
+        )
+        .order_by(Subscription.created_at.desc())
+        .limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
+async def deactivate_user_trial_subscriptions(
+    db: AsyncSession,
+    user_id: int,
+    *,
+    exclude_subscription_id: int | None = None,
+) -> list[Subscription]:
+    """Deactivate all trial subscriptions for a user.
+
+    Called when user purchases a paid tariff — trial is a probe that must die on purchase.
+    Returns remaining trial time in seconds (for TRIAL_ADD_REMAINING_DAYS_TO_PAID).
+    Handles both tariff-based and squad-based trials uniformly.
+    """
+    result = await db.execute(
+        select(Subscription).where(
+            Subscription.user_id == user_id,
+            Subscription.is_trial.is_(True),
+            Subscription.status.in_(
+                [
+                    SubscriptionStatus.ACTIVE.value,
+                    SubscriptionStatus.TRIAL.value,
+                ]
+            ),
+        )
+    )
+    trial_subs = list(result.scalars().all())
+
+    deactivated = []
+    for sub in trial_subs:
+        if exclude_subscription_id and sub.id == exclude_subscription_id:
+            continue
+        sub.status = SubscriptionStatus.DISABLED.value
+        sub.is_trial = False
+        sub.autopay_enabled = False
+        sub.updated_at = datetime.now(UTC)
+        deactivated.append(sub)
+        logger.info(
+            'Trial subscription deactivated on paid purchase',
+            subscription_id=sub.id,
+            user_id=user_id,
+            tariff_id=sub.tariff_id,
+        )
+
+    if deactivated:
+        await db.flush()
+
+    return deactivated
+
+
+async def get_all_subscriptions_by_user_id(db: AsyncSession, user_id: int) -> list[Subscription]:
+    """Get all subscriptions for a user (any status).
+
+    Ordering: active first, then trial, then everything else — newest first within each group.
+    """
+    result = await db.execute(
+        select(Subscription)
+        .options(
+            selectinload(Subscription.user),
+            selectinload(Subscription.tariff),
+        )
+        .where(Subscription.user_id == user_id)
+        .order_by(
+            case(
+                (Subscription.status == SubscriptionStatus.ACTIVE.value, 0),
+                (Subscription.status == SubscriptionStatus.TRIAL.value, 1),
+                else_=2,
+            ),
+            Subscription.created_at.desc(),
+        )
+    )
+    return list(result.scalars().all())
@@ -61,16 +61,17 @@ async def get_conversion_statistics(db: AsyncSession) -> dict:
    total_conversions = total_conversions_result.scalar() or 0

    # Подсчитываем пользователей с платными подписками
-    users_with_paid_result = await db.execute(select(func.count(User.id)).where(User.has_had_paid_subscription == True))
+    users_with_paid_result = await db.execute(
+        select(func.count(User.id)).where(User.has_had_paid_subscription.is_(True))
+    )
    users_with_paid = users_with_paid_result.scalar() or 0

    # Подсчитываем всех пользователей с подписками (использовавших триал)
-    # Считаем что все новые пользователи начинают с триала
    total_users_with_subscriptions_result = await db.execute(select(func.count(func.distinct(Subscription.user_id))))
    total_users_with_subscriptions = total_users_with_subscriptions_result.scalar() or 0

    # Расчёт конверсии: (оплатившие) / (всего с подписками) * 100
-    # Это показывает какой % пользователей, получивших подписку, в итоге оплатили
+    # Знаменатель = все юзеры с подписками (включая уже конвертированных)
    if total_users_with_subscriptions > 0:
        conversion_rate = round((users_with_paid / total_users_with_subscriptions) * 100, 1)
    else:
@@ -3,7 +3,7 @@ from sqlalchemy import func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload

-from app.database.models import PromoGroup, Subscription, Tariff
+from app.database.models import PromoGroup, Subscription, SubscriptionStatus, Tariff


 logger = structlog.get_logger(__name__)
@@ -83,13 +83,16 @@ async def count_tariffs(db: AsyncSession, *, include_inactive: bool = False) ->
 async def get_trial_tariff(db: AsyncSession) -> Tariff | None:
    """Получает тариф, доступный для триала (is_trial_available=True).

+    Триальный тариф может быть неактивным — это сделано специально,
+    чтобы он не отображался в списке покупки, но использовался для триала
+    со своими лимитами (трафик, устройства, серверы).
+
    Сортируется по updated_at DESC, чтобы вернуть последний установленный
    триальный тариф (на случай если их несколько).
    """
    query = (
        select(Tariff)
        .where(Tariff.is_trial_available.is_(True))
-        .where(Tariff.is_active.is_(True))
        .options(selectinload(Tariff.allowed_promo_groups))
        .order_by(Tariff.updated_at.desc().nullslast(), Tariff.id.desc())
        .limit(1)
@@ -188,7 +191,7 @@ async def create_tariff(
    # Видимость в разделе подарков
    show_in_gift: bool = True,
    # Режим сброса трафика
-    traffic_reset_mode: str | None = None,  # DAY, WEEK, MONTH, NO_RESET, None = глобальная настройка
+    traffic_reset_mode: str | None = None,  # DAY, WEEK, MONTH, MONTH_ROLLING, NO_RESET, None = глобальная настройка
    # Внешний сквад RemnaWave
    external_squad_uuid: str | None = None,
 ) -> Tariff:
@@ -390,7 +393,8 @@ async def update_tariff(
 async def delete_tariff(db: AsyncSession, tariff: Tariff) -> bool:
    """
    Удаляет тариф.
-    Подписки с этим тарифом получат tariff_id = NULL.
+    FK с ondelete=RESTRICT — удаление невозможно, если есть привязанные подписки.
+    Вызывающий код должен проверить отсутствие активных подписок до вызова.
    """
    tariff_id = tariff.id
    tariff_name = tariff.name
@@ -401,7 +405,7 @@ async def delete_tariff(db: AsyncSession, tariff: Tariff) -> bool:
    )
    affected_subscriptions = subscriptions_count.scalar_one()

-    # Удаляем тариф (FK с ondelete=SET NULL автоматически обнулит tariff_id в подписках)
+    # Удаляем тариф (FK RESTRICT — подписок с tariff_id быть не должно)
    await db.delete(tariff)
    await db.commit()

@@ -421,6 +425,18 @@ async def get_tariff_subscriptions_count(db: AsyncSession, tariff_id: int) -> in
    return int(result.scalar_one())


+async def get_active_subscriptions_count_by_tariff_id(db: AsyncSession, tariff_id: int) -> int:
+    """Подсчитывает количество активных (active/trial) подписок на тарифе."""
+    active_statuses = [SubscriptionStatus.ACTIVE.value, SubscriptionStatus.TRIAL.value]
+    result = await db.execute(
+        select(func.count(Subscription.id)).where(
+            Subscription.tariff_id == tariff_id,
+            Subscription.status.in_(active_statuses),
+        )
+    )
+    return int(result.scalar_one())
+
+
 async def set_tariff_promo_groups(
    db: AsyncSession,
    tariff: Tariff,
--- a/Show More
+++ b/Show More