xync-bot 0.3.24.dev12__py3-none-any.whl → 0.3.26__py3-none-any.whl

xync_bot/routers/pay/handler.py

@@ -1,156 +1,159 @@
 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
-    store.curr.is_target = True
-    await gather(window.type_select(msg), 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)
+@pr.message(Command("pay"))
+async def h_start(msg: Message, store: Store, **kwargs):
+    """Step 1: Select a target type"""
+    uid = msg.from_user.id
+    store.pers[uid] = Store.Personal(1)
+    store.pers[uid].curr.is_target = True
+    await gather(window.type_select(msg, store), dlt(msg))
+    store.pers[uid].user = await models.User.get(username_id=msg.from_user.id)
+    store.pers[uid].creds, store.pers[uid].cur_creds = await fill_creds(store.pers[uid].user.person_id)
+    store.pers[uid].actors = await fill_actors(store.pers[uid].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, "Понял, фиат"))
+    uid = query.from_user.id
+    store.pers[uid].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.pers.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.pers.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.pers.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
+    uid = msg.from_user.id
     cred, _ = await models.Cred.update_or_create(
         {"name": msg.text},
         detail=store.pay.cred_dtl,
-        person_id=store.perm.user.person_id,
+        person_id=store.pers[uid].user.person_id,
         pmcur_id=store.pay.t_pmcur_id,
     )
     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))
+    store.pers[uid].creds[cred.id] = cred
+    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
+    uid = query.from_user.id
+    ist = store.pers.curr.is_target
     setattr(store.pay, ("t" if ist else "s") + "_ex_id", callback_data.id)
     if ist:
-        await window.amount(query.message)
-        actor_id = store.perm.actors[store.pay.t_ex_id]
+        await window.amount(query.message, store)
+        actor_id = store.pers[uid].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("Пожалуйста, введите корректное число")
+        store.pers.curr.msg_to_del = await msg.answer("Пожалуйста, введите корректное число")
         return
-    if store.curr.msg_to_del:
-        await store.curr.msg_to_del.delete()
+    if store.pers.curr.msg_to_del:
+        await store.pers.curr.msg_to_del.delete()
     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())
+    store.pers.curr.is_target = False
+    await gather(
+        (window.type_select if store.pers.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):
+    # payreq_id = store.pers[query.from_user.id].
+    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 +167,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 +177,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,23 +6,15 @@ 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
+    uid = msg.from_user.id
+    ist: bool = store.pers[uid].curr.is_target
     rm = InlineKeyboardMarkup(
         inline_keyboard=[
             [
@@ -30,33 +22,34 @@ async def type_select(msg: Message):
                     text="Банковская валюта", callback_data=cd.MoneyType(is_fiat=1, is_target=ist).pack()
                 ),
                 InlineKeyboardButton(
-                    text="Крипта", callback_data=cd.MoneyType(is_fiat=0, is_target=store.curr.is_target).pack()
+                    text="Крипта",
+                    callback_data=cd.MoneyType(is_fiat=0, is_target=store.pers[uid].curr.is_target).pack(),
                 ),
             ]
         ]
     )
-    if store.curr.is_target:
+    if store.pers[uid].curr.is_target:
         txt = "Что нужно?"
     else:
-        if store.pay.t_coin_id:
-            inf = f"{store.glob.coins[store.pay.t_coin_id]} на {store.glob.exs[store.pay.t_ex_id]}:{store.pay.addr_id}"
+        if store.pers[uid].pay.t_coin_id:
+            inf = f"{store.glob.coins[store.pers[uid].pay.t_coin_id]} на {store.glob.exs[store.pers[uid].pay.t_ex_id]}:{store.pay.addr_id}"
         else:
             cur = store.glob.curs[store.pay.t_cur_id].ticker
-            cred: models.Cred = store.perm.creds[store.pay.cred_id]
+            cred: models.Cred = store.pers[uid].creds[store.pay.cred_id]
             inf = f"{cur} на {store.glob.pmcurs[store.pay.t_pmcur_id]}: {cred.repr()}"
         txt = f"Нужен платеж: {store.pay.amount} {inf}\nЧем будете платить?"
-    if store.perm.msg_id:
+    if store.pers[uid].msg_id:
         await edt(msg, txt, rm)
     else:
         msg = await msg.answer(txt, reply_markup=rm)
-        store.perm.msg_id = msg.message_id
+        store.pers[uid].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 +57,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 +71,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 +86,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,13 +101,13 @@ 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):
+    uid = msg.from_user.id
     builder = InlineKeyboardBuilder()
-    store: Store = msg.bot.store
     txt = "В"
-    if cred_ids := store.perm.cur_creds.get(store.pay.t_pmcur_id):
+    if cred_ids := store.pers[uid].cur_creds.get(store.pay.t_pmcur_id):
         for cred_id in cred_ids:
-            cred = store.perm.creds[cred_id]
+            cred = store.pers[uid].creds[cred_id]
             builder.button(text=cred.repr(), callback_data=cd.Cred(id=cred_id))
         txt = "Выберите реквизиты куда нужно получить деньги, если в списке нет нужных, то\nв"
 
@@ -130,22 +120,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 +149,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 +167,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,19 +184,19 @@ 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):
+    uid = msg.from_user.id
     pay_req, _ = await models.PayReq.update_or_create(
         {"pay_until": datetime.now() + timedelta(minutes=store.pay.urg)},
         amount=store.pay.amount,
         parts=store.pay.ppo,
         addr_id=store.pay.addr_id,
         cred_id=store.pay.cred_id,
-        user=store.perm.user,
+        user=store.pers[uid].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} платежами"
@@ -224,14 +210,14 @@ async def create_payreq(msg: Message):
     # create_task(window.run_timer(msg))В
 
 
-async def run_timer(message, state: FSMContext):
+async def run_timer(msg, state: FSMContext):
     builder = InlineKeyboardBuilder()
     builder.button(text="Платеж получен", callback_data=cd.Action(act=cd.ActionType.received))
 
     seconds = await state.get_value("timer") * 60
 
     try:
-        await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
+        await msg.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
     except Exception:
         return
 
@@ -239,7 +225,7 @@ async def run_timer(message, state: FSMContext):
         await sleep(1)
         seconds -= 1
         try:
-            await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
+            await msg.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
             await state.update_data(timer=seconds)
         except Exception:
             break
@@ -249,7 +235,7 @@ async def run_timer(message, state: FSMContext):
         builder.button(text="Платеж получен", callback_data=cd.Action(act=cd.ActionType.received))
         builder.button(text="Денег нет", callback_data=cd.Action(act=cd.ActionType.not_received))
         try:
-            await message.edit_text("⏳ Время вышло!", reply_markup=builder.as_markup())
+            await msg.edit_text("⏳ Время вышло!", reply_markup=builder.as_markup())
         except Exception:
             pass