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

xync_client/Okx/ex.py

@@ -1,7 +1,7 @@
 from asyncio import run
 
 from pyro_client.client.file import FileClient
-from pyro_client.loader import TOKEN
+from pyro_client.loader import NET_TOKEN
 from x_model import init_db
 
 from xync_client.Abc.Exception import NoPairOnEx
@@ -102,7 +102,7 @@ class ExClient(BaseExClient):
 async def main():
     _ = await init_db(TORM)
     bg = await models.Ex.get(name="Okx")
-    cl = ExClient(bg, FileClient(TOKEN))
+    cl = ExClient(bg, FileClient(NET_TOKEN))
     await cl.ads("USDT", "EUR", True)
     # curs = await cl.curs()
     # coins = await cl.coins()

xync_client/Pms/Payeer/__init__.py

@@ -1,22 +1,65 @@
 import logging
 from asyncio import run
+from base64 import b64encode
 from datetime import datetime
 from decimal import Decimal
 from enum import StrEnum
+from hashlib import sha256
+from json import dumps
 from math import ceil
+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 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
 
 
+def encrypt_data(data: dict, md5digest: bytes):
+    # Convert data to JSON string (equivalent to json_encode)
+    bdata = dumps(data).encode()
+
+    # Generate random IV (16 bytes for AES)
+    iv = urandom(16)
+
+    # Pad or truncate key to 32 bytes
+    if len(md5digest) < 32:
+        md5digest = md5digest.ljust(32, b"\0")  # Pad with null bytes
+    elif len(md5digest) > 32:
+        md5digest = md5digest[:32]  # Truncate to 32 bytes
+
+    # Apply PKCS7 padding
+    padder = padding.PKCS7(128).padder()  # 128 bits = 16 bytes block size
+    padded_data = padder.update(bdata)
+    padded_data += padder.finalize()
+
+    # Create cipher
+    cipher = Cipher(AES(md5digest), CBC(iv))
+    encryptor = cipher.encryptor()
+
+    # Encrypt
+    ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+
+    return iv + ciphertext
+
+
 class Client(PmAgentClient):
     class Pages(StrEnum):
         _base = "https://payeer.com/en/"
@@ -26,40 +69,94 @@ class Client(PmAgentClient):
     norm: str = "payeer"
     pages: type(StrEnum) = Pages
     api: PayeerAPI
+    with_userbot: bool = False
 
-    async def start(self, pw: Playwright, headed: bool = False) -> "PmAgentClient":
-        await super().start(pw, headed)
+    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"])
-        return self
 
     async def _login(self):
         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]:
+        m_shop = str(topup.topupable.auth["id"])
+        m_orderid = str(topup.id)
+        m_amount = "{0:.2f}".format(topup.amount * 0.01)
+        m_curr = topup.cur.ticker
+        m_desc = b64encode(b"XyncPay top up").decode()
+        m_key = topup.topupable.auth["sec"]
+        data = [m_shop, m_orderid, m_amount, m_curr, m_desc]
+
+        # # additional
+        # m_params = {
+        #     'success_url': 'https://xync.net/topup?success=1',
+        #     'fail_url': 'https://xync.net/topup?success=0',
+        #     'status_url': 'https://xync.net/topup',
+        #     'reference': {'var1': '1'},
+        # }
+        #
+        # key = md5(m_orderid.to_bytes()).digest()
+        #
+        # base64url_encode(encrypt_data(params, key))
+        #
+        # data.append(m_params)
+        # # additional
+
+        data.append(m_key)
+
+        sign = sha256(":".join(data).encode()).hexdigest().upper()
+
+        params = {
+            "m_shop": m_shop,
+            "m_orderid": m_orderid,
+            "m_amount": m_amount,
+            "m_curr": m_curr,
+            "m_desc": m_desc,
+            "m_sign": sign,
+            # 'm_params': m_params,
+            # 'm_cipher_method': 'AES-256-CBC-IV',
+            "form[ps]": "2609",
+            "form[curr[2609]]": m_curr,
+        }
+        url = "https://payeer.com/merchant/?" + urlencode(params)
+        return url, None
+
+    def get_topup(self, tid: str) -> dict:
+        hi = self.api.get_history_info(tid)
+        ti = self.api.shop_order_info(hi["params"]["SHOP_ID"], hi["params"]["ORDER_ID"])["info"]
+        return ti["status"] == "execute" and {
+            "pmid": ti["id"],
+            "from_acc": hi["params"]["ACCOUNT_NUMBER"],
+            "oid": hi["params"]["ORDER_ID"],
+            "amount": int(float(ti["sumOut"]) * 100),
+            "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/")
-        fiat_accounts = await page.locator(
-            f".balance-item.balance-item--green.balance-item--{cur.lower()}"
-        ).all_text_contents()
-        has_amount = float(fiat_accounts[0].replace(",", "").strip())
-        if float(amount) <= has_amount:
+                await page.goto("https://payeer.com/en/account/send/", wait_until="commit")
+        has_amount = float(self.api.get_balance()[cur]["DOSTUPNO"])
+        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)
-            sleep(0.9)
+            sleep(0.8)
             await page.locator('input[name="sum_receive"]').fill(str(amount))
             sleep(0.1)
             # await page.locator("div.n-form--title").first.click()
@@ -67,7 +164,7 @@ class Client(PmAgentClient):
             await page.click(".btn.n-form--btn.n-form--btn-mod")
             sleep(0.5)
             await page.click(".btn.n-form--btn.n-form--btn-mod")
-            sleep(1.2)
+            sleep(1.1)
             if await page.locator(".input4").count():
                 await page.locator(".input4").fill(self.agent.auth.get("master_key"))
                 await page.click(".ok.button_green2")
@@ -77,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/{dest}.png"), 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
@@ -125,30 +222,37 @@ async def main(uid: int):
     from x_model import init_db
 
     _ = await init_db(TORM, True)
+    agent = await PmAgent.get_or_none(pm__norm="payeer", user__username_id=uid).prefetch_related(
+        "user__username__session", "pm"
+    )
+    if not agent:
+        raise Exception(f"No active user #{uid} with agent for volet!")
+    abot = Bot(PAY_TOKEN)
+    pyr = agent.client(abot)
     playwright: Playwright = await async_playwright().start()
-    pyr = Client(uid)
     try:
-        await pyr.start(playwright, True)
+        dest, amount, cur = "P79619335", 4, "RUB"
+        ta = await TopUpAble.get(pm__norm="payeer")
+        topup = await TopUp.create(amount=1001, cur_id=1, topupable=ta, user_id=1)
+        await topup.fetch_related("cur")
+        _url, _data = pyr.form_redirect(topup)
 
-        dest, amount, cur = "P79619335", 2, "RUB"
+        await pyr.start(playwright, False)
 
-        res = await pyr.send(dest, amount, cur)
-        res = await pyr.send(dest, 3, cur)
-        res = await pyr.send(dest, amount, cur)
-        res = await pyr.send(dest, 3, cur)
-        res = await pyr.send(dest, amount, cur)
+        _res = await pyr.send(dest, amount, cur)
+        _res = await pyr.send(dest, 3, cur)
 
-        res = pyr.check_in(2, cur, datetime.now())
+        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

@@ -8,7 +8,31 @@ import time
 
 
 async def login(agent: PmAgent):
-    driver = uc.Chrome(no_sandbox=True, headless=False)
+    options = uc.ChromeOptions()
+    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("--disable-renderer-backgrounding")
+    options.add_argument("--disable-background-timer-throttling")
+    options.add_argument("--disable-backgrounding-occluded-windows")
+    options.add_argument("--disable-client-side-phishing-detection")
+    options.add_argument("--disable-crash-reporter")
+    options.add_argument("--disable-oopr-debug-crash-dump")
+    options.add_argument("--no-crash-upload")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-low-res-tiling")
+    options.add_argument("--log-level=3")
+    options.add_argument("--silent")
+    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=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")
@@ -22,7 +46,10 @@ async def login(agent: PmAgent):
         login_button = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, "login-form__login-btn.step1")))
         login_button.click()
         time.sleep(4)
-        login_button.click()
+        try:
+            login_button.click()
+        except Exception:
+            pass
         time.sleep(1)
         if (v := driver.find_elements(By.CLASS_NAME, "form-input-top")) and v[0].text == "Введите проверочный код":
             code = input("Email code: ")