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

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.1b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tonutils
-Version: 2.0.1b3
+Version: 2.0.1b5
 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]

{tonutils-2.0.1b3.dist-info → tonutils-2.0.1b5.dist-info}/RECORD

@@ -1,22 +1,23 @@
 tonutils/__init__.py,sha256=ueJrDkU1JBlZiX0q8roQfzYOZY62Of_CiHZlxIIQFO0,228
-tonutils/__meta__.py,sha256=mRBQ57iGzpByxckbLnojX_P1AgfSuWhjlMZaHQ9G32Y,24
-tonutils/exceptions.py,sha256=fxw2TJTKp4siBgP5RD_AsvFsHh7xqmSuomHZ-3OYD6s,6268
+tonutils/__meta__.py,sha256=uHnZdT43kWVuqeXaVY86NLU06cIBG4SuxsLdEUaX6v8,24
+tonutils/cli.py,sha256=WGir-ihgPuKTgKGmhjPZeKk9wgsm64jiJciOnVlsdco,2645
+tonutils/exceptions.py,sha256=67jXCFPyOnVnd8EaqYg1osVIXg34VZX-aJHPunpc-oI,6462
 tonutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tonutils/types.py,sha256=JIX3JYbpAOeRaGDHXg_ABNUzZfCjloUh6KHeskC8b9k,14283
+tonutils/types.py,sha256=ORevKllLjb7pmL3AQTMeSoiZQ4KFhoB_rA7KpGqZZjU,14542
 tonutils/utils.py,sha256=w2sXvVMA2Erz_JSSN2WuYSi7RAPDAOOwWYiThu8Q0Ps,16499
-tonutils/clients/__init__.py,sha256=df1v30j2PR1Pg75s8oTx-gtD6t7TKkYJ9VAumeqWS7M,561
-tonutils/clients/base.py,sha256=K2Z0FTF1c1V420mJn8Az9PGgzfbHmK6fnyFPXtrEWGM,9594
+tonutils/clients/__init__.py,sha256=PvHsOHOtkVonfiowEPi6P7ggDeQeQorXcksujru6efQ,561
+tonutils/clients/base.py,sha256=DjNhFd_p82Osqn0qWIjflpt9S1NVZc3MQIEj5U5E9-k,9631
 tonutils/clients/limiter.py,sha256=d2WO7Dx-ksg3gvl05WuDMu1KycuQj0XrmiG67Q7wnFo,3592
 tonutils/clients/protocol.py,sha256=4QerYoqBKAAfNZVpyQW2sp5KZZlq8xHCn9yWbbJERPQ,2557
-tonutils/clients/adnl/__init__.py,sha256=YiRYJ-Q8CNmbEEkoonmMWvaOEBYHn1eIa7YAXhuAMHo,174
-tonutils/clients/adnl/balancer.py,sha256=1oyCwW8tOLs0GcBRBHCYb27ElhPZqn2RlH2FKt4biPI,26772
-tonutils/clients/adnl/client.py,sha256=lgUBfovfzn_z7kCZsvZc2l3M_lnHBPruBn-655j3Fag,14060
+tonutils/clients/adnl/__init__.py,sha256=shkczPIYlTrOHjpnOBIoRwEYRQ4rVGfLnOZvnQY0a5U,174
+tonutils/clients/adnl/balancer.py,sha256=L5tvSwklgsp1QGBypMcxta_vhGdCXrOahi33-EFMPfs,26877
+tonutils/clients/adnl/client.py,sha256=hClnodq57bi6Q2p-9vbmh89GKpRDwXdIABUM8BEtKUs,14111
 tonutils/clients/adnl/utils.py,sha256=rKLbTiGbZQ0ozvh5jYjjaFEKsmqEschjuUiHOX9e6ps,5154
 tonutils/clients/adnl/provider/__init__.py,sha256=lLwFEEgCifMlYozwSzQbvq97R6Du7TzgGFnTgUnk4gw,63
-tonutils/clients/adnl/provider/config.py,sha256=8GDrfAf6B5IKrbK_Wq28XUQZHoYQ0YG_ngqXM2jo-0Y,690
+tonutils/clients/adnl/provider/config.py,sha256=nhe9jwDeN6d4yTlgaVHGKk5TaALYSvIfaok2myvIJXY,894
 tonutils/clients/adnl/provider/models.py,sha256=3dn4oZv7PIgiwlP2lGs0O6VckC19ejxCFlSPhzU0wX8,4537
-tonutils/clients/adnl/provider/provider.py,sha256=2EoI7PJ3-JOfcNqEzb02saa_T6tcwlks32I8UXhsYfs,24416
-tonutils/clients/adnl/provider/transport.py,sha256=bDM_qBbd3jH7uPiyq8Jctlxi-CIzryGXHqa5TuX7zWk,10961
+tonutils/clients/adnl/provider/provider.py,sha256=Er5RNR490RIQlRTI5KMxVarshHRNVseAbUYGM48fcbg,24180
+tonutils/clients/adnl/provider/transport.py,sha256=lgp1N0LGjYYIKWiwBIm-pnF064TkkCsSTDAFKt8_U-I,10983
 tonutils/clients/adnl/provider/workers/__init__.py,sha256=M65q7mVfinHImIZNCEaHBJ-SO4DdVBsSkeZFrJs9OoE,177
 tonutils/clients/adnl/provider/workers/base.py,sha256=8RenR2MU_B-b8mevzCytLJmPgjLCJ8bVI-4q-wx78Q8,2031
 tonutils/clients/adnl/provider/workers/pinger.py,sha256=lBpy4TU8L-I_6sxEft-Bn9XmntJhMg5Rm2o2tN2Mp0A,2443
@@ -86,8 +87,22 @@ tonutils/contracts/wallet/versions/v2.py,sha256=pwrlan-utZo_WmnzDwSbnzV8ibkPEWx2
 tonutils/contracts/wallet/versions/v3.py,sha256=d7cM8wjmW-1H7jGuY3AuUd7eTY3wq9ZYpJ4f5OeYX08,2470
 tonutils/contracts/wallet/versions/v4.py,sha256=2sAsjJ8_3oYAj5JwWH3PiMyoGbgl6-f7-p6T5X7MGTI,2713
 tonutils/contracts/wallet/versions/v5.py,sha256=1J6KXPOc7Q5S5EdFM9WXQzNGRZrw5EgxDZ9dmyHwsXE,8890
-tonutils-2.0.1b3.dist-info/licenses/LICENSE,sha256=fG-yM-8DSkOTaJ558P7uF5PNXBmineVO9-HC12YbIxs,1060
-tonutils-2.0.1b3.dist-info/METADATA,sha256=pG9mZCq1liFBJPKDuPuqP_HPlADYa8AZ6ndFibrNuEM,4279
-tonutils-2.0.1b3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tonutils-2.0.1b3.dist-info/top_level.txt,sha256=-7H_mGl8S9HKQrkUiTLmEbtMM-knzRzd_a0cZZnuZIU,9
-tonutils-2.0.1b3.dist-info/RECORD,,
+tonutils/tonconnect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tonutils/tools/__init__.py,sha256=QYOVuGY50FFkWlgIvHc2RPU3xiEWSbwnwZ6wuZPQnCA,102
+tonutils/tools/block_scanner/__init__.py,sha256=NRZ2XuDL3VwXJJ0iMe6ETh5w1aX4pCMMIv9UmmOj5yE,260
+tonutils/tools/block_scanner/annotations.py,sha256=i6Xsu_rBERr7qEmhGGcwlYYkqf8cLjNJlZ4rXUf51WY,795
+tonutils/tools/block_scanner/dispatcher.py,sha256=lgrs0MPnnyx0VibVQGYXU6s5mpqV_lO47yhO0uOCV30,4393
+tonutils/tools/block_scanner/events.py,sha256=6M80JoiVMRy7kBBuT8-KlHJ5Dx3GHUjIKmZVPaXXeaA,727
+tonutils/tools/block_scanner/scanner.py,sha256=2arPhNPu-6Klcj-PnSnP3DBVWekhlYjn2iqvN-1wigU,9929
+tonutils/tools/block_scanner/traversal.py,sha256=Zp0Uon0OTvLTsZi-zviMyvJHBsZRUx9XExxLU6LMkVA,3101
+tonutils/tools/block_scanner/where.py,sha256=sZUuabQ5joATkJqUh5R3N5r4P9WblmRrVYEVdZeJvZw,1239
+tonutils/tools/status_monitor/__init__.py,sha256=QnMlA0IDLtCGgXsEgB9q3EJTBo2s5js6lSJk0oZkQZQ,72
+tonutils/tools/status_monitor/console.py,sha256=UX3BzjjzeS_nKFGg4NkZJpu9fR_IAJZdQUMz0HcJCdg,5036
+tonutils/tools/status_monitor/models.py,sha256=yHuiEuij4h2kVoOK3sbhNq6SwiGDW_evZmzUwMy1GQs,608
+tonutils/tools/status_monitor/monitor.py,sha256=8zUwNwFScmcjK9ES7XX1LZWjw49lk8CSUQATcUYM57E,10085
+tonutils-2.0.1b5.dist-info/licenses/LICENSE,sha256=fG-yM-8DSkOTaJ558P7uF5PNXBmineVO9-HC12YbIxs,1060
+tonutils-2.0.1b5.dist-info/METADATA,sha256=1Wvi3Vlsb0IYwLaKlchY-OdFZ_TYNmHmZIzuyDQj55w,4181
+tonutils-2.0.1b5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tonutils-2.0.1b5.dist-info/entry_points.txt,sha256=qijo1cqvbbzLVbXp-PCYh19Pgmd7duH6yljmnUPd55I,47
+tonutils-2.0.1b5.dist-info/top_level.txt,sha256=-7H_mGl8S9HKQrkUiTLmEbtMM-knzRzd_a0cZZnuZIU,9
+tonutils-2.0.1b5.dist-info/RECORD,,

tonutils-2.0.1b5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tonutils = tonutils.cli:main