xync-client 0.0.43.dev15__tar.gz → 0.0.43.dev17__tar.gz

{xync_client-0.0.43.dev15/xync_client.egg-info → xync_client-0.0.43.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev15
+Version: 0.0.43.dev17
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.43.dev15 → xync_client-0.0.43.dev17}/xync_client/Bybit/agent.py

@@ -1,11 +1,14 @@
+import logging
 from asyncio import run, sleep, gather
 from enum import IntEnum
 from http.client import HTTPException
-from math import floor
 from typing import Literal
 
 import pyotp
+from asyncpg import ConnectionDoesNotExistError
 from bybit_p2p import P2P
+from bybit_p2p._exceptions import FailedRequestError
+from urllib3.exceptions import ReadTimeoutError
 from x_model import init_db
 from xync_schema import models
 
@@ -174,10 +177,9 @@ class AgentClient(BaseAgentClient):  # Bybit client
         res = await self._post("/fiat/otc/maker/work-config/switch", data)
         return res
 
-    async def ads(self, coin: models.Coin, cur: models.Cur, is_sell: bool, pms: list[models.Pm]) -> list[Ad]:
+    async def ads(self, coin: models.Coin, cur: models.Cur, is_sell: bool, pmexs: list[models.Pmex]) -> list[Ad]:
         coinex = await models.Coinex.get(ex=self.ex, coin=coin)
         curex = await models.Curex.get(ex=self.ex, cur=cur)
-        pmexs = await models.Pmex.filter(ex=self.ex, pm_id__in=[pm.id for pm in pms])
         return await self.ex_client.ads(coinex.exid, curex.exid, is_sell, [pmex.exid for pmex in pmexs])
 
     def online_ads(self) -> str:
@@ -362,43 +364,56 @@ class AgentClient(BaseAgentClient):  # Bybit client
         coin: models.Coin,
         cur: models.Cur,
         is_sell: bool,
-        pms: list[models.Pm],
+        pms: dict[models.Pmex, models.CredEx],
         amount: float,
         ceil: float,
         place: int = 1,
     ):
-        k = (-1) ** int(is_sell)
-        pays: list[str] = []
+        k = (-1) ** int(is_sell)  # on_buy=1, on_sell=-1
         while self.actor.person.user.status > 0:
-            ads: list[Ad] = await self.ads(coin, cur, is_sell, pms)
+            ads: list[Ad] = await self.ads(coin, cur, is_sell, list(pms.keys()))
             idiot_maker_filter(ads, ceil, k)
             cur_plc = [i for i, ad in enumerate(ads) if int(ad.accountId) == self.actor.exid][0]
-            if cur_plc > place:
-                cad: Ad = ads[place]
-                mad: Ad = ads.pop(cur_plc)
-                if not pays:  # cached
-                    pays += await models.CredEx.filter(
-                        cred__pmcur__pm__pmexs__exid__in=mad.payments, cred__pmcur__pm__pmexs__ex_id=self.ex.id
-                    ).values_list("exid", flat=True)
-                cprice = float(cad.price)
-                if (cprice - ceil) * k > 0:
-                    rprice = cprice
-                else:
-                    rprice = float(ads[cur_plc].price)
-                step = 0.01 if cad.recentExecuteRate > mad.recentExecuteRate else 0
-                mew_price = str(round(rprice - k * step, cur.scale))
-                if mad.price == mew_price:
-                    print(end="V" if is_sell else "A", flush=True)
-                    await sleep(2)
-                    continue
-                mad.price = mew_price
-                mad.quantity = str(floor(amount))
-                req = AdUpdateRequest.model_validate({**mad.model_dump(), "paymentIds": [str(p) for p in pays]})
-                _res = self.ad_upd(req)
-                print("-" if is_sell else "+", end=req.price, flush=True)
-            else:
+            mad: Ad = ads.pop(cur_plc)
+            # чью цену будем обгонять, предыдущей или слещующей объявы?
+            cad: Ad = ads[place] if cur_plc > place else ads[cur_plc]
+            # а цена обгоняемой объявы не выше нашего потолка?
+            if (float(cad.price) - ceil) * k < 0:
+                # тогда берем следующую
+                cad = ads[cur_plc]
+            cprice = float(cad.price)
+            new_price = round(cprice - k * step(mad, cad), cur.scale)
+            if mad.price == f"%.{cur.scale}f" % new_price:
                 print(end="v" if is_sell else "^", flush=True)
-            await sleep(3)
+                await sleep(2)
+                continue
+            if cad.priceType:  # Если цена конкурента плавающая, то повышаем себе не цену, а %
+                mad.premium = str(round(float(cad.premium) - k * step(mad, cad), 2))
+            mad.priceType = cad.priceType
+            mad.price = str(new_price)
+            mad.quantity = str(round(amount, coin.scale))
+            mad.maxAmount = str(2_000_000)
+            req = AdUpdateRequest.model_validate(
+                {**mad.model_dump(), "paymentIds": [str(p.exid) for p in pms.values()]}
+            )
+            try:
+                _res = self.ad_upd(req)
+            except FailedRequestError:
+                # logging.error(e.message)
+                await sleep(51)
+            except (ReadTimeoutError, ConnectionDoesNotExistError):
+                logging.warning("Connection failed. Restarting..")
+            print("-" if is_sell else "+", end=req.price, flush=True)
+            await sleep(40)
+
+
+def step(mad, cad) -> float:
+    return (
+        0.01
+        if cad.recentExecuteRate > mad.recentExecuteRate
+        or (cad.recentExecuteRate == mad.recentExecuteRate and cad.recentOrderNum > mad.recentOrderNum)
+        else 0
+    )
 
 
 def idiot_maker_filter(ads: list[Ad], ceil: float, k: Literal[-1, 1]):
@@ -412,6 +427,13 @@ def listen(data: dict):
     print(data)
 
 
+async def get_creds(norms: list[str], ex_id: int) -> dict[models.Pmex, models.CredEx]:
+    return {
+        await models.Pmex.get(ex_id=ex_id, pm__norm=n): await models.CredEx.get(ex_id=ex_id, cred__pmcur__pm__norm=n)
+        for n in norms
+    }
+
+
 async def main():
     _ = await init_db(PG_DSN, models, True)
     actor = (
@@ -419,15 +441,27 @@ async def main():
     )
     cl: AgentClient = actor.client()
     # await cl.ex_client.set_pmcurexs(cookies=actor.agent.auth["cookies"])  # 607 -> 629
-    coin = await models.Coin.get(ticker="USDT")
-    cur = await models.Cur.get(ticker="RUB")
-    volet = await models.Pm.get(norm="volet")
-    asset = await models.Asset.filter(addr__actor=actor, addr__coin=coin).first()
-    asset.free - (asset.freeze or 0) - (asset.lock or 0)
+    usdt = await models.Coin.get(ticker="USDT")
+    btc = await models.Coin.get(ticker="BTC")
+    eth = await models.Coin.get(ticker="ETH")
+    rub = await models.Cur.get(ticker="RUB")
+    # await models.Direction.get(
+    #     pairex__ex=cl.ex, pairex__pair__coin__ticker="USDT", pairex__pair__cur__ticker="RUB", sell=True
+    # )
+    usdt_asset = await models.Asset.get(addr__actor=actor, addr__coin=usdt)
+    btc_asset = await models.Asset.get(addr__actor=actor, addr__coin=btc)
+    eth_asset = await models.Asset.get(addr__actor=actor, addr__coin=eth)
+    creds = await get_creds(["volet"], 9)
+    volet = await models.Fiat.get(cred_id=list(creds.values())[0].cred_id)
+    usdt_amount = usdt_asset.free - (usdt_asset.freeze or 0) - (usdt_asset.lock or 0)
+    btc_asset.free - (btc_asset.freeze or 0) - (btc_asset.lock or 0)
+    eth_asset.free - (eth_asset.freeze or 0) - (eth_asset.lock or 0)
     # await cl.set_creds()
     await gather(
-        cl.battle(coin, cur, False, [volet], 235, 86.9, 0),
-        cl.battle(coin, cur, True, [volet], 65, 82.1, 0),
+        cl.battle(usdt, rub, False, creds, usdt_amount, 85.39, 0),  # гонка в стакане покупки - мы продаем
+        cl.battle(usdt, rub, True, creds, volet.amount / 82, 82, 0),  # гонка в стакане продажи - мы покупаем
+        cl.battle(eth, rub, True, creds, volet.amount / 144_000, 144_000, 0),
+        cl.battle(btc, rub, True, creds, volet.amount / 7_600_000, 7_600_000, 0),
     )
 
     bor = BaseOrderReq(
@@ -436,12 +470,12 @@ async def main():
         fiat_amount=3000,
         amount_is_fiat=True,
         is_sell=False,
-        cur_exid=cur.ticker,
-        coin_exid=coin.ticker,
-        coin_scale=coin.scale,
+        cur_exid=rub.ticker,
+        coin_exid=usdt.ticker,
+        coin_scale=usdt.scale,
     )
     res: OrderResp = await cl.order_request(bor)
-    cl.cancel_order(res.orderId)
+    await cl.cancel_order(res.orderId)
     await cl.close()
 
 

xync_client-0.0.43.dev15/xync_client/Pms/Volet/volet.py → xync_client-0.0.43.dev17/xync_client/Pms/Volet/__init__.py

@@ -55,7 +55,7 @@ async def report(uid: int, byts: bytes, msg: str, exc: bool = True):
         raise Exception(msg)
 
 
-class VoletAgent:
+class Client:
     agent: PmAgent
     pbot: PyroClient
     page: Page
@@ -246,7 +246,7 @@ async def _test(uid: int, dest: str, amount):
     from xync_schema import models
 
     _ = await init_db(PG_DSN, models, True)
-    va = VoletAgent(uid)
+    va = Client(uid)
     try:
         await va.start(True)
         await va.send(dest, amount)

xync_client-0.0.43.dev17/xync_client/pyro.py

@@ -0,0 +1,121 @@
+from asyncio import run, sleep
+from io import BytesIO
+
+from aiogram import Bot
+from pyrogram import Client
+from pyrogram.errors import UserNotParticipant
+from pyrogram.raw.functions.messages import UploadMedia
+from pyrogram.raw.functions.photos import GetUserPhotos
+from pyrogram.raw.functions.upload import GetFile
+from pyrogram.raw.types import (
+    InputPeerSelf,
+    InputMediaUploadedDocument,
+    MessageMediaDocument,
+    InputMediaUploadedPhoto,
+    MessageMediaPhoto,
+    InputDocumentFileLocation,
+    InputPhotoFileLocation,
+)
+from pyrogram.raw.types.photos import Photos
+from pyrogram.raw.types.upload import File
+from pyrogram.types import Chat, ChatPrivileges
+from x_model import init_db
+from xync_client.loader import TG_API_ID, TG_API_HASH, PG_DSN
+from xync_schema import models
+from xync_schema.models import User
+
+
+class PyroClient:
+    max_privs = ChatPrivileges(
+        can_manage_chat=True,  # default
+        can_delete_messages=True,
+        can_delete_stories=True,  # Channels only
+        can_manage_video_chats=True,  # Groups and supergroups only
+        can_restrict_members=True,
+        can_promote_members=True,
+        can_change_info=True,
+        can_post_messages=True,  # Channels only
+        can_post_stories=True,  # Channels only
+        can_edit_messages=True,  # Channels only
+        can_edit_stories=True,  # Channels only
+        can_invite_users=True,
+        can_pin_messages=True,  # Groups and supergroups only
+        can_manage_topics=True,  # Supergroups only
+        is_anonymous=True,
+    )
+
+    def __init__(self, ub: User | Bot):
+        auth = {"bot_token": ub.token} if isinstance(ub, Bot) else {"session_string": ub.sess}
+        self.app: Client = Client(str(ub.id), TG_API_ID, TG_API_HASH, **auth, in_memory=True)
+
+    @staticmethod
+    def ref_enc(ph_id: int, access_hash: int, ref: bytes) -> bytes:
+        return ph_id.to_bytes(8, "big") + access_hash.to_bytes(8, "big", signed=True) + ref
+
+    @staticmethod
+    def ref_dec(full_ref: bytes) -> tuple[int, int, bytes]:
+        pid, ah = int.from_bytes(full_ref[:8], "big"), int.from_bytes(full_ref[8:16], "big", signed=True)
+        return pid, ah, full_ref[16:]
+
+    async def create_orders_forum(self, uid: str | int) -> tuple[int, bool]:
+        chat: Chat = await self.app.create_supergroup("Xync Orders", "Xync Orders")
+        if not (await self.app.toggle_forum_topics(chat_id=chat.id, enabled=True)):
+            await self.app.delete_channel(chat.id)
+            await chat.leave()
+            raise Exception(f"Chat {chat.id} for {self.app.me.username} not converted to forum")
+        await chat.add_members(["XyncNetBot"])  # , "xync_bot"
+        await chat.promote_member("XyncNetBot", self.max_privs)
+        added = await chat.add_members([uid])
+        try:
+            await sleep(1, await chat.get_member(uid))
+        except UserNotParticipant:
+            added = False
+        # await chat.leave()
+        return chat.id, added
+
+    async def get_user_photos(self, uid: str | int) -> Photos:
+        try:
+            peer = await self.app.resolve_peer(uid)
+        except Exception as e:
+            raise e
+        return await self.app.invoke(GetUserPhotos(user_id=peer, offset=0, limit=1, max_id=-1))
+
+    async def send_img(self, txt: str, byts: bytes, uid="me"):
+        return await self.app.send_photo(uid, BytesIO(byts), txt)
+
+    async def save_file(self, byts: bytes, ctype: str) -> tuple[MessageMediaDocument, bytes]:
+        in_file = await self.app.save_file(BytesIO(byts))
+        imud = InputMediaUploadedDocument(file=in_file, mime_type=ctype, attributes=[])
+        upf: MessageMediaDocument = await self.app.invoke(UploadMedia(peer=InputPeerSelf(), media=imud))
+        return upf, (
+            upf.document.id.to_bytes(8, "big")
+            + upf.document.access_hash.to_bytes(8, "big", signed=True)
+            + upf.document.file_reference
+        )
+
+    async def save_photo(self, file: bytes) -> tuple[MessageMediaPhoto, bytes]:
+        in_file = await self.app.save_file(BytesIO(file))
+        upm = UploadMedia(peer=InputPeerSelf(), media=InputMediaUploadedPhoto(file=in_file))
+        upp: MessageMediaPhoto = await self.app.invoke(upm)
+        return upp, self.ref_enc(upp.photo.id, upp.photo.access_hash, upp.photo.file_reference)
+
+    async def get_file(self, fid: bytes) -> File:
+        pid, ah, ref = self.ref_dec(fid)
+        loc = InputDocumentFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size="x")
+        return await self.app.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
+
+    async def get_photo(self, fid: bytes, st: str) -> File:
+        pid, ah, ref = self.ref_dec(fid)
+        loc = InputPhotoFileLocation(id=pid, access_hash=ah, file_reference=ref, thumb_size=st)
+        return await self.app.invoke(GetFile(location=loc, offset=0, limit=512 * 1024))
+
+
+async def main():
+    _ = await init_db(PG_DSN, models, True)
+    user: User = await User.filter(sess__isnull=False, status__gt=0, pm_agent__pm__norm="volet").first()
+    pcl = PyroClient(user)
+    await pcl.create_orders_forum(user.id)
+
+
+if __name__ == "__main__":
+    run(main())

{xync_client-0.0.43.dev15 → xync_client-0.0.43.dev17/xync_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-client
-Version: 0.0.43.dev15
+Version: 0.0.43.dev17
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 Project-URL: Homepage, https://gitlab.com/XyncNet/client
 Project-URL: Repository, https://gitlab.com/XyncNet/client

{xync_client-0.0.43.dev15 → xync_client-0.0.43.dev17}/xync_client.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ tests/_todo_refact/Wallet/test_ex.py
 xync_client/__init__.py
 xync_client/loader.py
 xync_client/pm_unifier.py
+xync_client/pyro.py
 xync_client.egg-info/PKG-INFO
 xync_client.egg-info/SOURCES.txt
 xync_client.egg-info/dependency_links.txt
@@ -87,8 +88,8 @@ xync_client/Mexc/etype/pm.py
 xync_client/Okx/ex.py
 xync_client/Okx/etype/ad.py
 xync_client/Okx/etype/pm.py
+xync_client/Pms/Volet/__init__.py
 xync_client/Pms/Volet/api.py
-xync_client/Pms/Volet/volet.py
 xync_client/Pms/Volet/_todo_req/req.mjs
 xync_client/Pms/Volet/_todo_req/req.py
 xync_client/TgWallet/agent.py