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

xync_client/Pms/Payeer/__init__.py

@@ -11,17 +11,22 @@ from os import urandom
 from time import sleep
 from urllib.parse import urlencode
 
+from PGram import Bot
 from asyncpg.pgproto.pgproto import timedelta
 from cryptography.hazmat.primitives import padding
 from cryptography.hazmat.primitives.ciphers import Cipher
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
 from cryptography.hazmat.primitives.ciphers.modes import CBC
 from payeer_api import PayeerAPI
-from playwright.async_api import async_playwright, Playwright, Error
+from playwright.async_api import async_playwright, Playwright, Error, Browser
+
+# noinspection PyProtectedMember
 from playwright._impl._errors import TimeoutError
-from xync_schema.models import TopUp, TopUpAble, PmAgent
+from tortoise.timezone import now
+from xync_bot import XyncBot
+from xync_schema.models import TopUp, TopUpAble, PmAgent, Transfer
 
-from xync_client.loader import TORM
+from xync_client.loader import TORM, PAY_TOKEN
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_client.Pms.Payeer.login import login
@@ -64,9 +69,10 @@ class Client(PmAgentClient):
     norm: str = "payeer"
     pages: type(StrEnum) = Pages
     api: PayeerAPI
+    with_userbot: bool = False
 
-    def __init__(self, agent: PmAgent):
-        super().__init__(agent)
+    def __init__(self, agent: PmAgent, browser: Browser, abot: XyncBot):
+        super().__init__(agent, browser, abot)
         if api_id := self.agent.auth.get("api_id"):
             self.api = PayeerAPI(self.agent.auth["email"], api_id, self.agent.auth["api_sec"])
 
@@ -74,7 +80,7 @@ class Client(PmAgentClient):
         await login(self.agent)
         for cookie in self.agent.state["cookies"]:
             await self.page.context.add_cookies([cookie])
-        await self.page.goto(self.pages.SEND)
+        await self.page.goto(self.pages.SEND, wait_until="commit")
 
     @staticmethod
     def form_redirect(topup: TopUp) -> tuple[str, dict | None]:
@@ -131,20 +137,22 @@ class Client(PmAgentClient):
             "ts": datetime.strptime(ti["dateCreate"], "%d.%m.%Y %H:%M:%S") - timedelta(hours=3),
         }
 
-    async def send(self, dest: str, amount: int, cur: str) -> tuple[int, bytes, int] | int:
-        self.last_active = datetime.now()
+    async def send(self, t: Transfer) -> tuple[str, bytes] | float:
+        dest, cur = t.order.cred.detail, t.order.cred.pmcur.cur.ticker
+        amount = round(t.order.amount * 10**-t.order.cred.pmcur.cur.scale, t.order.cred.pmcur.cur.scale)
+        self.last_active = now()
         page = self.page
         if not page.url.startswith(self.pages.SEND):
             try:
-                await page.goto(self.pages.SEND)
+                await page.goto(self.pages.SEND, wait_until="commit")
             except (TimeoutError, Error):
                 await login(self.agent)
                 for cookie in self.agent.state["cookies"]:
                     await page.context.add_cookies([cookie])
                 sleep(0.5)
-                await page.goto("https://payeer.com/en/account/send/")
+                await page.goto("https://payeer.com/en/account/send/", wait_until="commit")
         has_amount = float(self.api.get_balance()[cur]["DOSTUPNO"])
-        if float(amount) <= has_amount:
+        if amount <= has_amount:
             sleep(0.1)
             await page.locator('input[name="param_ACCOUNT_NUMBER"]').fill(dest)
             await page.locator("select[name=curr_receive]").select_option(value=cur)
@@ -166,42 +174,42 @@ class Client(PmAgentClient):
             except TimeoutError as _:
                 logging.error("Repeat!")
                 sleep(0.5)
-                return await self.send(dest, amount, cur)
+                return await self.send(t)
             if await page.locator('.note_txt:has-text("successfully completed")').count():
                 transaction = await page.locator(".note_txt").all_text_contents()
-                trans_num = int(transaction[0].replace("Transaction #", "").split()[0])
-                await page.goto("https://payeer.com/ru/account/history/")
+                trans_num = transaction[0].replace("Transaction #", "").split()[0]
+                await page.goto("https://payeer.com/ru/account/history/", wait_until="commit")
                 await page.click(f".history-id-{trans_num} a.link")
                 sleep(1)
                 receipt = await page.query_selector(".ui-dialog.ui-corner-all")
-                return trans_num, await receipt.screenshot(path=f"tmp/{trans_num}.png"), int(has_amount - amount)
+                return trans_num, receipt and await receipt.screenshot(path=f"tmp/{trans_num}.png")
             else:
-                await self.bot.send("Payeer хз", self.uid, photo=await self.page.screenshot())
+                await self.receive("Payeer хз", photo=await self.page.screenshot())
                 return -1
         else:
-            await self.bot.send(
+            await self.receive(
                 f"Payeer no have {amount}, only {has_amount}{cur} to {dest}",
-                self.uid,
                 photo=await self.page.screenshot(),
             )
             return has_amount
 
-    def check_in(
-        self, amount: Decimal | int | float, cur: str, tme: datetime = None, tid: str | int = None
+    async def check_in(
+        self, amount: Decimal | int | float, cur: str, dt: datetime = None, tid: str | int = None
     ) -> tuple[Decimal | None, int | None]:
-        history = self.api.history(type="incoming", append=tid, count=3)
+        history = self.api.history(type="incoming", count=10)
         if tid:
             return (t := history.get(tid)) and Decimal(t["creditedAmount"])
-        t = [
+        ts: list[dict] = [
             h
             for h in history.values()
             if (
                 amount <= Decimal(h["creditedAmount"]) <= ceil(amount)
                 and h["creditedCurrency"] == cur
-                and datetime.fromisoformat(h["date"]) > tme - timedelta(minutes=1)
+                # todo: wrong tz
+                and datetime.fromisoformat(h["date"]) > dt - timedelta(minutes=3)  # +180(tz)-5
             )
         ]
-        if not (t := t and t[0]):
+        if not (t := ts and ts[0]):
             return None, None
         return (
             amount <= (am := Decimal(t["creditedAmount"])) <= ceil(amount) and t["creditedCurrency"] == cur
@@ -219,7 +227,8 @@ async def main(uid: int):
     )
     if not agent:
         raise Exception(f"No active user #{uid} with agent for volet!")
-    pyr = agent.client()
+    abot = Bot(PAY_TOKEN)
+    pyr = agent.client(abot)
     playwright: Playwright = await async_playwright().start()
     try:
         dest, amount, cur = "P79619335", 4, "RUB"
@@ -236,14 +245,14 @@ async def main(uid: int):
         res = pyr.check_in(3, cur, datetime.now())
 
         if len(res) > 1 and isinstance(res[1], bytes):
-            await pyr.bot.send(f"Transaction #{res[0]}", uid, photo=res[1])
+            await pyr.receive(f"Transaction #{res[0]}", photo=res[1])
         elif res[0] > 0:
-            await pyr.bot.send(f"Sreen of transaction #{res[0]} failed", uid, photo=await pyr.page.screenshot())
+            await pyr.receive(f"Sreen of transaction #{res[0]} failed", photo=await pyr.page.screenshot())
         else:
-            await pyr.bot.send(f"Sending {amount} {cur} to {dest} FAILED", uid, photo=await pyr.page.screenshot())
+            await pyr.receive(f"Sending {amount} {cur} to {dest} FAILED", photo=await pyr.page.screenshot())
 
     except TimeoutError as te:
-        await pyr.bot.send(repr(te), uid, photo=await pyr.page.screenshot())
+        await pyr.receive(repr(te), photo=await pyr.page.screenshot())
         raise te
     # finally:
     #     await pyr.stop()

xync_client/Pms/Payeer/login.py

@@ -12,7 +12,7 @@ async def login(agent: PmAgent):
     options.add_argument("--disable-blink-features=AutomationControlled")
     options.add_argument("--no-sandbox")
     options.add_argument("--disable-dev-shm-usage")
-    options.add_argument("--headless=new")  # for Chrome >= 109
+    # options.add_argument("--headless=new")  # for Chrome >= 109
     options.add_argument("--disable-renderer-backgrounding")
     options.add_argument("--disable-background-timer-throttling")
     options.add_argument("--disable-backgrounding-occluded-windows")
@@ -28,7 +28,11 @@ async def login(agent: PmAgent):
     options.add_argument("--window-size=1920,1080")
     options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
 
-    driver = uc.Chrome(options=options, headless=True)
+    driver = uc.Chrome(
+        options=options,
+        headless=False,
+        browser_executable_path="/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+    )
     wait = WebDriverWait(driver, timeout=10)
     try:
         driver.get("https://payeer.com/en/auth")

xync_client/Pms/Volet/__init__.py

@@ -1,23 +1,28 @@
 import logging
 import re
-from asyncio import run, ensure_future
+from asyncio import run
+from datetime import datetime
 from decimal import Decimal
 from enum import StrEnum
 from hashlib import sha256
 
-from playwright.async_api import async_playwright, Page, Locator, Position, Playwright  # , FloatRect
+from PGram import Bot
+from playwright.async_api import async_playwright, Page, Locator, Position, Playwright, Browser  # , FloatRect
 from pyotp import TOTP
 
 # noinspection PyProtectedMember
 from playwright._impl._errors import TimeoutError
 from pyro_client.client.user import UserClient
 from pyrogram.handlers import MessageHandler
+from tortoise.timezone import now
+from xync_schema import models
 from xync_schema.enums import UserStatus
-from xync_schema.models import Cur, User, PmAgent, Cred, PmCur, Fiat, TopUp
+from xync_schema.models import Cur, User, PmAgent, Cred, PmCur, Fiat, TopUp, Transfer
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_client.Gmail import GmClient
 from xync_client.Pms.Volet.api import APIClient
+from xync_client.loader import PAY_TOKEN
 
 
 class CaptchaException(Exception): ...
@@ -58,24 +63,28 @@ class Client(PmAgentClient):
         # HOME = base + "pages/transaction"
         SEND = base + "pages/transfer/wallet"
 
-    async def check_in(self, amount: int | Decimal | float, cur: str, tid: str | int = None) -> float | None:
-        pass
+    async def check_in(
+        self, amount: int | Decimal | float, cur: str, dt: datetime, tid: str | int = None
+    ) -> float | None:
+        return await (self.api.check_by_id(tid) if tid else self.api.check_by_amount(amount, cur))
 
     async def proof(self) -> bytes:
         pass
 
     uid: int
     agent: PmAgent
-    bot: UserClient
+    abot: Bot
+    ubot: UserClient
     api: APIClient
     page: Page
     gmail: GmClient
     norm: str = "payeer"
     pages: type(StrEnum) = Pages
+    with_userbot: bool = True
 
-    def __init__(self, agent: PmAgent):
-        super().__init__(agent)
-        self.gmail = GmClient(self.uid)
+    def __init__(self, agent: PmAgent, browser: Browser, abot: Bot):
+        super().__init__(agent, browser, abot)
+        self.gmail = GmClient(agent.user)
         self.api = APIClient(self.agent.auth["api"], self.agent.auth["password"], self.agent.auth["login"])
 
     @staticmethod
@@ -113,77 +122,92 @@ class Client(PmAgentClient):
             "ts": t["updatedTime"],
         }
 
-    async def start(self, pw: Playwright, headed: bool = False):
-        ensure_future(self.gmail.start(pw, True))
-        return await super().start(pw, True, True)
-
     async def wait_for_code(self, uid: int, topic: str, hg: tuple[MessageHandler, int]) -> str:
-        code = await self.bot.wait_from(uid, topic, hg)
+        code = await self.ubot.wait_from(uid, topic, hg)
         return code and code[-6:]
 
     async def _login(self):
         ll = self.page.locator("input#j_username")
-        await ll.fill("mixartemev@gmail.com")
-        await self.page.locator("input#j_password").fill("mixfixX98")
-        await self.page.wait_for_timeout(200)
+        await ll.fill(self.agent.auth["login"])
+        await self.page.locator("input#j_password").fill(self.agent.auth["password"])
+        await self.page.wait_for_timeout(300)
         await ll.click()
+        await ll.press(key="ArrowLeft")
+        await ll.blur()
         volet_bot_id, topic = 243630567, "otp_login"
         await self.page.locator("input#loginToAdvcashButton", has_text="log in").hover()
-        hg = self.bot.subscribe_for(volet_bot_id, topic)  # 243630567 - is volet bot
+        hg = self.ubot.subscribe_for(volet_bot_id, topic)
         await self.page.locator("input#loginToAdvcashButton:not([disabled])", has_text="log in").click()
         await self.page.wait_for_url(self.pages.OTP_LOGIN)
         if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
-            await self.bot.receive("no login code", photo=await self.page.screenshot())
+            await self.ubot.receive("no login code", photo=await self.page.screenshot())
             raise NoCodeException(self.agent.user_id)
         await self.page.locator("input#otpId").fill(code)
         await self.page.click("input#checkOtpButton")
-        await self.page.wait_for_url(self.pages.SEND)
+        await self.page.wait_for_url(self.pages.SEND, wait_until="domcontentloaded")
+        # save state
+        # noinspection PyTypeChecker
+        self.agent.state = await self.page.context.storage_state()
+        await self.agent.save()
 
-    async def send(self, dest: str, amount: float, cur: str) -> tuple[int, bytes, float]:
+    async def send(self, t: Transfer) -> tuple[str, bytes] | float:
+        dest, cur = t.order.cred.detail, t.order.cred.pmcur.cur.ticker
+        amount = round(t.order.amount * 10**-t.order.cred.pmcur.cur.scale, t.order.cred.pmcur.cur.scale)
+        self.last_active = now()
         curs_map = {"RUB": "Ruble"}
-
-        await self.go(self.pages.SEND)
+        await self.go(self.pages.SEND, False)
         await self.page.click("[class=combobox-account]")
-        await self.page.click(f'[class=rf-ulst-itm] b:has-text("{curs_map[cur]}") ")')
-        await self.page.wait_for_timeout(200)
+        await self.page.click(f'[class=rf-ulst-itm] b:has-text("{curs_map[cur]}")')
+        await self.page.wait_for_selector(f"#srcCurrency:has-text('{cur}')")
         await self.page.fill("#srcAmount", str(amount))
-        await self.page.fill("#destWalletId", dest)
-        await self.page.wait_for_timeout(300)
+        dw = self.page.locator("#destWalletId")
+        await dw.fill(dest)
+        await dw.blur()
+        await self.page.wait_for_selector(f"#destCurrency:has-text('{cur}')")
+        volet_bot_id, topic = 243630567, "otp_send"
+        hg = self.ubot.subscribe_for(volet_bot_id, topic)
         await self.page.locator("form#mainForm input[type=submit]", has_text="continue").click()
         # todo: check success confirming
         if otp := self.agent.auth.get("otp"):
             totp = TOTP(otp)
             code = totp.now()
         elif self.agent.user.username.session:
-            if not (code := await self.wait_for_code("send")):
-                if 1:  # todo: need main confirm
-                    await self.gmail.mail_confirm()
-                await self.bot.receive("no send trans code", photo=await self.page.screenshot())
+            if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
+                if 1:  # todo: Is mail_confirm required?
+                    if _mcr := await self.gmail.volet_confirm(amount, t.updated_at):
+                        ...
+                        # todo: click Continue
+                    if not (code := await self.wait_for_code(volet_bot_id, topic, hg)):
+                        code = await self.wait_for_code(volet_bot_id, topic, hg)
+            if not code:
+                await self.receive("no send trans code", photo=await self.page.screenshot())
                 raise NoCodeException(self.agent.user_id)
         else:
             raise OtpNotSetException(self.agent.user_id)
         await self.page.fill("#securityValue", code)
         await self.page.locator("input[type=submit]", has_text="confirm").click()
         await self.page.wait_for_url(self.pages.SEND)
+        tid = await self.page.text_content("ul.p-confirmation-info dl.success>dd")
         await self.page.get_by_role("heading").click()
-        slip = await self.page.screenshot(clip={"x": 440, "y": 205, "width": 420, "height": 360})
-        await self.bot.receive(f"{amount} to {dest} sent", photo=slip)
+        slip = await self.page.screenshot(clip={"x": 440, "y": 205, "width": 440, "height": 415})
+        await self.receive(f"{amount} to {dest} sent", photo=slip)
+        return tid, slip
 
-    async def go(self, url: Pages):
+    async def go(self, url: Pages, commit: bool = True):
         try:
-            await self.page.goto(url)
+            await self.page.goto(url, wait_until="commit" if commit else "domcontentloaded")
             if len(await self.page.content()) < 1000:  # todo: fix captcha symptom
                 await self.captcha_click()
         except Exception as e:
-            await self.bot.receive(repr(e), photo=await self.page.screenshot())
+            await self.receive(repr(e), photo=await self.page.screenshot())
             raise e
 
     async def send_cap_help(self, xcap: Locator):
         if await xcap.count():
             bb = await xcap.bounding_box(timeout=2000)
             byts = await self.page.screenshot(clip=bb)
-            await self.bot.receive("put x, y", photo=byts)
-            txt = await self.bot.bot.wait_from(self.bot.me.id, "xy", timeout=59)
+            await self.receive("put x, y", photo=byts)
+            txt = await self.ubot.wait_from(self.uid, "xy", timeout=59)  # todo: fix
             for xy in txt.split(";"):
                 px, py = xy
                 x, y = bb["x"] + bb["width"] * int(px) / 100, bb["y"] + bb["height"] * int(py) / 100
@@ -202,7 +226,7 @@ class Client(PmAgentClient):
         if await xcap.count():
             await self.send_cap_help(xcap)
         try:
-            await self.page.wait_for_url(lambda url: url != captcha_url)
+            await self.page.wait_for_url(lambda url: url != captcha_url, wait_until="commit")
         except TimeoutError:  # if page no changed -> captcha is undone
             await self.page.screenshot()
             raise CaptchaException(self.page.url)
@@ -233,41 +257,36 @@ class Client(PmAgentClient):
         ]
         [await Fiat.update_or_create({"amount": amount}, cred=cred) for cred, amount in creds]
 
-    async def stop(self):
-        # save state
-        self.agent.state = await self.page.context.storage_state()
-        await self.agent.save()
-        # closing
-        await self.bot.stop()
-        await self.gmail.stop()
-        await self.page.context.close()
-        await self.page.context.browser.close()
-
 
 async def _test():
     from x_model import init_db
-    from xync_schema import TORM
+    from xync_client.loader import TORM
 
     _ = await init_db(TORM, True)
-    logging.basicConfig(level=logging.DEBUG)
-    uid = 193017646
+    logging.basicConfig(level=logging.INFO)
+    abot = Bot(PAY_TOKEN)
     playwright: Playwright = await async_playwright().start()
-    agent = await PmAgent.get_or_none(pm__norm="volet", user__username_id=uid).prefetch_related(
-        "user__username__session"
-    )
-    if not agent:
-        raise Exception(f"No active user #{uid} with agent for volet!")
 
-    va = agent.client()
     try:
-        await va.start(playwright)
-        await va.send("alena.artemeva25@gmail.com", 7.98)
-        await va.wait_for_payments()
+        o = await models.Order.create(ad_id=7, exid=1, amount=900, cred_id=522, taker_id=419)
+        await o.fetch_related("cred__pmcur__cur", "ad")
+        pma = await models.PmAgent.get(
+            active=True,
+            auth__isnull=False,
+            pm_id=o.cred.pmcur.pmex_exid,
+            user__person__actors=o.ad.maker_id,
+            user__status=UserStatus.ACTIVE,
+        ).prefetch_related("pm", "user__gmail", "user__username__session")
+        t = models.Transfer(amount=9, created_at=now(), order=o)
+        pcl: Client = pma.client(abot)
+        pcl = await pcl.start(playwright, True, True)
+        await pcl.send(t)
+        await pcl.wait_for_payments()
     except TimeoutError as te:
-        await va.bot.receive(repr(te), photo=await va.page.screenshot())
+        await pcl.receive(repr(te), photo=await pcl.page.screenshot())
         raise te
     finally:
-        await va.stop()
+        await pcl.stop()
 
 
 if __name__ == "__main__":

xync_client/Pms/Volet/api.py

@@ -88,16 +88,17 @@ class APIClient:
     async def check_by_amount(self, amount: decimal, cur: str = "RUB", timeout: int = 5 * 60, past: int = 0):
         hist: list = self.make_request("history", {"transactionDirection": "INCOMING", "count": 3, "from": 0})
         if int(hist[0].amount) == int(amount):
-            return hist[0]
+            return hist[0]["amount"], hist[0]["id"]
         await sleep(period)
         past += period
         if past < timeout:
             return await self.check_by_amount(amount, cur, timeout, past)
-        return False
+        return None, None
 
     def check_by_id(self, tid: str):
-        t: dict = self.make_request("findTransaction", tid)
-        return t
+        if t := self.make_request("findTransaction", tid):
+            return t["amount"], t["id"]
+        return None, None
 
 
 async def main():

xync_client/loader.py

@@ -5,6 +5,7 @@ from xync_schema import models
 load_dotenv()
 
 NET_TOKEN = env("NET_TOKEN")
+PAY_TOKEN = env("PAY_TOKEN")
 PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
 TORM = {
     "connections": {"default": PG_DSN},

xync_client/pm_unifier.py

@@ -17,7 +17,7 @@ class PmUnifier:
     pms: dict[str, PmUni] = {}  # {origin: normalized}
 
     re_bank = [
-        r"^bank (?!of )|bank$",
+        r"^bank (?!(of |transfer))|(?<!(to|the)\s) bank$",
         r" banka$",
         r" bankas$",
         r" bankasi$",

{xync_client-0.0.141.dist-info → xync_client-0.0.155.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.141
+Version: 0.0.155
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client
@@ -8,6 +8,9 @@ Requires-Python: >=3.11
 Requires-Dist: asynchuobi
 Requires-Dist: bs4
 Requires-Dist: bybit-p2p
+Requires-Dist: google-api-python-client
+Requires-Dist: google-auth-httplib2
+Requires-Dist: google-auth-oauthlib
 Requires-Dist: requests-toolbelt
 Requires-Dist: msgspec
 Requires-Dist: python-binance

{xync_client-0.0.141.dist-info → xync_client-0.0.155.dist-info}/RECORD

@@ -1,17 +1,19 @@
 xync_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/details.py,sha256=21itVPCgAtaYRR1H9J9oYudj95gafcFjExUN6QL17OI,1330
-xync_client/loader.py,sha256=zhslCMgtgp-xINPG4qQwhI1ee5Ap1vuoC8oK7GyhyMw,571
-xync_client/pm_unifier.py,sha256=T2Xh-tvcu114P2YBI6RK_XDiaIhyq6ABMrXDuXPlx7A,6541
-xync_client/Abc/Agent.py,sha256=OJaJ1RIMDYAS4xeefeXxVIVI0EKnMczQtrO35MLzqr4,5390
+xync_client/loader.py,sha256=hxf8ob50DO7r_qjr2qBoO7IyjkXeHHzVQ63YjXerjoU,600
+xync_client/pm_unifier.py,sha256=DYkFYXzmhVEh8WJvI---3Geas34mZ83cT1O-88D68YQ,6568
+xync_client/Abc/AdLoader.py,sha256=EsrQY_yjhRE2V-4eK2nfq1aAmZPY-FX7x9yKXfp7ILk,14066
+xync_client/Abc/Agent.py,sha256=FjpFWnVj6FB498KCDtGPzCMHdRuOo4ejPvRmOeug7qM,8764
 xync_client/Abc/Asset.py,sha256=hlgyFaU9byr2N2r8Heh-_ICx49SKuKxfRTUA4yQWmEw,454
 xync_client/Abc/Auth.py,sha256=OPQXN7_XYQZP9431ylFksd6JDusbKG8N_1g6CXTZ6yY,1495
 xync_client/Abc/BaseTest.py,sha256=vaAs5Z4HYV7k_C3zQz6JKO75s2hXtVbBI3-0Srkzv5Q,2388
-xync_client/Abc/Ex.py,sha256=n41-XCjoIV-KpC_lK3jO049tQKbFmE0eDU3SDlgZTws,12986
+xync_client/Abc/Ex.py,sha256=s6v_jR_Wqj64RxU6lDd6-IYpmGBcWNASsBqkX3MCoPo,13554
 xync_client/Abc/Exception.py,sha256=Sts7RpP370NBdjaH_cyXDdHtjge8zXNUGWCrKw49Zyk,482
-xync_client/Abc/InAgent.py,sha256=svKGATUM0c9YIDDEVLc-NxpUNWqZoVr5PjxoxK64RKs,650
+xync_client/Abc/HasAbotUid.py,sha256=LsTHHjMHBauCwJoqgDa9Lx4R6xsDOHfsN4jM539Bpqg,279
+xync_client/Abc/InAgent.py,sha256=8BnZ7VzWLIJY93xnNTqlpY3JdarQkkpRRjDDEALaVAA,303
 xync_client/Abc/Order.py,sha256=7-FGIJu5z9aYi0A_eJV4F-cp_6Mz_izNpefexDQZvHw,2428
-xync_client/Abc/PmAgent.py,sha256=wS1ZQs-hcC8ICDLcc9EfyNBKrM_ZDpJolAg-l_5ro-8,4094
-xync_client/Abc/xtype.py,sha256=o1JEzWmEXCPddtlqWZ6HRTZTKX6SAnvsztbASj21zOQ,2584
+xync_client/Abc/PmAgent.py,sha256=Xl-0-KMwcTp_7qIt7NV7-aD22j955tFYFqcHHbmGMTQ,4193
+xync_client/Abc/xtype.py,sha256=H2S5UV67v5Uiy0KC3JI4N142MYQWS_8d9d3N8_WHnVs,3050
 xync_client/Binance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xync_client/Binance/binance_async.py,sha256=LP2DZaHwkfsp_4Tjvetb-1ntjQtJfODF0OgZpoPx4KU,2688
 xync_client/Binance/earn_api.py,sha256=hvk0MaVTLszIglQXVhbUjGcaHfbF9Ul7FFXmy94U2so,4411
@@ -34,25 +36,25 @@ xync_client/BitGet/agent.py,sha256=YVs3bDY0OcEJGU7m2A8chzO6PFhWDnQQrA-E6MVkBBg,3
 xync_client/BitGet/ex.py,sha256=uEvvXuLaJv8o8BFi0bMA3XyBuTfVDWagAjLOHZl-xlE,3765
 xync_client/BitGet/etype/ad.py,sha256=fysSW47wGYjSOPUqY864z857AJz4gjN-nOkI1Jxd27U,1838
 xync_client/BitPapa/ex.py,sha256=U-RRB_RSOtErfRgxOZYWegZ_td_uZO37YKo3Jxchf_w,912
-xync_client/Bybit/InAgent.py,sha256=QQTRWcZXhNO-AZi9wfCAA-x24FIRL00_f4T5xCVgC10,25324
-xync_client/Bybit/agent.py,sha256=fz76f-6g81TnFoFqWX0AqMaKvnYzgYKfhpkckIOM0cM,61769
-xync_client/Bybit/ex.py,sha256=3oARvReBoDs90FzQY31-L-q_YU-TIRbvWB7z4lwESsA,4715
+xync_client/Bybit/InAgent.py,sha256=sHpugXfgeAYG68z6cKiTc3QSeGGNGKUSCh5NzXIbAKw,26657
+xync_client/Bybit/agent.py,sha256=ekzuPdZQpKMhONe_tZT54nri2D0aYRMao4UOjIE123A,59456
+xync_client/Bybit/ex.py,sha256=ovbCZ1-36KIo-8FYb8yt_VNE3UZszBoik10Adzrpi2Y,5088
 xync_client/Bybit/order.py,sha256=H4UIb8hxFGnw1hZuSbr0yZ4qeaCOIZOMc6jEst0ycBs,1713
 xync_client/Bybit/web_earn.py,sha256=qjqS10xlFc8r40IhDdPZ0LxA2dFEGbvBGXdsrUUJCMo,3019
 xync_client/Bybit/web_p2p.py,sha256=sAXzK03t6jwDnz4rrvP2IzI0KxfKa7C_5GuzH1HwLuA,11768
 xync_client/Bybit/ws.py,sha256=OQjZHo_MiAH1dlOs3c-aUZBKyqToNTmH560udh6RYDE,1431
-xync_client/Bybit/etype/ad.py,sha256=HJOHi9KrbLQMpwEyd4oA8436QTNRqrd2HWFF-JNZGDo,8066
-xync_client/Bybit/etype/cred.py,sha256=dgFExLB4e5Wf6SqfU9SOdeooHQa84DRbTGm_OJhNw_o,1354
-xync_client/Bybit/etype/order.py,sha256=rPXw9eHJW3afVPQDRiooUkHfQhmqJ5fTdZ4vKdO6uHQ,8273
+xync_client/Bybit/etype/ad.py,sha256=r356t4Kmho5Q6BAS0JWyRmsxui427W9O2Y1glUU6l3g,5091
+xync_client/Bybit/etype/cred.py,sha256=CH6xqHh1214bLhHy_K9eVBb1SJVhWBfGb0l3LtBf3fU,1701
+xync_client/Bybit/etype/order.py,sha256=A1LQSqSOIgDu-dfZDhAdSnED_Xty4vXdJEoikRbelH0,8350
 xync_client/Gate/ex.py,sha256=QbhB3u7TWnvVGD-AknB2nay6KZjEXQ-1JT9UacX4sWI,3735
 xync_client/Gate/premarket.py,sha256=IW-CgkmNJePJR2j_NRfULNKTePMX35XlhldqdiO76zY,2138
 xync_client/Gate/etype/ad.py,sha256=-EwtFcOWWvtE6UjaOdsuXWDTCVjAIRK0kSEsqPP4Yls,1296
-xync_client/Gmail/__init__.py,sha256=98pRNlyx7e49QJMxzYPcbCROv2m2LGyGkSCGyrh0dow,4646
-xync_client/Htx/agent.py,sha256=rOURgTeY9TsA-IzT78l5-Ze91i0x1PY683mrX38MSgs,7356
+xync_client/Gmail/__init__.py,sha256=9JGT8PyzJaOTVvaFV0Gki3Fdo6Bp6m6DnWOPGZJ-eAA,5436
+xync_client/Htx/agent.py,sha256=NqoiK95Zhxle5ZqB0aa1kfIbQo2qEGjkhlzwr4LA9Y0,12573
 xync_client/Htx/earn.py,sha256=jL6eRwytZEMRom_3bFm1DYthi_GFg-E1Mm3ZDXENHSg,2386
-xync_client/Htx/ex.py,sha256=GuWK5lA_MvtSd-0DhKf2MAstKvZMHhc3BIiZSgdwZv4,6074
+xync_client/Htx/ex.py,sha256=66GTk7kitTXrNdwM0xRJTc2sIlLk0VUOAWunYG7iF-s,6051
 xync_client/Htx/etype/__init__.py,sha256=sZIhFOxj2dRQRmMe86-y9vlzOGAPo1qoOi6u1qVxWr0,123
-xync_client/Htx/etype/ad.py,sha256=bShCGHRAvFJxt2io5rjQrEFMB0zZzkTww7sBxIcmLVM,2000
+xync_client/Htx/etype/ad.py,sha256=2nTTUgL1utDBVUYiVpDzCowlXFg-94leihFpAAguK8A,2311
 xync_client/Htx/etype/cred.py,sha256=sAOQTsk7BA8zBWUkkwM6vIQcq1LcSK5NLYGrkTdtkQ8,1129
 xync_client/Htx/etype/pm.py,sha256=ILCP9reFRkfuzmtsJDYomJ3WBTU4s_KE-69JksTxwMk,375
 xync_client/Htx/etype/test.py,sha256=uomFicPE1OoA3WXnXOxhsTtGJEpVCQ0CId9D0NI6vto,893
@@ -60,8 +62,11 @@ xync_client/KuCoin/ex.py,sha256=w-6-aedlC1mYf8LShMv6pOrQzqMR9E6yIyXGUHQP888,3237
 xync_client/KuCoin/web.py,sha256=--OHS0Z29xjfNUjdTL7K0EDmU4dwej95OJ8Sv4PsxLI,920
 xync_client/KuCoin/etype/ad.py,sha256=MTx90Qo2xFKvfgIr4_qMowjwO23HVpFCD6J7INNFDuQ,1223
 xync_client/KuCoin/etype/pm.py,sha256=S50S5fyY5YeWlcPwO66o-GsPcdqgoeXuxvmEIy6Zqvs,130
-xync_client/Mexc/ex.py,sha256=jpITGa2GTeYayMVStQOomBW-P0YQoXjKExKZi_kS-2A,4295
+xync_client/Mexc/agent.py,sha256=7xhT-UH3aLFAVAfnGUhHqOauNeADNt84ifsT-x3ydq4,2843
+xync_client/Mexc/api.py,sha256=RUbggGalZllKcxTRjXzhW05WTvhXCtdCLETRty-ZcAE,18998
+xync_client/Mexc/ex.py,sha256=JAx07nIzMs8p2PfAmlTpvugis4dlgGjxhQiKlGRS0jY,4416
 xync_client/Mexc/etype/ad.py,sha256=GUgvylx_z64CXNcw0YejUQJHg9F59eRo5v0zU7DRrAM,1434
+xync_client/Mexc/etype/order.py,sha256=LUA4jL5Y1Qmf1C6rU9_PFyg9aCqo60kZbZPAiSrx77U,19001
 xync_client/Mexc/etype/pm.py,sha256=m5kCoMx9IEKUPB-z7YwwymQhASkv2npC4-Z_ePYeeRY,453
 xync_client/Okx/ex.py,sha256=WG1NSh7wFMNePV0eXDePWELUBD1ksxE_-Q87QaDXLvE,4542
 xync_client/Okx/etype/ad.py,sha256=rTWMMmDwJK9chBByyihCZcgE5P6c5ti2yR1RbUtev3A,3773
@@ -72,14 +77,14 @@ xync_client/Pms/Alfa/state.json,sha256=MKE6vl-JsJO9PNCVqoQgBgYZTgYkHCas7USwl8QFt
 xync_client/Pms/MTS/__init__.py,sha256=P_E7W46IZEk8RsEgl7H1xV3JplMT5l9vYQYTYyNbyQ8,2101
 xync_client/Pms/Ozon/__init__.py,sha256=EvQZDSPv0fOT2hNCTP44nXHOIEQvP5bQf_7HVLiZc2I,4123
 xync_client/Pms/Payeer/.gitignore,sha256=sWORdRp8ROppV2CsMEDJ3M_SokrNWCf8b1hlaNs64hg,12
-xync_client/Pms/Payeer/__init__.py,sha256=xN3L-IURWJ6oYXq85qu34u0OZEQOXkshgeEuMG29qg8,9584
+xync_client/Pms/Payeer/__init__.py,sha256=dSQw0JSQGW33sjScyhpOkFK4VsNU-ob1K-ldmZWLmQQ,10020
 xync_client/Pms/Payeer/api.py,sha256=bb8qrlPYyWafel1VR-2nate6xBeRZAVciFJblHygfAs,549
-xync_client/Pms/Payeer/login.py,sha256=W5FAA0reW5x2hSh8sBIWmR38VcYhwvrn1R64IAtWHVw,2921
+xync_client/Pms/Payeer/login.py,sha256=GyNwB-GKE_1nlkbZJ0KNI-EnCT0j_S9ogFdn-ufb-zU,3053
 xync_client/Pms/Sber/__init__.py,sha256=dxQfd9ZPhFTc_C4xrwaxrV6p0SijDCLNzBeUv3oQG38,4926
 xync_client/Pms/Sber/utils.py,sha256=gIeJspwvoBbOBt-fjxwW4WDHPoL2Evs8LVufsjrFOfo,1870
 xync_client/Pms/Tinkoff/__init__.py,sha256=ZyLvBEUn-vh-85oPUUDS586AHgvx3c-mkQE3yBQtbw8,5580
-xync_client/Pms/Volet/__init__.py,sha256=h1bRO4x58-_-Yf9g3noYow0DDu8P4NFLwx83FnDZptM,10719
-xync_client/Pms/Volet/api.py,sha256=okqppqT7M5E6sswu-xz3L4Y9-ngefBPbFtywRi6A7Xo,3595
+xync_client/Pms/Volet/__init__.py,sha256=mYJEmZwFoNU2B2erv7n8k6RA0PsXU12K7hpyrdEocrk,12088
+xync_client/Pms/Volet/api.py,sha256=6_dH2rzmyyvha3PeoiZdSltiAzKDWn8roSUJOAErX4M,3673
 xync_client/Pms/Volet/pl.py,sha256=l7lvUrpjFoObXPHaseOIAcSbkNqJdpy6OLDutxYJH3U,2451
 xync_client/Pms/Volet/_todo_req/req.mjs,sha256=ut3Jw37rL5lY7SskjZ9f1l0VE33tuP-PZEYUTcJMc2I,817
 xync_client/Pms/Volet/_todo_req/req.py,sha256=mKvdPrb-lkQ98Ws92_oBKu5yqyU8Krxy9XwuIhdsBao,1570
@@ -95,7 +100,7 @@ xync_client/TgWallet/order.py,sha256=BOmBx5WWfJv0-_-A8DcR-Xd8utqO_VTmSqSegm0cteQ
 xync_client/TgWallet/pyd.py,sha256=Ys3E8b3RLuyQ26frWT0F0BorkNxVpxnd18tY4Gp9dik,5636
 xync_client/TgWallet/pyro.py,sha256=2K7QWdo48k4MbbgQt90gdz_HiPck69Njm4xaMjIVgoo,1440
 xync_client/TgWallet/web.py,sha256=kDcv9SKKQPe91mw1qJBpbuyKYCAmZdfdHJylHumLBVU,1608
-xync_client-0.0.141.dist-info/METADATA,sha256=Evn_XBCNvwhXH0mxMhCRRkwc7cMk8ux285aJ9NdRyyI,1037
-xync_client-0.0.141.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xync_client-0.0.141.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
-xync_client-0.0.141.dist-info/RECORD,,
+xync_client-0.0.155.dist-info/METADATA,sha256=PizI21QJhBoGXcmRFqqmjbcilHvhK9uwXdD5zmz1t6k,1149
+xync_client-0.0.155.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xync_client-0.0.155.dist-info/top_level.txt,sha256=bmYEVIIrD3v7yFwH-X15pEfRvzhuAdfsAZ2igvNI4O8,12
+xync_client-0.0.155.dist-info/RECORD,,