tonutils 2.0.1b3__py3-none-any.whl → 2.0.1b4__py3-none-any.whl

tonutils/tools/block_scanner/where.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import typing as t
+
+from pytoniq_core import Address
+
+from tonutils.tools.block_scanner import TransactionEvent
+from tonutils.tools.block_scanner.annotations import TEvent
+from tonutils.types import AddressLike
+
+
+class Where(t.Generic[TEvent]):
+    __slots__ = ()
+
+    def __call__(self, event: TEvent) -> bool:
+        raise NotImplementedError
+
+    def __and__(self, other: Where[TEvent]) -> _And[TEvent]:
+        return _And(self, other)
+
+    def __or__(self, other: Where[TEvent]) -> _Or[TEvent]:
+        return _Or(self, other)
+
+    def __invert__(self) -> _Not[TEvent]:
+        return _Not(self)
+
+
+class _And(Where[TEvent]):
+    __slots__ = ("_a", "_b")
+
+    def __init__(self, a: Where[TEvent], b: Where[TEvent]) -> None:
+        self._a = a
+        self._b = b
+
+    def __call__(self, event: TEvent) -> bool:
+        return self._a(event) and self._b(event)
+
+
+class _Or(Where[TEvent]):
+    __slots__ = ("_a", "_b")
+
+    def __init__(self, a: Where[TEvent], b: Where[TEvent]) -> None:
+        self._a = a
+        self._b = b
+
+    def __call__(self, event: TEvent) -> bool:
+        return self._a(event) or self._b(event)
+
+
+class _Not(Where[TEvent]):
+    __slots__ = ("_f",)
+
+    def __init__(self, f: Where[TEvent]) -> None:
+        self._f = f
+
+    def __call__(self, event: TEvent) -> bool:
+        return not self._f(event)
+
+
+class _Opcode(Where[TransactionEvent]):
+    __slots__ = ("_ops",)
+
+    def __init__(self, *ops: int) -> None:
+        self._ops = frozenset(ops)
+
+    def __call__(self, event: TransactionEvent) -> bool:
+        msg = event.transaction.in_msg
+        if msg is None or msg.body is None:
+            return False
+
+        if len(msg.body.bits) < 32:
+            return False
+
+        op = msg.body.begin_parse().load_uint(32)
+        return op in self._ops
+
+
+class _Comment(Where[TransactionEvent]):
+    __slots__ = ("_texts", "_any")
+
+    def __init__(self, *texts: str) -> None:
+        self._texts = frozenset(texts)
+        self._any = len(texts) == 0
+
+    def __call__(self, event: TransactionEvent) -> bool:
+        msg = event.transaction.in_msg
+        if msg is None or msg.body is None:
+            return False
+
+        body = msg.body.begin_parse()
+        if len(body.bits) < 32:
+            return False
+
+        op = body.load_uint(32)
+        if op != 0:
+            return False
+
+        if self._any:
+            return True
+        try:
+            text = body.load_snake_string()
+        except (Exception,):
+            return False
+
+        return text in self._texts
+
+
+class _Sender(Where[TransactionEvent]):
+    __slots__ = ("_addrs",)
+
+    def __init__(self, *addrs: AddressLike) -> None:
+        self._addrs = frozenset(Address(a) if isinstance(a, str) else a for a in addrs)
+
+    def __call__(self, event: TransactionEvent) -> bool:
+        msg = event.transaction.in_msg
+        if msg is None:
+            return False
+
+        src = msg.info.src
+        return src is not None and src in self._addrs
+
+
+class _Destination(Where[TransactionEvent]):
+    __slots__ = ("_addrs",)
+
+    def __init__(self, *addrs: AddressLike) -> None:
+        self._addrs = frozenset(Address(a) if isinstance(a, str) else a for a in addrs)
+
+    def __call__(self, event: TransactionEvent) -> bool:
+        msg = event.transaction.in_msg
+        if msg is None:
+            return False
+
+        dest = msg.info.dest
+        return dest is not None and dest in self._addrs
+
+
+def opcode(*ops: int) -> Where[TransactionEvent]:
+    return _Opcode(*ops)
+
+
+def comment(*texts: str) -> Where[TransactionEvent]:
+    return _Comment(*texts)
+
+
+def sender(*addresses: AddressLike) -> Where[TransactionEvent]:
+    return _Sender(*addresses)
+
+
+def destination(*addresses: AddressLike) -> Where[TransactionEvent]:
+    return _Destination(*addresses)

tonutils/tools/status_monitor/__init__.py

@@ -0,0 +1,3 @@
+from .monitor import LiteServerMonitor
+
+__all__ = ["LiteServerMonitor"]

tonutils/tools/status_monitor/console.py

@@ -0,0 +1,157 @@
+import sys
+import typing as t
+from collections import deque
+from datetime import datetime
+
+from tonutils.tools.status_monitor.models import BlockInfo, LiteServerStatus
+
+_ENTER_ALT_SCREEN = "\033[?1049h"
+_EXIT_ALT_SCREEN = "\033[?1049l"
+_HIDE_CURSOR = "\033[?25l"
+_SHOW_CURSOR = "\033[?25h"
+_MOVE_HOME = "\033[H"
+_CLEAR_SCREEN = "\033[2J"
+_CLEAR_LINE = "\033[K"
+
+
+class Console:
+    HEADERS = [
+        "LS",
+        "HOST",
+        "PORT",
+        "Version",
+        "Time",
+        "Ping",
+        "Connect RTT",
+        "Request RTT",
+        "Last MC Block",
+        "Last BC Block",
+        "Archive From",
+    ]
+    WIDTHS = [2, 15, 5, 7, 19, 7, 11, 11, 16, 16, 12]
+
+    TABLE_TITLE = "Lite Server Status"
+    ERROR_TITLE = "Error Log"
+    MAX_ERROR_LOGS = 10
+
+    def __init__(self) -> None:
+        self._index_width = 2
+        self._is_tty = sys.stdout.isatty()
+        self._error_log: deque[str] = deque(maxlen=self.MAX_ERROR_LOGS)
+        self._prev_errors: t.Dict[int, t.Optional[str]] = {}
+
+    def enter(self) -> None:
+        if self._is_tty:
+            sys.stdout.write(_ENTER_ALT_SCREEN + _HIDE_CURSOR + _CLEAR_SCREEN)
+            sys.stdout.flush()
+
+    def exit(self) -> None:
+        if self._is_tty:
+            sys.stdout.write(_SHOW_CURSOR + _EXIT_ALT_SCREEN)
+            sys.stdout.flush()
+
+    def render(self, statuses: t.List[LiteServerStatus]) -> None:
+        self._update_state(statuses)
+        self._home()
+        self._draw(statuses)
+
+    def _home(self) -> None:
+        if self._is_tty:
+            sys.stdout.write(_MOVE_HOME)
+            sys.stdout.flush()
+
+    def _update_state(self, statuses: t.List[LiteServerStatus]) -> None:
+        self._update_index_width(statuses)
+        self._update_error_log(statuses)
+
+    def _update_index_width(self, statuses: t.List[LiteServerStatus]) -> None:
+        if statuses:
+            self._index_width = max(2, len(str(len(statuses) - 1)))
+
+    def _update_error_log(self, statuses: t.List[LiteServerStatus]) -> None:
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        for status in statuses:
+            prev = self._prev_errors.get(status.server.index)
+            if status.last_error and status.last_error != prev:
+                idx = str(status.server.index).rjust(self._index_width)
+                self._error_log.appendleft(f"  {now} [LS {idx}]: {status.last_error}")
+            self._prev_errors[status.server.index] = status.last_error
+
+    def _get_table_width(self) -> int:
+        return sum(self.WIDTHS) + (len(self.WIDTHS) - 1) * 3
+
+    def _draw(self, statuses: t.List[LiteServerStatus]) -> None:
+        table_width = self._get_table_width()
+        padding = (table_width - len(self.TABLE_TITLE)) // 2
+
+        lines = [
+            "═" * table_width,
+            " " * padding + self.TABLE_TITLE,
+            "═" * table_width,
+            self._format_header(),
+            self._format_separator(),
+        ]
+
+        for status in statuses:
+            lines.append(self._format_row(status))
+
+        lines.append("")
+
+        if self._error_log:
+            lines.append("─" * table_width)
+            lines.append(f"  {self.ERROR_TITLE}:")
+            lines.extend(self._error_log)
+
+        output = (_CLEAR_LINE + "\n").join(lines) + _CLEAR_LINE
+
+        output += "\n" + _CLEAR_LINE
+        sys.stdout.write(output)
+        sys.stdout.flush()
+
+    def _format_header(self) -> str:
+        return " │ ".join(h.ljust(w) for h, w in zip(self.HEADERS, self.WIDTHS))
+
+    def _format_separator(self) -> str:
+        return "─┼─".join("─" * w for w in self.WIDTHS)
+
+    def _format_row(self, status: LiteServerStatus) -> str:
+        cells = [
+            str(status.server.index),
+            status.server.host,
+            str(status.server.port),
+            self._fmt_int(status.version),
+            self._fmt_datetime(status.time),
+            self._fmt_ms(status.ping_ms),
+            self._fmt_ms(status.connect_ms),
+            self._fmt_ms(status.request_ms),
+            self._fmt_block(status.last_mc_block),
+            self._fmt_block(status.last_bc_block),
+            self._fmt_date(status.archive_from),
+        ]
+        return " │ ".join(c.ljust(w) for c, w in zip(cells, self.WIDTHS))
+
+    @staticmethod
+    def _fmt_int(value: t.Optional[int]) -> str:
+        return str(value) if value is not None else "-"
+
+    @staticmethod
+    def _fmt_ms(value: t.Optional[int]) -> str:
+        return f"{value}ms" if value is not None else "-"
+
+    @staticmethod
+    def _fmt_block(block: t.Optional[BlockInfo]) -> str:
+        if block is None:
+            return "-"
+        return f"{block.seqno} / {block.txs_count}"
+
+    @staticmethod
+    def _fmt_date(ts: t.Optional[int]) -> str:
+        if ts is None:
+            return "-"
+        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
+
+    @staticmethod
+    def _fmt_datetime(ts: t.Optional[int]) -> str:
+        if ts is None:
+            return "-"
+        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S")

tonutils/tools/status_monitor/models.py

@@ -0,0 +1,27 @@
+import typing as t
+
+from pydantic import BaseModel
+
+
+class LiteServer(BaseModel):
+    index: int
+    host: str
+    port: int
+
+
+class BlockInfo(BaseModel):
+    seqno: int
+    txs_count: int
+
+
+class LiteServerStatus(BaseModel):
+    server: LiteServer
+    version: t.Optional[int] = None
+    time: t.Optional[int] = None
+    ping_ms: t.Optional[int] = None
+    connect_ms: t.Optional[int] = None
+    request_ms: t.Optional[int] = None
+    last_mc_block: t.Optional[BlockInfo] = None
+    last_bc_block: t.Optional[BlockInfo] = None
+    archive_from: t.Optional[int] = None
+    last_error: t.Optional[str] = None

tonutils/tools/status_monitor/monitor.py

@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+import asyncio
+import time
+import typing as t
+
+from tonutils.clients import LiteClient
+from tonutils.clients.adnl.provider.models import GlobalConfig
+from tonutils.tools.status_monitor.console import Console
+from tonutils.tools.status_monitor.models import (
+    BlockInfo,
+    LiteServerStatus,
+    LiteServer,
+)
+from tonutils.types import (
+    NetworkGlobalID,
+    WorkchainID,
+    MAINNET_GENESIS_UTIME,
+    MASTERCHAIN_SHARD,
+)
+
+
+class LiteServerMonitor:
+    RENDER_INTERVAL = 0.1
+    RECONNECT_INTERVAL = 30.0
+
+    FAST_UPDATE_INTERVAL = 0.3
+    MEDIUM_UPDATE_INTERVAL = 3.0
+    SLOW_UPDATE_INTERVAL = 10.0
+
+    def __init__(self, clients: t.List[LiteClient]) -> None:
+        self._clients = clients
+        self._console = Console()
+
+        self._archive_cache: t.Dict[int, int] = {}
+        self._statuses: t.Dict[int, LiteServerStatus] = {}
+        self._last_connect: t.Dict[int, float] = {}
+
+        self._tasks: t.List[asyncio.Task[None]] = []
+        self._stop = asyncio.Event()
+
+        self._locks: t.Dict[int, asyncio.Lock] = {}
+
+    @classmethod
+    def from_config(
+        cls,
+        config: GlobalConfig,
+        network: NetworkGlobalID,
+        rps_limit: t.Optional[int] = 100,
+    ) -> LiteServerMonitor:
+        return cls(
+            [
+                LiteClient(
+                    network=network,
+                    ip=server.host,
+                    port=server.port,
+                    public_key=server.id,
+                    rps_limit=rps_limit,
+                )
+                for server in config.liteservers
+            ]
+        )
+
+    @property
+    def statuses(self) -> t.List[LiteServerStatus]:
+        return list(self._statuses.values())
+
+    async def run(self) -> None:
+        self._console.enter()
+        self._init_statuses()
+        self._start_update_loops()
+
+        try:
+            while not self._stop.is_set():
+                self._console.render(self.statuses)
+                await self._sleep(self.RENDER_INTERVAL)
+        finally:
+            self._console.exit()
+
+    async def stop(self) -> None:
+        if self._stop.is_set():
+            return
+        self._stop.set()
+
+        for task in self._tasks:
+            task.cancel()
+        await asyncio.gather(*self._tasks, return_exceptions=True)
+
+        close_tasks = [client.close() for client in self._clients]
+        await asyncio.gather(*close_tasks, return_exceptions=True)
+
+    def _init_statuses(self) -> None:
+        for index, client in enumerate(self._clients):
+            server = LiteServer(
+                index=index,
+                host=client.provider.node.host,
+                port=client.provider.node.port,
+            )
+            self._statuses[index] = LiteServerStatus(server=server)
+            self._locks[index] = asyncio.Lock()
+
+    def _start_update_loops(self) -> None:
+        if self._tasks:
+            return
+
+        for index, client in enumerate(self._clients):
+            fast = self._fast_update_loop(index, client)
+            self._tasks.append(asyncio.create_task(fast))
+
+            medium = self._medium_update_loop(index, client)
+            self._tasks.append(asyncio.create_task(medium))
+
+            slow = self._slow_update_loop(index, client)
+            self._tasks.append(asyncio.create_task(slow))
+
+    async def _ensure_connected(self, index: int, client: LiteClient) -> bool:
+        if client.provider.is_connected:
+            return True
+
+        now = time.monotonic()
+        last_attempt = self._last_connect.get(index, 0.0)
+        if now - last_attempt < self.RECONNECT_INTERVAL:
+            return False
+
+        self._last_connect[index] = now
+        await self._connect(index, client)
+        return client.provider.is_connected
+
+    async def _fast_update_loop(self, index: int, client: LiteClient) -> None:
+        while not self._stop.is_set():
+            if not await self._ensure_connected(index, client):
+                await self._sleep(1.0)
+                continue
+
+            await asyncio.gather(
+                self._update_time(index, client),
+                self._update_last_blocks(index, client),
+                return_exceptions=True,
+            )
+            await self._sleep(self.FAST_UPDATE_INTERVAL)
+
+    async def _medium_update_loop(self, index: int, client: LiteClient) -> None:
+        while not self._stop.is_set():
+            if not client.is_connected:
+                await self._sleep(1.0)
+                continue
+
+            await asyncio.gather(
+                self._update_ping_ms(index, client),
+                self._update_request_ms(index, client),
+                return_exceptions=True,
+            )
+            await self._sleep(self.MEDIUM_UPDATE_INTERVAL)
+
+    async def _slow_update_loop(self, index: int, client: LiteClient) -> None:
+        while not self._stop.is_set():
+            if not client.is_connected:
+                await self._sleep(1.0)
+                continue
+
+            await asyncio.gather(
+                self._update_version(index, client),
+                self._update_archive_from(index, client),
+                return_exceptions=True,
+            )
+            await self._sleep(self.SLOW_UPDATE_INTERVAL)
+
+    async def _sleep(self, seconds: float) -> None:
+        try:
+            await asyncio.wait_for(self._stop.wait(), timeout=seconds)
+        except asyncio.TimeoutError:
+            pass
+
+    async def _set_status(self, index: int, **kwargs: t.Any) -> None:
+        async with self._locks[index]:
+            current = self._statuses[index]
+            self._statuses[index] = current.model_copy(update=kwargs)
+
+    async def _connect(self, index: int, client: LiteClient) -> None:
+        try:
+            start = time.perf_counter()
+            await client.connect()
+            connect_ms = int((time.perf_counter() - start) * 1000)
+            await self._set_status(index, connect_ms=connect_ms, last_error=None)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_version(self, index: int, client: LiteClient) -> None:
+        try:
+            version = await client.get_version()
+            await self._set_status(index, version=version)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_time(self, index: int, client: LiteClient) -> None:
+        try:
+            server_time = await client.get_time()
+            await self._set_status(index, time=server_time)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_ping_ms(self, index: int, client: LiteClient) -> None:
+        try:
+            ping_ms = client.provider.last_ping_ms
+            if ping_ms is not None:
+                await self._set_status(index, ping_ms=ping_ms)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_request_ms(self, index: int, client: LiteClient) -> None:
+        try:
+            start = time.perf_counter()
+            await client.get_masterchain_info()
+            request_ms = int((time.perf_counter() - start) * 1000)
+            await self._set_status(index, request_ms=request_ms)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_last_blocks(self, index: int, client: LiteClient) -> None:
+        try:
+            mc_block = client.provider.last_mc_block
+            if mc_block is None:
+                return
+
+            mc_txs, shards = await asyncio.gather(
+                client.get_block_transactions_ext(mc_block),
+                client.get_all_shards_info(mc_block),
+            )
+            last_mc_block = BlockInfo(seqno=mc_block.seqno, txs_count=len(mc_txs))
+
+            if shards:
+                bc_block = max(shards, key=lambda b: b.seqno)
+                bc_txs = await client.get_block_transactions_ext(bc_block)
+                last_bc_block = BlockInfo(seqno=bc_block.seqno, txs_count=len(bc_txs))
+                await self._set_status(
+                    index,
+                    last_mc_block=last_mc_block,
+                    last_bc_block=last_bc_block,
+                )
+            else:
+                await self._set_status(index, last_mc_block=last_mc_block)
+
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    async def _update_archive_from(self, index: int, client: LiteClient) -> None:
+        try:
+            now = int(time.time())
+            result = await self._find_archive_depth(
+                client, now, self._archive_cache.get(index)
+            )
+            self._archive_cache[index] = result
+            await self._set_status(index, archive_from=result)
+        except Exception as e:
+            await self._set_status(index, last_error=str(e))
+
+    @staticmethod
+    async def _find_archive_depth(
+        client: LiteClient,
+        now: int,
+        cached: t.Optional[int] = None,
+    ) -> int:
+        seconds_per_day = 86400
+        seconds_diff = now - MAINNET_GENESIS_UTIME
+        right = seconds_diff // seconds_per_day
+
+        if cached is not None:
+            cached_days = (now - cached) // seconds_per_day
+            left = cached_days
+            best_days = cached_days
+        else:
+            left = 0
+            best_days = 0
+
+        async def probe(days: int) -> bool:
+            utime = now - days * seconds_per_day
+            try:
+                await client.provider.lookup_block(
+                    workchain=WorkchainID.MASTERCHAIN,
+                    shard=MASTERCHAIN_SHARD,
+                    utime=utime,
+                )
+                return True
+            except (Exception,):
+                return False
+
+        while left <= right:
+            mid = (left + right) // 2
+            if await probe(mid):
+                best_days = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+
+        return now - best_days * seconds_per_day

tonutils/types.py

@@ -17,10 +17,6 @@ __all__ = [
     "ClientType",
     "ContractState",
     "ContractStateInfo",
-    "DEFAULT_ADNL_RETRY_POLICY",
-    "DEFAULT_HTTP_RETRY_POLICY",
-    "DEFAULT_SENDMODE",
-    "DEFAULT_SUBWALLET_ID",
     "DNSCategory",
     "DNSPrefix",
     "MetadataPrefix",
@@ -34,6 +30,12 @@ __all__ = [
     "StackItems",
     "StackTag",
     "WorkchainID",
+    "DEFAULT_ADNL_RETRY_POLICY",
+    "DEFAULT_HTTP_RETRY_POLICY",
+    "DEFAULT_SENDMODE",
+    "DEFAULT_SUBWALLET_ID",
+    "MAINNET_GENESIS_UTIME",
+    "MASTERCHAIN_SHARD",
 ]
 
 from tonutils.exceptions import CDN_CHALLENGE_MARKERS
@@ -495,3 +497,9 @@ DEFAULT_SUBWALLET_ID = 698983191
 
 DEFAULT_SENDMODE = SendMode.PAY_GAS_SEPARATELY | SendMode.IGNORE_ERRORS
 """Default send mode: pay fees separately and ignore errors."""
+
+MASTERCHAIN_SHARD = -9223372036854775808
+"""Shard identifier for the masterchain (-2^63)."""
+
+MAINNET_GENESIS_UTIME = 1573822385
+"""Unix timestamp of the TON mainnet genesis block (November 15, 2019)."""

{tonutils-2.0.1b3.dist-info → tonutils-2.0.1b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tonutils
-Version: 2.0.1b3
+Version: 2.0.1b4
 Summary: Tonutils is a high-level, object-oriented Python library designed to facilitate seamless interactions with the TON blockchain.
 Author: nessshon
 Maintainer: nessshon
@@ -26,11 +26,8 @@ Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.7.0
-Requires-Dist: pycryptodomex~=3.23.0
 Requires-Dist: pydantic<3.0,>=2.0
-Requires-Dist: pynacl~=1.6.0
-Requires-Dist: pytoniq-core~=0.1.45
-Requires-Dist: requests>=2.31.0
+Requires-Dist: pytoniq-core~=0.1.46
 Dynamic: license-file
 
 # 📦 Tonutils 2.0 [BETA]