xync-db 0.6.1.dev1__tar.gz → 0.8.0__tar.gz

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/PKG-INFO

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

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/src/xync_db/enums.py

@@ -43,6 +43,26 @@ class W3SendStatus(IntEnum):
     done = 3
 
 
+class W3SwapStatus(IntEnum):
+    """Своп web3-монеты в фиат Xync (W3Swap, web3.md): pending — заявка, ждём монету с `frm`; received — external
+    поймал перевод (tx_hash, amount), api зачисляет фиат; done — зачислено (W3Swap.tx); manual — разбирает админ
+    (перевод без заявки или зачисление упало)."""
+
+    pending = 0
+    received = 1
+    done = 2
+    manual = 3
+
+
+class ExTopUpStatus(IntEnum):
+    """Пополнение монетой внутренним переводом на бирже (ExTopUp): pending — ждём перевод на UID актора Xync;
+    done — пришёл, зачислено (ExTopUp.tx); expired — за окно ожидания перевод не нашли."""
+
+    pending = 0
+    done = 1
+    expired = 2
+
+
 class LinkType(IntEnum):
     ref = 0  # open or trusted
     request = 1  # open or personalized

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/src/xync_db/migrations/models/0001_initial.py

@@ -23,6 +23,7 @@ from xync_db.enums import (
     DepType,
     ExAction,
     ExStatus,
+    ExTopUpStatus,
     ExType,
     FileType,
     GeminiModel,
@@ -39,6 +40,7 @@ from xync_db.enums import (
     TransactionStatus,
     UserStatus,
     W3SendStatus,
+    W3SwapStatus,
 )
 
 
@@ -200,10 +202,27 @@ class Migration(migrations.Migration):
             name="Cur",
             fields=[
                 ("id", UInt1Field(generated=True, primary_key=True, unique=True, db_index=True)),
-                ("ticker", fields.CharField(unique=True, max_length=3)),
+                ("ticker", fields.CharField(unique=True, max_length=15)),
                 ("scale", UInt1Field(db_default=2)),
+                (
+                    "coin",
+                    fields.OneToOneField(
+                        "models.Coin",
+                        source_field="coin_id",
+                        null=True,
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="cur",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
             ],
-            options={"table": "cur", "app": "models", "pk_attr": "id", "table_description": "Fiat currencies"},
+            options={
+                "table": "cur",
+                "app": "models",
+                "pk_attr": "id",
+                "table_description": "Xync ledger units: fiat currencies and coins (coin_id)",
+            },
             bases=["Model"],
         ),
         ops.CreateModel(
@@ -1951,6 +1970,7 @@ class Migration(migrations.Migration):
                 ),
                 ("contract", fields.CharField(null=True, max_length=128)),
                 ("decimals", UInt1Field()),
+                ("scanned", fields.BigIntField(null=True)),
             ],
             options={
                 "table": "coin_net",
@@ -2602,6 +2622,153 @@ class Migration(migrations.Migration):
             options={"table": "transaction", "app": "models", "pk_attr": "id"},
             bases=["Model"],
         ),
+        ops.CreateModel(
+            name="W3Swap",
+            fields=[
+                ("id", fields.IntField(generated=True, primary_key=True, unique=True, db_index=True)),
+                ("created_at", DatetimeSecField(db_default=Now(), auto_now=False, auto_now_add=True)),
+                ("updated_at", DatetimeSecField(db_default=Now(), auto_now=True, auto_now_add=False)),
+                (
+                    "user",
+                    fields.ForeignKeyField(
+                        "models.User",
+                        source_field="user_id",
+                        null=True,
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="w3_swaps",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                (
+                    "coin_net",
+                    fields.ForeignKeyField(
+                        "models.CoinNet",
+                        source_field="coin_net_id",
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="w3_swaps",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                (
+                    "cur",
+                    fields.ForeignKeyField(
+                        "models.Cur",
+                        source_field="cur_id",
+                        null=True,
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="w3_swaps",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                ("frm", fields.CharField(max_length=128)),
+                ("rate", fields.FloatField(null=True)),
+                (
+                    "status",
+                    fields.IntEnumField(
+                        description="pending: 0\nreceived: 1\ndone: 2\nmanual: 3",
+                        db_default=W3SwapStatus.pending,
+                        enum_type=W3SwapStatus,
+                        generated=False,
+                    ),
+                ),
+                ("tx_hash", fields.CharField(null=True, unique=True, max_length=128)),
+                ("amount", UInt16Field(null=True)),
+                (
+                    "tx",
+                    fields.ForeignKeyField(
+                        "models.Transaction",
+                        source_field="tx_id",
+                        null=True,
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="w3_swaps",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+            ],
+            options={
+                "table": "w3_swap",
+                "app": "models",
+                "pk_attr": "id",
+                "table_description": "Web3 coin → Xync fiat swap",
+            },
+            bases=["Model", "TsTrait"],
+        ),
+        ops.CreateModel(
+            name="ExTopUp",
+            fields=[
+                ("id", fields.IntField(generated=True, primary_key=True, unique=True, db_index=True)),
+                ("created_at", DatetimeSecField(db_default=Now(), auto_now=False, auto_now_add=True)),
+                ("updated_at", DatetimeSecField(db_default=Now(), auto_now=True, auto_now_add=False)),
+                (
+                    "user",
+                    fields.ForeignKeyField(
+                        "models.User",
+                        source_field="user_id",
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="ex_topups",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                (
+                    "actor",
+                    fields.ForeignKeyField(
+                        "models.Actor",
+                        source_field="actor_id",
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="ex_topups",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                (
+                    "cur",
+                    fields.ForeignKeyField(
+                        "models.Cur",
+                        source_field="cur_id",
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="ex_topups",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+                ("amount", UInt4Field()),
+                (
+                    "status",
+                    fields.IntEnumField(
+                        description="pending: 0\ndone: 1\nexpired: 2",
+                        db_default=ExTopUpStatus.pending,
+                        enum_type=ExTopUpStatus,
+                        generated=False,
+                    ),
+                ),
+                ("dep_id", fields.CharField(null=True, unique=True, max_length=64)),
+                ("frm", fields.CharField(null=True, max_length=64)),
+                (
+                    "tx",
+                    fields.ForeignKeyField(
+                        "models.Transaction",
+                        source_field="tx_id",
+                        null=True,
+                        db_constraint=True,
+                        to_field="id",
+                        related_name="ex_topups",
+                        on_delete=OnDelete.CASCADE,
+                    ),
+                ),
+            ],
+            options={
+                "table": "ex_topup",
+                "app": "models",
+                "pk_attr": "id",
+                "table_description": "Coin top-up by internal exchange transfer to a Xync actor",
+            },
+            bases=["Model", "TsTrait"],
+        ),
         ops.CreateModel(
             name="Sign",
             fields=[

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/src/xync_db/migrations/models/0002_triggers.py

@@ -16,6 +16,7 @@ Channels emitted:
     ads_upd / mads_upd        -- ad row changed (diff payload)
     creds_new/creds_del/creds_upd, credexs_del, credexs_orphan -- cred/credex lifecycle
     w3addr_wanted / w3addr_filled -- web3 address handshake
+    w3swap_received           -- w3_swap: монета свопа пришла (received) → api зачисляет фиат
 
 Guards (RAISE, без NOTIFY): tx_before (баланс/иммутабельность/монотонность), tx_no_delete,
 ad_exid_ex_uniq (exid уникален per-exchange), ad_cond_side_uniq/cond_txt_side_uniq (unique
@@ -475,6 +476,21 @@ $net_addr_upd$ LANGUAGE plpgsql;
 CREATE OR REPLACE TRIGGER net_addr_upd AFTER UPDATE ON "net_addr" FOR EACH ROW EXECUTE FUNCTION net_addr_upd();
 """
 
+# своп web3→фиат: external пишет пришедший перевод в заявку (status → received) — api зачисляет фиат. Каждый
+# UPDATE received-строки шлёт заново: так external рекикает потерянный NOTIFY (рестарт api), а зачисление
+# идемпотентно (claim received→done).
+W3SWAP_SQL = """
+CREATE OR REPLACE FUNCTION w3_swap_upd() RETURNS trigger AS $w3_swap_upd$
+BEGIN
+    IF NEW.status = 1 THEN
+        PERFORM pg_notify('w3swap_received', NEW.id::varchar);
+    END IF;
+    RETURN NULL;
+END
+$w3_swap_upd$ LANGUAGE plpgsql;
+CREATE OR REPLACE TRIGGER w3_swap_upd AFTER UPDATE ON "w3_swap" FOR EACH ROW EXECUTE FUNCTION w3_swap_upd();
+"""
+
 
 class Migration(BaseMigration):
     dependencies: ClassVar = [("models", "0001_initial")]
@@ -495,4 +511,5 @@ class Migration(BaseMigration):
         RunSQL(COND_SIDE_UNIQ_SQL),
         RunSQL(COND_GC_SQL),
         RunSQL(NET_ADDR_TRIGGERS_SQL),
+        RunSQL(W3SWAP_SQL),
     ]

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/src/xync_db/migrations/models/seed/c_net_seed.py

@@ -1,6 +1,6 @@
 from tortoise import BaseDBAsyncClient
 
-from xync_db.models import Coin, Net
+from xync_db.models import Coin, CoinEx, CoinNet, Cur, Net
 
 # Сети web3-модуля фронта (ChainId, см. xync-web/src/web3/types.ts) → тикер их нативной монеты.
 # `Net.name` = идентификатор сети во фронте. id=0 — домашняя сеть Xync (как Coin/Ex id=0).
@@ -17,6 +17,21 @@ NETS: list[tuple[int, str, str]] = [
     (9, "btc", "BTC"),
 ]
 
+# Токены в сетях (CoinNet, `GET /public/coin-nets`, своп web3→фиат): (тикер, сеть, контракт, decimals) — как
+# в xync-pay/src/web3/tokens.ts.
+COIN_NETS: list[tuple[str, str, str, int]] = [
+    ("USDT", "eth", "0xdAC17F958D2ee523a2206206994597C13D831ec7", 6),
+    ("USDT", "bsc", "0x55d398326f99059fF775485246999027B3197955", 18),
+    ("USDT", "polygon", "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", 6),
+    ("USDT", "arbitrum", "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", 6),
+    ("USDT", "gram", "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs", 6),
+    ("USDT", "sol", "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB", 6),
+    ("USDT", "trx", "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", 6),
+]
+
+# Монеты в книге Xync (кастодиальный баланс, Cur.coin): пополнение внутренним переводом на бирже (ExTopUp).
+LEDGER_COINS = ("USDT",)
+
 
 async def net_seed(db: BaseDBAsyncClient) -> str:
     # ARB/BASE/POL (нативные токены arbitrum/base/polygon, 18 decimals) не заводятся в
@@ -31,4 +46,14 @@ async def net_seed(db: BaseDBAsyncClient) -> str:
     coins = dict(await Coin.all().values_list("ticker", "id"))
     for nid, name, ticker in NETS:
         await Net.update_or_create({"name": name, "native_coin_id": coins[ticker]}, id=nid)
+    nets = dict(await Net.all().values_list("name", "id"))
+    for ticker, net, contract, decimals in COIN_NETS:
+        await CoinNet.update_or_create(
+            {"contract": contract, "decimals": decimals}, coin_id=coins[ticker], net_id=nets[net]
+        )
+    for ticker in LEDGER_COINS:  # scale = CoinEx(ex_id=0): сырые суммы книги и Asset ex0 в одних единицах
+        if not await Cur.exists(coin_id=coins[ticker]):
+            scale = (await CoinEx.get(coin_id=coins[ticker], ex_id=0)).scale
+            cid = (await Cur.all().order_by("-id").first()).id + 1
+            await Cur.create(id=cid, ticker=ticker, scale=scale, coin_id=coins[ticker])
     return ""

{xync_db-0.6.1.dev1 → xync_db-0.8.0}/src/xync_db/models/__init__.py

@@ -81,6 +81,7 @@ from xync_db.enums import (
     DepType,
     ExAction,
     ExStatus,
+    ExTopUpStatus,
     ExType,
     GeminiModel,
     GeminiRes,
@@ -97,6 +98,7 @@ from xync_db.enums import (
     TaskType,
     UserStatus,
     W3SendStatus,
+    W3SwapStatus,
 )
 from xync_db.enums import (
     TransactionStatus as TS,
@@ -135,9 +137,13 @@ class City(Model):
 
 
 class Cur(Model):
+    """Единица книги Xync (`Transaction.cur`, 1 байт в pack): фиат, а с `coin` — монета (её кастодиальный баланс)."""
+
     id = UInt1Field(True)
-    ticker: str = CharField(3, unique=True)
+    ticker: str = CharField(15, unique=True)
     scale: int = UInt1Field(db_default=2)
+    coin: OneToOneNullableRelation[Coin] = OneToOneField("models.Coin", "cur", on_update=CASCADE, null=True)
+    coin_id: int | None
 
     def real(self, amount: int) -> float:
         """Скейленый int в этой валюте (/10^scale) → реальное значение — на отдачу юзеру."""
@@ -153,7 +159,7 @@ class Cur(Model):
     _name: ClassVar = {"ticker"}
 
     class Meta:
-        table_description = "Fiat currencies"
+        table_description = "Xync ledger units: fiat currencies and coins (coin_id)"
 
 
 class Coin(Model):
@@ -201,6 +207,9 @@ class CoinNet(Model):
     net_id: int
     contract: str | None = CharField(128, null=True)
     decimals: int = UInt1Field()
+    # курсор скана входящих на адрес Xync (W3Swap): блок (EVM) / мс (trx) / unix-время (gram) / слот (sol);
+    # None — ещё не сканировали (первый скан ставит «сейчас»)
+    scanned: int | None = BigIntField(null=True)
 
     class Meta:
         table = "coin_net"
@@ -373,6 +382,89 @@ class W3Send(Model, TsTrait):
         table_description = "Outbound web3 send (NetAddr → NetAddr)"
 
 
+class W3Swap(Model, TsTrait):
+    """Своп web3-монеты в фиат Xync (web3.md): юзер шлёт токен `coin_net` с адреса `frm` на адрес Xync этой сети
+    (NetAddr user#0); external ловит входящий перевод (`tx_hash`, `amount` → received), api зачисляет `cur` от
+    user#0 по курсу `W3Swap.rates()` (курса нет — по котировке заявки `rate`) → done, `tx`. Перевод без заявки —
+    строка без user/cur со статусом manual (разбирает админ)."""
+
+    user: ForeignKeyNullableRelation[User] = ForeignKeyField("models.User", "w3_swaps", on_update=CASCADE, null=True)
+    user_id: int | None
+    coin_net: ForeignKeyRelation[CoinNet] = ForeignKeyField("models.CoinNet", "w3_swaps", on_update=CASCADE)
+    coin_net_id: int
+    cur: ForeignKeyNullableRelation[Cur] = ForeignKeyField("models.Cur", "w3_swaps", on_update=CASCADE, null=True)
+    cur_id: int | None
+    frm: str = CharField(128)  # адрес отправителя, нормализованный (common.chains.norm)
+    rate: float | None = FloatField(null=True)  # котировка при заявке: сколько cur за 1 монету
+    status: W3SwapStatus = IntEnumField(W3SwapStatus, db_default=W3SwapStatus.pending)
+    tx_hash: str | None = CharField(128, unique=True, null=True)
+    amount: int | None = UInt16Field(null=True)  # пришло on-chain, /10^coin_net.decimals (у BSC-USDT 18 знаков)
+    tx: ForeignKeyNullableRelation[Transaction] = ForeignKeyField(
+        "models.Transaction", "w3_swaps", on_update=CASCADE, null=True
+    )
+    tx_id: UUID | None
+
+    class Meta:
+        table = "w3_swap"
+        table_description = "Web3 coin → Xync fiat swap"
+
+    @staticmethod
+    async def rates() -> dict[tuple[int, int], float]:
+        """{(coin_id, cur_id): сколько cur за 1 монету} — курс свопа монеты в фиат по активным hot-объявам (как их
+        видит тейкер), без оглядки на лимиты и объёмы: есть покупные — самая дорогая; нет — зеркало самой дешёвой
+        продажной: цена, которую ads_fresh дал бы покупной объяве её слота (`mid·price_k`). Нет объяв — нет свопа."""
+        mads = await MyAd.hot_mads_query([]).exclude(Q(hex__isnull=True, ad__maker__ex_id__in=SHARE_HEX_EX_IDS))
+        curexs = {
+            (cx.ex_id, cx.cur_id): cx
+            for cx in await CurEx.filter(
+                ex_id__in={m.ad.maker.ex_id for m in mads}, cur_id__in={m.ad.pair_side.pair.cur_id for m in mads}
+            ).prefetch_related("cur")
+        }
+        rates: dict[tuple[int, int], float] = {}  # сначала — лучшие покупные
+        sells: dict[tuple[int, int], tuple[float, MyAd, tuple[int, int]]] = {}  # лучшая продажная + её слот
+        for m in mads:
+            pair = m.ad.pair_side.pair
+            cx = curexs[(m.ad.maker.ex_id, pair.cur_id)]
+            key, price = (pair.coin_id, pair.cur_id), m.ad.price * 10**-cx.scale
+            if not m.ad.pair_side.is_sell:
+                rates[key] = max(rates.get(key, 0), price)
+            elif (slot := Ad.slot_of(m.ad.min_fiat, m.ad.filtered, cx.minimum)) and (
+                key not in sells or price < sells[key][0]
+            ):
+                sells[key] = price, m, slot
+        for key, (_, m, (k_min, fltrd)) in sells.items():
+            if key not in rates:
+                ticker = curexs[(m.ad.maker.ex_id, key[1])].cur.ticker
+                k = m.ad.maker.ex.agent_cls().price_k(k_min, bool(fltrd), False, ticker)
+                rates[key] = m.ad.pair_side.pair.real() * k
+        return rates
+
+
+class ExTopUp(Model, TsTrait):
+    """Пополнение монетой внутренним переводом на бирже: юзер шлёт ровно `amount` монеты `cur.coin` на UID актора
+    Xync `actor`; api поллит его входящие внутренние депозиты (`AgentClient.internal_deposits`) и на совпадении суммы
+    зачисляет её в книгу от user#0 → done (`dep_id` — id депозита на бирже, `frm` — UID отправителя, `tx`)."""
+
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "ex_topups", on_update=CASCADE)
+    user_id: int
+    actor: ForeignKeyRelation[Actor] = ForeignKeyField("models.Actor", "ex_topups", on_update=CASCADE)
+    actor_id: int
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "ex_topups", on_update=CASCADE)  # монетный (coin)
+    cur_id: int
+    amount: int = UInt4Field()  # /10^cur.scale
+    status: ExTopUpStatus = IntEnumField(ExTopUpStatus, db_default=ExTopUpStatus.pending)
+    dep_id: str | None = CharField(64, unique=True, null=True)
+    frm: str | None = CharField(64, null=True)
+    tx: ForeignKeyNullableRelation[Transaction] = ForeignKeyField(
+        "models.Transaction", "ex_topups", on_update=CASCADE, null=True
+    )
+    tx_id: UUID | None
+
+    class Meta:
+        table = "ex_topup"
+        table_description = "Coin top-up by internal exchange transfer to a Xync actor"
+
+
 class PairEx(Model, TsTrait):
     pair: ForeignKeyRelation[Pair] = ForeignKeyField("models.Pair", "pairexs", on_update=CASCADE)
     pair_id: int
@@ -547,37 +639,40 @@ class User(TgUser, TsTrait):
     async def balance_sum(self) -> int:
         return int(await self.free_assets()) + int(await self.fiats_sum())
 
-    async def balances(self, ctd: bool = True) -> dict[int, int | float]:  # ctd - convert to decimal
-        scales: dict[int, int] = {1: 2, 2: 2, 3: 2}
+    async def balances(self, ctd: bool = True, coins: bool = False) -> dict[int, int | float]:  # ctd - to decimal
+        """{cur_id: баланс} по фиату книги; coins → {coin_id: баланс} по монетным Cur (Cur.coin)."""
+        scales: dict[int, int] = {} if coins else {1: 2, 2: 2, 3: 2}
+        key, flt = ("cur__coin_id" if coins else "cur_id"), {"cur__coin_id__isnull": not coins}
 
         def grab(rows):
             scales.update({c: s for c, _, s in rows})
             return {c: v for c, v, _ in rows}
 
-        dbt = {1: 0, 2: 0, 3: 0} | grab(
-            await Transaction.filter(receiver=self, status=TS.verified)
-            .group_by("cur_id", "cur__scale")
+        dbt = ({} if coins else {1: 0, 2: 0, 3: 0}) | grab(
+            await Transaction.filter(receiver=self, status=TS.verified, **flt)
+            .group_by(key, "cur__scale")
             .annotate(debit=Sum("amount"))
-            .values_list("cur_id", "debit", "cur__scale")
+            .values_list(key, "debit", "cur__scale")
         )
         crd = grab(
-            await Transaction.filter(sender=self, status__gte=TS.signed)
-            .group_by("cur_id", "cur__scale")
+            await Transaction.filter(sender=self, status__gte=TS.signed, **flt)
+            .group_by(key, "cur__scale")
             .annotate(credit=Sum("amount"))
-            .values_list("cur_id", "credit", "cur__scale")
+            .values_list(key, "credit", "cur__scale")
         )
         top = grab(
-            await TopUp.filter(user=self, completed_at__isnull=False)
-            .group_by("cur_id", "cur__scale")
+            await TopUp.filter(user=self, completed_at__isnull=False, **flt)
+            .group_by(key, "cur__scale")
             .annotate(topup=Sum("amount"))
-            .values_list("cur_id", "topup", "cur__scale")
+            .values_list(key, "topup", "cur__scale")
         )
         raw = {c: dbt.get(c, 0) - crd.get(c, 0) + top.get(c, 0) for c in dbt.keys() | crd.keys() | top.keys()}
         return {c: round(v * 10 ** -scales[c], scales[c]) for c, v in raw.items()} if ctd else raw
 
     async def coin_balances(self, ctd: bool = True) -> dict[int, int | float]:  # ctd - convert to decimal
         """Плоский {coin_id: amount} — суммарный ВНУТРЕННИЙ (ex_id=0) баланс юзера по каждой монете:
-        person → actors(ex_id=0) → addr → assets, суммируя Asset.free. ctd → /10^CoinEx(ex_id=0).scale."""
+        person → actors(ex_id=0) → addr → assets, суммируя Asset.free, плюс книга (монетные Cur, их scale =
+        CoinEx(ex_id=0).scale). ctd → /10^CoinEx(ex_id=0).scale."""
         rows = (
             await Asset.filter(addr__actor__person__user_id=self.id, addr__actor__ex_id=0)
             .group_by("addr__coin_id")
@@ -585,6 +680,8 @@ class User(TgUser, TsTrait):
             .values_list("addr__coin_id", "total")
         )
         raw = {coin_id: total for coin_id, total in rows}
+        for coin_id, amount in (await self.balances(False, coins=True)).items():
+            raw[coin_id] = raw.get(coin_id, 0) + amount
         if not ctd:
             return raw
         scales = dict(await CoinEx.filter(ex_id=0).values_list("coin_id", "scale"))