xync-client 0.0.144__py3-none-any.whl → 0.0.147__py3-none-any.whl

xync_client/Bybit/agent.py

@@ -24,13 +24,14 @@ from tortoise.signals import post_save
 from urllib3.exceptions import ReadTimeoutError
 from x_model import init_db
 from x_model.func import ArrayAgg
+from xync_bot import XyncBot
 from xync_schema import models
 from xync_schema.enums import OrderStatus
 
-from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide
+from xync_schema.models import Actor, Cond, CondSim, PmCur, PairSide, Agent
 
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Abc.xtype import BaseOrderReq, FlatDict
+from xync_client.Abc.xtype import FlatDict, BaseOrderReq
 from xync_client.Bybit.etype.ad import AdPostRequest, AdUpdateRequest, Ad, AdStatus
 from xync_client.Bybit.etype.cred import CredEpyd
 from xync_client.Bybit.etype.order import (
@@ -42,8 +43,10 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     Message,
     Status,
+    OrderSellRequest,
+    TakeAdReq,
 )
-from xync_client.loader import TORM, NET_TOKEN
+from xync_client.loader import TORM, NET_TOKEN, PAY_TOKEN
 
 
 class NoMakerException(Exception):
@@ -87,9 +90,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
     rcond_sims: dict[int, set[int]] = defaultdict(set)  # backward
     tree: dict = {}
 
-    def __init__(self, actor: Actor, bot: FileClient, **kwargs):
-        super().__init__(actor, bot, **kwargs)
-        self.api = P2P(testnet=False, api_key=actor.agent.auth["key"], api_secret=actor.agent.auth["sec"])
+    def __init__(self, agent: Agent, fbot: FileClient, bbot: XyncBot, **kwargs):
+        super().__init__(agent, fbot, bbot, **kwargs)
+        self.api = P2P(testnet=False, api_key=agent.auth["key"], api_secret=agent.auth["sec"])
         self.hist: dict = None
         self.completed_orders: list[int] = None
 
@@ -272,20 +275,39 @@ class AgentClient(BaseAgentClient):  # Bybit client
         security_risk_token = data["result"]["securityRiskToken"]
         return security_risk_token
 
-    def _check_2fa(self, risk_token):
-        # 2fa code
-        bybit_secret = self.agent.auth["2fa"]
-        totp = pyotp.TOTP(bybit_secret)
-        totp_code = totp.now()
-
-        res = self._post(
-            "/user/public/risk/verify", {"risk_token": risk_token, "component_list": {"google2fa": totp_code}}
+    async def _check_2fa(self, risk_token) -> int:
+        cres = await self._post("/user/public/risk/components", {"risk_token": risk_token})
+        if cres["ret_msg"] != "success":
+            raise HTTPException("get")
+        cres = cres["result"]["component_list"]
+        res = await self._post(
+            "/user/public/risk/verify",
+            {
+                "risk_token": risk_token,
+                "component_list": {c["component_id"]: self.__get_2fa(c["component_id"]) for c in cres},
+            },
         )
         if res["ret_msg"] != "success":
-            print("Wrong 2fa, wait 5 secs and retry..")
-            sleep(5)
-            self._check_2fa(risk_token)
-        return res
+            logging.error("Wrong 2fa, wait 5 secs and retry..")
+            await sleep(5)
+            await self._check_2fa(risk_token)
+        return res["ret_code"]
+
+    async def __get_2fa(self, typ: Literal["google2fa", "email_verify", "payment_password_verify"], rt: str = None):
+        if typ == "google2fa":
+            bybit_secret = self.agent.auth["2fa"]
+            totp = pyotp.TOTP(bybit_secret)
+            return totp.now()
+        elif typ == "email_verify":
+            res = await self._post("/user/public/risk/send/code", {"risk_token": rt, "component_id": "email_verify"})
+            if res["ret_msg"] != "success":
+                return self.gmail.bybit_code()
+            elif cool_down := int(res["result"]["cool_down"]):
+                await sleep(cool_down)
+                return self.gmail.bybit_code()
+        elif typ == "payment_password_verify":
+            return self.agent.auth["pass"]
+        raise Exception("2fa fail")
 
     def _post_ad(self, risk_token: str):
         self.create_ad_body.update({"securityRiskToken": risk_token})
@@ -339,27 +361,56 @@ class AgentClient(BaseAgentClient):  # Bybit client
         data = self.api.remove_ad(itemId=ad_id)
         return data
 
-    async def order_request(self, br: BaseOrderReq) -> OrderResp:
-        res0 = await self._post("/fiat/otc/item/simple", data={"item_id": str(br.ad_id)})
-        if res0["ret_code"] == 0:
-            res0 = res0["result"]
-        res0 = PreOrderResp.model_validate(res0)
+    async def __preorder_request(self, ad_id: int) -> PreOrderResp:
+        res = await self._post("/fiat/otc/item/simple", data={"item_id": str(ad_id)})
+        if res["ret_code"] == 0:
+            res = res["result"]
+        return PreOrderResp.model_validate(res)
+
+    async def __order_request_build(self, por: PreOrderResp, br: BaseOrderReq) -> OrderRequest:
         req = OrderRequest(
-            itemId=br.ad_id,
+            itemId=por.id,
             tokenId=br.coin_exid,
             currencyId=br.cur_exid,
-            side=str(OrderRequest.Side(int(br.is_sell))),
-            amount=str(br.fiat_amount or br.asset_amount * float(res0.price)),
-            curPrice=res0.curPrice,
-            quantity=str(br.asset_amount or round(br.fiat_amount / float(res0.price), br.coin_scale)),
-            flag="amount" if br.amount_is_fiat else "quantity",
+            side="1" if br.is_sell else "0",
+            amount=str(br.fiat_amount),
+            curPrice=por.curPrice,
+            quantity=str(round(br.fiat_amount / float(por.price), br.coin_scale)),
+            flag="amount",
+            # paymentType="51",
+            # paymentId="20399134",
+            # online="0"
         )
+        if br.is_sell:
+            credex = await models.CredEx.get(
+                cred__person_id=self.actor.person_id,
+                pmcur__pm__pmexs__exid=por.payments[0],
+                pmcur__pm__pmexs__ex_id=self.ex_client.ex.id,
+                pmcur__cur_id=br.cur_exid,
+            )
+            req = OrderSellRequest(**req.model_dump(), paymentType=por.payments[0], paymentId=str(credex.exid))
+        return req
+
+    async def _order_request(self, bor: BaseOrderReq) -> OrderResp:
+        por: PreOrderResp = await self.__preorder_request(bor.ad_id)
+        req: OrderRequest | OrderSellRequest = await self.__order_request_build(por, bor)
         # вот непосредственно сам запрос на ордер
-        res = await self._post("/fiat/otc/order/create", data=req.model_dump())
+        return await self.__order_create(req, bor)
+
+    async def __order_create(self, req: OrderRequest | OrderSellRequest, bor: BaseOrderReq) -> OrderResp:
+        res: dict = await self._post("/fiat/otc/order/create", data=req.model_dump())
         if res["ret_code"] == 0:
-            return OrderResp.model_validate(res["result"])
+            resp = OrderResp.model_validate(res["result"])
         elif res["ret_code"] == 912120030 or res["ret_msg"] == "The price has changed, please try again later.":
-            return await self.order_request(br)
+            resp = await self._order_request(bor)
+        if not resp.orderId and resp.needSecurityRisk:
+            if rc := await self._check_2fa(resp.securityRiskToken):
+                await self.bbot.send(self.actor.person.user.username_id, f"Bybit 2fa: {rc}")
+                raise Exception(f"Bybit 2fa: {rc}")
+            # еще раз уже с токеном
+            req.securityRiskToken = resp.securityRiskToken
+            resp = await self.__order_create(req, bor)
+        return resp
 
     async def cancel_order(self, order_id: str) -> bool:
         cr = CancelOrderReq(orderId=order_id)
@@ -545,7 +596,7 @@ class AgentClient(BaseAgentClient):  # Bybit client
             to = ((odb.payed_at or odb.created_at) + timedelta(minutes=180 + 30)).isoformat(sep=" ").split("+")[0]
             tsa = [
                 t
-                for tid, t in self.hist.items()
+                for tid, t in (self.hist.items() if self.hist else [])
                 if (ecredex.accountNo == t["to"] and t["from"] != "@merchant" and frm < t["date"] < to)
             ]
             buyer_person = (
@@ -1184,6 +1235,20 @@ class AgentClient(BaseAgentClient):  # Bybit client
 
         self.tree = tree
 
+    async def take_ad(self, req: TakeAdReq):
+        ad: Ad = Ad.model_validate(self.api.get_ad_details(itemId=req.ad_id))
+        bor = BaseOrderReq(
+            ad_id=str(ad.id),
+            fiat_amount=req.amount,
+            is_sell=bool(ad.side),
+            cur_exid=ad.currencyId,
+            coin_exid=ad.tokenId,
+            coin_scale=ad.token.scale,
+            pm_id=req.pm_id,
+        )
+        resp: OrderResp = await self._order_request(bor)
+        return resp
+
 
 def ms2utc(msk_ts_str: str):
     return datetime.fromtimestamp(int(msk_ts_str) / 1000, timezone(timedelta(hours=3), name="MSK"))
@@ -1248,7 +1313,7 @@ class ExcCode(IntEnum):
 
 async def main():
     logging.basicConfig(level=logging.INFO)
-    _ = await init_db(TORM)
+    cn = await init_db(TORM)
 
     @post_save(models.Race)
     async def race_upserted(
@@ -1261,18 +1326,20 @@ async def main():
         else:  # параметры гонки изменены
             ...
 
-    actor = (
-        await models.Actor.filter(ex_id=4, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
+    agent = (
+        await models.Agent.filter(actor__ex_id=4, auth__isnull=False, active=True)
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
+        .first()
     )
     filebot = FileClient(NET_TOKEN)
     await filebot.start()
     # b.add_handler(MessageHandler(cond_start_handler, command("cond")))
-    cl: AgentClient = actor.client(filebot)
+    cl: AgentClient = agent.client(filebot, XyncBot(PAY_TOKEN, cn))
 
     # await cl.ex_client.set_pairs()
     # await cl.ex_client.set_pms()
-    # await cl.set_creds()
-    # await cl.export_my_ads()
+    await cl.set_creds()
+    await cl.export_my_ads()
 
     # создание гонок по мои активным объявам:
     # for ma in cl.my_ads():
@@ -1320,7 +1387,7 @@ async def main():
     # )
     # await cl.get_api_orders()  # 43, 1741294800000, 1749157199999)
 
-    races = await models.Race.filter(started=True).prefetch_related(
+    races = await models.Race.filter(started=True, road__ad__maker_id=agent.actor_id).prefetch_related(
         "road__ad__pair_side__pair__cur",
         "road__ad__pms",
     )
@@ -1332,20 +1399,10 @@ async def main():
             # cl.get_api_orders(),  # 10, 1738357200000, 1742504399999
         )
     except Exception as e:
-        await filebot.send("🤬Bybit agent CRASHED!!!🤬", actor.person.user.username_id)
-        await filebot.send(e.__repr__(), actor.person.user.username_id)
+        await filebot.send("🤬Bybit agent CRASHED!!!🤬", agent.actor.person.user.username_id)
+        await filebot.send(e.__repr__(), agent.actor.person.user.username_id)
         raise e
-    # bor = BaseOrderReq(
-    #     ad_id="1861440060199632896",
-    #     # asset_amount=40,
-    #     fiat_amount=3000,
-    #     amount_is_fiat=True,
-    #     is_sell=False,
-    #     cur_exid=rub.exid,
-    #     coin_exid=usdt.exid,
-    #     coin_scale=usdt.coin.scale,
-    # )
-    # res: OrderResp = await cl.order_request(bor)
+
     # await cl.cancel_order(res.orderId)
     await filebot.stop()
     await cl.close()

xync_client/Bybit/etype/order.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from enum import IntEnum
 from typing import Literal
 
@@ -45,6 +44,12 @@ class StatusApi(IntEnum):
     waiting_for_objection = 110
 
 
+class TakeAdReq(BaseModel):
+    ad_id: int | str
+    amount: float
+    pm_id: int = None
+
+
 class OrderRequest(BaseModel):
     class Side(IntEnum):
         BUY = 0
@@ -60,33 +65,46 @@ class OrderRequest(BaseModel):
     flag: Literal["amount", "quantity"]
     version: str = "1.0"
     securityRiskToken: str = ""
+    isFromAi: bool = False
+
+
+class OrderSellRequest(OrderRequest):
+    paymentId: str
+    paymentType: str
 
 
 class PreOrderResp(BaseModel):
-    price: str  # float
-    curPrice: str
-    totalAmount: float
-    minAmount: float
-    maxAmount: float
-    minQuantity: float
-    maxQuantity: float
+    id: str  # bigint
+    price: str  # float .cur.scale
+    lastQuantity: str  # float .coin.scale
+    curPrice: str  # hex 32
+    lastPrice: str  # float .cur.scale # future
+    isOnline: bool
+    lastLogoutTime: str  # timestamp(0)+0
     payments: list[str]  # list[int]
     status: Literal[10, 20]
-    paymentTerms: list
-    paymentPeriod: Literal[15]
-    lastQuantity: float
-    lastPrice: float
-    isOnline: bool
-    lastLogoutTime: datetime
-    itemPriceAvailableTime: datetime
-    itemPriceValidTime: int  # 45000
+    paymentTerms: list  # empty
+    paymentPeriod: Literal[15, 30, 60]
+    totalAmount: str  # float .cur.scale
+    minAmount: str  # float .cur.scale
+    maxAmount: str  # float .cur.scale
+    minQuantity: str  # float .coin.scale
+    maxQuantity: str  # float .coin.scale
+    itemPriceAvailableTime: str  # timestamp(0)+0
+    itemPriceValidTime: Literal["45000"]
     itemType: Literal["ORIGIN"]
+    shareItem: bool  # False
 
 
 class OrderResp(BaseModel):
     orderId: str
     isNeedConfirm: bool
+    confirmId: str = ""
     success: bool
+    securityRiskToken: str = ""
+    riskTokenType: Literal["challenge"] = None
+    riskVersion: Literal["1", "2"] = None
+    needSecurityRisk: bool
     isBulkOrder: bool
     confirmed: str = None
     delayTime: str

xync_client/Gmail/__init__.py

@@ -1,113 +1,134 @@
-from playwright.async_api import Page, Playwright
-from pyro_client.client.file import FileClient
-from pyro_client.client.user import UserClient
+import logging
+import pickle
+import re
+from base64 import urlsafe_b64decode
+from datetime import datetime
+
+from google.auth.transport.requests import Request
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import Resource, build
+from requests import get
 from xync_schema.models import User, Gmail
 
-from xync_client.loader import NET_TOKEN
+from xync_client.Abc.HasAbotUid import HasAbotUid
+from xync_client.loader import TORM
+
+# Область доступа
+SCOPES = ["https://www.googleapis.com/auth/gmail.readonly"]
+
+
+class GmClient(HasAbotUid):
+    service: Resource
+
+    def __init__(self, user: User):
+        """Авторизация и создание сервиса Gmail API"""
+        creds = None
+        # Файл token.pickle хранит токены доступа пользователя
+        if user.gmail.token:
+            creds = pickle.loads(user.gmail.token)
+
+        # Если нет валидных credentials, запрашиваем авторизацию
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_config(user.gmail.auth, SCOPES)
+                creds = flow.run_local_server(port=0)
 
+            # Сохраняем credentials для следующего запуска
+            user.gmail.token = pickle.dumps(creds)
 
-class GmClient:
-    uid: int
-    user: User
-    page: Page
-    bot: UserClient = None
-    HOME = "https://mail.google.com/mail/u/0/"
+        self.service = build("gmail", "v1", credentials=creds)
+        self.uid = user.username_id
 
-    def __init__(self, uid: int):
-        self.uid = uid
+    def _get_last_email(self, sender_email, subject_keyword=None):
+        """
+        Получить последнее письмо от определенного отправителя
 
-    async def start(self, pw: Playwright, headed: bool = False):
-        self.user = await User.get(username_id=self.uid).prefetch_related("gmail")
-        if not self.user.gmail:
-            self.user.gmail = await Gmail.create(
-                login=input(f"{self.user.last_name} gmail login:"), password=input("password:")
+        Args:
+            sender_email: email отправителя (например, 'example@gmail.com')
+            subject_keyword: ключевое слово в теме (опционально)
+        """
+
+        def _get_email_body(payload):
+            """Извлечь текст письма из payload"""
+            if "body" in payload and "data" in payload["body"]:
+                return urlsafe_b64decode(payload["body"]["data"]).decode("utf-8")
+            return ""
+
+        # Формируем поисковый запрос
+        query = f"from:{sender_email}"
+        if subject_keyword:
+            query += f" subject:{subject_keyword}"
+
+        # Ищем письма с этим запросом
+        results = (
+            self.service.users()
+            .messages()
+            .list(
+                userId="me",
+                q=query,
+                maxResults=1,  # Только последнее письмо
             )
-        browser = await pw.chromium.launch(
-            channel="chrome" if headed else "chromium-headless-shell",
-            headless=not headed,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-web-security",
-                "--disable-infobars",
-                "--disable-extensions",
-                "--start-maximized",
-            ],
+            .execute()
         )
-        context = await browser.new_context(storage_state=self.user.gmail.auth, locale="en")
-        self.page = await context.new_page()
-        # go home
-        await self.page.goto(self.HOME, timeout=62000)
-        if not self.page.url.startswith(self.HOME):
-            if await (  # ваще с 0 заходим
-                sgn_btn := self.page.locator(
-                    'header a[href^="https://accounts.google.com/AccountChooser/signinchooser"]:visible',
-                    has_text="sign",
-                )
-            ).count():
-                await sgn_btn.click()
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/accountchooser"):  # надо выбрать акк
-                await self.page.locator("li").first.click()
-            # если предлагает залогиниться
-            elif await self.page.locator("h1#headingText", has_text="Sign In").count():
-                await self.page.fill("input[type=email]", self.user.gmail.login)
-                await self.page.locator("button", has_text="Next").click()
-            # осталось ввести пороль:
-            await self.page.fill("input[type=password]", self.user.gmail.password)
-            await self.page.locator("#passwordNext").click()
-            await self.page.wait_for_timeout(3000)
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/challenge/dp"):
-                await self.load_bot()
-                await self.bot.receive("Аппрувни гмейл, у тебя 1.5 минуты", photo=await self.page.screenshot())
-        await self.page.wait_for_url(lambda u: u.startswith(self.HOME), timeout=90 * 1000)  # убеждаемся что мы в почте
-        self.user.gmail.auth = await self.page.context.storage_state()
-        await self.user.gmail.save()
-
-    async def mail_confirm(self):
-        lang = await self.page.get_attribute("html", "lang")
-        labs = {
-            "ru": "Оповещения",
-            "en-US": "Updates",
-        }
-        tab = self.page.get_by_role("heading").get_by_label(labs[lang]).last
-        await tab.click()
-        rows = self.page.locator("tbody>>nth=4 >> tr")
-        row = rows.get_by_text("Volet.com").and_(rows.get_by_text("Please Confirm Withdrawal"))
-        if not await row.count():
-            await self.bot.receive("А нет запросов от волета", photo=await self.page.screenshot())
-
-        await row.click()
-        await self.page.wait_for_load_state()
-        btn = self.page.locator('a[href^="https://account.volet.com/verify/"]', has_text="confirm").first
-        await btn.click()
-
-    async def load_bot(self):
-        if not self.bot:
-            bot = FileClient(NET_TOKEN)
-            self.bot = UserClient(self.uid, bot)
-        if not self.bot.is_connected:
-            await self.bot.start()
-
-    async def stop(self):
-        if self.bot and self.bot.is_connected:  # todo: do not stop if
-            await self.bot.stop(False)
-        await self.page.context.close()
-        await self.page.context.browser.close()
+
+        if not (messages := results.get("messages", [])):
+            logging.warning("Письма не найдены")
+            return None
+
+        # Получаем полную информацию о письме
+        message_id = messages[0]["id"]
+        message = self.service.users().messages().get(userId="me", id=message_id, format="full").execute()
+
+        # Извлекаем заголовки
+        headers = message["payload"]["headers"]
+        subject = next((h["value"] for h in headers if h["name"] == "Subject"), "Нет темы")
+        from_email = next((h["value"] for h in headers if h["name"] == "From"), "Неизвестно")
+        date = next((h["value"] for h in headers if h["name"] == "Date"), "Неизвестно")
+
+        # Извлекаем текст письма
+        body = _get_email_body(message["payload"])
+
+        return {"id": message_id, "subject": subject, "from": from_email, "date": date, "body": body}
+
+    async def volet_confirm(self, amount: float, dt: datetime):
+        if email := self._get_last_email("noreply@volet.com", "Please Confirm Withdrawal"):  # "Volet.com"
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r"Amount: <b>([\d.]+) [A-Z]{3}</b>", email["body"]):
+                amt = float(match.group(1))
+            if match := re.search(r"https://account\.volet\.com/verify/([a-f0-9-]+)", email["body"]):
+                token = match.group(1)
+
+        if email and amount == amt and date > dt and token:
+            get(f"https://account.volet.com/verify/{token}")
+            return True
+
+        await self.receive("А нет запросов от волета")
+        return False
+
+    async def bybit_code(self, dt: datetime) -> str | None:
+        if email := self._get_last_email("Bybit", "[Bybit]Security Code for Your Bybit Account"):
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r'<span style="font-size:28pt;color:#ff9c2e">(\d{6})</span>', email["body"]):
+                code = match.group(1)
+
+        if email and date > dt and code:
+            get(f"https://account.volet.com/verify/{code}")
+            return code
+
+        await self.receive("А нет запросов от волета")
+        return None
 
 
 async def _test():
     from x_model import init_db
-    from xync_schema import TORM
-
-    _ = await init_db(TORM, True)
-    uid = 193017646
-    gmc = GmClient(uid)
-    try:
-        await gmc.start(True)
-    except TimeoutError as te:
-        raise te
-    finally:
-        await gmc.stop()
+
+    _ = await init_db(TORM)
+
+    gm = await Gmail.get(id=1).prefetch_related("user__username")
+    gmc = GmClient(gm)
+    await gmc.volet_confirm(amount=90, dt=datetime.now())
 
 
 if __name__ == "__main__":