xync-db 0.0.2.dev2__py3-none-any.whl

xync_db/models/__init__.py

@@ -0,0 +1,1781 @@
+from __future__ import annotations
+import logging
+import struct
+import sys
+from time import time
+from uuid import UUID
+from datetime import datetime
+from decimal import Decimal
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+
+from tortoise.fields import (
+    SmallIntField,
+    BigIntField,
+    CharField,
+    BooleanField,
+    IntEnumField,
+    FloatField,
+    JSONField,
+    ForeignKeyField,
+    OneToOneField,
+    ManyToManyField,
+    ForeignKeyRelation,
+    OneToOneRelation,
+    ForeignKeyNullableRelation,
+    OneToOneNullableRelation,
+    ManyToManyRelation,
+    UUIDField,
+    CASCADE,
+    BinaryField,
+    IntField,
+)
+from tortoise.fields.relational import BackwardFKRelation, BackwardOneToOneRelation
+from tortoise.functions import Sum
+from tortoise import Model as BaseModel, BaseDBAsyncClient, connections
+from tortoise.signals import pre_save
+from tortoise.timezone import now
+
+# noinspection PyUnresolvedReferences
+from x_auth.models import (
+    Model,
+    Username as Username,
+    User as TgUser,
+    Proxy as Proxy,
+    Dc as Dc,
+    Fcm as Fcm,
+    App as App,
+    Session as Session,
+    Peer as Peer,
+    UpdateState as UpdateState,
+    Version as Version,
+    Country as BaseCountry,
+)
+from x_model.field import UInt1Field, UInt2Field, UInt4Field, UInt8Field, UniqBinaryField, DatetimeSecField
+from x_model.models import TsTrait
+
+from xync_db.enums import (
+    ExType,
+    AdStatus,
+    OrderStatus,
+    ExAction,
+    ExStatus,
+    PersonStatus,
+    UserStatus,
+    PmType,
+    FileType,
+    AddrExType,
+    DepType,
+    Party,
+    Slip,
+    SynonymType,
+    AbuserType,
+    Boundary,
+    SbpStrict,
+    HotStatus,
+    TaskType,
+    TransactionStatus as TS,
+    OrderErr,
+    LinkType,
+    CoinType,
+)
+from xync_db.exceptions import RaiseError, PgRaiseError
+from xync_db.shared import qr_gen, typ_ts_pack
+from xync_db.typs import OrderResult
+from xync_db.typs.db import AdNewFlatRaw
+
+
+class Country(BaseCountry):
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "countries", on_update=CASCADE)
+    curexs: ManyToManyRelation[CurEx]
+    forbidden_exs: ManyToManyRelation[Ex]
+    fiats: BackwardFKRelation[Fiat]
+
+
+class Cur(Model):
+    id = UInt1Field(True)
+    ticker: str = CharField(3, unique=True)
+    scale: int = UInt1Field(default=2)
+
+    pms: ManyToManyRelation[Pm] = ManyToManyField("models.Pm", "pmcur", on_update=CASCADE)
+    exs: ManyToManyRelation[Ex] = ManyToManyField("models.Ex", "curex", on_update=CASCADE)
+    pairs: BackwardFKRelation[Pair]
+    countries: BackwardFKRelation[Country]
+    synonyms: ManyToManyRelation[Synonym]
+
+    _name = {"ticker"}
+
+    class Meta:
+        table_description = "Fiat currencies"
+
+
+class Coin(Model):
+    id: int = SmallIntField(True)
+    ticker: str = CharField(15, unique=True)
+    rate: float | None = FloatField(default=0)
+    is_fiat: bool = BooleanField(default=False)
+    scale: int = UInt1Field()
+    typ: CoinType = IntEnumField(CoinType, default=CoinType.normal)
+    exs: ManyToManyRelation[Ex] = ManyToManyField("models.Ex", "coinex", on_update=CASCADE)
+
+    assets: BackwardFKRelation[Asset]
+    nets: BackwardFKRelation[Net]
+    pairs: BackwardFKRelation[Pair]
+    # deps: BackwardFKRelation[Dep]
+    # deps_reward: BackwardFKRelation[Dep]
+    # deps_bonus: ReverseRelation[Dep]
+
+    _name = {"ticker"}
+
+
+class Net(Model):
+    id: int = UInt1Field(True)
+    name: str = CharField(63)
+    native_coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "nets", on_update=CASCADE)
+    native_coin_id: int
+
+
+class Ex(Model):
+    id: int = UInt1Field(True)
+    name: str = CharField(31)
+    host: str | None = CharField(63, null=True, description="With no protocol 'https://'")
+    host_p2p: str | None = CharField(63, null=True, description="With no protocol 'https://'")
+    url_login: str | None = CharField(63, null=True, description="With no protocol 'https://'")
+    typ: ExType = IntEnumField(ExType)
+    status: ExStatus = IntEnumField(ExStatus, default=ExStatus.plan)
+    logo: str = CharField(511, default="")
+
+    ads: ManyToManyRelation[Ad]
+    pms: ManyToManyRelation[Pm]
+    curs: ManyToManyRelation[Cur]
+    # pmcurs: ManyToManyRelation[PmCur] = ManyToManyField("models.PmCur", through="pmcurex")
+    coins: ManyToManyRelation[Coin]
+    forbidden_countries: ManyToManyRelation[Country] = ManyToManyField(
+        "models.Country", related_name="forbidden_exs", on_update=CASCADE
+    )
+
+    actors: BackwardFKRelation[Actor]
+    pmexs: BackwardFKRelation[PmEx]
+    pm_reps: BackwardFKRelation[PmRep]
+    pairexs: BackwardFKRelation[PairEx]
+    deps: BackwardFKRelation[Dep]
+    stats: BackwardFKRelation[ExStat]
+
+    class Meta:
+        table_description = "Exchanges"
+        unique_together = (("name", "typ"),)
+
+    class PydanticMeta(Model.PydanticMeta):
+        include = "name", "logo"
+
+    def client(self, **kwargs):
+        module_name = f"xync_client.{self.name}.ex"
+        __import__(module_name)
+        client = sys.modules[module_name].ExClient
+        return client(self, **kwargs)
+
+    def etype(self):
+        module_name = f"xync_client.{self.name}.etype"
+        __import__(module_name)
+        return sys.modules[module_name]
+
+
+class CurEx(BaseModel):
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", on_update=CASCADE)
+    cur_id: int
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", on_update=CASCADE)
+    ex_id: int
+    exid: str = CharField(32)
+    minimum: int = UInt4Field(null=True)  # /10^cur.scale
+    scale: int = UInt1Field(null=True)
+
+    # countries: ManyToManyRelation[Country] = ManyToManyField (
+    #     "models.Country", through="curex_country", backward_key="curexs"
+    # )
+
+    class Meta:
+        table_description = "Currency in Exchange"
+        unique_together = (("ex_id", "cur_id"), ("ex_id", "exid"))
+
+
+class CoinEx(BaseModel):
+    coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", on_update=CASCADE)
+    coin_id: int
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", on_update=CASCADE)
+    ex_id: int
+    minimum: int = BigIntField(null=True)  # /10^self.scale
+    scale: int = UInt1Field()
+
+    exid: str = CharField(32)
+    p2p: bool = BooleanField(default=True)
+
+    class Meta:
+        table_description = "Currency in Exchange"
+        unique_together = (("ex_id", "coin_id"), ("ex_id", "exid"))
+
+
+class Pair(Model):
+    id = SmallIntField(True)
+    coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "pairs", on_update=CASCADE)
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "pairs", on_update=CASCADE)
+    rate: int | None = BigIntField(null=True)
+
+    _name = {"coin__ticker", "cur__ticker"}
+
+    class Meta:
+        table_description = "Coin/Currency pairs"
+        unique_together = (("coin_id", "cur_id"),)
+
+
+class PairSide(Model):  # Way
+    id = SmallIntField(True)
+    pair: ForeignKeyRelation[Pair] = ForeignKeyField("models.Pair", "pair_sides", on_update=CASCADE)
+    pair_id: int
+    is_sell: bool = BooleanField()
+    rate: int | None = BigIntField(null=True)
+
+    class Meta:
+        table = "pair_side"
+        unique_together = (("pair_id", "is_sell"),)
+
+
+class NetAddr(Model):  # Way
+    net: ForeignKeyRelation[Net] = ForeignKeyField("models.Net", "net_addrs", on_update=CASCADE)
+    net_id: int
+    addr: ForeignKeyRelation[Addr] = ForeignKeyField("models.Addr", "net_addrs", on_update=CASCADE)
+    addr_id: int
+    val: str = CharField(200)
+    memo: str | None = CharField(54, null=True)
+    qr: str | None = CharField(255, null=True)
+
+    class Meta:
+        table = "net_addr"
+        unique_together = (("net_id", "addr_id"),)
+
+
+class PairEx(Model, TsTrait):  # todo: refact to PairSideEx?
+    # todo: различаются ли комиссии на buy/sell по одной паре хоть на одной бирже? если да, то переделать
+    pair: ForeignKeyRelation[Pair] = ForeignKeyField("models.Pair", "pairexs", on_update=CASCADE)
+    pair_id: int
+    fee: int = SmallIntField(default=0)  # /10_000
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "pairs", on_update=CASCADE)
+    ex_id: int
+    pair_sides: BackwardFKRelation[PairSide]
+
+    _name = {"pair__coin__ticker", "pair__cur__ticker", "ex__name"}
+
+    class Meta:
+        table_description = "Pairs on Exs"
+        unique_together = (("pair_id", "ex_id"),)
+
+
+class Person(Model, TsTrait):
+    status: PersonStatus = IntEnumField(PersonStatus, default=PersonStatus.DEFAULT)
+    name: str | None = CharField(127, null=True)
+    note: bool = CharField(255, null=True)
+    # name+user(where user is not null)=unique in raw migration!
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "persons", on_update=CASCADE, null=True)
+    user_id: int
+    creds: BackwardFKRelation[Cred]
+    actors: BackwardFKRelation[Actor]
+    pm_agents: BackwardFKRelation[PmAgent]
+
+    async def merge(self, new_person: Person):
+        """Вмерджить new_person в self: перенести акторов и креды, удалить new_person."""
+        await new_person.fetch_related("creds", "actors")
+        for cred in new_person.creds:
+            cred.person = self
+            await cred.save(update_fields=["person_id"])
+        for actor in new_person.actors:
+            actor.person = self
+            await actor.save(update_fields=["person_id"])
+        self.name = self.name or new_person.name
+        await self.save(update_fields=["name"])
+        # после переноса у new_person не должно остаться связей
+        await new_person.fetch_related("creds", "actors")
+        if not len(new_person.creds) + len(new_person.actors) and new_person.user_id in (self.user_id, None):
+            await new_person.delete()
+        else:
+            raise ValueError(
+                f"Merge to person#{self.id} failed: new person#{new_person.id} still has "
+                f"{len(new_person.creds)} creds, {len(new_person.actors)} actors, user_id={new_person.user_id}"
+            )
+
+
+class User(TgUser, TsTrait):
+    status: UserStatus = IntEnumField(UserStatus, null=True)
+    ref: ForeignKeyNullableRelation[User] = ForeignKeyField("models.User", "proteges", on_update=CASCADE, null=True)
+    ref_id: int | None
+    bonus: int = UInt2Field(default=0)
+    tz: int = SmallIntField(default=3)
+    prv: bytes = UniqBinaryField(unique=True, null=True)  # len=32
+    pub: bytes = UniqBinaryField(unique=True, null=True)  # len=32
+
+    actors: BackwardFKRelation[Actor]
+    borrows: BackwardFKRelation[Credit]
+    contacts: BackwardFKRelation[User]
+    created_forums: BackwardFKRelation[Forum]
+    creds: BackwardFKRelation[Cred]
+    gmail: BackwardOneToOneRelation[Gmail]
+    forum: BackwardOneToOneRelation[Forum]
+    hots: BackwardFKRelation[Hot]
+    investments: BackwardFKRelation[Investment]
+    invite_requests: BackwardFKRelation[Invite]
+    invite_approvals: BackwardFKRelation[Invite]
+    lends: BackwardFKRelation[Credit]
+    limits: BackwardFKRelation[Limit]
+    msgs: BackwardFKRelation[Msg]
+    persons: BackwardFKRelation[Person]
+    pm_agents: BackwardFKRelation[PmAgent]
+    proteges: BackwardFKRelation[User]
+    sends: BackwardFKRelation[Transaction]
+    receives: BackwardFKRelation[Transaction]
+    validates: BackwardFKRelation[Transaction]
+    vpn: BackwardOneToOneRelation[Vpn]
+    hot_ads: ManyToManyRelation[MyAd]
+
+    # def __init__(self, **kwargs: Any) -> None:
+    #     super().__init__(**kwargs)
+    #     self.pm_clients = {pma.pm_id: pma.client() for pma in self.pm_agents}
+    #     self.agent_clients = {a.id: a.client() for a in self.person.actor.agents}
+
+    async def free_assets(self):
+        assets = await Asset.filter(agent__actor__person__user__id=self.id).values("free", "addr__coin__rate")
+        return sum(asset["free"] * asset["addr__coin__rate"] for asset in assets)
+
+    async def fiats_sum(self):
+        fiats = await Fiat.filter(cred__person__user__id=self.id).values("amount", "cred__pmcur__cur__rate")
+        return sum(fiat["amount"] * Decimal(fiat["cred__pmcur__cur__rate"]) for fiat in fiats)
+
+    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}
+
+        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")
+            .annotate(debit=Sum("amount"))
+            .values_list("cur_id", "debit", "cur__scale")
+        )
+        crd = grab(
+            await Transaction.filter(sender=self, status__gte=TS.signed)
+            .group_by("cur_id", "cur__scale")
+            .annotate(credit=Sum("amount"))
+            .values_list("cur_id", "credit", "cur__scale")
+        )
+        top = grab(
+            await TopUp.filter(user=self, completed_at__isnull=False)
+            .group_by("cur_id", "cur__scale")
+            .annotate(topup=Sum("amount"))
+            .values_list("cur_id", "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 balance(self, cur_id: int, ts: int = None) -> int:
+        flt = dict(cur_id=cur_id)
+        if ts:
+            flt["ts__lte"] = ts
+        dbt = (
+            await Transaction.filter(receiver=self, status=TS.verified, **flt)
+            .group_by("cur_id")
+            .annotate(debit=Sum("amount"))
+            .values_list("debit", flat=True)
+        ) or [0]
+        crd = (
+            await Transaction.filter(sender_id=self.id or None, status__in=[TS.signed, TS.verified], **flt)
+            .group_by("cur_id")
+            .annotate(credit=Sum("amount"))
+            .values_list("credit", flat=True)
+        ) or [0]
+        return dbt[0] - crd[0]
+
+    def keygen(self):  # moved to front
+        prv = Ed25519PrivateKey.generate()
+        self.prv = prv.private_bytes_raw()
+        self.pub = prv.public_key().public_bytes_raw()
+
+    async def get_validator(self, amount: int, cur_id: int, receiver_id: int) -> "User":
+        r = {
+            c: v
+            for c, v in await Transaction.filter(  # todo: rm ` or receiver_id` - is hack for first trans
+                receiver_id__not_in={receiver_id, self.id or receiver_id}, status=TS.verified, cur_id=cur_id
+            )
+            .group_by("receiver_id")
+            .annotate(debit=Sum("amount"))
+            .values_list("receiver_id", "debit")
+        }
+        s = {
+            c: v
+            for c, v in await Transaction.filter(
+                sender_id__not_in={self.id, receiver_id}, status=TS.verified, cur_id=cur_id
+            )
+            .group_by("sender_id")
+            .annotate(credit=Sum("amount"))
+            .values_list("sender_id", "credit")
+            if c is not None  # todo: rm `if c is not None` - is hack
+        }
+        val_ids = r.keys() | s.keys()
+        # noinspection PyUnboundLocalVariable
+        vals = {c: am for c in val_ids if c is not None and (am := r.get(c, 0) - s.get(c, 0)) > amount}
+        val_id, _ = sorted(vals.items(), key=lambda x: x[1], reverse=True)[0]
+        if val_id is None:
+            raise ValueError("No available validators:(")
+        validator = await User[val_id]
+        return validator
+
+    async def req(self, amount: int, cur_id: int, sender_id: int = None, ts: int = None) -> Transaction:
+        return await Transaction.create(
+            receiver=self,
+            sender_id=sender_id,
+            amount=amount,
+            cur_id=cur_id,
+            status=TS.request,
+            ts=ts,
+        )
+
+    async def send(
+        self, cur_id: int, rcv_id: int, amount: int, ts: int = None, sign: bytes = None
+    ) -> Transaction | int:
+        assert sign or self.prv, "sign or user.prv is required"
+        # sender check balance himself befor send
+        if (b := await self.balance(cur_id)) < amount and self.id:
+            return b
+        # creating tx
+        tx = Transaction(
+            ts=ts or int(time()),
+            cur_id=cur_id,
+            receiver_id=rcv_id,
+            amount=amount,
+            sender=self,
+            proof=sign,
+            # status=TS.signed,
+        )
+        tx.id = UUID(bytes=tx.pack)
+        return await tx.sign(sign)
+
+    # доступные hot объявления для юзера с его текущими балансами
+    async def get_hot_ads(self, ex_ids: list[int] = None) -> tuple[list[MyAd], list[MyAd], dict[int, float]]:
+        adq = MyAd.hot_mads_query(ex_ids).filter(ad__maker__person__user_id__not=self.id)
+        bads = await adq.filter(ad__pair_side__is_sell=False)
+
+        sads = []
+        if balances := await self.balances():
+            curexs = await CurEx.filter(cur_id__in=balances.keys(), ex_id__in=[4])  # todo: fix hardcode cur mins
+            minimums = {cx.cur_id: cx.minimum for cx in curexs}
+            balances = {cur_id: b for cur_id, b in balances.items() if minimums.get(cur_id) and b >= minimums[cur_id]}
+            sads = await adq.filter(ad__pair_side__is_sell=True, ad__pair_side__pair__cur_id__in=balances.keys()).all()
+
+        return bads, sads, balances
+
+    async def get_last_hot(self, force_create: bool = False) -> Hot:
+        if not force_create and (
+            hot := await Hot.filter(status=HotStatus.opened, user=self).order_by("-updated_at").first()
+        ):
+            await hot.update_from_dict({"updated_at": now()}).save()
+            return hot
+        return await Hot.create(user=self)
+
+    def name(self):
+        return f"{self.first_name} {self.last_name}".rstrip()
+
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion = 0
+        include = "role", "status"
+        # computed = ["balance"]
+
+    def qr_invite(self, bot_nick: str) -> bytes:
+        data = f"{bot_nick and 't.me/' + bot_nick + '?startapp='}{int.from_bytes(self.id.bytes + self.proof)}"
+        # Prepare text
+        typ = ("Personalized" if self.sender_id else "Opened") if self.status == TS.request else "Receipt"
+        text = f"{typ} {self.status.name}"
+        return qr_gen(data, text)
+
+
+@pre_save(User)  # keygen for custodian users
+async def keys(_cls: type[User], user: User, _db: BaseDBAsyncClient, _updated: list[str]) -> None:
+    if not user.pub:
+        user.keygen()
+
+
+class Gmail(Model):
+    login: str = CharField(127)
+    auth: dict = JSONField(default={})
+    token: bytes = BinaryField(null=True)
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    user: OneToOneRelation[User] = OneToOneField("models.User", "gmail", on_update=CASCADE)
+
+
+class Forum(Model, TsTrait):
+    id: int = BigIntField(True)
+    joined: bool = BooleanField(default=False)
+    user: OneToOneRelation[User] = OneToOneField("models.User", "forum", on_update=CASCADE)
+    user_id: int
+    # created_by: BackwardFKRelation[User] = ForeignKeyField("models.User", "created_forums")
+
+
+class Actor(Model):
+    exid: int = UInt8Field()
+    name: str = CharField(63)
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "actors", on_update=CASCADE)
+    ex_id: int
+    person: ForeignKeyRelation[Person] = ForeignKeyField("models.Person", "actors", on_update=CASCADE)
+    person_id: int
+
+    agent: BackwardOneToOneRelation[Agent]
+    conds: BackwardFKRelation[Cond]
+    my_ads: BackwardFKRelation[Ad]
+    taken_orders: BackwardFKRelation[Order]
+
+    hots: ManyToManyRelation[Hot]
+
+    class Meta:
+        table_description = "Actors"
+        unique_together = (("ex_id", "exid"),)
+
+    async def get_credexs_by(self, pm_ids: list[int], cur_id: int) -> list[CredEx]:
+        return await CredEx.filter(
+            ex_id=self.ex_id,
+            cred__pmcur__pm_id__in=pm_ids,
+            cred__person_id=self.person_id,
+            cred__pmcur__cur_id=cur_id,
+        )
+
+    async def set_user(self, username_id: int) -> tuple[int, str, User]:
+        """Назначить актору персону юзера с username_id.
+
+        Логика мерджа персон:
+        - Если персона юзера все еще без акторов (базовая от триггера) — мерджим в неё.
+        - Если все персоны юзера заняты акторами, но имя совпадает — мерджим в ту персону.
+        - Если имена не совпадают — оставляем новую персону, и привязываем к юзеру.
+        """
+        assert isinstance(self.person, Person), "person should be fetched"
+        err, txt = 0, ""
+
+        user_persons: list[Person] = (
+            await Person.filter(user__username_id=username_id).prefetch_related("user", "actors").all()
+        )
+        if not user_persons:
+            raise ValueError(f"Не найдено персон юзера:{username_id}! Персона создаётся триггером при создании User")
+        user = user_persons[0].user
+
+        # персоне этого актора уже назначен юзер
+        if self.person.user_id:
+            if (await self.person.user).username_id == username_id:
+                txt = f"У персоны актора:{self.id} уже назначен этот юзер"
+                logging.warning(txt)
+                return 1, txt, user
+            txt = f"У персоны актора:{self.id} уже назначен другой юзер"
+            logging.error(txt)
+            return 3, txt, user
+
+        merged = False
+        for i, person in enumerate(user_persons):
+            if [a for a in person.actors if a.ex_id]:
+                # персона юзера уже занята актором(ами) — мерджим только если имена совпадают
+                if self.person.name == person.name:
+                    await person.merge(self.person)
+                    merged = True
+            elif i:
+                # у юзера >1 персоны без акторов — аномалия
+                txt = (
+                    f"У {i + 1}-й персоны #{person.id} нет акторов (юзер #{username_id}), но персон без акторов уже > 1"
+                )
+                logging.error(txt)
+                return 2, txt, user
+            else:
+                # первая персона юзера без акторов (базовая от триггера) — мерджим
+                await person.merge(self.person)
+                merged = True
+
+        if not merged:
+            # все персоны юзера заняты акторами с другими именами — оставляем новую, привязываем к юзеру
+            self.person.user = user
+            await self.person.save(update_fields=["user_id"])
+
+        txt = f"Юзер#{username_id} подтвердил что Actor#{self.id} его"
+        logging.info(txt)
+        return err, txt, user
+
+
+class Agent(Model, TsTrait):
+    auth: dict = JSONField(default={})
+    actor: OneToOneRelation[Actor] = OneToOneField("models.Actor", "agent", on_update=CASCADE)
+    actor_id: int
+    expire_at: int | None = IntField(null=True)
+    status: int = SmallIntField(default=0)
+    same_dir_ad: int = UInt1Field(default=0)
+
+    assets: BackwardFKRelation[Asset]
+
+    _name = {"actor__name"}
+
+    # def balance(self) -> int:
+    #     return sum(asset.free * (asset.coin.rate or 0) for asset in self.assets)
+
+    # class PydanticMeta(Model.PydanticMeta):
+    # max_recursion = 3
+    # include = "id", "actor__ex", "auth", "updated_at"
+    # computed = ["balance"]
+
+    def client(self, ex_cl, pm_clients=None, proxy=None):
+        module_name = f"xync_client.{self.actor.ex.name}.agent"
+        __import__(module_name)
+        client = sys.modules[module_name].AgentClient
+        return client(
+            self,
+            ex_cl,
+            pm_clients or {},
+            headers=self.auth.get("headers"),
+            cookies=self.auth.get("cookies"),
+            proxy=proxy,
+        )
+
+    async def coins_balance(self, to_float: bool = True):
+        await self.fetch_related("assets__addr")
+        scales = dict(to_float and await CoinEx.filter(ex_id=self.actor.ex_id).values_list("coin_id", "scale") or ())
+        return {a.addr.coin_id: round(a.free * 10 ** -(s := scales.get(a.addr.coin_id, 0)), s) for a in self.assets if a.free}
+
+    @classmethod
+    async def upsert(
+        cls, exid: int, host: str, auth: dict, exp: int, rname: str, nick: str, email: str
+    ) -> tuple[int, Agent]:
+        err = 0
+        if host and (ex := await Ex.get_or_none(host=host)):
+            if not (actor := await Actor.get_or_none(exid=exid, ex=ex)):  # такого актора еще нет
+                mail_tpl = email.replace("*", "_")
+                if person := await Person.get_or_none(name=rname):
+                    err = 1  # уточнить что person c таким именем действительно тот
+                # если нашелся (и не больше 1) юзер по gmail-у
+                elif (gml := await Gmail.raw(f"SELECT * FROM gmail WHERE login LIKE '{mail_tpl}'")) and len(gml) == 1:
+                    err = 2  # уточнить что почта правильная
+                    if persons := await Person.filter(user_id=gml[0].user_id).all():
+                        if len(persons) > 1:
+                            err = 3  # уточнить какой именно персон нужен этому актору
+                        person = persons[0]
+                        if person.name != rname:
+                            person.name = rname
+                            await person.save(update_fields=["name"])
+                    else:
+                        raise ValueError(f"Это как так почта {gml[0]} с юзером есть, а персоны нет!?")
+                else:  # если нет, то создаем пустой персон со статусом "определить юзера"
+                    person = await Person.create(name=rname, status=PersonStatus.USER_DEF)
+                actor = await Actor.create(ex=ex, exid=exid, name=nick, person=person)
+            if ag := await Agent.get_or_none(actor=actor):
+                ag.auth |= auth
+                ag.expire_at = exp
+                await ag.save(update_fields=["auth", "expire_at"])
+            else:
+                ag = await Agent.create(auth=auth, actor=actor, expire_at=exp)
+            return err, ag
+        raise ValueError("Wrong ex: " + host)
+
+
+class Cond(Model, TsTrait):
+    raw_txt: str = CharField(4095, unique=True)
+    last_ver: str = CharField(4095, null=True)
+
+    ads: BackwardFKRelation[Ad]
+    parsed: BackwardOneToOneRelation[CondParsed]
+    sim: BackwardOneToOneRelation[Cond]
+
+    async def sims(self):
+        return {self.raw_txt: await self.sim.sims()} if await self.sim else self.raw_txt
+
+
+class Synonym(BaseModel):
+    typ: SynonymType = IntEnumField(SynonymType, db_index=True)
+    txt: str = CharField(255, unique=True)
+    boundary: Boundary = IntEnumField(Boundary, default=Boundary.no)
+    curs: ManyToManyRelation[Cur] = ManyToManyField(
+        "models.Cur", "synonym_cur", related_name="synonyms", on_update=CASCADE
+    )
+    val: int | None = UInt2Field(null=True)  # SynonymType dependent (e.g., no-slavic for name, approx for ppo.)
+    is_re: bool = BooleanField(default=False)
+
+
+class CondSim(BaseModel):
+    cond: OneToOneRelation[Cond] = OneToOneField("models.Cond", "sim", primary_key=True, on_update=CASCADE)
+    cond_id: int  # new
+    similarity: int = UInt2Field(db_index=True)  # /1000
+    cond_rel: ForeignKeyRelation[Cond] = ForeignKeyField("models.Cond", "sims_rel", on_update=CASCADE)
+    cond_rel_id: int  # old
+
+    class Meta:
+        table = "cond_sim"
+
+
+class PmGroup(Model):
+    id: int = SmallIntField(True)
+    name: str = CharField(127)
+    pms: BackwardFKRelation[Pm]
+
+    class Meta:
+        table = "pm_group"
+
+
+class Pm(Model):
+    # name: str = CharField(63)  # mv to pmex cause it diffs on each ex
+    norm: str | None = CharField(255)
+    acronym: str | None = CharField(7, null=True)
+    country: ForeignKeyNullableRelation[Country] = ForeignKeyField(
+        "models.Country", "pms", on_update=CASCADE, null=True
+    )
+    df_cur: ForeignKeyNullableRelation[Cur] = ForeignKeyField("models.Cur", "df_pms", on_update=CASCADE, null=True)
+    grp: ForeignKeyNullableRelation[PmGroup] = ForeignKeyField("models.PmGroup", "pms", on_update=CASCADE, null=True)
+    alias: str | None = CharField(63, null=True)
+    extra: str | None = CharField(63, null=True)
+    ok: bool = BooleanField(default=True)
+    bank: bool | None = BooleanField(null=True)
+    qr: bool = BooleanField(default=False)
+    fee: int | None = UInt2Field(null=True)  # /10_000
+
+    typ: PmType | None = IntEnumField(PmType, null=True)
+
+    ads: ManyToManyRelation[Ad]
+    curs: ManyToManyRelation[Cur]
+    no_conds: ManyToManyRelation[Cond]
+    only_conds: ManyToManyRelation[Cond]
+    exs: ManyToManyRelation[Ex] = ManyToManyField("models.Ex", "pmex", on_update=CASCADE)  # no need. use pmexs[.exid]
+    conds: BackwardFKRelation[CondParsed]
+    orders: BackwardFKRelation[Order]
+    pmcurs: BackwardFKRelation[PmCur]  # no need. use curs
+    pmexs: BackwardFKRelation[PmEx]
+    agents: BackwardFKRelation[PmAgent]
+    topupable: BackwardFKRelation[TopUpAble]
+
+    class Meta:
+        table_description = "Payment methods"
+        unique_together = (("norm", "country_id"), ("alias", "country_id"))
+
+    # class PydanticMeta(Model.PydanticMeta):
+    #     max_recursion = 3
+    #     backward_relations = True
+    #     include = "id", "name", "logo", "pmexs__sbp"
+
+    # def epyd(self):
+    #     module_name = f"xync_client.{self.ex.name}.pyd"
+    #     __import__(module_name)
+    #     return sys.modules[module_name].PmEpyd
+
+
+class CondParsed(Model, TsTrait):
+    cond: OneToOneNullableRelation[Cond] = OneToOneField("models.Cond", "parsed", on_update=CASCADE, null=True)
+    cond_id: int  # new
+    to_party: Party = IntEnumField(Party, null=True)
+    from_party: Party = IntEnumField(Party, null=True)
+    ppo: int = UInt1Field(null=True)  # Payments per order
+    slip_req: Slip = IntEnumField(Slip, null=True)
+    slip_send: Slip = IntEnumField(Slip, null=True)
+    abuser: AbuserType = IntEnumField(AbuserType, default=AbuserType.no)
+    slavic: bool = BooleanField(null=True)
+    mtl_like: bool = BooleanField(null=True)
+    scale: int = SmallIntField(null=True)
+    bank_side: bool = BooleanField(null=True)  # False - except these banks, True - only this banks
+    sbp_strict: SbpStrict = IntEnumField(SbpStrict, default=SbpStrict.no)
+    contact: str | None = CharField(127, null=True)
+    done: bool = BooleanField(default=False, db_index=True)
+    banks: ManyToManyRelation[Pm] = ManyToManyField("models.Pm", "cond_banks", related_name="conds", on_update=CASCADE)
+
+    class Meta:
+        table = "cond_parsed"
+
+
+class Ad(Model, TsTrait):
+    exid: int = UInt8Field(db_index=True)  # todo: спарить уникальность с биржей, тк на разных биржах могут совпасть
+    pair_side: ForeignKeyRelation[PairSide] = ForeignKeyField("models.PairSide", "ads", on_update=CASCADE)
+    price: int = UInt4Field()  # /10^cur.scale
+    premium: int = IntField(null=True)  # /10_000
+    amount: int = UInt4Field()  # /10^cur.scale
+    quantity: int = UInt8Field(null=True)  # /10^coinex.scale
+    min_fiat: int = UInt4Field()  # /10^cur.scale
+    max_fiat: int | None = UInt4Field(null=True)  # /10^cur.scale
+    auto_msg: str | None = CharField(4095, null=True)
+    status: AdStatus = IntEnumField(AdStatus, default=AdStatus.active)
+    filtered: bool = BooleanField(default=False)
+
+    cond: ForeignKeyNullableRelation[Cond] = ForeignKeyField("models.Cond", "ads", on_update=CASCADE, null=True)
+    cond_id: int
+    maker: ForeignKeyRelation[Actor] = ForeignKeyField("models.Actor", "my_ads", on_update=CASCADE)
+    maker_id: int
+
+    pms: ManyToManyRelation[Pm] = ManyToManyField("models.Pm", "ad_pm", related_name="ads", on_update=CASCADE)
+    my_ad: BackwardOneToOneRelation[MyAd]
+    orders: BackwardFKRelation[Order]
+
+    _icon = "ad"
+    _name = {"pair_side__pairex__coin__ticker", "pair_side__pairex__cur__ticker", "pair_side__sell", "price"}
+
+    class Meta:
+        table_description = "P2P Advertisements"
+        unique_together = (("exid", "maker_id"),)
+
+    async def to_float(self, ex_id: int = None) -> Ad:
+        ex_id = ex_id or self.maker.ex_id
+        cur_scl = await CurEx.get(cur_id=self.pair_side.pair.cur_id, ex_id=ex_id).values_list('scale', flat=True)
+        coin_scl = await CoinEx.get(coin_id=self.pair_side.pair.coin_id, ex_id=ex_id).values_list('scale', flat=True)
+        cur_k = 10 ** -cur_scl
+        coin_k = 10 ** -coin_scl
+        self.amount = round(self.amount * cur_k, cur_scl)
+        self.price = round(self.price * cur_k, cur_scl)
+        self.quantity = self.quantity and round(self.quantity * coin_k, coin_scl)
+        return self
+
+    @classmethod
+    async def from_flat(cls, ad: AdNewFlatRaw, coin_scl: int = None, cur_scl: int = None) -> Ad:
+        cur_scl = cur_scl or await CurEx.get(exid=ad.curex_exid, ex_id=ad.ex_id).values_list('scale', flat=True)
+        coin_scl = coin_scl or await CoinEx.get(exid=ad.coinex_exid, ex_id=ad.ex_id).values_list('scale', flat=True)
+        cur_k = 10 ** cur_scl
+        coin_k = 10 ** coin_scl
+
+        self.amount = round(self.amount * cur_k, cur_scl)
+        self.price = round(self.price * cur_k, cur_scl)
+        self.quantity = self.quantity and round(self.quantity * coin_k, coin_scl)
+        return self
+
+    # def epyds(self) -> tuple[PydModel, PydModel, PydModel, PydModel, PydModel, PydModel]:
+    #     module_name = f"xync_client.{self.maker.ex.name}.pyd"
+    #     __import__(module_name)
+    #     return (
+    #         sys.modules[module_name].AdEpyd,
+    #         sys.modules[module_name].AdFullEpyd,
+    #         sys.modules[module_name].MyAdEpydPurchase,
+    #         sys.modules[module_name].MyAdInEpydPurchase,
+    #         sys.modules[module_name].MyAdEpydSale,
+    #         sys.modules[module_name].MyAdInEpydSale,
+    #     )
+
+
+class MyAd(Model):  # Road
+    WEB = "https://www.bybit.com/{lang}/p2p/{side}/{coin}/{cur}?share="
+    MOB = "https://app.bybit.com/inapp?by_dp=bybitapp://open/route?targetUrl=by-mini://p2p/home?share="
+
+    ad: OneToOneRelation[Ad] = OneToOneField("models.Ad", "my_ad", on_update=CASCADE)
+    ad_id: int  # new
+    target_place: int = UInt1Field(default=1)
+    hex: bytes = BinaryField(null=True)
+    shared_at: datetime | None = DatetimeSecField(null=True)
+    blocked: bool = BooleanField(default=False)
+
+    pay_req: ForeignKeyNullableRelation[PayReq] = ForeignKeyField(
+        "models.PayReq", "maked_ads", on_update=CASCADE, null=True
+    )
+    credexs: ManyToManyRelation[CredEx] = ManyToManyField(
+        "models.CredEx", through="myad_cred", related_name="my_ads", on_update=CASCADE
+    )
+    hot_users: ManyToManyRelation[User] = ManyToManyField(
+        "models.User", "myad_user", related_name="hot_ads", on_update=CASCADE
+    )
+
+    class Meta:
+        table = "my_ad"
+
+    def get_url(self, lang: str = "en-US") -> tuple[str, str]:
+        # if not self.hex:
+        #     return None
+        hx = self.hex.hex()
+        side = "buy" if self.ad.pair_side.is_sell else "sell"
+        coin, cur = self.ad.pair_side.pair.coin.ticker, self.ad.pair_side.pair.cur.ticker
+        mob_pref = self.WEB.format(lang=lang, side=side, coin=coin, cur=cur)
+        return mob_pref + hx, self.MOB + hx
+
+    @classmethod
+    # запрос для получения объяв всех агентов этой биржи для разогрева
+    def hot_mads_query(cls, ex_ids: list[int], active: bool = True):
+        fltr = dict(credexs__cred__ovr_pm_id=0, ad__maker__agent__status__gte=3)
+        if active:
+            fltr["ad__status"] = AdStatus.active
+        if ex_ids:
+            fltr["ad__maker__ex_id__in"] = ex_ids
+        return cls.filter(**fltr).prefetch_related("ad__pair_side__pair__coin", "ad__pair_side__pair__cur", "ad__maker")
+
+    @classmethod
+    #
+    def new(cls, coin_id: int, cur_id: int, min_fiat: int, is_hot: bool = False): ...
+
+
+class Hot(Model, TsTrait):
+    user: ForeignKeyNullableRelation[User] = ForeignKeyField("models.User", "hots", on_update=CASCADE)
+    user_id: int
+    status: HotStatus = IntEnumField(HotStatus, default=HotStatus.opened)
+    msg_id: int | None = IntField(null=True)
+    actors: ManyToManyRelation[Actor] = ManyToManyField("models.Actor", related_name="hots", on_update=CASCADE)
+
+    orders: BackwardFKRelation[Order]
+
+    _name = {"id"}
+
+
+class MyAdHotUser(Model):
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", on_update=CASCADE)
+    user_id: int
+    my_ad: ForeignKeyRelation[MyAd] = ForeignKeyField("models.MyAd", on_update=CASCADE)
+    my_ad_id: int
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    class Meta:
+        table = "myad_user"
+
+
+class Race(Model):
+    road: ForeignKeyRelation[MyAd] = ForeignKeyField("models.MyAd", "race", on_update=CASCADE)
+    road_id: int
+    ceil: int = UInt4Field(null=True)  # /10^cur.scale
+    target_place: int = SmallIntField(default=1)
+    vm_filter: bool = BooleanField(default=True)
+    started: bool = BooleanField(default=True)
+    filter_amount: int = UInt4Field()  # /10^cur.scale
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    stats: BackwardFKRelation[RaceStat]
+
+    # def overprice_filter(self, ads: list[BaseAd]):
+    #     ads[0]
+    #     # вырезаем ads с ценами выше потолка
+    #     if ads and (self.ceil - Decimal(ads[0].price)) * k > 0:
+    #         if int(ads[0].userId) != self.actor.exid:
+    #             ads.pop(0)
+    #             self.overprice_filter(ads, self.ceil, k)
+
+
+class RaceStat(Model):
+    race: ForeignKeyRelation[Race] = ForeignKeyField("models.Race", "stats", on_update=CASCADE)
+    race_id: int
+    rivals: ManyToManyRelation[Ad] = ManyToManyField("models.Ad", "rivals", related_name="stats", on_update=CASCADE)
+    rival_id: int
+    price: int = UInt4Field()  # /10^cur.scale
+    premium: int = SmallIntField(null=True)  # /10_000
+    place: int = UInt1Field()
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+
+    class Meta:
+        table = "race_stat"
+
+
+class PmRep(Model):
+    ex: ForeignKeyNullableRelation[Ex] = ForeignKeyField("models.Ex", "pm_reps", on_update=CASCADE, null=True)
+    ex_id: int
+    src: str | None = CharField(63, unique=True)
+    target: str | None = CharField(63)
+    used_at: datetime | None = DatetimeSecField(null=True)
+
+    class Meta:
+        table = "pm_rep"
+        # unique_together = (("src", "target"),)
+
+
+class PmAgent(Model):
+    pm: ForeignKeyRelation[Pm] = ForeignKeyField("models.Pm", "agents", on_update=CASCADE)
+    pm_id: int
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "pm_agents", on_update=CASCADE)
+    user_id: int
+    auth: dict = JSONField(default={})
+    state: dict = JSONField(default={})
+    active: bool = BooleanField(null=True, default=False)
+
+    class Meta:
+        table = "pm_agent"
+        unique_together = (("pm_id", "user_id"),)
+
+    def client(self, browser=None):
+        module_name = f"xync_client.Pms.{self.pm.norm.capitalize()}.agent"
+        __import__(module_name)
+        kwargs = {}
+        if browser:
+            kwargs["browser"] = browser
+        return sys.modules[module_name].PmAgentClient(self, **kwargs)
+
+
+class PmCur(Model):  # for fiat with no exs tie
+    pm: ForeignKeyRelation[Pm] = ForeignKeyField("models.Pm", on_update=CASCADE)
+    pm_id: int
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", on_update=CASCADE)
+    cur_id: int
+
+    creds: BackwardFKRelation[Cred]
+    sends: BackwardFKRelation[Transfer]
+    exs: ManyToManyRelation[Ex]
+
+    class Meta:
+        table_description = "Payment methods - Currencies"
+        unique_together = (("pm_id", "cur_id"),)
+
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion: int = 2  # default: 3
+        include = "cur_id", "pm"
+
+
+class PmEx(BaseModel):  # existence pm in ex with no cur tie
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "pmexs", on_update=CASCADE)
+    ex_id: int
+    pm: ForeignKeyRelation[Pm] = ForeignKeyField("models.Pm", "pmexs", on_update=CASCADE)
+    pm_id: int
+    logo: ForeignKeyNullableRelation[File] = ForeignKeyField("models.File", "pmex_logos", on_update=CASCADE, null=True)
+    logo_id: int
+    exid: str = CharField(63)
+    name: str = CharField(255)
+
+    banks: BackwardFKRelation[PmExBank]
+
+    class Meta:
+        unique_together = (("ex_id", "exid"),)  # , ("ex", "pm"), ("ex", "name")  # todo: tmp removed for HTX duplicates
+
+
+class PmExBank(BaseModel):  # banks for SBP
+    pmex: ForeignKeyRelation[PmEx] = ForeignKeyField("models.PmEx", "banks", on_update=CASCADE)
+    pmex_id: int
+    exid: str = CharField(63)
+    name: str = CharField(63)
+
+    creds: ManyToManyRelation[Cred]
+
+    class Meta:
+        table = "pmex_bank"
+        unique_together = (("pmex", "exid"),)
+
+
+# class PmCurEx(BaseModel):  # existence pm in ex for exact cur, with "blocked" flag
+#     pmcur: ForeignKeyRelation[PmCur] = ForeignKeyField("models.PmCur")
+#     pmcur_id: int
+#     ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex")
+#     ex_id: int
+#     blocked: bool = BooleanField(default=False)  # todo: move to curex or pmex?
+#
+#     # class Meta:
+#     #     unique_together = (("ex_id", "pmcur_id"),)
+
+
+class Cred(Model):
+    pmcur: ForeignKeyRelation[PmCur] = ForeignKeyField("models.PmCur", on_update=CASCADE)
+    pmcur_id: int
+    detail: str = CharField(255)
+    name: str | None = CharField(127, null=True)
+    extra: str | None = CharField(255, null=True)
+    person: ForeignKeyRelation[Person] = ForeignKeyField("models.Person", "creds")
+    person_id: int
+    from_chat: int  # todo: ForeignKeyNullableRelation[Order] = ForeignKeyField("models.Order", null=True)
+
+    ovr_pm: ForeignKeyRelation[Pm] = ForeignKeyField("models.Pm", on_update=CASCADE, null=True)
+    ovr_pm_id: int
+    banks: ManyToManyRelation[PmExBank] = ManyToManyField("models.PmExBank", related_name="creds", on_update=CASCADE)
+
+    fiat: BackwardOneToOneRelation[Fiat]
+    receives: BackwardOneToOneRelation[Transfer]
+    credexs: BackwardFKRelation[CredEx]
+    orders: BackwardFKRelation[Order]
+    pay_reqs: BackwardFKRelation[PayReq]
+
+    _name = {"detail"}
+
+    def repr(self):
+        xtr = f" ({self.extra})" if self.extra else ""
+        name = f", имя: {self.name}" if self.name else ""
+        return f"`{self.detail}`{name}{xtr}"
+
+    class Meta:
+        table_description = "Currency accounts"
+        unique_together = (("person_id", "pmcur_id", "ovr_pm_id"),)
+
+
+class CredEx(Model):
+    exid: int = UInt8Field()
+    cred: ForeignKeyRelation[Cred] = ForeignKeyField("models.Cred", "credexs", on_update=CASCADE)
+    cred_id: int
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "credexs", on_update=CASCADE)
+    ex_id: int
+
+    _name = {"exid"}
+
+    class Meta:
+        table_description = "Credential on Exchange"
+        unique_together = (("ex_id", "exid"),)
+
+
+class Fiat(Model):
+    cred: OneToOneRelation[Cred] = OneToOneField("models.Cred", "fiat", on_update=CASCADE)
+    cred_id: int
+    amount: int = UInt4Field()  # /10^cur.scale
+    target: int = UInt4Field(null=True)  # /10^cur.scale
+    min_deposit: int = UInt4Field(null=True)  # /10^cur.scale
+
+    class Meta:
+        table_description = "Currency balances"
+
+    class PydanticMeta(Model.PydanticMeta):
+        # max_recursion: int = 2
+        backward_relations = False
+        include = "id", "cred__pmcur", "cred__detail", "cred__name", "amount"
+
+    @staticmethod
+    def epyd(ex: Ex):
+        module_name = f"xync_client.{ex.name}.pyd"
+        __import__(module_name)
+        return sys.modules[module_name].FiatEpyd
+
+
+class Limit(Model):
+    pmcur: ForeignKeyRelation[PmCur] = ForeignKeyField("models.PmCur", on_update=CASCADE)
+    pmcur_id: int
+    amount: int = UInt4Field(null=True)  # '$' if unit >= 0 else 'transactions count'
+    unit: int = UInt1Field(default=30)  # positive: $/days, 0: $/transaction, negative: transactions count / days
+    # 0 - same group, 1 - to parent group, 2 - to grandparent # only for output trans, on input = None
+    level: float | None = UInt1Field(default=0, null=True)
+    income: bool = BooleanField(default=False)
+    added_by: ForeignKeyRelation[User] = ForeignKeyField("models.User", "limits", on_update=CASCADE)
+    added_by_id: int
+
+    _name = {"pmcur__pm__name", "pmcur__cur__ticker", "unit", "income", "amount"}
+
+    class Meta:
+        table_description = "Currency accounts balance"
+
+
+class Addr(Model):
+    coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "addrs", on_update=CASCADE)
+    coin_id: int
+    actor: ForeignKeyRelation[Actor] = ForeignKeyField("models.Actor", "addrs", on_update=CASCADE)
+    actor_id: int
+
+    nets: ManyToManyRelation[Net] = ManyToManyField("models.Net", "net_addr", related_name="addrs", on_update=CASCADE)
+
+    pay_reqs: BackwardFKRelation[PayReq]
+
+    _name = {"coin__ticker", "free"}
+
+    class Meta:
+        table_description = "Coin address on cex"
+        unique_together = (("coin_id", "actor_id"),)
+
+
+class Asset(Model):
+    addr: ForeignKeyRelation[Addr] = ForeignKeyField("models.Addr", "addrs", on_update=CASCADE)
+    addr_id: int
+    agent: ForeignKeyRelation[Agent] = ForeignKeyField("models.Agent", "assets", on_update=CASCADE)
+    agent_id: int
+    typ: AddrExType = IntEnumField(AddrExType, default=AddrExType.found)
+    free: int = UInt8Field()  # /10^coinex.scale
+    freeze: int | None = UInt8Field(default=0)  # /10^coinex.scale
+    lock: int | None = UInt8Field(default=0)  # /10^coinex.scale
+    target: int | None = UInt8Field(default=0, null=True)  # /10^coinex.scale
+
+    _name = {"asset__coin__ticker", "free"}
+
+    class Meta:
+        table_description = "Coin balance"
+        unique_together = (("addr_id", "agent_id", "typ"),)
+
+    def epyd(self):
+        module_name = f"xync_client.{self.agent.ex.name}.pyd"
+        __import__(module_name)
+        return sys.modules[module_name].AssetEpyd
+
+
+class PayReq(Model, TsTrait):
+    pay_until: datetime = DatetimeSecField()
+    addr: ForeignKeyNullableRelation[Addr] = ForeignKeyField("models.Addr", "pay_reqs", on_update=CASCADE, null=True)
+    addr_id: int
+    cred: ForeignKeyNullableRelation[Cred] = ForeignKeyField("models.Cred", "pay_reqs", on_update=CASCADE, null=True)
+    cred_id: int
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "pay_reqs", on_update=CASCADE)
+    user_id: int
+    amount: float = UInt4Field()
+    parts: int = UInt1Field(default=1)
+    payed_at: datetime | None = DatetimeSecField(null=True)
+
+    maked_ads: BackwardFKRelation[MyAd]
+    taken_orders: BackwardFKRelation[Order]
+
+    _icon = "pay"
+    _name = {"ad_id"}
+
+    class Meta:
+        table_description = "Payment request"
+        unique_together = (("user_id", "cred_id", "addr_id"),)
+
+
+class Order(Model, TsTrait):
+    exid: int = UInt8Field(unique=True)  # todo: спарить уникальность с биржей, тк на разных биржах могут совпасть
+    ad: ForeignKeyRelation[Ad] = ForeignKeyField("models.Ad", "orders", on_update=CASCADE)
+    ad_id: int
+    amount: int = UInt4Field()  # /10^cur.scale
+    quantity: int = UInt8Field(null=True)  # /10^coinex.scale
+    cred: ForeignKeyRelation[Cred] = ForeignKeyField("models.Cred", "orders", on_update=CASCADE, null=True)
+    cred_id: int | None
+    taker: ForeignKeyRelation[Actor] = ForeignKeyField("models.Actor", "taken_orders", on_update=CASCADE)
+    taker_id: int
+    payreq: ForeignKeyNullableRelation[PayReq] = ForeignKeyField(
+        "models.PayReq", "taken_orders", on_update=CASCADE, null=True
+    )
+    payreq_id: int
+    hot: ForeignKeyNullableRelation[Hot] = ForeignKeyField("models.Hot", "orders", on_update=CASCADE, null=True)
+    hot_id: int
+    maker_topic: int = UInt2Field(null=True)  # todo: remove nullability
+    taker_topic: int = UInt2Field(null=True)
+    status: OrderStatus = IntEnumField(OrderStatus, default=OrderStatus.created)
+    chat_parsed: bool = BooleanField(default=False)
+
+    hots: ManyToManyRelation[Hot]
+    msgs: BackwardFKRelation[Msg]
+    transfers: BackwardFKRelation[Transfer]
+
+    _name = {"cred__pmcur__pm__name"}
+
+    def ami_maker(self, actor_id: int) -> bool:
+        return self.taker_id != actor_id
+
+    async def is_it_seller(self, actor_id: int) -> bool:
+        await self.fetch_related("ad__pair_side")  # todo: check and fetch if only need
+        return self.ad.pair_side.is_sell == self.ami_maker(actor_id)
+
+    async def actors_bs(self) -> tuple[Actor, Actor]:  # (buyer, seller)
+        # ad_not_fetched = not isinstance(self.ad, Ad)
+        # if ad_not_fetched or not isinstance(self.ad.pair_side, PairSide):
+        #     await self.fetch_related("ad__pair_side")
+        # if ad_not_fetched or not isinstance(self.ad.maker, Actor):
+        #     await self.fetch_related("ad__maker")
+        # if not isinstance(self.taker, Actor):
+        #     await self.fetch_related("taker")
+        # todo: СУКАПИЗДЕЦБЛЯ! Один фетч перекрывает получений предыдущих связей фетчем!!!
+        k = int(self.ad.pair_side.is_sell) * 2 - 1
+        # noinspection PyTypeChecker
+        return (self.taker, self.ad.maker)[::k]
+
+    async def users_bs(self) -> tuple[User, User]:  # (buyer, seller)
+        actors_bs = await self.actors_bs()
+        return await User.get(persons__id=actors_bs[0].person_id), await User.get(persons__id=actors_bs[1].person_id)
+
+    def client(self, agent_client: BaseAgentClient = None):  # noqa
+        module_name = f"xync_client.{agent_client.ex_client.ex.name}.order"
+        __import__(module_name)
+        client = sys.modules[module_name].OrderClient
+        return client(self, agent_client)
+
+    async def get_chat(self):
+        await self.fetch_related("ad__pair_side", "msgs")
+        return [
+            f"{'b' if self.ad.pair_side.is_sell == m.to_maker else 's'}{m.to_maker and 't' or 'm'}: {m.txt or '<file>'}"
+            for m in self.msgs
+        ]
+
+    async def is_hot_ad(self) -> bool:
+        assert isinstance(self.ad.maker, Actor), "ad__maker should be fetched"
+        assert isinstance(self.ad.pms[0], Pm), "ad__pms should be fetched"
+        # проверяем что это именно DUMB ордер, а не COLD # todo: fox DRY: move to schema.model.fn:is_hot_ad()
+        is_cold = await Cred.exists(
+            pmcur__pm_id__in=[pm.id for pm in self.ad.pms], person=self.ad.maker.person_id, ovr_pm_id=0
+        )
+        return not is_cold
+
+    # когда прилетел новый ордер, и мы уже знаем юзера которому он принадлежит, и его последний hot
+    async def hot_process(self) -> OrderResult:
+        await self.fetch_related(
+            "taker", "hot__user", "ad__pair_side__pair__cur", "ad__maker__person__user", "transfers"
+        )
+        # оптимистично сразу проставляем удачный результат, если ошибки - перезапишется
+        res = OrderResult(err=OrderErr.ok if self.ad.pair_side.is_sell else OrderErr.i_wait_for_release)
+        if self.status in (OrderStatus.created, OrderStatus.paid):
+            # нет ли у тейкера незавершенных ордеров?
+            if (
+                incomplete_order := await Order.filter(
+                    id__not=self.id,
+                    taker__person__user_id=self.hot.user.id,
+                    ad__pair_side__is_sell=False,
+                    status__not_in={OrderStatus.completed, OrderStatus.canceled},
+                )
+                .first()
+                .values("exid", "status", "amount")
+            ):
+                res.err = OrderErr.uncompleted_orders
+                res.data = OrderResult.Order.load(incomplete_order)
+                return res
+            # покупатель оплачивает ордер
+            payment: Transfer | int = await self.pay()  # -> self.status = paid
+            if isinstance(payment, int):  # если не хватило денег - там число=баланс
+                # мы мейкер, и если это ad:sell значит покупатель - тейкер, иначе - мейкер
+                res.err = self.ad.pair_side.is_sell and OrderErr.taker_balance_deficit or OrderErr.maker_balance_deficit
+                res.data = (self.amount - payment) * 0.01
+            elif self.ad.pair_side.is_sell:  # успех и мы продавец - отпускаем
+                self.status = OrderStatus.completed
+                await self.save(update_fields=["status"])
+                res.data = payment.amount * 0.01
+            else:  # успех и мы покупатель - ждем когда продавец отпустит
+                res.data = OrderResult.Order.load(self)
+            return res
+        # статус ордера не "новый" и не "оплачен": мы не должны сюда попадать, чини!
+        logging.error(f"Hot order status SHOULD NOT BE: {self.status.name}! Fix it!")
+        res.data = OrderResult.Order.load(self)
+        res.err = OrderErr.wrong_status_for_hot
+        return res
+
+    async def pay(self, pm_id: int = 0) -> Transfer | int:
+        if tsfs := self.transfers:
+            if sum(t.amount for t in tsfs) < self.amount:
+                ValueError(f"Оплачено меньше суммы ордера {self.exid}")
+            if len(tsfs) > 1:
+                logging.warning(f"Несколько оплат по ордеру {self.exid}")
+            return tsfs[0]
+        if pm_id == 0:
+            buyer, seller = await self.users_bs()
+
+            # партнерские отчисления:
+            if self.ad.maker.person.user.status == UserStatus.HOT_PARTNER:
+                hspread = abs(self.ad.price - self.ad.pair_side.pair.cur.rate)
+                earn = hspread * self.quantity * 0.0001
+                fee = int(earn * (0.7 - self.ad.maker.person.user.bonus * 0.0001))  # 1% = 100
+                b = await self.ad.maker.person.user.balance(self.ad.pair_side.pair.cur_id)
+                if b < fee + (0 if self.ad.pair_side.is_sell else self.amount):
+                    return b
+                _txf = await self.ad.maker.person.user.send(self.ad.pair_side.pair.cur_id, 0, fee)
+
+            tx = await buyer.send(self.ad.pair_side.pair.cur_id, seller.id, self.amount)
+            if isinstance(tx, int):
+                logging.error("КАК БЛЯТЬ МЫ СЮДА ПОПАЛИ? Its unreal!")
+                return tx
+            if not self.id:
+                logging.warning("No ID order payment")
+                await self.save()
+            tsf = await Transfer.create(
+                amount=tx.amount, order_id=self.id, pmid=tx.id.hex, sender_acc=buyer.username_id
+            )
+            self.status = OrderStatus.paid  # todo: запрещать ставить paid, если у ордера нет трансферов на сумму amount
+            await self.save(update_fields=["status", "updated_at"])
+            return tsf
+
+        raise NotImplementedError("Pay method implemented now only for XyncPay pm")
+
+    async def cancel_request(self):
+        if not (payments := await self.fetch_related("transfers")):
+            self.status = OrderStatus.canceled
+            await self.save(update_fields=["status", "updated_at"])
+            return {"err": 0}
+        return {"err": payments}
+
+    # def epyd(self):  # todo: for who?
+    #     module_name = f"xync_client.{self.ex.name}.pyd"
+    #     __import__(module_name)
+    #     return sys.modules[module_name].OrderEpyd
+
+    class Meta:
+        table_description = "P2P Orders"
+        # unique_together = (("exid", "ad_id"),)
+
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion: int = 0
+        exclude_raw_fields: bool = False
+        exclude = ("taker", "ad", "cred", "msgs")
+
+
+class Task(Model):
+    order: ForeignKeyRelation[Order] = ForeignKeyField("models.Order", "tasks", on_update=CASCADE)
+    typ: TaskType = IntEnumField(TaskType)
+    data: dict = JSONField()
+
+
+class Transaction(Model):
+    id: UUID = UUIDField(primary_key=True, default=None)
+    amount: int = UInt4Field()  # /10^cur.scale
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "transfers", on_update=CASCADE)
+    cur_id: int
+    sender: ForeignKeyRelation[User] = ForeignKeyField("models.User", "sends", on_update=CASCADE, null=True)
+    sender_id: int | None
+    receiver: ForeignKeyRelation[User] = ForeignKeyField("models.User", "receives", on_update=CASCADE)
+    receiver_id: int
+    # validator: ForeignKeyRelation[User] = ForeignKeyField("models.User", "validates", null=True)
+    # validator_id: int
+    status: TS = IntEnumField(TS)
+    proof: bytes = UniqBinaryField(unique=True, null=True)  # len=128
+    ts: int | None = IntField(null=True, db_index=True)
+
+    def is_expired(self) -> bool:
+        """Проверка истёк ли запрос"""
+        assert not self.proof and self.ts, "It is method for ttl requests only"
+        return time() > self.ts
+
+    def is_valid_sender(self, sender_id: int) -> bool:
+        """Проверка может ли отправитель оплатить этот запрос"""
+        assert self.proof is None, "It is method for requests only"
+        return self.sender_id is None or self.sender_id == sender_id
+
+    @property
+    def pack(self) -> bytes:
+        """Упаковка тип+время+валюта+получатель+сумма+отправитель в 4+(1+3+5)+3=16 байт"""
+
+        def tt():  # тип + ts (2+30=32bit=4byte)
+            """Упаковка тип+время в 4 байта"""
+            typ: LinkType = LinkType.request if self.status == TS.request else LinkType.receipt
+            return typ_ts_pack(typ.value, self.ts)
+
+        def cr(cur_id: int, rec_id: int):
+            """Упаковка валюта + получатель в 1+3=4 байт"""
+            rcv = struct.pack(">I", rec_id)[1:4]  # последние 3 байта от 4х-байтного идшника
+            return struct.pack(">B", cur_id) + rcv
+
+        def cra(cur_id: int, rec_id: int, amount: int):
+            """Упаковка валюта + получатель + сумма в (1+3)+5=9 байт"""
+            amt = struct.pack(">Q", amount)[3:8]  # последние 5 байт от 8-байтной суммы (max 1_099_511_627_775)
+            return cr(cur_id, rec_id) + amt
+
+        def ttcras():
+            assert self.sender_id < 1 << 24
+            sndr = struct.pack(">I", self.sender_id)[1:4]  # последние 3 байта от 4х-байтного идшника
+            return tt() + cra(self.cur_id, self.receiver_id, self.amount) + sndr
+
+        # если это запрос, то все, пруфа нет и не нужен
+        proof_len = len(self.proof or b"")
+        if self.status == TS.request:
+            assert not proof_len, f"no proof `{self.proof}` for request"
+        # return cra(
+        #     self.cur_id,  # 1
+        #     self.receiver_id,  # 4
+        #     self.amount,  # 4
+        # )
+        # иначе это отправка
+        elif not self.ts:
+            raise ValueError("Time of sending is required for transaction")
+        elif (self.status == TS.signed and proof_len != 64) or (self.status == TS.verified and proof_len != 128):
+            raise ValueError(f"wrong proof length `{proof_len}` for `{self.status.name}` transaction")
+        return ttcras()
+
+    async def can_be_send(self) -> bool:
+        if not self.sender_id:
+            return True
+        assert isinstance(self.sender, User), "Sender is not fetched!"
+        sender_balance = await self.sender.balance(self.cur_id, self.ts)
+        is_in_db = await Transaction.exists(id=self.id, status__gte=TS.signed)
+        if not (res := sender_balance >= (0 if is_in_db else self.amount)):
+            for ttx in await Transaction.filter(id__not=self.id, ts=self.ts, receiver=self.sender, status=TS.signed):
+                await ttx.approve()
+            res = await self.can_be_send()
+        return res
+
+    async def sign(self, front_sign: bytes = None) -> "Transaction | int":
+        assert isinstance(self.sender, User), "Sender is not fetched!"
+        back_sign = self.sender.prv and Ed25519PrivateKey.from_private_bytes(self.sender.prv).sign(self.pack)
+        if self.sender.prv and front_sign:  # if fronted sign passed, and sender has backend priv key, check the match
+            if front_sign != back_sign:
+                raise InvalidSignature(front_sign, "old_front_pub")
+        elif not front_sign:  # if fronted sign not passed, use back sign
+            self.proof = back_sign
+        self.status = TS.signed
+        # xync verify tx
+        await self.approve()
+        # validator = await self.sender.get_validator(amount, cur_id, rcv_id)
+        return self
+
+    async def approve(self, prv: bytes = None):
+        assert self.status == TS.signed, "It is method for signed transfers only"
+        # assert len(self.proof) == 64, "Sender did not signed yet"
+        # 1. Проверяем подпись отправителя
+        await self.fetch_related("sender")
+        snd_pub = Ed25519PublicKey.from_public_bytes(self.sender.pub)
+        # отправитель подписывал транзу когда в ней еще не было пруфа, поэтому проверяем обрезок пака до него
+        snd_pub.verify(self.proof[:64], self.id.bytes)
+        # 2. Проверяем что баланс отправителя не меньшы отправляемой суммы. # todo: remove origin hack
+        assert await self.can_be_send(), "Less sender balance"
+        # 3. Подписываем
+        prv = prv or (await User[0]).prv  # or (await self.receiver).prv
+        pk = Ed25519PrivateKey.from_private_bytes(prv)  # ключем Xync-a, если не был передан другой
+        self.proof += pk.sign(
+            self.id.bytes + self.proof
+        )  # ид транзы + пруф отправителя и добавляем эту подпись к пруфу 64+64=128
+        self.status = TS.verified
+        # Только две подписи: отправителя + валидатора (128 байт)
+        try:
+            await self.save(**dict(update_fields=["proof", "status"]) if self._saved_in_db else {})
+        except RaiseError as e:
+            re = PgRaiseError(e)
+            raise re
+
+    def check(self, vld_pub: bytes = None) -> bool:
+        """Проверка доказательства"""
+        if len(self.proof) != 128:  # 64 + 64
+            return False  # wrong size
+        sender_sig, vld_sig = self.proof[:64], self.proof[64:128]
+        try:
+            # Проверяем подпись отправителя
+            sender_pub = Ed25519PublicKey.from_public_bytes(self.sender.pub)
+            sender_pub.verify(sender_sig, self.id.bytes)
+            # Проверяем подпись валидатора
+            if vld_pub:
+                vld_pub = Ed25519PublicKey.from_public_bytes(vld_pub)
+                vld_pub.verify(vld_sig, self.id.bytes + sender_sig)
+            return True
+        except InvalidSignature as _:
+            return False  # wrong sign
+
+    def get_qr(self, bot_nick: str) -> bytes:
+        data = f"{bot_nick and 't.me/' + bot_nick + '?startapp='}{int.from_bytes(self.id.bytes + self.proof)}"
+        # Prepare text
+        typ = ("Personalized" if self.sender_id else "Opened") if self.status == TS.request else "Receipt"
+        text = f"{typ} {self.status.name}"
+        return qr_gen(data, text)
+
+    @classmethod
+    async def snapshot(cls, ts: int = None) -> dict[int, dict[int, int]]:  # {user_id: {cur_id: balance}}
+        conn = connections.get("default")
+        r = await conn.execute_query_dict(
+            """
+            SELECT user_id,
+                   cur_id::int,
+                   SUM(total)::int AS balance
+            FROM (SELECT receiver_id AS user_id, t.cur_id, SUM(amount) AS total
+
+                  FROM transaction t -- deposits
+                  WHERE status = 2 -- verified
+                    AND ts <= $1
+                  GROUP BY receiver_id, t.cur_id
+
+                  UNION ALL
+
+                  SELECT sender_id AS user_id, t.cur_id, -SUM(amount) AS total
+                  FROM transaction t -- credits
+                  WHERE status in (1, 2)      -- signed+
+                    AND sender_id IS NOT NULL -- исключаем Request-ы денег
+                    AND ts <= $1
+                  GROUP BY sender_id, t.cur_id) a
+
+            GROUP BY user_id, cur_id
+            HAVING SUM(total) != 0
+            ORDER BY user_id, cur_id;
+            """,
+            [ts or int(time())],
+        )
+        result: dict[int, dict[int, int]] = {}
+        for row in r:
+            result.setdefault(row["user_id"], {})[row["cur_id"]] = row["balance"]
+        return result
+
+
+class Sign(Model):
+    transaction: ForeignKeyRelation[Transaction] = ForeignKeyField("models.Transaction", "signs", on_update=CASCADE)
+    transaction_id: int
+    validator: ForeignKeyRelation[User] = ForeignKeyField("models.User", "approves", on_update=CASCADE)
+    validator_id: int
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+
+
+# class Checkpoint(Model):
+#     amount: int = BigIntField()  # /10^cur.scale
+#     cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", related_name="transfers")
+#     cur_id: int
+#     user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "checkpoints", null=True)
+#     user_id: int | None
+#
+#     class Meta:
+#         unique_together = (("user_id", "cur_id"),)
+
+
+class Transfer(Model):
+    amount: int = UInt4Field()  # /10^cur.scale
+    order: ForeignKeyRelation[Order] = ForeignKeyField("models.Order", "transfers", on_update=CASCADE, null=True)
+    order_id: int
+    file: OneToOneNullableRelation["File"] = OneToOneField("models.File", "transfer", on_update=CASCADE, null=True)
+    file_id: int
+    pmid: str = CharField(32, unique=True, null=True)
+    sender_acc: str = CharField(63, null=True)
+    # pm: ForeignKeyRelation["Pm"] = ForeignKeyField("models.Pm", "transfers", on_update=CASCADE)
+    # pm_id: int
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    # class Meta:
+    #     unique_together = (("pmid", "pm_id"),)
+
+
+class Msg(Model):
+    tg_mid: int = UInt4Field(null=True)
+    txt: str = CharField(4095, null=True)
+    read: bool = BooleanField(default=False, db_index=True)
+    to_maker: bool = BooleanField()
+    file: OneToOneNullableRelation["File"] = OneToOneField("models.File", "msg", on_update=CASCADE, null=True)
+    order: ForeignKeyRelation[Order] = ForeignKeyField("models.Order", "msgs", on_update=CASCADE)
+    sent_at: datetime | None = DatetimeSecField()
+
+    # todo: required txt or file
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion: int = 0
+        exclude_raw_fields: bool = False
+        exclude = ("receiver", "order")
+
+    class Meta:
+        unique_together = (
+            ("order", "txt"),
+            # ("order", "sent_at"),
+        )
+
+
+class TopUpAble(Model):
+    pm: OneToOneRelation[Pm] = OneToOneField("models.Pm", "topupable", on_update=CASCADE)
+    pm_id: int
+    url: str = CharField(127)
+    auth: dict = JSONField(default={})
+    fee: int = SmallIntField(default=0)  # /10_000
+
+
+class TopUp(Model):
+    topupable: ForeignKeyRelation[TopUpAble] = ForeignKeyField("models.TopUpAble", "topup", on_update=CASCADE)
+    topupable_id: int
+    pmid: str = CharField(36, unique=True, null=True)
+    tid: str = CharField(36, unique=True, null=True)
+    amount: int = UInt4Field()  # /10^cur.scale
+    cur: ForeignKeyRelation[Cur] = ForeignKeyField("models.Cur", "topups", on_update=CASCADE)
+    cur_id: int
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "topups", on_update=CASCADE)
+    user_id: int
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+    completed_at: datetime | None = DatetimeSecField(null=True)
+
+
+class Dep(Model, TsTrait):
+    pid: str = CharField(31)  # product_id
+    apr: int = UInt2Field()  # /10_000
+    fee: int | None = UInt2Field(null=True)  # /10_000
+    apr_is_fixed: bool = BooleanField(default=False)
+    duration: int | None = UInt2Field(null=True)
+    early_redeem: bool | None = BooleanField(null=True)
+    typ: DepType = IntEnumField(DepType)
+    # mb: renewable?
+    min_limit: float = UInt8Field()
+    max_limit: float | None = UInt8Field(null=True)
+    is_active: bool = BooleanField(default=True)
+
+    coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "deps", on_update=CASCADE)
+    coin_id: int
+    reward_coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "deps_reward", on_update=CASCADE, null=True)
+    reward_coin_id: int | None = None
+    bonus_coin: ForeignKeyRelation[Coin] = ForeignKeyField("models.Coin", "deps_bonus", on_update=CASCADE, null=True)
+    bonus_coin_id: int | None = None
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "deps", on_update=CASCADE)
+    ex_id: int
+    investments: BackwardFKRelation[Investment]
+
+    _icon = "seeding"
+    _name = {"pid"}
+
+    def repr(self):
+        return (
+            f"{self.coin.ticker}:{self.apr * 100:.3g}% "
+            f"{f'{self.duration}d' if self.duration and self.duration > 0 else 'flex'}"
+        )
+
+    class Meta:
+        table_description = "Investment products"
+        unique_together = (("pid", "typ", "ex_id"),)
+
+
+class Investment(Model, TsTrait):
+    dep: ForeignKeyRelation[Dep] = ForeignKeyField("models.Dep", "investments", on_update=CASCADE)
+    # dep_id: int
+    amount: float = UInt8Field()
+    is_active: bool = BooleanField(default=True)
+    user: ForeignKeyRelation[User] = ForeignKeyField("models.User", "investments", on_update=CASCADE)
+
+    _icon = "trending-up"
+    _name = {"dep__pid", "amount"}
+
+    def repr(self):
+        return f"{self.amount:.3g} {self.dep.repr()}"
+
+    class Meta:
+        table_description = "Investments"
+
+
+class ExStat(Model):
+    ex: ForeignKeyRelation[Ex] = ForeignKeyField("models.Ex", "stats", on_update=CASCADE)
+    ex_id: int
+    action: ExAction = IntEnumField(ExAction)
+    ok: bool | None = BooleanField(default=False, null=True)
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    _icon = "test-pipe"
+    _name = {"ex_id", "action", "ok"}
+
+    def repr(self):
+        return f"{self.ex_id} {self.action.name} {self.ok}"
+
+    class Meta:
+        table = "ex_stat"
+        table_description = "Ex Stats"
+        unique_together = (("action", "ex_id"),)
+
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion: int = 2
+
+
+class Vpn(Model):
+    user: OneToOneRelation[User] = OneToOneField("models.User", "vpn", on_update=CASCADE)
+    user_id: int
+    prv: str = CharField(63, unique=True)
+    pub: str = CharField(63, unique=True)
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+
+    _icon = "vpn"
+    _name = {"pub"}
+
+    def repr(self):
+        return self.user.username
+
+    class Meta:
+        table_description = "VPNs"
+
+
+class File(Model):
+    name: str = CharField(178, null=True, unique=True)
+    typ: FileType = IntEnumField(FileType)
+    ref: bytes = UniqBinaryField(unique=True)
+    size: bytes = UInt4Field()
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+
+    msg: BackwardOneToOneRelation[Msg]
+    transfer: BackwardOneToOneRelation[Transfer]
+    pmex_logos: BackwardFKRelation[PmEx]
+
+    _icon = "file"
+    _name = {"name"}
+
+    class Meta:
+        table_description = "Files"
+        # Создаем индекс через raw SQL
+        # indexes = [CREATEUNIQUE INDEX IF NOT EXISTS idx_bytea_unique ON file (encode(sha256(ref), 'hex'))"]
+
+
+class Invite(Model, TsTrait):
+    ref: ForeignKeyRelation[User] = ForeignKeyField("models.User", "invite_approvals", on_update=CASCADE)
+    ref_id: int
+    protege: ForeignKeyRelation[User] = ForeignKeyField("models.User", "invite_requests", on_update=CASCADE)
+    protege_id: int
+    approved: str = BooleanField(default=False)  # status
+
+    _icon = "invite"
+    _name = {"ref__username", "protege__username", "approved"}
+
+    def repr(self):
+        return self.protege.name
+
+    class Meta:
+        table_description = "Invites"
+
+
+class Credit(Model, TsTrait):
+    lender: ForeignKeyRelation[User] = ForeignKeyField("models.User", "lends", on_update=CASCADE)
+    lender_id: int
+    borrower: ForeignKeyRelation[User] = ForeignKeyField("models.User", "borrows", on_update=CASCADE)
+    borrower_id: int
+    borrower_priority: bool = BooleanField(default=True)
+    amount: int = UInt4Field(default=None)  # 0 - is all remain borrower balance
+
+    _icon = "credit"
+    _name = {"lender__username", "borrower__username", "amount"}
+
+    def repr(self):
+        return self.borrower.name
+
+    class Meta:
+        table_description = "Credits"