xync-client 0.0.141__py3-none-any.whl → 0.0.155__py3-none-any.whl

xync_client/Htx/agent.py

@@ -1,18 +1,30 @@
+import re
 from json import dumps
+from time import time
+from urllib.parse import quote
 
+from aiohttp import ClientResponse
+from pyro_client.client.file import FileClient
+from x_client import df_hdrs
 from x_client.aiohttp import Client
+from xync_bot import XyncBot
+
+from xync_client.Abc.xtype import AdUpd, GetAds
+from xync_client.loader import NET_TOKEN, PAY_TOKEN, TORM
+
+from xync_client.Htx.etype.ad import Req, TradeRule, TradeRulesV2
 from xync_schema.enums import AdStatus, PmType, OrderStatus
 from xync_schema.models import Pm, Coin, Cur, Ad, Order
 from xync_schema import models
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Htx.etype import test
+from xync_client.Htx.etype import test, ad
 
 import logging
 
 url_ads_req = "https://otc-cf.huobi.com/v1/data/trade-market"
 url_ads_web = "https://www.huobi.com/en-us/fiat-crypto/trade/"
 url_my_ads = "https://otc-api.trygofast.com/v1/data/trade-list?pageSize=50"
-url_my_ad = "https://www.huobi.com/-/x/otc/v1/otc/trade/"  # + id
+url_my_ad = "/-/x/otc/v1/otc/trade/"  # + id
 url_my_bals = "https://www.huobi.com/-/x/otc/v1/capital/balance"
 url_paccs = "https://www.huobi.com/-/x/otc/v1/user/receipt-account"
 
@@ -22,9 +34,17 @@ class Public(Client):
 
 
 class AgentClient(BaseAgentClient):
-    headers = {
-        "portal": "web",
-    }
+    headers = {"portal": "web"} | df_hdrs
+
+    async def login(self):
+        t = int(time() * 1000)
+        resp = await self._get("/-/x/uc/uc/open/ticket/get", {"t": t})
+        if ticket := resp["data"].get("ticket"):
+            resp = await self._post("/-/x/otc/v1/user/login", form_data={"ticket": ticket, "type": "WEB"})
+            if resp["success"]:
+                self.agent.auth["headers"]["Token"] = resp["data"]
+                await self.agent.save(update_fields=["auth"])
+                self.session.headers["Token"] = resp["data"]
 
     async def creds(self) -> list[test.CredEpyd]:
         resp = await self._get("/-/x/otc/v1/user/receipt-account")
@@ -46,7 +66,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_new(self, cred: models.Cred) -> models.CredEx:
         pmcur = await cred.pmcur
-        exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -71,7 +91,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_upd(self, cred: models.Cred, exid: int) -> models.CredEx:
         pmcur = await cred.pmcur
-        _exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        _exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -137,17 +157,79 @@ class AgentClient(BaseAgentClient):
     ) -> Ad:
         pass
 
-    async def ad_upd(
-        self,
-        pms: [Pm] = None,
-        price: float = None,
-        is_float: bool = None,
-        min_fiat: int = None,
-        details: str = None,
-        autoreply: str = None,
-        status: AdStatus = None,
-    ) -> bool:
-        pass
+    async def _ad_upd(self, ad_upd: AdUpd, hdrs: dict[str, str] = None) -> dict:
+        creds = [
+            TradeRule(
+                content="Payment method-%s",
+                contentCode="PAY",
+                hint="Please enter",
+                inputType=0,
+                inputValue=cx.cred.detail,
+                sort=1,
+                title="【Payment related】",
+                titleValue=await models.PmEx.get(pm_id=cx.cred.pmcur.pm_id, ex=self.ex_client.ex).values_list(
+                    "name", flat=True
+                ),
+            )
+            for cx in ad_upd.credexs
+        ]
+        trs = TradeRulesV2(
+            [
+                *creds,
+                TradeRule(
+                    content="",
+                    contentCode="MERCHANT",
+                    hint="Please enter",
+                    inputType=0,
+                    inputValue="",
+                    sort=4,
+                    title="【Merchant Tips】",
+                ),
+            ]
+        ).model_dump_json(exclude_none=True)
+        req = Req(
+            tradeType=int(ad_upd.is_sell),
+            coinId=2,
+            currency=11,
+            minTradeLimit=500.00,
+            maxTradeLimit=ad_upd.amount,
+            tradeCount=ad_upd.quantity,
+            password=self.agent.auth["pass"],
+            payTerm=15,
+            premium=0.00,
+            isFixed="on",
+            fixedPrice=ad_upd.price,
+            isAutoReply="off",
+            takerAcceptOrder=0,
+            isPayCode="off",
+            receiveAccounts=ad_upd.credexs[0].exid,
+            deviation=0,
+            isTakerLimit="on",
+            takerIsMerchant="on",
+            takerRealLevel="off",
+            takerIsPhoneBind="off",
+            takerIsPayment="on",
+            blockType=1,
+            session=1,
+            chargeType=False,
+            apiVersion=4,
+            channel="web",
+            tradeRulesV2=quote(trs),
+        )
+        res = await self._post(self.url_my_ad + str(ad_upd.id), form_data=req.model_dump(exclude_none=True), hdrs=hdrs)
+        if res["code"] == 200:
+            return res["data"]
+        elif res["code"] == 605:
+            hdrs = {"x-dialog-trace-id": res["extend"]["traceId"]}
+            return await self._ad_upd(ad_upd, hdrs)
+        elif res["code"] == 1010:
+            if (match := re.search(r"Available amount ([\d.]+)", res["message"])) and (qty := match.group(1)):
+                ad_upd.quantity = float(qty)
+                ad_upd.amount = round(ad_upd.quantity * ad_upd.price, 2)
+                return await self._ad_upd(ad_upd, hdrs)
+        elif res["code"] == 401:
+            raise Exception(res)
+        raise BaseException(res)
 
     async def ad_del(self) -> bool:
         pass
@@ -182,32 +264,81 @@ class AgentClient(BaseAgentClient):
     base_url = ""
     middle_url = ""
 
-    htok: str = "Ev5lFfAvxDU2MA9BJ-Mc4U6zZG3Wb6qsp3Tx2fz6GIoY-uOP2m0-gvjE57ad1qDF"
-
     url_ads_req = "https://otc-cf.huobi.com/v1/data/trade-market"
     url_my_ads = "https://otc-api.trygofast.com/v1/data/trade-list?pageSize=50"
-    url_my_ad = "https://www.huobi.com/-/x/otc/v1/otc/trade/"  # + id
+    url_my_ad = "/-/x/otc/v1/otc/trade/"  # + id
     url_my_bals = "https://www.huobi.com/-/x/otc/v1/capital/balance"
     url_paccs = "https://www.huobi.com/-/x/otc/v1/user/receipt-account"
 
+    async def _proc(self, resp: ClientResponse, bp: dict | str = None) -> dict | str:
+        if (await resp.json()).get("code") == 401:
+            await self.login()
+            return await self.METHS[resp.method](self, resp.url.path, bp)
+        return await super()._proc(resp, bp)
+
 
 async def _test():
     from x_model import init_db
-    from xync_schema import TORM
 
-    _ = await init_db(TORM, True)
-    actor = (
-        await models.Actor.filter(ex_id=15, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
+    cn = await init_db(TORM, True)
+    ex = await models.Ex[9]
+    filebot = FileClient(NET_TOKEN)
+    ecl = ex.client(filebot)
+    agent = (
+        await models.Agent.filter(actor__ex=ex, auth__isnull=False)
+        .prefetch_related(
+            "actor__ex",
+            "actor__person__user__gmail",
+            "actor__my_ads__my_ad__race",
+            "actor__my_ads__pair_side__pair__cur",
+            "actor__my_ads__pms",
+        )
+        .first()
     )
-    cl: AgentClient = actor.client()
-    cred = await models.Cred[89]
-    _ = await cl.cred_new(cred)
-    _creds = await cl.creds()
+    cl: AgentClient = agent.client(ecl, filebot, XyncBot(PAY_TOKEN, cn))
+    # cred = await models.Cred[89]
+    # _ = await cl.cred_new(cred)
+    # _creds = await cl.creds()
     # _ = await cl.cred_del(16984748)
-    await cl.close()
+
+    while True:
+        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpd(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 80001})
+        sreq_upd = AdUpd(id=1188929, price=92.99, **{**sreq.model_dump(), "amount": 65001})
+
+        bads: list[ad.Resp] = await cl.ex_client.ads(breq)
+        sads: list[ad.Resp] = await cl.ex_client.ads(sreq)
+
+        if bads:
+            if bads[0].uid == cl.actor.exid:
+                if round(bads[0].price - bads[1].price, 2) > 0.01:
+                    breq_upd.price = bads[1].price + 0.01
+                    await cl.ad_upd(breq_upd)
+                    print(end="!", flush=True)
+            elif bads[0].price < 89:
+                breq_upd.price = bads[0].price + 0.01
+                await cl.ad_upd(breq_upd)
+                print(end="!", flush=True)
+
+        if sads:
+            if sads[0].uid == cl.actor.exid:
+                if round(sads[1].price - sads[0].price, 2) > 0.01:
+                    sreq_upd.price = sads[1].price - 0.01
+                    await cl.ad_upd(sreq_upd)
+                    print(end="!", flush=True)
+            elif sads[0].price > 91:
+                sreq_upd.price = sads[0].price - 0.01
+                await cl.ad_upd(sreq_upd)
+                print(end="!", flush=True)
+
+        print(end=".", flush=True)
+        await sleep(15)
+
+    await cl.stop()
 
 
 if __name__ == "__main__":
-    from asyncio import run
+    from asyncio import run, sleep
 
     run(_test())

xync_client/Htx/etype/ad.py

@@ -1,20 +1,24 @@
 from typing import Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, RootModel
 from xync_schema.xtype import BaseAd
 
 
 class TradeRule(BaseModel):
     title: str
-    titleValue: str
+    titleValue: str | None = None
     content: str
     inputType: int
     inputValue: str
     hint: str
-    contentCode: str
+    contentCode: Literal["PAY", "MERCHANT"]
+    contentType: int | None = None
     sort: int
 
 
+TradeRulesV2 = RootModel[list[TradeRule]]
+
+
 class Req(BaseModel):
     tradeType: int
     coinId: int
@@ -22,27 +26,30 @@ class Req(BaseModel):
     minTradeLimit: float
     maxTradeLimit: float
     tradeCount: float
-    password: str
+    password: str = ""
     payTerm: int
     isFixed: Literal["off", "on"]
-    premium: int
+    premium: float
     isAutoReply: Literal["off", "on"]
     takerAcceptOrder: int
     isPayCode: Literal["off", "on"]
-    isVerifyCapital: bool
+    verifyCapitalStatus: str = None  # todo: check if int
     receiveAccounts: int
     deviation: int
     isTakerLimit: Literal["off", "on"]
+    takerRealLevel: Literal["off", "on"]
+    takerIsPhoneBind: Literal["off", "on"]
+    takerIsMerchant: Literal["off", "on"]
+    takerIsPayment: Literal["off", "on"]
     blockType: int
     session: int
     chargeType: bool
     apiVersion: int
     channel: str
-    tradeRulesV2: list[TradeRule]
+    tradeRulesV2: str  # TradeRulesV2
     securityToken: str | None = ""
-    fixedPrice: str | None = ""
+    fixedPrice: float | None = None
     autoReplyContent: str | None = ""
-    tradeRule: str | None = ""
 
 
 class PayMethod(BaseModel):
@@ -75,9 +82,9 @@ class Resp(BaseAd):
     orderCompleteRate: str
     payMethod: str
     payMethods: list[PayMethod]
-    payName: str  # list[PayName]  # приходит массив объектов внутри строки
+    payName: str  # list[PayName] # приходит массив объектов внутри строки
     payTerm: int
-    price: str
+    price: float
     takerAcceptAmount: str
     takerAcceptOrder: int
     takerLimit: int

xync_client/Htx/ex.py

@@ -9,7 +9,7 @@ from xync_schema.models import Ex, Cur
 from xync_schema.enums import PmType
 
 from xync_client.Abc.Ex import BaseExClient
-from xync_client.Abc.xtype import PmEx, MapOfIdsList
+from xync_client.Abc.xtype import PmEx, MapOfIdsList, GetAds
 from xync_client.Htx.etype import pm, Country, ad
 from xync_client.loader import NET_TOKEN
 from xync_client.loader import TORM
@@ -42,20 +42,18 @@ class ExClient(BaseExClient):
                         pair[rcurs[cur["name"]]] += [coen]
         return tuple(pairs.values())
 
-    async def ads(
-        self, coin_exid: int, cur_exid: int, is_sell: bool, pm_exids: list[str] = None, amount: int = None
-    ) -> list[xtype.BaseAd]:
+    async def _ads(self, req: GetAds, lim: int = None, vm_filter: bool = False, **kwargs) -> list[ad.Resp]:
         params = {
-            "coinId": coin_exid,
-            "currency": cur_exid,
-            "tradeType": "sell" if is_sell else "buy",
+            "coinId": req.coin_id,
+            "currency": req.cur_id,
+            "tradeType": "sell" if req.is_sell else "buy",
             "currPage": 1,
-            "payMethod": ",".join(pm_exids) if pm_exids else 0,
+            "payMethod": ",".join(req.pm_ids) if req.pm_ids else 0,
             "acceptOrder": 0,
             "blockType": "general",
             "online": 1,
             "range": 0,
-            "amount": amount or "",
+            "amount": req.amount or "",
             "onlyTradable": "false",
             "isFollowed": "false",
         }

xync_client/Mexc/agent.py

@@ -0,0 +1,85 @@
+from asyncio import run
+from hashlib import md5
+from uuid import uuid4
+
+from pyro_client.client.file import FileClient
+from xync_bot import XyncBot
+from xync_client.Bybit.etype.order import TakeAdReq
+
+from xync_client.loader import PAY_TOKEN, NET_TOKEN
+from xync_schema import models
+from xync_schema.enums import UserStatus
+
+from xync_client.Abc.Agent import BaseAgentClient
+
+
+class AgentClient(BaseAgentClient):
+    i: int = 0
+    headers = {
+        "accept-language": "ru,en;q=0.9",
+        "language:": "ru-RU",
+        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+    }
+
+    async def _take_ad(self, req: TakeAdReq):
+        self.i = 33 if self.i > 9998 else self.i + 2
+        hdrs = self.headers | {"trochilus-trace-id": f"{uuid4()}-{self.i:04d}"}
+        auth = {
+            "p0": self.actor.agent.auth["p0"],
+            "k0": self.actor.agent.auth["k0"],
+            "chash": self.actor.agent.auth["chash"],
+            "mtoken": self.actor.agent.auth["deviceId"],
+            "mhash": md5(self.actor.agent.auth["deviceId"].encode()).hexdigest(),
+        }
+        data = {
+            "scene": "TRADE_BUY",
+            "quantity": req.quantity,
+            "amount": req.amount,
+            "orderId": req.ad_id,
+            "authVersion": "v2",
+            "deviceId": auth["mtoken"],
+        }
+        res = await self._post("/api/verify/second_auth/risk/scene", json=data, hdrs=hdrs)
+        data = {
+            "amount": req.amount,
+            "authVersion": "v2",
+            "orderId": req.ad_id,
+            "price": req.price,
+            "ts": int(1761155700.8372989 * 1000),
+            "userConfirmPaymentId" if req.is_sell else "userConfirmPayMethodId": req.pm_id,
+        }
+        self.i = 33 if self.i > 9999 else self.i + 1
+        hdrs = self.headers | {"trochilus-trace-id": f"{uuid4()}-{self.i:04d}"}
+        res = await self._post("/api/order/deal?mhash=" + auth["mhash"], data=auth | data, hdrs=hdrs)
+        return res["data"]
+
+
+async def main():
+    from x_model import init_db
+    from xync_client.loader import TORM
+
+    cn = await init_db(TORM, True)
+
+    agent = (
+        await models.Agent.filter(
+            actor__ex_id=12,
+            active=True,
+            auth__isnull=False,
+            actor__person__user__status=UserStatus.ACTIVE,
+            actor__person__user__pm_agents__isnull=False,
+        )
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
+        .first()
+    )
+
+    bbot = XyncBot(PAY_TOKEN, cn)
+    fbot = FileClient(NET_TOKEN)
+
+    cl = agent.client(fbot, bbot)
+    req = TakeAdReq(ad_id="a1574088909645125632", amount=500, pm_id=366, cur_="RUB", price=85.8, is_sell=True)
+    res = await cl.take_ad(req)
+    print(res)
+
+
+if __name__ == "__main__":
+    run(main())