xync-bot 0.3.24.dev12__py3-none-any.whl → 0.3.25.dev1__py3-none-any.whl

xync_bot/__main__.py

@@ -0,0 +1,36 @@
+import logging
+from asyncio import run
+
+from PGram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import UpdateType
+from x_model import init_db
+
+from xync_bot.routers.main.handler import mr
+from xync_bot.routers.cond import cr
+from xync_bot.routers.pay.handler import pr
+from xync_bot.routers import last
+from xync_bot.store import Store
+
+au = [
+    UpdateType.MESSAGE,
+    UpdateType.CALLBACK_QUERY,
+    UpdateType.CHAT_MEMBER,
+    UpdateType.MY_CHAT_MEMBER,
+]  # , UpdateType.CHAT_JOIN_REQUEST
+bot = Bot([cr, pr, mr, last], Store(), au, default=DefaultBotProperties(parse_mode="HTML"))
+
+if __name__ == "__main__":
+    from xync_bot.loader import TOKEN, TORM
+
+    logging.basicConfig(level=logging.INFO)
+
+    async def main() -> None:
+        cn = await init_db(TORM)
+        bot.dp.workflow_data["store"].glob = await Store.Global()  # todo: refact store loading
+        await bot.start(
+            TOKEN,
+            cn,
+        )
+
+    run(main())

xync_bot/routers/__init__.py

@@ -0,0 +1,41 @@
+import logging
+
+from aiogram import Router, F
+from aiogram.enums import ContentType
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.types import Message
+
+last = Router(name="last")
+
+
+@last.message(
+    F.content_type.not_in(
+        {
+            ContentType.NEW_CHAT_MEMBERS,
+            # ContentType.LEFT_CHAT_MEMBER,
+            # ContentType.SUPERGROUP_CHAT_CREATED,
+            # ContentType.NEW_CHAT_PHOTO,
+            # ContentType.FORUM_TOPIC_CREATED,
+            # ContentType.FORUM_TOPIC_EDITED,
+            ContentType.FORUM_TOPIC_CLOSED,
+            # ContentType.GENERAL_FORUM_TOPIC_HIDDEN, # deletable
+        }
+    )
+)
+async def del_cbq(msg: Message):
+    try:
+        await msg.delete()
+        logging.info({"DELETED": msg.model_dump(exclude_none=True)})
+    except TelegramBadRequest:
+        logging.error({"NOT_DELETED": msg.model_dump(exclude_none=True)})
+
+
+@last.message()
+async def all_rest(msg: Message):
+    logging.warning(
+        {
+            "NO_HANDLED": msg.model_dump(
+                exclude_none=True,
+            )
+        }
+    )

xync_bot/routers/cond/__init__.py

@@ -8,7 +8,7 @@ from xync_schema.enums import SynonymType
 
 from xync_bot.routers.cond.func import wrap_cond, get_val, btns, rkm, ikm, SynTypeCd, CondCd
 
-cr = Router()
+cr = Router(name="cond")
 
 
 @cr.message(Command("cond"))
@@ -89,9 +89,3 @@ async def got_action(cbq: CallbackQuery, callback_data: CondCd, state: FSMContex
         await (await state.get_value("cmsg")).delete()
         await show_cond(cbq.message, cond)
     return await cbq.answer(callback_data.act)
-
-
-@cr.message()
-async def unknown(msg: Message):
-    # user = await User.get(username_id=msg.from_user.id)
-    await msg.delete()

xync_bot/routers/{main.py → main/handler.py}

@@ -1,8 +1,6 @@
 import logging
 
 from aiogram import Router, F
-from aiogram.enums import ContentType
-from aiogram.exceptions import TelegramBadRequest
 from aiogram.filters import CommandStart, CommandObject, ChatMemberUpdatedFilter, JOIN_TRANSITION, LEAVE_TRANSITION
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import (
@@ -18,8 +16,9 @@ from aiogram.utils.deep_linking import create_start_link
 from xync_schema import models
 
 from xync_bot.shared import NavCallbackData
+from xync_bot.store import Store
 
-mr = Router()
+mr = Router(name="main")
 
 
 class RrCallbackData(CallbackData, prefix="reg_res"):  # registration response
@@ -30,6 +29,7 @@ class RrCallbackData(CallbackData, prefix="reg_res"):  # registration response
 home_btns = InlineKeyboardMarkup(
     inline_keyboard=[
         [
+            InlineKeyboardButton(text="Transfer", callback_data=NavCallbackData(to="transfer").pack()),
             InlineKeyboardButton(text="Invite", callback_data=NavCallbackData(to="ref_link").pack()),
             InlineKeyboardButton(text="Get VPN", callback_data=NavCallbackData(to="get_vpn").pack()),
         ]
@@ -41,7 +41,7 @@ home_btns = InlineKeyboardMarkup(
 async def start_handler(msg: Message, command: CommandObject):
     me: User = msg.from_user
     ref_id: int = command.args.isnumeric() and int(command.args)
-    user = await models.User.get_or_none(id=me.id, blocked=False)
+    user = await models.User.get(username_id=me.id, blocked=False)
     rm = None
     logging.info(msg, {"src": "start"})
     if user:
@@ -66,6 +66,27 @@ async def start_handler(msg: Message, command: CommandObject):
     return await msg.answer(rs, reply_markup=rm)
 
 
+@mr.message(CommandStart(deep_link=True))  # attempt to reg by fake link
+async def fraud_handler(msg: Message):
+    logging.warning(f"Start: {msg.from_user.id}. Msg: {msg}")
+    # todo: alert to admins! Fraud attempt!
+    await msg.answer("🤔")
+
+
+@mr.message(CommandStart())  # обычный /start
+async def home(msg: Message, store: Store):
+    me = msg.from_user
+    user, is_new = await models.User.tg_upsert(me, False)
+
+    rr = "сначала вы должны найти поручителя, и перейти по его реферальной ссылке.\nhttps://telegra.ph/XyncNet-02-13"
+    if is_new:  # has ref and created now
+        await msg.answer(f"Здравствуйте {me.full_name}, что бы использовать возможности нашей сети, {rr}")
+    elif not user.ref_id:
+        await msg.answer(rr.capitalize())
+    else:
+        await msg.answer(f"{me.full_name}, не балуйтесь, вы и так уже активный участник👌🏼", reply_markup=home_btns)
+
+
 @mr.callback_query(RrCallbackData.filter())
 async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData) -> None:
     protege = await models.User[callback_data.to]
@@ -83,27 +104,7 @@ async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData
     await cb.message.edit_text(rs)
 
 
-@mr.message(CommandStart(deep_link=True))  # attempt to reg by fake link
-async def fraud_handler(msg: Message):
-    logging.warning(f"Start: {msg.from_user.id}. Msg: {msg}")
-    # todo: alert to admins! Fraud attempt!
-    await msg.answer("🤔")
-
-
-@mr.message(CommandStart())
-async def start_no_ref_handler(msg: Message):
-    me = msg.from_user
-    user, cr = await models.User.tg2in(me, False)
-    rr = "сначала вы должны найти поручителя, и перейти по его реферальной ссылке.\nhttps://telegra.ph/XyncNet-02-13"
-    if cr:  # has ref and created now
-        await msg.answer(f"Здравствуйте {me.full_name}, что бы использовать возможности нашей сети, {rr}")
-    elif not user.ref_id:
-        await msg.answer(rr.capitalize())
-    else:
-        await msg.answer(f"{me.full_name}, не балуйтесь, вы и так уже активный участник👌🏼", reply_markup=home_btns)
-
-
-@mr.callback_query(NavCallbackData.filter(F.to == "ref_link"))
+@mr.callback_query(NavCallbackData.filter(F.to.__eq__("ref_link")))
 async def ref_link_handler(cbq: CallbackQuery):
     me = cbq.from_user
     if not (u := await models.User.get_or_none(id=me.id, blocked=False).prefetch_related("ref")):
@@ -118,7 +119,7 @@ async def ref_link_handler(cbq: CallbackQuery):
     await cbq.answer("Wait for your protege request..")
 
 
-@mr.my_chat_member(F.chat.type == "private")  # my_chat_member is fired on add bot to any chat. filter for preventing
+@mr.my_chat_member(F.chat.type == "private")  # my_chat_member is fired on adding bot to any chat. filter for preventing
 async def my_user_set_status(my_chat_member: ChatMemberUpdated):
     logging.info({"my_chat_member": my_chat_member.model_dump(exclude_none=True)})
     u: User = my_chat_member.from_user
@@ -128,7 +129,7 @@ async def my_user_set_status(my_chat_member: ChatMemberUpdated):
 
 @mr.my_chat_member()
 async def user_set_status(my_chat_member: ChatMemberUpdated):
-    if my_chat_member.new_chat_member.user.username == "XyncNetBot":  # удалена группа где бот был добавлен админом
+    if my_chat_member.new_chat_member.user.username == "XyncNetBot":  # удалена группа, где бот был добавлен админом
         if forum := await models.Forum.get_or_none(id=my_chat_member.chat.id):
             await forum.delete()
         res = f"I {my_chat_member.new_chat_member.status} from {my_chat_member.chat.id}:{my_chat_member.chat.title}"
@@ -186,36 +187,3 @@ async def order_msg(msg: Message):
     await models.Msg.create(tgid=msg.message_id, txt=msg.text, order_id=order.id, receiver=receiver)
     logging.info(msg, {"src": "order_msg"})
     return await msg.send_copy(receiver.forum, message_thread_id=rcv_topic)
-
-
-@mr.message(
-    F.content_type.not_in(
-        {
-            ContentType.NEW_CHAT_MEMBERS,
-            # ContentType.LEFT_CHAT_MEMBER,
-            # ContentType.SUPERGROUP_CHAT_CREATED,
-            # ContentType.NEW_CHAT_PHOTO,
-            # ContentType.FORUM_TOPIC_CREATED,
-            # ContentType.FORUM_TOPIC_EDITED,
-            ContentType.FORUM_TOPIC_CLOSED,
-            # ContentType.GENERAL_FORUM_TOPIC_HIDDEN, # deletable
-        }
-    )
-)
-async def del_cbq(msg: Message):
-    try:
-        await msg.delete()
-        logging.info({"DELETED": msg.model_dump(exclude_none=True)})
-    except TelegramBadRequest:
-        logging.error({"NOT_DELETED": msg.model_dump(exclude_none=True)})
-
-
-@mr.message()
-async def all_rest(msg: Message):
-    logging.warning(
-        {
-            "NO_HANDLED": msg.model_dump(
-                exclude_none=True,
-            )
-        }
-    )

xync_bot/routers/pay/dep.py

@@ -1,4 +1,3 @@
-import logging
 from asyncio import gather
 from enum import IntEnum
 
@@ -6,8 +5,6 @@ from aiogram.exceptions import TelegramBadRequest
 from aiogram.fsm.state import StatesGroup, State
 from aiogram.types import Message, InlineKeyboardMarkup
 from pyrogram.types import CallbackQuery
-from tortoise.functions import Min
-from x_auth.enums import Role
 from x_model.func import ArrayAgg
 from xync_schema import models
 
@@ -60,107 +57,6 @@ class PayStep(IntEnum):
     pending_receive = 19  # Ожидание поступления (если мы получаем фиат)
 
 
-flags = {
-    "RUB": "🇷🇺",
-    "THB": "🇹🇭",
-    "IDR": "🇮🇩",
-    "TRY": "🇹🇷",
-    "GEL": "🇬🇪",
-    "VND": "🇻🇳",
-    "AED": "🇦🇪",
-    "AMD": "🇦🇲",
-    "AZN": "🇦🇿",
-    "CNY": "🇨🇳",
-    "EUR": "🇪🇺",
-    "HKD": "🇭🇰",
-    "INR": "🇮🇳",
-    "PHP": "🇵🇭",
-    "USD": "🇺🇸",
-}
-
-
-class SingleStore(type):
-    _store = None
-
-    async def __call__(cls):
-        if not cls._store:
-            cls._store = super(SingleStore, cls).__call__()
-            cls._store.coins = {k: v for k, v in await models.Coin.all().order_by("ticker").values_list("id", "ticker")}
-            curs = {c.id: c for c in await models.Cur.filter(ticker__in=flags.keys()).order_by("ticker")}
-            cls._store.curs = curs
-            cls._store.exs = {k: v for k, v in await models.Ex.all().values_list("id", "name")}
-            cls._store.pmcurs = {
-                k: v
-                for k, v in await models.Pmex.filter(pm__pmcurs__cur_id__in=cls._store.curs.keys())
-                .annotate(sname=Min("name"))
-                .group_by("pm__pmcurs__id")
-                .values_list("pm__pmcurs__id", "sname")
-            }
-            cls._store.coinexs = {
-                c.id: [ex.ex_id for ex in c.coinexs] for c in await models.Coin.all().prefetch_related("coinexs")
-            }
-            cls._store.curpms = {
-                cur_id: ids
-                for cur_id, ids in await models.Pmcur.filter(cur_id__in=curs.keys())
-                .annotate(ids=ArrayAgg("id"))
-                .group_by("cur_id")
-                .values_list("cur_id", "ids")
-            }
-            cls._store.curpms = {
-                cur_id: ids
-                for cur_id, ids in await models.Pmcur.filter(cur_id__in=curs.keys())
-                .annotate(ids=ArrayAgg("id"))
-                .group_by("cur_id")
-                .values_list("cur_id", "ids")
-            }
-
-        return cls._store
-
-
-class Store:
-    class Global(metaclass=SingleStore):
-        coins: dict[int, str]  # id:ticker
-        curs: dict[int, models.Cur]  # id:Cur
-        exs: dict[int, str]  # id:name
-        coinexs: dict[int, list[int]]  # id:[ex_ids]
-        pmcurs: dict[int, str]  # pmcur_id:name
-        curpms: dict[int, list[int]]  # id:[pmcur_ids]
-
-    class Permanent:
-        msg_id: int = None
-        user: models.User = None
-        actors: dict[int, int] = None  # key=ex_id
-        creds: dict[int, models.Cred] = None  # key=cred_id
-        cur_creds: dict[int, list[int]] = None  # pmcur_id:[cred_ids]
-
-    class Current:
-        is_target: bool = True
-        is_fiat: bool = None
-        msg_to_del: Message = None
-
-    class Payment:
-        t_cur_id: int = None
-        s_cur_id: int = None
-        t_coin_id: int = None
-        s_coin_id: int = None
-        t_pmcur_id: int = None
-        s_pmcur_id: int = None
-        t_ex_id: int = None
-        s_ex_id: int = None
-        amount: int | float = None
-        ppo: int = 1
-        addr_id: int = None
-        cred_dtl: str = None
-        cred_id: int = None
-        urg: int = 5
-        pr_id: int = None
-
-    glob: Global
-    perm: Permanent = Permanent()
-    pay: Payment = Payment()
-    curr: Current = Current()
-
-
 async def fill_creds(person_id: int) -> tuple[dict[int, models.Cred], dict[int, list[int]]]:
     cq = models.Cred.filter(person_id=person_id)
     creds = {c.id: c for c in await cq}
@@ -207,73 +103,6 @@ async def edt(msg: Message, txt: str, rm: InlineKeyboardMarkup):
             print(msg.bot.store.perm.msg_id, e)
 
 
-async def xync_have_coin_amount(store: Store) -> bool:
-    assets = await models.Asset.filter(
-        addr__coin_id=store.pay.t_coin_id, addr__ex_id=store.pay.t_ex_id, addr__actor__user__role__in=Role.ADMIN
-    )
-    return store.pay.amount <= sum(a.free for a in assets)
-
-
-async def client_have_coin_amount(store: Store) -> bool:
-    assets = await models.Asset.filter(addr__coin_id=store.pay.t_coin_id, addr__actor_id__in=store.perm.actors.values())
-    return store.pay.amount <= sum(a.free for a in assets)
-
-
-async def need_ppo(store: Store):
-    cur_id = getattr(store.pay, ("t" if store.curr.is_target else "s") + "_cur_id")
-    usd_amount = store.pay.amount * store.glob.curs[cur_id].rate
-    if usd_amount < 50:
-        return 0
-    elif usd_amount > 100:
-        return 2
-    else:
-        return 1
-
-
-async def client_target_repr(store: Store) -> tuple[models.Addr | models.Cred, str]:
-    if store.pay.t_ex_id:
-        addr_to = (
-            await models.Addr.filter(
-                actor__ex_id=store.pay.t_ex_id, coin_id=store.pay.t_coin_id, actor__user=store.perm.user
-            )
-            .prefetch_related("actor")
-            .first()
-        )
-        ex, coin = store.glob.exs[store.pay.s_ex_id], store.glob.coins[store.pay.s_coin_id]
-        if not addr_to:
-            logging.error(f"No {coin} addr in {ex} for user: {store.perm.user.username_id}")
-        return addr_to, f"{coin} на {ex} по id: `{addr_to.actor.exid}`"
-    # иначе: реквизиты для фиата
-    cur, pm = store.glob.curs[store.pay.t_cur_id], store.glob.pmcurs[store.pay.t_pmcur_id]
-    cred = store.perm.creds[store.pay.cred_id]
-    return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
-
-
-async def get_merch_target(store: Store) -> tuple[models.Addr | models.Cred, str]:
-    if store.pay.s_ex_id:
-        addr_in = (
-            await models.Addr.filter(
-                actor__ex_id=store.pay.s_ex_id, coin_id=store.pay.s_coin_id, actor__user__role__gte=Role.ADMIN
-            )
-            .prefetch_related("actor")
-            .first()
-        )
-        ex, coin = store.glob.exs[store.pay.s_ex_id], store.glob.coins[store.pay.s_coin_id]
-        if not addr_in:
-            logging.error(f"No {coin} addr in {ex}")
-        return addr_in, f"{coin} на {ex} по id: `{addr_in.actor.exid}`"
-    # иначе: реквизиты для фиатной оплаты
-    s_pmcur = await models.Pmcur.get(id=store.pay.s_pmcur_id).prefetch_related("pm__grp")
-    cred = await models.Cred.filter(
-        **({"pmcur__pm__grp": s_pmcur.pm.grp} if s_pmcur.pm.grp else {"pmcur_id": store.pay.s_pmcur_id}),
-        person__user__role__gte=Role.ADMIN,
-    ).first()  # todo: order by fiat.target-fiat.amount
-    cur, pm = store.glob.curs[store.pay.s_cur_id], store.glob.pmcurs[store.pay.s_pmcur_id]
-    if not cred:
-        logging.error(f"No {cur.ticker} cred for {pm}")
-    return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
-
-
 def fmt_sec(sec: int):
     days = sec // (24 * 3600)
     sec %= 24 * 3600

xync_bot/routers/pay/handler.py

@@ -1,88 +1,86 @@
 from asyncio import gather
 from datetime import datetime
 
-import PGram
 from aiogram import Router, F
 from aiogram.filters import Command
 from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.context import FSMContext
-from xync_bot.routers.pay.dep import fill_creds, fill_actors, dlt, ans, Store
+from xync_bot.routers.pay.dep import fill_creds, fill_actors, dlt, ans
 from xync_schema import models
 
 from xync_bot.routers.pay import cd, dep, window
+from xync_bot.store import Store
 
-pay = Router()
+pr = Router(name="pay")
 
 
-@pay.message(Command("pay"))
-async def h_start(msg: Message):
-    """Step 1: Select target type"""
-    store: Store = msg.bot.store
+@pr.message(Command("pay"))
+async def h_start(msg: Message, store: Store):
+    """Step 1: Select a target type"""
     store.curr.is_target = True
-    await gather(window.type_select(msg), dlt(msg))
+    await gather(window.type_select(msg, store), dlt(msg))
     store.perm.user = await models.User.get(username_id=msg.from_user.id)
     store.perm.creds, store.perm.cur_creds = await fill_creds(store.perm.user.person_id)
     store.perm.actors = await fill_actors(store.perm.user.person_id)
 
 
-@pay.callback_query(cd.MoneyType.filter(F.is_fiat))
-async def h_got_fiat_type(query: CallbackQuery, bot: PGram):
+@pr.callback_query(cd.MoneyType.filter(F.is_fiat))
+async def h_got_fiat_type(query: CallbackQuery, store: Store):
     """Step 2f: Select cur"""
-    bot.store.curr.is_fiat = True
-    await gather(window.cur_select(query.message), ans(query, "Понял, фиат"))
+    store.curr.is_fiat = True
+    await gather(window.cur_select(query.message, store), ans(query, "Понял, фиат"))
 
 
-@pay.callback_query(cd.MoneyType.filter(F.is_fiat.__eq__(0)))
-async def h_got_crypto_type(query: CallbackQuery, bot: PGram):
+@pr.callback_query(cd.MoneyType.filter(F.is_fiat.__eq__(0)))
+async def h_got_crypto_type(query: CallbackQuery, store: Store):
     """Step 2c: Select coin"""
-    bot.store.curr.is_fiat = False
-    await gather(window.coin_select(query.message), ans(query, "Понял, крипта"))
+    store.curr.is_fiat = False
+    await gather(window.coin_select(query.message, store), ans(query, "Понял, крипта"))
 
 
-@pay.callback_query(cd.Coin.filter())
-async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, bot: PGram):
+@pr.callback_query(cd.Coin.filter())
+async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, store: Store):
     """Step 3c: Select target ex"""
-    setattr(bot.store.pay, ("t" if bot.store.curr.is_target else "s") + "_coin_id", callback_data.id)
-    await gather(window.ex_select(query.message), ans(query, "Эта монета есть на следующих биржах"))
+    setattr(store.pay, ("t" if store.curr.is_target else "s") + "_coin_id", callback_data.id)
+    await gather(window.ex_select(query.message, store), ans(query, "Эта монета есть на следующих биржах"))
 
 
-@pay.callback_query(cd.Cur.filter())
-async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, bot: PGram):
+@pr.callback_query(cd.Cur.filter())
+async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, store: Store):
     """Step 3f: Select target pm"""
-    setattr(bot.store.pay, ("t" if bot.store.curr.is_target else "s") + "_cur_id", callback_data.id)
-    await gather(window.pm(query.message), ans(query, "Вот платежные системы доступные для этой валюты"))
+    setattr(store.pay, ("t" if store.curr.is_target else "s") + "_cur_id", callback_data.id)
+    await gather(window.pm(query.message, store), ans(query, "Вот платежные системы доступные для этой валюты"))
 
 
-@pay.callback_query(cd.Pm.filter(F.is_target))
-async def h_got_target_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSMContext):
+@pr.callback_query(cd.Pm.filter(F.is_target))
+async def h_got_target_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSMContext, store: Store):
     """Step 4f: Fill target cred.detail"""
-    query.message.bot.store.pay.t_pmcur_id = callback_data.pmcur_id
+    store.pay.t_pmcur_id = callback_data.pmcur_id
     await gather(
-        window.fill_cred_dtl(query.message),
+        window.fill_cred_dtl(query.message, store),
         ans(query, "Теперь нужны реквизиты"),
         state.set_state(dep.CredState.detail),
     )
 
 
-@pay.callback_query(cd.Cred.filter())
-async def h_got_cred(query: CallbackQuery, callback_data: cd.Cred, state: FSMContext):
-    query.message.bot.store.pay.cred_id = callback_data.id
+@pr.callback_query(cd.Cred.filter())
+async def h_got_cred(query: CallbackQuery, callback_data: cd.Cred, state: FSMContext, store: Store):
+    store.pay.cred_id = callback_data.id
     await gather(
-        window.amount(query.message), ans(query, "Теперь нужна сумма"), state.set_state(dep.PaymentState.amount)
+        window.amount(query.message, store), ans(query, "Теперь нужна сумма"), state.set_state(dep.PaymentState.amount)
     )
 
 
-@pay.message(dep.CredState.detail)
-async def h_got_cred_dtl(msg: Message, state: FSMContext):
+@pr.message(dep.CredState.detail)
+async def h_got_cred_dtl(msg: Message, state: FSMContext, store: Store):
     """Step 4.1f: Fill target cred.name"""
-    msg.bot.store.pay.cred_dtl = msg.text
-    await gather(window.fill_cred_name(msg), dlt(msg), state.set_state(dep.CredState.name))
+    store.pay.cred_dtl = msg.text
+    await gather(window.fill_cred_name(msg, store), dlt(msg), state.set_state(dep.CredState.name))
 
 
-@pay.message(dep.CredState.name)
-async def h_got_cred_name(msg: Message, state: FSMContext):
+@pr.message(dep.CredState.name)
+async def h_got_cred_name(msg: Message, state: FSMContext, store: Store):
     """Step 5f: Save target cred"""
-    store: Store = msg.bot.store
     cred, _ = await models.Cred.update_or_create(
         {"name": msg.text},
         detail=store.pay.cred_dtl,
@@ -91,30 +89,28 @@ async def h_got_cred_name(msg: Message, state: FSMContext):
     )
     store.pay.cred_id = cred.id
     store.perm.creds[cred.id] = cred
-    await gather(window.amount(msg), dlt(msg), state.set_state(dep.PaymentState.amount))
+    await gather(window.amount(msg, store), dlt(msg), state.set_state(dep.PaymentState.amount))
 
 
-@pay.callback_query(cd.Ex.filter())
-async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext):
+@pr.callback_query(cd.Ex.filter())
+async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext, store: Store):
     """Step 4c: Save target"""
-    store: Store = query.message.bot.store
     ist = store.curr.is_target
     setattr(store.pay, ("t" if ist else "s") + "_ex_id", callback_data.id)
     if ist:
-        await window.amount(query.message)
+        await window.amount(query.message, store)
         actor_id = store.perm.actors[store.pay.t_ex_id]
         addr = await models.Addr.get(coin_id=store.pay.t_coin_id, actor_id=actor_id)
         store.pay.addr_id = addr.id
     else:
-        await window.set_ppo(query.message)
+        await window.set_ppo(query.message, store)
     await ans(query, f"Биржа {store.glob.exs[callback_data.id]} выбрана")
     await state.set_state(dep.PaymentState.amount)
 
 
-@pay.message(dep.PaymentState.amount)
-async def h_got_amount(msg: Message, state: FSMContext):
-    """Step 6: Save target amount"""
-    store: Store = msg.bot.store
+@pr.message(dep.PaymentState.amount)
+async def h_got_amount(msg: Message, state: FSMContext, store: Store):
+    """Step 6: Save a target amount"""
     if not msg.text.isnumeric():
         store.curr.msg_to_del = await msg.answer("Пожалуйста, введите корректное число")
         return
@@ -123,34 +119,33 @@ async def h_got_amount(msg: Message, state: FSMContext):
     store.pay.amount = float(msg.text)
     """Step 7: Select source type"""
     store.curr.is_target = False
-    await gather((window.type_select if store.curr.is_fiat else window.cur_select)(msg), dlt(msg), state.clear())
+    await gather((window.type_select if store.curr.is_fiat else window.cur_select)(msg, store), dlt(msg), state.clear())
 
 
-@pay.callback_query(cd.Pm.filter(F.is_target.__eq__(0)))
-async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm):
-    store: Store = query.message.bot.store
+@pr.callback_query(cd.Pm.filter(F.is_target.__eq__(0)))
+async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm, store: Store):
     store.pay.s_pmcur_id = callback_data.pmcur_id
     await gather(
-        window.set_ppo(query.message),
+        window.set_ppo(query.message, store),
         ans(query, store.glob.pmcurs[callback_data.pmcur_id]),
     )
 
 
-@pay.callback_query(cd.Ppo.filter())
-async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo):
-    query.message.bot.store.pay.ppo = callback_data.num
-    await gather(window.set_urgency(query.message), ans(query, str(callback_data.num)))
+@pr.callback_query(cd.Ppo.filter())
+async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo, store: Store):
+    store.pay.ppo = callback_data.num
+    await gather(window.set_urgency(query.message, store), ans(query, str(callback_data.num)))
 
 
-@pay.callback_query(cd.Time.filter())
-async def h_got_urgency(query: CallbackQuery, callback_data: cd.Time):
-    query.message.bot.store.pay.urg = callback_data.minutes
-    await window.create_payreq(query.message)
+@pr.callback_query(cd.Time.filter())
+async def h_got_urgency(query: CallbackQuery, callback_data: cd.Time, store: Store):
+    store.pay.urg = callback_data.minutes
+    await window.create_payreq(query.message, store)
     await ans(query, f"Ok {callback_data.minutes} min.")
 
 
 # ACTIONS
-@pay.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.received)))
+@pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.received)))
 async def payment_confirmed(query: CallbackQuery, state: FSMContext):
     await ans(query, None)
     payed_at = datetime.now()
@@ -164,7 +159,7 @@ async def payment_confirmed(query: CallbackQuery, state: FSMContext):
     await window.success(query.message)
 
 
-@pay.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.not_received)))
+@pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.not_received)))
 async def no_payment(query: CallbackQuery, state: FSMContext):
     await ans(query, None)
     await state.update_data(timer_active=False)
@@ -174,80 +169,80 @@ async def no_payment(query: CallbackQuery, state: FSMContext):
     await state.set_state(dep.Report.text)
 
 
-@pay.message(dep.Report.text)
+@pr.message(dep.Report.text)
 async def payment_not_specified(msg: Message, state: FSMContext):
     await state.update_data(text=msg.text)
     data = await state.get_data()
     complaint_text = (
         f"Жалоба на неполученный платеж:\n"
         f"Пользователь: @{msg.from_user.username or msg.from_user.id}\n"
-        f"Детали платежа: {data["text"]}\n"
+        f"Детали платежа: {data['text']}\n"
         f"Время: {msg.date.strftime('%Y-%m-%d %H:%M:%S')}"
     )
     await msg.bot.send_message(chat_id="xyncpay", text=complaint_text)
 
 
 # NAVIGATION
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_type, cd.PayStep.s_type])))
-async def handle_home(query: CallbackQuery, state: FSMContext):
-    await gather(window.type_select(query.message), state.clear(), ans(query, "Создаем платеж заново"))
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_type, cd.PayStep.s_type])))
+async def handle_home(query: CallbackQuery, state: FSMContext, store: Store):
+    await gather(window.type_select(query.message, store), state.clear(), ans(query, "Создаем платеж заново"))
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_coin, cd.PayStep.s_coin])))
-async def to_coin_select(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_coin, cd.PayStep.s_coin])))
+async def to_coin_select(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     is_target = await state.get_value("is_target")
     pref = "t" if is_target else "s"
     await state.update_data({pref + "_ex_id": None, pref + "_coin_id": None})
-    await window.coin_select(query.message)
+    await window.coin_select(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_cur, cd.PayStep.s_cur])))
-async def to_cur_select(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_cur, cd.PayStep.s_cur])))
+async def to_cur_select(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     is_target = await state.get_value("is_target")
     pref = "t" if is_target else "s"
     await state.update_data({pref + "_pmcur_id": None, pref + "_cur_id": None})
-    await window.cur_select(query.message)
+    await window.cur_select(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm, cd.PayStep.s_pm])))
-async def to_pm_select(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm, cd.PayStep.s_pm])))
+async def to_pm_select(query: CallbackQuery, store: Store):
     await ans(query, None)
-    await window.pm(query.message)
+    await window.pm(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_dtl)))
-async def back_to_cred_detail(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_dtl)))
+async def back_to_cred_detail(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     await state.update_data(detail=None)
-    await window.fill_cred_dtl(query.message)
+    await window.fill_cred_dtl(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_name)))
-async def back_to_cred_name(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_name)))
+async def back_to_cred_name(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     await state.update_data(name=None)
-    await window.fill_cred_name(query.message)
+    await window.fill_cred_name(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_ex, cd.PayStep.s_ex])))
-async def back_to_ex_select(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_ex, cd.PayStep.s_ex])))
+async def back_to_ex_select(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     await state.update_data({("t" if await state.get_value("is_target") else "s") + "ex_id": None})
-    await window.ex_select(query.message)
+    await window.ex_select(query.message, store)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_amount)))
-async def back_to_amount(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_amount)))
+async def back_to_amount(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     await state.update_data(amount=None)
-    await window.amount(query.message)
+    await window.amount(query.message, store)
     await state.set_state(dep.PaymentState.amount)
 
 
-@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm])))
-async def back_to_payment(query: CallbackQuery, state: FSMContext):
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm])))
+async def back_to_payment(query: CallbackQuery, state: FSMContext, store: Store):
     await ans(query, None)
     await state.update_data(payment=None)
-    await window.pm(query.message)
+    await window.pm(query.message, store)

xync_bot/routers/pay/window.py

@@ -6,22 +6,13 @@ from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 from xync_schema import models
 
-from xync_bot.routers.pay.dep import (
-    edt,
-    need_ppo,
-    Store,
-    get_merch_target,
-    fmt_sec,
-    client_have_coin_amount,
-    client_target_repr,
-)
-
+from xync_bot.routers.pay.dep import edt, fmt_sec
 from xync_bot.routers.pay import cd, dep
+from xync_bot.store import Store
 
 
-async def type_select(msg: Message):
+async def type_select(msg: Message, store: Store):
     """Step 1: Select type"""
-    store: Store = msg.bot.store
     ist: bool = store.curr.is_target
     rm = InlineKeyboardMarkup(
         inline_keyboard=[
@@ -52,11 +43,11 @@ async def type_select(msg: Message):
         store.perm.msg_id = msg.message_id
 
 
-async def cur_select(msg: Message):
+async def cur_select(msg: Message, store: Store):
     """Common using cur func"""
     builder = InlineKeyboardBuilder()
-    ist: bool = msg.bot.store.curr.is_target
-    for cur_id, cur in msg.bot.store.glob.curs.items():
+    ist: bool = store.curr.is_target
+    for cur_id, cur in store.glob.curs.items():
         builder.button(text=cur.ticker + dep.flags[cur.ticker], callback_data=cd.Cur(id=cur_id, is_target=ist))
     builder.button(text="Назад к выбору типа", callback_data=cd.PayNav(to=cd.PayStep.t_type))
     builder.adjust(3, 3, 3, 3, 3, 1)
@@ -64,10 +55,9 @@ async def cur_select(msg: Message):
     await edt(msg, "Выбери валюту котор" + sfx, builder.as_markup())
 
 
-async def coin_select(msg: Message):
+async def coin_select(msg: Message, store: Store):
     """Common using coin func"""
     builder = InlineKeyboardBuilder()
-    store: Store = msg.bot.store
     for coin_id, ticker in store.glob.coins.items():
         builder.button(text=ticker, callback_data=cd.Coin(id=coin_id, is_target=store.curr.is_target))
     builder.button(
@@ -79,8 +69,7 @@ async def coin_select(msg: Message):
     await msg.edit_text("Выберите монету котор" + sfx, reply_markup=builder.as_markup())
 
 
-async def ex_select(msg: Message):
-    store: Store = msg.bot.store
+async def ex_select(msg: Message, store: Store):
     ist = store.curr.is_target
     coin_id = getattr(store.pay, ("t" if ist else "s") + "_coin_id")
     builder = InlineKeyboardBuilder()
@@ -95,8 +84,7 @@ async def ex_select(msg: Message):
     await msg.edit_text("На какую биржу?" if ist else "С какой биржи?", reply_markup=keyboard)
 
 
-async def pm(msg: Message):
-    store: Store = msg.bot.store
+async def pm(msg: Message, store: Store):
     ist = store.curr.is_target
     cur_id = getattr(store.pay, ("t" if ist else "s") + "_cur_id")
     builder = InlineKeyboardBuilder()
@@ -111,9 +99,8 @@ async def pm(msg: Message):
     await msg.edit_text("На какую платежную систему?" if ist else "C какой платежной системы?", reply_markup=keyboard)
 
 
-async def fill_cred_dtl(msg: Message):
+async def fill_cred_dtl(msg: Message, store: Store):
     builder = InlineKeyboardBuilder()
-    store: Store = msg.bot.store
     txt = "В"
     if cred_ids := store.perm.cur_creds.get(store.pay.t_pmcur_id):
         for cred_id in cred_ids:
@@ -130,22 +117,20 @@ async def fill_cred_dtl(msg: Message):
     )
 
 
-async def fill_cred_name(msg: Message):
+async def fill_cred_name(msg: Message, store: Store):
     builder = InlineKeyboardBuilder()
     builder.button(text="Назад к вводу реквизитов", callback_data=cd.PayNav(to=cd.PayStep.t_cred_dtl))
     builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
     builder.adjust(2)
-    store: Store = msg.bot.store
     cur = store.glob.curs[store.pay.t_cur_id]
     payment = store.glob.pmcurs[store.pay.t_pmcur_id]
     detail = store.pay.cred_dtl
     await edt(msg, f"{cur.ticker}:{payment}:{detail}: Введите имя получателя", builder.as_markup())
 
 
-async def amount(msg: Message):
+async def amount(msg: Message, store: Store):
     """Step 5: Filling target amount"""
     builder = InlineKeyboardBuilder()
-    store: Store = msg.bot.store
     if store.curr.is_fiat:
         cur_coin = store.glob.curs[store.pay.t_cur_id].ticker
         builder.button(text="Назад к вводу имени", callback_data=cd.PayNav(to=cd.PayStep.t_cred_name))
@@ -161,10 +146,9 @@ async def amount(msg: Message):
     await edt(msg, f"Введите нужную сумму {cur_coin} для {t_name}", builder.as_markup())
 
 
-async def set_ppo(msg: Message):
-    store: Store = msg.bot.store
+async def set_ppo(msg: Message, store: Store):
     ist = store.curr.is_target
-    if nppo := await need_ppo(store):
+    if nppo := await store.need_ppo():
         builder = InlineKeyboardBuilder()
         builder.button(text="Нет", callback_data=cd.Ppo(num=1, is_target=ist)).button(
             text="Да", callback_data=cd.Ppo(num=2, is_target=ist)
@@ -180,9 +164,8 @@ async def set_ppo(msg: Message):
         await set_urgency(msg)
 
 
-async def set_urgency(msg: Message):
-    store: Store = msg.bot.store
-    if not store.curr.is_fiat or await client_have_coin_amount(store):
+async def set_urgency(msg: Message, store: Store):
+    if not store.curr.is_fiat or await store.client_have_coin_amount():
         return await create_payreq(msg)  # next
     builder = InlineKeyboardBuilder()
     (
@@ -198,8 +181,7 @@ async def set_urgency(msg: Message):
     return await edt(msg, "Сколько можешь ждать?", builder.as_markup())
 
 
-async def create_payreq(msg: Message):
-    store: Store = msg.bot.store
+async def create_payreq(msg: Message, store: Store):
     pay_req, _ = await models.PayReq.update_or_create(
         {"pay_until": datetime.now() + timedelta(minutes=store.pay.urg)},
         amount=store.pay.amount,
@@ -209,8 +191,8 @@ async def create_payreq(msg: Message):
         user=store.perm.user,
     )
     store.pay.pr_id = pay_req.id
-    inp, txt = await get_merch_target(store)
-    ccred, ctxt = await client_target_repr(store)
+    inp, txt = await store.get_merch_target()
+    ccred, ctxt = await store.client_target_repr()
     txt += f"\nИ получите {store.pay.amount} {ctxt} в течение {fmt_sec(store.pay.urg * 60)}"
     if store.pay.ppo > 1:
         txt += f" максимум {store.pay.ppo} платежами"

xync_bot/shared.py

@@ -3,3 +3,22 @@ from aiogram.filters.callback_data import CallbackData
 
 class NavCallbackData(CallbackData, prefix="nav"):  # navigate menu
     to: str
+
+
+flags = {
+    "RUB": "🇷🇺",
+    "THB": "🇹🇭",
+    "IDR": "🇮🇩",
+    "TRY": "🇹🇷",
+    "GEL": "🇬🇪",
+    "VND": "🇻🇳",
+    "AED": "🇦🇪",
+    "AMD": "🇦🇲",
+    "AZN": "🇦🇿",
+    "CNY": "🇨🇳",
+    "EUR": "🇪🇺",
+    "HKD": "🇭🇰",
+    "INR": "🇮🇳",
+    "PHP": "🇵🇭",
+    "USD": "🇺🇸",
+}

xync_bot/store.py

@@ -0,0 +1,157 @@
+import logging
+from aiogram.types import Message
+from tortoise.functions import Min
+from x_model.func import ArrayAgg
+from x_auth.enums import Role
+from xync_schema.models import Addr, Asset, Cred, Coin, Pmcur, Cur, User, Ex, Pmex
+
+from xync_bot.shared import flags
+
+
+class SingleStore(type):
+    _store = None
+
+    async def __call__(cls):
+        if not cls._store:
+            cls._store = super(SingleStore, cls).__call__()
+            cls._store.coins = {k: v for k, v in await Coin.all().order_by("ticker").values_list("id", "ticker")}
+            curs = {c.id: c for c in await Cur.filter(ticker__in=flags.keys()).order_by("ticker")}
+            cls._store.curs = curs
+            cls._store.exs = {k: v for k, v in await Ex.all().values_list("id", "name")}
+            cls._store.pmcurs = {
+                k: v
+                for k, v in await Pmex.filter(pm__pmcurs__cur_id__in=cls._store.curs.keys())
+                .annotate(sname=Min("name"))
+                .group_by("pm__pmcurs__id")
+                .values_list("pm__pmcurs__id", "sname")
+            }
+            cls._store.coinexs = {
+                c.id: [ex.ex_id for ex in c.coinexs] for c in await Coin.all().prefetch_related("coinexs")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await Pmcur.filter(cur_id__in=curs.keys())
+                .annotate(ids=ArrayAgg("id"))
+                .group_by("cur_id")
+                .values_list("cur_id", "ids")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await Pmcur.filter(cur_id__in=curs.keys())
+                .annotate(ids=ArrayAgg("id"))
+                .group_by("cur_id")
+                .values_list("cur_id", "ids")
+            }
+
+        return cls._store
+
+
+class Store:
+    class Global(metaclass=SingleStore):
+        coins: dict[int, str]  # id:ticker
+        curs: dict[int, Cur]  # id:Cur
+        exs: dict[int, str]  # id:name
+        coinexs: dict[int, list[int]]  # id:[ex_ids]
+        pmcurs: dict[int, str]  # pmcur_id:name
+        curpms: dict[int, list[int]]  # id:[pmcur_ids]
+
+    class Personal:
+        class Current:
+            is_target: bool = True
+            is_fiat: bool = None
+            msg_to_del: Message = None
+
+        msg_id: int = None
+        user: User = None
+        actors: dict[int, int] = None  # key=ex_id
+        creds: dict[int, Cred] = None  # key=cred_id
+        cur_creds: dict[int, list[int]] = None  # pmcur_id:[cred_ids]
+
+        def __init__(self, order_id: int):
+            self.order_id = order_id
+
+        curr: Current = Current()
+
+    class PayReq:
+        t_cur_id: int = None
+        s_cur_id: int = None
+        t_coin_id: int = None
+        s_coin_id: int = None
+        t_pmcur_id: int = None
+        s_pmcur_id: int = None
+        t_ex_id: int = None
+        s_ex_id: int = None
+        amount: int | float = None
+        ppo: int = 1
+        addr_id: int = None
+        cred_dtl: str = None
+        cred_id: int = None
+        urg: int = 5
+        pr_id: int = None
+
+        def __init__(self, uid: int):
+            self.uid = uid
+
+        async def xync_have_coin_amount(self) -> bool:
+            assets = await Asset.filter(
+                addr__coin_id=self.t_coin_id, addr__ex_id=self.t_ex_id, addr__actor__user__role__in=Role.ADMIN
+            )
+            return self.amount <= sum(a.free for a in assets)
+
+        async def client_have_coin_amount(self) -> bool:
+            assets = await Asset.filter(addr__coin_id=self.t_coin_id, addr__actor_id__in=self.perm.actors.values())
+            return self.amount <= sum(a.free for a in assets)
+
+        async def need_ppo(self):
+            cur_id = getattr(self, ("t" if self.curr.is_target else "s") + "_cur_id")
+            usd_amount = self.amount * self.glob.curs[cur_id].rate
+            if usd_amount < 50:
+                return 0
+            elif usd_amount > 100:
+                return 2
+            else:
+                return 1
+
+        async def client_target_repr(self) -> tuple[Addr | Cred, str]:
+            if self.t_ex_id:
+                addr_to = (
+                    await Addr.filter(actor__ex_id=self.t_ex_id, coin_id=self.t_coin_id, actor__user=self.perm.user)
+                    .prefetch_related("actor")
+                    .first()
+                )
+                ex, coin = self.glob.exs[self.s_ex_id], self.glob.coins[self.s_coin_id]
+                if not addr_to:
+                    logging.error(f"No {coin} addr in {ex} for user: {self.perm.user.username_id}")
+                return addr_to, f"{coin} на {ex} по id: `{addr_to.actor.exid}`"
+            # иначе: реквизиты для фиата
+            cur, pm = self.glob.curs[self.t_cur_id], self.glob.pmcurs[self.t_pmcur_id]
+            cred = self.perm.creds[self.cred_id]
+            return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
+
+        async def get_merch_target(self) -> tuple[Addr | Cred, str]:
+            if self.s_ex_id:
+                addr_in = (
+                    await Addr.filter(
+                        actor__ex_id=self.s_ex_id, coin_id=self.s_coin_id, actor__user__role__gte=Role.ADMIN
+                    )
+                    .prefetch_related("actor")
+                    .first()
+                )
+                ex, coin = self.glob.exs[self.s_ex_id], self.glob.coins[self.s_coin_id]
+                if not addr_in:
+                    logging.error(f"No {coin} addr in {ex}")
+                return addr_in, f"{coin} на {ex} по id: `{addr_in.actor.exid}`"
+            # иначе: реквизиты для фиатной оплаты
+            s_pmcur = await Pmcur.get(id=self.s_pmcur_id).prefetch_related("pm__grp")
+            cred = await Cred.filter(
+                **({"pmcur__pm__grp": s_pmcur.pm.grp} if s_pmcur.pm.grp else {"pmcur_id": self.s_pmcur_id}),
+                person__user__role__gte=Role.ADMIN,
+            ).first()  # todo: payreq by fiat.target-fiat.amount
+            cur, pm = self.glob.curs[self.s_cur_id], self.glob.pmcurs[self.s_pmcur_id]
+            if not cred:
+                logging.error(f"No {cur.ticker} cred for {pm}")
+            return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
+
+    glob: Global
+    pers: dict[int, Personal] = {}
+    payreq: dict[int, PayReq] = {}

{xync_bot-0.3.24.dev12.dist-info → xync_bot-0.3.25.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.24.dev12
+Version: 0.3.25.dev1
 Summary: Telegram bot with web app for xync net
 Author-email: Artemiev <mixartemev@gmail.com>
 License-Expression: GPL-3.0-or-later

xync_bot-0.3.25.dev1.dist-info/RECORD

@@ -0,0 +1,22 @@
+xync_bot/__main__.py,sha256=OvUQ9A4YZajOgs8CoRhjFzXQnZvNnH8l8MV_brZCOpo,991
+xync_bot/loader.py,sha256=4ZeR-yVMoOmswdLS0UEBG19K7JVcuvH6WpP-_0yAK3I,573
+xync_bot/shared.py,sha256=PPzvt1ewowCInKE1bk2CWHPjnrV2eQJzKxgyxe3h7vk,496
+xync_bot/store.py,sha256=NhUMl0Zr4PKiukQKH8HDA6KRjghjtIcDioNLZArmdhg,6385
+xync_bot/typs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xync_bot/routers/__init__.py,sha256=30W7PmD3stkRebGh5J-9CJIlY5P-Ixrtlxb_W9usSo4,1083
+xync_bot/routers/order.py,sha256=ZKWDLyiWrXzcR-aHKLBTBCACwp-P0Vvnr22T-EuLHaM,274
+xync_bot/routers/photo.py,sha256=aq6ImIOoZQYTW-lEy26qjgj5TYAuk4bQjgiCv64mPJs,1203
+xync_bot/routers/vpn.py,sha256=qKK55UrjEZeDvu7ljWXNUFBFgXTPTIEaCT2OAmKWky4,2219
+xync_bot/routers/xicon.png,sha256=O57_kvzhVcCXSoGYZ61m0dW9pizY6gxR8Yj5aeCP0RQ,429283
+xync_bot/routers/cond/__init__.py,sha256=AUP_V1TGUIa8GFTC_V2LF5YYEBrXdfrSm_O8ew5sXU8,4214
+xync_bot/routers/cond/func.py,sha256=m0NWDKunbqDJQmhv_5UnpjxjRzn78GFG94ThOFLVlQo,4720
+xync_bot/routers/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xync_bot/routers/main/handler.py,sha256=IDvHPcj1Z-MpL6DSlgibxxCZmaaVN3OhByIZZyrK2FM,8758
+xync_bot/routers/pay/cd.py,sha256=yu5U0j8f1RncfagiuycCeUFWwZtLmbT-Mx8G8whfdg8,927
+xync_bot/routers/pay/dep.py,sha256=WvIkLsMHsy6Z8qeQYB0uvHi9xgJ-pCjRad0dSp_GQS0,3956
+xync_bot/routers/pay/handler.py,sha256=7kb3ubkvolJPM9Sd51pnw9tlR9QxblNrIJN4QScgZQ8,10341
+xync_bot/routers/pay/window.py,sha256=HQWDDvknMMbTEt5Zu7cXsr6SaDnFlV43xZU4CF4S2Ps,10987
+xync_bot-0.3.25.dev1.dist-info/METADATA,sha256=QgjczDpDF437LM-dzo3MlstW0Fx6e0264dSQNYWF-yE,751
+xync_bot-0.3.25.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xync_bot-0.3.25.dev1.dist-info/top_level.txt,sha256=O2IjMc1ryAf0rwIXWohSNT5Kzcs9johgKRDz8lCC0rs,9
+xync_bot-0.3.25.dev1.dist-info/RECORD,,

xync_bot/__init__.py

@@ -1,26 +0,0 @@
-import logging
-from asyncio import run
-
-from PGram import Bot
-from aiogram.client.default import DefaultBotProperties
-from x_model import init_db
-
-from xync_bot.routers.cond import cr as cr
-from xync_bot.routers.pay.dep import Store
-
-# from xync_bot.routers.main import mr
-from xync_bot.routers.pay.handler import pay as pay
-
-if __name__ == "__main__":
-    from xync_bot.loader import TOKEN, TORM
-
-    logging.basicConfig(level=logging.INFO)
-
-    async def main() -> None:
-        cn = await init_db(TORM)
-        store = Store()
-        store.glob = await Store.Global()
-        bot = Bot(TOKEN, [pay], cn, default=DefaultBotProperties(parse_mode="HTML"), store=store)
-        await bot.start()
-
-    run(main())

xync_bot-0.3.24.dev12.dist-info/RECORD

@@ -1,20 +0,0 @@
-xync_bot/__init__.py,sha256=NSwTrA6NoOWDQK1L7M4qFcbLcCj1od8pgFM-arNv0AQ,713
-xync_bot/loader.py,sha256=4ZeR-yVMoOmswdLS0UEBG19K7JVcuvH6WpP-_0yAK3I,573
-xync_bot/shared.py,sha256=MlKkTrsT29l7fF6-qAN9FO14cSuXuOuYxbNY5F4S2w4,137
-xync_bot/typs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xync_bot/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xync_bot/routers/main.py,sha256=FumWa48ORhV77Df6NbEosHfgmFIe_Y2ci6IkJCvU4Zs,9535
-xync_bot/routers/order.py,sha256=ZKWDLyiWrXzcR-aHKLBTBCACwp-P0Vvnr22T-EuLHaM,274
-xync_bot/routers/photo.py,sha256=aq6ImIOoZQYTW-lEy26qjgj5TYAuk4bQjgiCv64mPJs,1203
-xync_bot/routers/vpn.py,sha256=qKK55UrjEZeDvu7ljWXNUFBFgXTPTIEaCT2OAmKWky4,2219
-xync_bot/routers/xicon.png,sha256=O57_kvzhVcCXSoGYZ61m0dW9pizY6gxR8Yj5aeCP0RQ,429283
-xync_bot/routers/cond/__init__.py,sha256=It4djVO8AxXL1I76buRz8yYF12dsjXaa4WNtPdb7CFc,4333
-xync_bot/routers/cond/func.py,sha256=m0NWDKunbqDJQmhv_5UnpjxjRzn78GFG94ThOFLVlQo,4720
-xync_bot/routers/pay/cd.py,sha256=yu5U0j8f1RncfagiuycCeUFWwZtLmbT-Mx8G8whfdg8,927
-xync_bot/routers/pay/dep.py,sha256=u1RCKl3gultJ509W9gbl-ixCCS6B9lgkrDYa_I8Uu2g,10249
-xync_bot/routers/pay/handler.py,sha256=aT_Oc_q-h_dX3pU2KhmX7PdRZUeLIuIpagTbBY45GJs,10207
-xync_bot/routers/pay/window.py,sha256=-scDDorW2qy9K1gNuGHZVBTaNIdd-7Hh64ZHCFizNVs,11256
-xync_bot-0.3.24.dev12.dist-info/METADATA,sha256=MhjS0p9XZSsZJBIwSCYrrr-h8oWNXx2a_0cctuB9FF8,752
-xync_bot-0.3.24.dev12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xync_bot-0.3.24.dev12.dist-info/top_level.txt,sha256=O2IjMc1ryAf0rwIXWohSNT5Kzcs9johgKRDz8lCC0rs,9
-xync_bot-0.3.24.dev12.dist-info/RECORD,,