xync-db 0.5.2__tar.gz → 0.5.3__tar.gz

{xync_db-0.5.2 → xync_db-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-db
-Version: 0.5.2
+Version: 0.5.3
 Summary: Xync DB schema: Tortoise ORM models, enums, pydantic DTOs.
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: LicenseRef-EULA

xync_db-0.5.3/src/xync_db/migrations/models/0011_pair_scale.py

@@ -0,0 +1,45 @@
+"""`Pair.rate` переезжает с фиксированного cur.scale на индивидуальный масштаб пары.
+
+Было: rate = real * 10^cur.scale — точность курса зашита в масштаб валюты (у BTC/RUB хвост
+из незначащих знаков, у дешёвых монет точности не хватает). Стало: rate — 20-битная мантисса,
+новая колонка `scale` — 4-битная (−8..7) степень десятки: real = rate / 10^scale. Пишется
+единственной точкой квантования `xync_db.shared.best_scale`; читается `Pair.real()`.
+
+Бэкфилл переводит существующие строки в новое представление без изменения реального значения
+(с точностью до 20-битной мантиссы ≈ 6 значащих цифр) — та же математика, что в best_scale.
+"""
+
+from typing import ClassVar
+
+from tortoise.migrations.migration import Migration as BaseMigration
+from tortoise.migrations.operations import RunSQL
+
+PAIR_SCALE_SQL = """
+ALTER TABLE "pair" ADD COLUMN "scale" SMALLINT NOT NULL DEFAULT 0;
+COMMENT ON COLUMN "pair"."rate" IS '20-bit мантисса курса: real = rate / 10^scale (пишется через best_scale)';
+COMMENT ON COLUMN "pair"."scale" IS '4-bit (-8..7) степень десятки мантиссы rate';
+UPDATE "pair" p
+SET "scale" = q."s", "rate" = round(q."rr" * power(10, q."s"))::bigint
+FROM (
+    SELECT p2."id",
+           p2."rate" / power(10, c."scale") AS "rr",
+           GREATEST(-8, LEAST(7, floor(log((1048575 / (p2."rate" / power(10, c."scale")))::numeric))))::smallint AS "s"
+    FROM "pair" p2 JOIN "cur" c ON c."id" = p2."cur_id"
+    WHERE p2."rate" IS NOT NULL AND p2."rate" > 0
+) q
+WHERE p."id" = q."id";
+ALTER TABLE "pair" ALTER COLUMN "rate" TYPE INT USING "rate"::int;
+"""
+
+PAIR_SCALE_SQL_DOWN = """
+ALTER TABLE "pair" ALTER COLUMN "rate" TYPE BIGINT USING "rate"::bigint;
+UPDATE "pair" p SET "rate" = round(p."rate" * power(10, c."scale" - p."scale"))::bigint
+FROM "cur" c WHERE c."id" = p."cur_id" AND p."rate" IS NOT NULL;
+ALTER TABLE "pair" DROP COLUMN "scale";
+COMMENT ON COLUMN "pair"."rate" IS NULL;
+"""
+
+
+class Migration(BaseMigration):
+    dependencies: ClassVar = [("models", "0010_updatestate_fix")]
+    operations: ClassVar = [RunSQL(PAIR_SCALE_SQL, PAIR_SCALE_SQL_DOWN)]

{xync_db-0.5.2 → xync_db-0.5.3}/src/xync_db/models/__init__.py

@@ -275,11 +275,18 @@ class CoinEx(BaseModel):
 class Pair(Model):
     id = SmallIntField(True)
     coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "pairs", on_update=CASCADE)
+    coin_id: int
     cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "pairs", on_update=CASCADE)
-    rate: int | None = BigIntField(null=True)
+    cur_id: int
+    rate: int | None = IntField(null=True)  # 20-битная мантисса курса (пишется ТОЛЬКО через best_scale)
+    scale: int = SmallIntField(default=0)  # 4-битная (−8..7) степень десятки мантиссы — своя у каждой пары
 
     _name: ClassVar = {"coin__ticker", "cur__ticker"}
 
+    def real(self) -> float:
+        """Реальный курс (цена 1 coin в cur): rate/10^scale — единственный способ читать rate."""
+        return (self.rate or 0) * 10**-self.scale
+
     class Meta:
         table_description = "Coin/Currency pairs"
         unique_together = (("coin", "cur"),)
@@ -563,15 +570,15 @@ class User(TgUser, TsTrait):
     def _assemble_rich(
         ss: dict[int, dict[int, int]],
         cur_meta: dict[int, tuple[str, int]],
-        usdt_rate: dict[int, int | None],
+        usdt_rate: dict[int, float | None],
         coins_by_user: dict[int, dict[int, dict]],
         names: dict[int, tuple[str, str | None]],
     ) -> list[dict]:
         # Pure assembly for `rich_list` (no DB) — kept separate so the ranking logic is unit-testable.
         #   ss:            {uid: {cur_id: raw}}  raw = amount * 10^cur.scale  (XyncPay fiat balances)
         #   cur_meta:      {cur_id: (ticker, scale)}
-        #   usdt_rate:     {cur_id: Pair(USDT, cur).rate}  rate = price_of_1_USDT_in_cur * 10^cur.scale
-        #                  ⇒ usdt_value = raw / rate  (the cur.scale factors cancel)
+        #   usdt_rate:     {cur_id: Pair(USDT, cur).real()}  real price of 1 USDT in cur
+        #                  ⇒ usdt_value = (raw / 10^cur.scale) / rate
         #   coins_by_user: {uid: {coin_id: {"ticker", "amount", "rate"}}}  amount already in whole coins
         #   names:         {uid: (display_name, "@handle" | None)}
         out: list[dict] = []
@@ -583,13 +590,13 @@ class User(TgUser, TsTrait):
                 if cid not in cur_meta:
                     continue
                 ticker, scale = cur_meta[cid]
-                rate = usdt_rate.get(cid) or 0
+                rate = usdt_rate.get(cid) or 0.0
                 curs.append(
                     {
                         "id": cid,
                         "ticker": ticker,
                         "amount": round(raw / 10**scale, scale),
-                        "usdt": raw / rate if rate else 0.0,
+                        "usdt": raw / 10**scale / rate if rate else 0.0,
                     }
                 )
             curs.sort(key=lambda b: b["usdt"], reverse=True)
@@ -628,16 +635,17 @@ class User(TgUser, TsTrait):
         ss = await Transaction.snapshot()  # {uid: {cur_id: raw}}
         cur_meta = {c.id: (c.ticker, c.scale) for c in await Cur.all()}
         # All rates live in Pair (Coin.rate is unpopulated). USDT = coin 1 is the base unit.
-        #   usdt_rate[cur] = Pair(USDT, cur).rate  → fiat value: raw / usdt_rate[cur]
-        #   coin_price[coin] = price of 1 coin in USDT = Pair(coin, X).rate / Pair(USDT, X).rate
-        #     for any cur X priced in both (the cur.scale cancels); first such X wins.
-        pairs = await Pair.all().values("coin_id", "cur_id", "rate")
-        usdt_rate = {p["cur_id"]: p["rate"] for p in pairs if p["coin_id"] == 1 and p["rate"]}
+        # Pair.real() — реальный курс (мантисса rate / 10^индивидуальный pair.scale):
+        #   usdt_rate[cur] = Pair(USDT, cur).real()  → fiat value: real_amount / usdt_rate[cur]
+        #   coin_price[coin] = price of 1 coin in USDT = Pair(coin, X).real() / Pair(USDT, X).real()
+        #     for any cur X priced in both; first such X wins.
+        pairs = await Pair.all()
+        usdt_rate = {p.cur_id: p.real() for p in pairs if p.coin_id == 1 and p.rate}
         coin_price: dict[int, float] = {1: 1.0}
         for p in pairs:
-            if p["coin_id"] == 1 or not p["rate"] or p["cur_id"] not in usdt_rate:
+            if p.coin_id == 1 or not p.rate or p.cur_id not in usdt_rate:
                 continue
-            coin_price.setdefault(p["coin_id"], p["rate"] / usdt_rate[p["cur_id"]])
+            coin_price.setdefault(p.coin_id, p.real() / usdt_rate[p.cur_id])
         # Asset.free is scaled per-exchange (/10^coinex.scale), so normalise each row before summing.
         cx_scale = {
             (r["ex_id"], r["coin_id"]): r["scale"] for r in await CoinEx.all().values("ex_id", "coin_id", "scale")
@@ -2206,9 +2214,10 @@ class Order(Model, TsTrait):
 
             # партнерские отчисления:
             if self.ad.maker.person.user.status == UserStatus.HOT_PARTNER:
-                # спред-заработок мейкера = |сумма ордера − та же сумма по мид-курсу| (всё уже в cur.scale)
+                # спред-заработок мейкера = |сумма ордера − та же сумма по мид-курсу|: amount в cur.scale,
+                # мид-курс — реальный Pair.real() → в cur.scale домножением на 10^cur.scale
                 qty = pair.coin.real(await excl.coin_e2x(pair.coin_id, self.quantity))
-                earn = abs(amount - pair.rate * qty)
+                earn = abs(amount - pair.real() * qty * 10**pair.cur.scale)
                 fee = int(earn * (0.7 - self.ad.maker.person.user.bonus * 0.0001))  # 1% = 100
                 b = await self.ad.maker.person.user.balance(pair.cur_id)
                 if b < fee + (0 if self.ad.pair_side.is_sell else amount):

{xync_db-0.5.2 → xync_db-0.5.3}/src/xync_db/shared.py

@@ -1,4 +1,5 @@
 from io import BytesIO
+from math import floor, log10
 from pathlib import Path
 from struct import pack, unpack
 
@@ -110,3 +111,20 @@ def obj_pop(obj, name, default=None):
 
 def k_space_sep(n: int) -> str:
     return f"{n:,}".replace(",", " ")
+
+
+def int_range(bits: int) -> tuple[int, int]:
+    if bits < 1:
+        raise ValueError("bits must be >= 1")
+    return -(1 << (bits - 1)), (1 << (bits - 1)) - 1
+
+
+def best_scale(price: float, mantissa_uint_bits: int = 20, exp_int_bits: int = 4) -> tuple[int, int]:
+    """(мантисса, степень) для цены: price ≈ мантисса / 10^степень, мантисса максимально
+    точная в mantissa_uint_bits битах, степень знаковая в exp_int_bits битах (Pair.rate/scale)."""
+    max_mantissa = (1 << mantissa_uint_bits) - 1  # for 20 is: 1048575
+    if price <= 0:
+        raise ValueError("price must be > 0")
+    mn, mx = int_range(exp_int_bits)
+    scale = max(mn, min(mx, floor(log10(max_mantissa / price))))
+    return round(price * 10**scale), scale