tonutils 2.0.1b6__py3-none-any.whl → 2.0.1b7__py3-none-any.whl

tonutils/clients/http/provider/toncenter.py

@@ -1,7 +1,6 @@
 import typing as t
 
 import aiohttp
-from pydantic import BaseModel
 
 from tonutils.clients.http.provider.base import HttpProvider
 from tonutils.clients.http.provider.models import (
@@ -10,7 +9,7 @@ from tonutils.clients.http.provider.models import (
     GetAddressInformationResult,
     GetTransactionsResult,
     RunGetMethodPayload,
-    RunGetMethodResul,
+    RunGetMethodResult,
 )
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
@@ -37,6 +36,7 @@ class ToncenterHttpProvider(HttpProvider):
         }
         base_url = base_url or urls[network]
         headers = {**(headers or {}), **({"X-Api-Key": api_key} if api_key else {})}
+
         super().__init__(
             base_url=base_url,
             session=session,
@@ -48,10 +48,6 @@ class ToncenterHttpProvider(HttpProvider):
             retry_policy=retry_policy,
         )
 
-    @staticmethod
-    def _model(model: t.Type[BaseModel], data: t.Any) -> t.Any:
-        return model.model_validate(data)
-
     async def send_boc(
         self,
         payload: SendBocPayload,
@@ -116,9 +112,9 @@ class ToncenterHttpProvider(HttpProvider):
     async def run_get_method(
         self,
         payload: RunGetMethodPayload,
-    ) -> RunGetMethodResul:
+    ) -> RunGetMethodResult:
         return self._model(
-            RunGetMethodResul,
+            RunGetMethodResult,
             await self.send_http_request(
                 "POST",
                 "/runGetMethod",

tonutils/clients/protocol.py

@@ -6,7 +6,7 @@ from pytoniq_core import Cell, Transaction
 
 from tonutils.types import (
     AddressLike,
-    ContractStateInfo,
+    ContractInfo,
     DNSCategory,
     NetworkGlobalID,
     ClientType,
@@ -40,19 +40,19 @@ class ClientProtocol(t.Protocol):
         """Underlying provider or transport backend."""
 
     @property
-    def is_connected(self) -> bool:
+    def connected(self) -> bool:
         """Whether the client is connected and ready for requests."""
 
-    async def send_boc(self, boc: str) -> None:
+    async def send_message(self, boc: str) -> None:
         """Send an external message to the blockchain."""
 
-    async def get_blockchain_config(self) -> t.Dict[int, t.Any]:
+    async def get_config(self) -> t.Dict[int, t.Any]:
         """Fetch global blockchain configuration."""
 
-    async def get_contract_info(
+    async def get_info(
         self,
         address: AddressLike,
-    ) -> ContractStateInfo:
+    ) -> ContractInfo:
         """Fetch basic contract state information."""
 
     async def get_transactions(

tonutils/contracts/base.py

@@ -13,7 +13,7 @@ from tonutils.exceptions import (
     StateNotLoadedError,
     ProviderResponseError,
 )
-from tonutils.types import AddressLike, ContractState, ContractStateInfo, WorkchainID
+from tonutils.types import AddressLike, ContractInfo, ContractState, WorkchainID
 from tonutils.utils import to_cell
 
 _R = t.TypeVar("_R")
@@ -61,7 +61,7 @@ class BaseContract(ContractProtocol[_D]):
         client: ClientProtocol,
         address: Address,
         state_init: t.Optional[StateInit] = None,
-        state_info: t.Optional[ContractStateInfo] = None,
+        info: t.Optional[ContractInfo] = None,
     ) -> None:
         """
         Initialize base contract wrapper.
@@ -69,12 +69,12 @@ class BaseContract(ContractProtocol[_D]):
         :param client: TON client for blockchain interactions
         :param address: Contract address on the blockchain
         :param state_init: Optional known StateInit (code and data)
-        :param state_info: Optional preloaded on-chain contract state
+        :param info: Optional preloaded on-chain contract state
         """
         self._client = client
         self._address = address
         self._state_init = state_init
-        self._state_info = state_info
+        self._info = info
 
     @property
     def client(self) -> ClientProtocol:
@@ -91,17 +91,6 @@ class BaseContract(ContractProtocol[_D]):
         """Locally known StateInit for this contract, if any."""
         return self._state_init
 
-    @property
-    def state_info(self) -> ContractStateInfo:
-        """
-        Cached snapshot of the contract state.
-
-        :return: Contract state information
-        """
-        if self._state_info is None:
-            raise StateNotLoadedError(self, missing="state_info")
-        return t.cast(ContractStateInfo, self._state_info)
-
     @property
     def state_data(self) -> _D:
         """
@@ -113,11 +102,22 @@ class BaseContract(ContractProtocol[_D]):
         """
         if not hasattr(self, "_data_model") or self._data_model is None:
             raise ContractError(self, "No `_data_model` defined for contract class.")
-        if not (self._state_info and self._state_info.data):
+        if not (self._info and self._info.data):
             raise StateNotLoadedError(self, missing="state_data")
-        cs = self._state_info.data.begin_parse()
+        cs = self._info.data.begin_parse()
         return self._data_model.deserialize(cs)
 
+    @property
+    def info(self) -> ContractInfo:
+        """
+        Cached snapshot of the contract state info.
+
+        :return: Contract state information
+        """
+        if self._info is None:
+            raise StateNotLoadedError(self, missing="info")
+        return t.cast(ContractInfo, self._info)
+
     @property
     def balance(self) -> int:
         """
@@ -125,7 +125,7 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: Balance from the latest known state
         """
-        return self.state_info.balance
+        return self.info.balance
 
     @property
     def state(self) -> ContractState:
@@ -134,7 +134,7 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: One of ContractState enum values (ACTIVE, FROZEN, UNINIT, NONEXIST)
         """
-        return self.state_info.state
+        return self.info.state
 
     @property
     def is_active(self) -> bool:
@@ -179,7 +179,7 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: Transaction LT or None if unknown
         """
-        return self.state_info.last_transaction_lt
+        return self.info.last_transaction_lt
 
     @property
     def last_transaction_hash(self) -> t.Optional[str]:
@@ -188,7 +188,7 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: Transaction hash as hex string or None if unknown
         """
-        return self.state_info.last_transaction_hash
+        return self.info.last_transaction_hash
 
     @property
     def code(self) -> t.Optional[Cell]:
@@ -197,7 +197,7 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: Code cell or None if not available
         """
-        return self.state_info.code
+        return self.info.code
 
     @property
     def data(self) -> t.Optional[Cell]:
@@ -206,36 +206,36 @@ class BaseContract(ContractProtocol[_D]):
 
         :return: Data cell or None if not available
         """
-        return self.state_info.data
+        return self.info.data
 
     @classmethod
-    async def _load_state_info(
+    async def _load_info(
         cls,
         client: ClientProtocol,
         address: Address,
-    ) -> ContractStateInfo:
+    ) -> ContractInfo:
         """
         Fetch contract state from the blockchain.
 
         If the request fails (except rate limits), sets state to default empty state.
         """
         try:
-            return await client.get_contract_info(address)
+            return await client.get_info(address)
         except ProviderResponseError as e:
             if e.code in {429, 228, 5556}:  # rate limit exceed
                 raise
-            return ContractStateInfo()
+            return ContractInfo()
         except (Exception,):
-            return ContractStateInfo()
+            return ContractInfo()
 
     async def refresh(self) -> None:
         """
         Refresh contract state from the blockchain.
 
-        Fetches current contract information and updates the cached state_info.
+        Fetches current contract information and updates the cached info.
         If the request fails (except rate limits), sets state to default empty state.
         """
-        self._state_info = await self._load_state_info(self.client, self.address)
+        self._info = await self._load_info(self.client, self.address)
 
     @classmethod
     def from_state_init(
@@ -323,8 +323,8 @@ class BaseContract(ContractProtocol[_D]):
         if not load_state:
             return cls(client, address)
 
-        state_info = await cls._load_state_info(client, address)
-        return cls(client, address, state_info=state_info)
+        info = await cls._load_info(client, address)
+        return cls(client, address, info=info)
 
     def __repr__(self) -> str:
         return f"< Contract {self.__class__.__name__} address: {self.address} >"

tonutils/contracts/protocol.py

@@ -5,7 +5,7 @@ import typing as t
 from pytoniq_core import Address, Cell, StateInit
 
 from tonutils.clients.protocol import ClientProtocol
-from tonutils.types import AddressLike, ContractState, ContractStateInfo, WorkchainID
+from tonutils.types import AddressLike, ContractInfo, ContractState, WorkchainID
 
 if t.TYPE_CHECKING:
     from tonutils.contracts.versions import ContractVersion
@@ -48,21 +48,21 @@ class ContractProtocol(t.Protocol[_D]):
         """Locally known StateInit for this contract, if any."""
 
     @property
-    def state_info(self) -> ContractStateInfo:
+    def state_data(self) -> _D:
         """
-        Cached snapshot of the contract state.
+        Decoded on-chain data in typed form.
 
-        Implementations usually update this via refresh() or in constructors
-        that read on-chain data.
+        Implementations must decode the current data cell from info
+        using the associated _data_model.
         """
 
     @property
-    def state_data(self) -> _D:
+    def info(self) -> ContractInfo:
         """
-        Decoded on-chain data in typed form.
+        Cached snapshot of the contract state info.
 
-        Implementations must decode the current data cell from state_info
-        using the associated _data_model.
+        Implementations usually update this via refresh() or in constructors
+        that read on-chain data.
         """
 
     @property

tonutils/contracts/wallet/base.py

@@ -22,7 +22,7 @@ from tonutils.contracts.wallet.tlb import BaseWalletData
 from tonutils.exceptions import ContractError
 from tonutils.types import (
     AddressLike,
-    ContractStateInfo,
+    ContractInfo,
     SendMode,
     PublicKey,
     PrivateKey,
@@ -61,7 +61,7 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         client: ClientProtocol,
         address: Address,
         state_init: t.Optional[StateInit] = None,
-        state_info: t.Optional[ContractStateInfo] = None,
+        info: t.Optional[ContractInfo] = None,
         config: t.Optional[_C] = None,
         private_key: t.Optional[PrivateKey] = None,
     ) -> None:
@@ -71,7 +71,7 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         :param client: TON client for blockchain interactions
         :param address: Wallet address on the blockchain
         :param state_init: Optional StateInit (code and data)
-        :param state_info: Optional preloaded contract state
+        :param info: Optional preloaded contract state
         :param config: Optional wallet configuration
         :param private_key: Optional private key for signing transactions
         """
@@ -82,7 +82,7 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         if private_key is not None:
             self._private_key = private_key
             self._public_key = private_key.public_key
-        super().__init__(client, address, state_init, state_info)
+        super().__init__(client, address, state_init, info)
 
     @property
     def state_data(self) -> _D:
@@ -295,7 +295,7 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         :return: Signed external message that was sent
         """
         external_msg = await self.build_external_message(messages, params)
-        await self.client.send_boc(external_msg.as_hex)
+        await self.client.send_message(external_msg.as_hex)
         return external_msg
 
     async def transfer_message(

tonutils/contracts/wallet/versions/v5.py

@@ -219,13 +219,13 @@ class WalletV5R1(
 
         :return: Typed wallet data
         """
-        if not (self._state_info and self._state_info.data):
+        if not (self._info and self._info.data):
             raise StateNotLoadedError(self, missing="state_data")
 
         network_global_id = (
             NetworkGlobalID.TESTNET if self.client.network else NetworkGlobalID.MAINNET
         )
-        cs = self._state_info.data.begin_parse()
+        cs = self._info.data.begin_parse()
         return self._data_model.deserialize(cs, network_global_id)
 
     async def _build_msg_cell(

tonutils/exceptions.py

@@ -27,7 +27,7 @@ class TransportError(TonutilsError):
 
     Covers: TCP connect, ADNL handshake, send/recv, crypto failures.
 
-    :param endpoint: Server address as "host:port"
+    :param endpoint: Endpoint identifier (URL or "host:port").
     :param operation: What was attempted ("connect", "handshake", "send", "recv")
     :param reason: Why it failed ("timeout 2.0s", "connection refused", etc.)
     """
@@ -46,7 +46,7 @@ class TransportError(TonutilsError):
         self.endpoint = endpoint
         self.operation = operation
         self.reason = reason
-        super().__init__(f"{operation} failed at {endpoint}: {reason}")
+        super().__init__(f"{operation} failed: {reason} ({endpoint})")
 
 
 class ProviderError(TonutilsError):
@@ -64,14 +64,28 @@ class BalancerError(TonutilsError):
 class NotConnectedError(TonutilsError, RuntimeError):
     """Raise when an operation requires an active connection."""
 
+    component: str
     endpoint: t.Optional[str]
+    operation: t.Optional[str]
 
-    def __init__(self, endpoint: t.Optional[str] = None) -> None:
+    def __init__(
+        self,
+        *,
+        component: str = "client",
+        endpoint: t.Optional[str] = None,
+        operation: t.Optional[str] = None,
+        hint: t.Optional[str] = None,
+    ) -> None:
+        self.component = component
         self.endpoint = endpoint
-        if endpoint:
-            super().__init__(f"not connected to {endpoint}")
-        else:
-            super().__init__("not connected")
+        self.operation = operation
+
+        if hint is None:
+            hint = "Call connect() first or use an async context manager (`async with ...`)."
+
+        where = f" ({endpoint})" if endpoint else ""
+        prefix = f"cannot `{operation}`: " if operation else ""
+        super().__init__(f"{prefix}{component} is not connected{where}. {hint}")
 
 
 class ProviderTimeoutError(ProviderError, asyncio.TimeoutError):
@@ -90,7 +104,7 @@ class ProviderTimeoutError(ProviderError, asyncio.TimeoutError):
         self.timeout = timeout
         self.endpoint = endpoint
         self.operation = operation
-        super().__init__(f"{operation} timed out after {timeout}s at {endpoint}")
+        super().__init__(f"{operation} timed out after {timeout}s ({endpoint})")
 
 
 class ProviderResponseError(ProviderError):
@@ -109,7 +123,7 @@ class ProviderResponseError(ProviderError):
         self.code = code
         self.message = message
         self.endpoint = endpoint
-        super().__init__(f"request failed with code {code} at {endpoint}: {message}")
+        super().__init__(f"request failed: {code} {message} ({endpoint})")
 
 
 class RetryLimitError(ProviderError):
@@ -134,7 +148,9 @@ class RetryLimitError(ProviderError):
         self.attempts = attempts
         self.max_attempts = max_attempts
         self.last_error = last_error
-        super().__init__(f"retry exhausted ({attempts}/{max_attempts}): {last_error}")
+        super().__init__(
+            f"retry limit reached ({attempts}/{max_attempts}): {last_error}"
+        )
 
 
 class ContractError(ClientError):
@@ -153,14 +169,14 @@ class ContractError(ClientError):
         name = (
             target.__name__ if isinstance(target, type) else target.__class__.__name__
         )
-        super().__init__(f"{name}: {message}")
+        super().__init__(f"{name} failed: {message}")
 
 
 class StateNotLoadedError(ContractError):
     """Raise when a contract wrapper requires state that is not loaded.
 
     :param contract: Contract instance related to the failure.
-    :param missing: Missing field name (e.g. "state_info", "state_data").
+    :param missing: Missing field name (e.g. "info", "state_data").
     """
 
     missing: str
@@ -188,7 +204,7 @@ class RunGetMethodError(ClientError):
         self.method_name = method_name
         self.exit_code = exit_code
         super().__init__(
-            f"get-method '{method_name}' failed for {address} with exit code {exit_code}"
+            f"get-method `{method_name}` failed: exit code {exit_code} ({address})"
         )
 
 

tonutils/tools/block_scanner/__init__.py

@@ -1,4 +1,8 @@
-from .events import BlockEvent, ErrorEvent, TransactionsEvent
+from .events import (
+    BlockEvent,
+    ErrorEvent,
+    TransactionsEvent,
+)
 from .scanner import BlockScanner
 
 __all__ = [

tonutils/tools/block_scanner/scanner.py

@@ -237,7 +237,7 @@ class BlockScanner:
             if self._on_transactions is None:
                 continue
 
-            get_block_transactions = self._client.get_block_transactions_ext
+            get_block_transactions = self._client.get_block_transactions
             try:
                 transactions = await get_block_transactions(shard_block)
             except asyncio.CancelledError:

tonutils/tools/status_monitor/monitor.py

@@ -114,7 +114,7 @@ class LiteServerMonitor:
             self._tasks.append(asyncio.create_task(slow))
 
     async def _ensure_connected(self, index: int, client: LiteClient) -> bool:
-        if client.provider.is_connected:
+        if client.provider.connected:
             return True
 
         now = time.monotonic()
@@ -124,7 +124,7 @@ class LiteServerMonitor:
 
         self._last_connect[index] = now
         await self._connect(index, client)
-        return client.provider.is_connected
+        return client.provider.connected
 
     async def _fast_update_loop(self, index: int, client: LiteClient) -> None:
         while not self._stop.is_set():
@@ -141,7 +141,7 @@ class LiteServerMonitor:
 
     async def _medium_update_loop(self, index: int, client: LiteClient) -> None:
         while not self._stop.is_set():
-            if not client.is_connected:
+            if not client.connected:
                 await self._sleep(1.0)
                 continue
 
@@ -154,7 +154,7 @@ class LiteServerMonitor:
 
     async def _slow_update_loop(self, index: int, client: LiteClient) -> None:
         while not self._stop.is_set():
-            if not client.is_connected:
+            if not client.connected:
                 await self._sleep(1.0)
                 continue
 
@@ -223,14 +223,14 @@ class LiteServerMonitor:
                 return
 
             mc_txs, shards = await asyncio.gather(
-                client.get_block_transactions_ext(mc_block),
+                client.get_block_transactions(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)
+                bc_txs = await client.get_block_transactions(bc_block)
                 last_bc_block = BlockInfo(seqno=bc_block.seqno, txs_count=len(bc_txs))
                 await self._set_status(
                     index,

tonutils/types.py

@@ -16,7 +16,7 @@ __all__ = [
     "BinaryLike",
     "ClientType",
     "ContractState",
-    "ContractStateInfo",
+    "ContractInfo",
     "DNSCategory",
     "DNSPrefix",
     "MetadataPrefix",
@@ -189,7 +189,7 @@ class ContractState(str, Enum):
     NONEXIST = "nonexist"
 
 
-class ContractStateInfo:
+class ContractInfo:
     """
     TON smart contract state information.
 

{tonutils-2.0.1b6.dist-info → tonutils-2.0.1b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tonutils
-Version: 2.0.1b6
+Version: 2.0.1b7
 Summary: Tonutils is a high-level, object-oriented Python library designed to facilitate seamless interactions with the TON blockchain.
 Author: nessshon
 Maintainer: nessshon
@@ -69,27 +69,13 @@ pip install --pre tonutils
 
 ## Usage
 
-Practical feature examples can be found in the **[examples](examples)** directory.\
-Each script demonstrates real-world usage and can be used as a reference when integrating `tonutils` into your project.
-
-## Contribution
-
-We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
-submit a pull request.
+Practical feature examples can be found in the **[examples](examples)** directory.
 
 ## Donations
 
 Your contributions help me continue developing and improving this project!
 
-- **TON**: `UQCZq3_Vd21-4y4m7Wc-ej9NFOhh_qvdfAkAYAOHoQ__Ness`
-
-- **BTC**: `1JXHbB5kE1DfkHdv5dsNygRkNC3unJdU8M`
-
-- **USDT** (TRC-20): `TU4fCFdWufKb4rd25ihksiNDZZdyEYqro6`
-
-- **Crypto Bot**: [Donate through Crypto Bot](https://t.me/send?start=IVW1cyG3DYqG)
-
-- **xRocket Bot**: [Donate through xRocket](https://t.me/xrocket?start=inv_R4llrClZtPjovVe)
+**TON**: `UQCZq3_Vd21-4y4m7Wc-ej9NFOhh_qvdfAkAYAOHoQ__Ness`
 
 ## Support
 
@@ -99,4 +85,3 @@ With special thanks to [Igroman787](https://github.com/Igroman787) for the suppo
 ## License
 
 This repository is distributed under the [MIT License](LICENSE).
-Feel free to use, modify, and distribute the code in accordance with the terms of the license.