tonutils 2.0.1b5__tar.gz → 2.0.1b6__tar.gz

{tonutils-2.0.1b5/tonutils.egg-info → tonutils-2.0.1b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tonutils
-Version: 2.0.1b5
+Version: 2.0.1b6
 Summary: Tonutils is a high-level, object-oriented Python library designed to facilitate seamless interactions with the TON blockchain.
 Author: nessshon
 Maintainer: nessshon

tonutils-2.0.1b6/tonutils/__meta__.py

@@ -0,0 +1 @@
+__version__ = "2.0.1b6"

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/__init__.py

@@ -5,12 +5,12 @@ from .adnl import (
 )
 from .http import (
     HttpBalancer,
-    ChainstackHttpClient,
-    QuicknodeHttpClient,
-    TatumHttpClient,
-    TonapiHttpClient,
+    ChainstackClient,
+    QuicknodeClient,
+    TatumClient,
+    TonapiClient,
     TonapiHttpProvider,
-    ToncenterHttpClient,
+    ToncenterClient,
     ToncenterHttpProvider,
 )
 
@@ -19,11 +19,11 @@ __all__ = [
     "LiteClient",
     "AdnlProvider",
     "HttpBalancer",
-    "ChainstackHttpClient",
-    "QuicknodeHttpClient",
-    "TatumHttpClient",
-    "TonapiHttpClient",
+    "ChainstackClient",
+    "QuicknodeClient",
+    "TatumClient",
+    "TonapiClient",
     "TonapiHttpProvider",
-    "ToncenterHttpClient",
+    "ToncenterClient",
     "ToncenterHttpProvider",
 ]

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/adnl/balancer.py

@@ -64,8 +64,8 @@ class LiteBalancer(BaseClient):
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         clients: t.List[LiteClient],
         connect_timeout: float = 2.0,
         request_timeout: float = 12.0,
@@ -206,8 +206,8 @@ class LiteBalancer(BaseClient):
     @classmethod
     def from_config(
         cls,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         config: t.Union[GlobalConfig, t.Dict[str, t.Any]],
         connect_timeout: float = 2.0,
         request_timeout: float = 12.0,
@@ -285,8 +285,8 @@ class LiteBalancer(BaseClient):
     @classmethod
     def from_network_config(
         cls,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         connect_timeout: float = 2.0,
         request_timeout: float = 12.0,
         client_connect_timeout: float = 1.5,
@@ -513,13 +513,14 @@ class LiteBalancer(BaseClient):
 
         return await self._with_failover(_call)
 
-    async def _get_contract_transactions(
+    async def _get_transactions(
         self,
         address: str,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
+        to_lt = 0 if to_lt is None else to_lt
         state = await self._get_contract_info(address)
         account = Address(address).to_tl_account_id()
 
@@ -530,41 +531,37 @@ class LiteBalancer(BaseClient):
         curr_hash = state.last_transaction_hash
         transactions: t.List[Transaction] = []
 
-        while len(transactions) < limit and curr_lt != 0:
-            batch_size = min(16, limit - len(transactions))
+        while curr_lt != 0:
+            fetch_lt = curr_lt
+            fetch_hash = curr_hash
 
             async def _call(provider: AdnlProvider) -> t.List[Transaction]:
                 return await provider.get_transactions(
                     account=account,
-                    count=batch_size,
-                    from_lt=curr_lt,
-                    from_hash=curr_hash,
+                    count=16,
+                    from_lt=fetch_lt,
+                    from_hash=fetch_hash,
                 )
 
             txs = await self._with_failover(_call)
             if not txs:
                 break
 
-            if to_lt > 0 and txs[-1].lt <= to_lt:
-                trimmed: t.List[Transaction] = []
-                for tx in txs:
-                    if tx.lt <= to_lt:
-                        break
-                    trimmed.append(tx)
-                transactions.extend(trimmed)
-                break
+            for tx in txs:
+                if from_lt is not None and tx.lt > from_lt:
+                    continue
+                if to_lt > 0 and tx.lt <= to_lt:
+                    return transactions[:limit]
 
-            transactions.extend(txs)
+                transactions.append(tx)
+                if len(transactions) >= limit:
+                    return transactions
 
             last_tx = txs[-1]
             curr_lt = last_tx.prev_trans_lt
             curr_hash = last_tx.prev_trans_hash.hex()
 
-        return (
-            [tx for tx in transactions if tx.lt < from_lt]
-            if from_lt is not None
-            else transactions
-        )
+        return transactions[:limit]
 
     async def _run_get_method(
         self,

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/adnl/client.py

@@ -34,8 +34,8 @@ class LiteClient(BaseClient):
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         ip: t.Union[str, int],
         port: int,
         public_key: BinaryLike,
@@ -119,8 +119,8 @@ class LiteClient(BaseClient):
     @classmethod
     def from_config(
         cls,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         config: t.Union[GlobalConfig, t.Dict[str, t.Any]],
         index: int,
         connect_timeout: float = 2.0,
@@ -170,8 +170,8 @@ class LiteClient(BaseClient):
     @classmethod
     def from_network_config(
         cls,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         index: int,
         connect_timeout: float = 2.0,
         request_timeout: float = 10.0,
@@ -225,13 +225,14 @@ class LiteClient(BaseClient):
     async def _get_contract_info(self, address: str) -> ContractStateInfo:
         return await self.provider.get_account_state(Address(address))
 
-    async def _get_contract_transactions(
+    async def _get_transactions(
         self,
         address: str,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
+        to_lt = 0 if to_lt is None else to_lt
         state = await self._get_contract_info(address)
         account = Address(address).to_tl_account_id()
 
@@ -242,38 +243,34 @@ class LiteClient(BaseClient):
         curr_hash = state.last_transaction_hash
         transactions: t.List[Transaction] = []
 
-        while len(transactions) < limit and curr_lt != 0:
-            batch_size = min(16, limit - len(transactions))
+        while curr_lt != 0:
+            fetch_lt = curr_lt
+            fetch_hash = curr_hash
 
             txs = await self.provider.get_transactions(
                 account=account,
-                count=batch_size,
-                from_lt=curr_lt,
-                from_hash=curr_hash,
+                count=16,
+                from_lt=fetch_lt,
+                from_hash=fetch_hash,
             )
             if not txs:
                 break
 
-            if to_lt > 0 and txs[-1].lt <= to_lt:
-                trimmed: t.List[Transaction] = []
-                for tx in txs:
-                    if tx.lt <= to_lt:
-                        break
-                    trimmed.append(tx)
-                transactions.extend(trimmed)
-                break
+            for tx in txs:
+                if from_lt is not None and tx.lt > from_lt:
+                    continue
+                if to_lt > 0 and tx.lt <= to_lt:
+                    return transactions[:limit]
 
-            transactions.extend(txs)
+                transactions.append(tx)
+                if len(transactions) >= limit:
+                    return transactions
 
             last_tx = txs[-1]
             curr_lt = last_tx.prev_trans_lt
             curr_hash = last_tx.prev_trans_hash.hex()
 
-        return (
-            [tx for tx in transactions if tx.lt < from_lt]
-            if from_lt is not None
-            else transactions
-        )
+        return transactions[:limit]
 
     async def _run_get_method(
         self,

tonutils-2.0.1b6/tonutils/clients/adnl/provider/config.py

@@ -0,0 +1,48 @@
+import json
+import urllib.request
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+
+from pydantic import ValidationError
+
+from tonutils.clients.adnl.provider.models import GlobalConfig
+
+
+def load_global_config(source: str) -> GlobalConfig:
+    try:
+        if source.startswith(("http://", "https://")):
+            with urllib.request.urlopen(source) as r:
+                data = json.loads(r.read().decode("utf-8"))
+        else:
+            data = json.loads(Path(source).read_text(encoding="utf-8"))
+        return GlobalConfig.model_validate(data)
+    except HTTPError as e:
+        raise RuntimeError(f"Config fetch failed: {e} ({source})") from e
+    except URLError as e:
+        raise RuntimeError(f"Config fetch failed: {e.reason} ({source})") from e
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"Config JSON is invalid: {e.msg} ({source})") from e
+    except ValidationError as e:
+        raise RuntimeError(f"Config validation failed: {e} ({source})") from e
+    except OSError as e:
+        raise RuntimeError(f"Config read failed: {e} ({source})") from e
+    except Exception as e:
+        raise RuntimeError(f"Config load failed: {e} ({source})") from e
+
+
+def get_mainnet_global_config() -> GlobalConfig:
+    """
+    Fetch mainnet global configuration.
+
+    :return: Parsed GlobalConfig instance
+    """
+    return load_global_config("https://ton.org/global-config.json")
+
+
+def get_testnet_global_config() -> GlobalConfig:
+    """
+    Fetch testnet global configuration.
+
+    :return: Parsed GlobalConfig instance
+    """
+    return load_global_config("https://ton.org/testnet-global-config.json")

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/base.py

@@ -98,20 +98,23 @@ class BaseClient(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    async def _get_contract_transactions(
+    async def _get_transactions(
         self,
         address: str,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
         """
-        Fetch a list of recent contract transactions from the provider.
+        Fetch transaction history for a contract.
+        Returns transactions in the range (to_lt, from_lt), ordered from newest to oldest.
 
-        :param address: Contract address in raw
+        :param address: Contract address as string
         :param limit: Maximum number of transactions to return
-        :param from_lt: Optional lower bound (exclusive) logical time
-        :param to_lt: Upper bound (inclusive) logical time, 0 means latest
+        :param from_lt: Upper bound logical time (inclusive).
+            If None, starts from the most recent transaction.
+        :param to_lt: Lower bound logical time (exclusive).
+            If None or 0, no lower bound is applied.
         :return: List of Transaction objects ordered from newest to oldest
         """
         raise NotImplementedError
@@ -180,25 +183,28 @@ class BaseClient(abc.ABC):
             address = Address(address).to_str(is_user_friendly=False)
         return await self._get_contract_info(address=address)
 
-    async def get_contract_transactions(
+    async def get_transactions(
         self,
         address: AddressLike,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
         """
         Fetch transaction history for a contract.
+        Returns transactions in the range (to_lt, from_lt), ordered from newest to oldest.
 
         :param address: Contract address as Address object or string
         :param limit: Maximum number of transactions to return
-        :param from_lt: Optional lower bound (exclusive) logical time
-        :param to_lt: Upper bound (inclusive) logical time, 0 means latest
+        :param from_lt: Upper bound logical time (inclusive).
+            If None, starts from the most recent transaction.
+        :param to_lt: Lower bound logical time (exclusive).
+            If None or 0, no lower bound is applied.
         :return: List of Transaction objects ordered from newest to oldest
         """
         if isinstance(address, Address):
             address = Address(address).to_str(is_user_friendly=False)
-        return await self._get_contract_transactions(
+        return await self._get_transactions(
             address=address,
             limit=limit,
             from_lt=from_lt,

tonutils-2.0.1b6/tonutils/clients/http/__init__.py

@@ -0,0 +1,23 @@
+from .balancer import HttpBalancer
+from .clients import (
+    ChainstackClient,
+    QuicknodeClient,
+    TatumClient,
+    TonapiClient,
+    ToncenterClient,
+)
+from .provider import (
+    TonapiHttpProvider,
+    ToncenterHttpProvider,
+)
+
+__all__ = [
+    "HttpBalancer",
+    "ChainstackClient",
+    "QuicknodeClient",
+    "TatumClient",
+    "TonapiClient",
+    "TonapiHttpProvider",
+    "ToncenterClient",
+    "ToncenterHttpProvider",
+]

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/http/balancer.py

@@ -10,7 +10,7 @@ from itertools import cycle
 from pytoniq_core import Transaction
 
 from tonutils.clients.base import BaseClient
-from tonutils.clients.http.clients.quicknode import QuicknodeHttpClient
+from tonutils.clients.http.clients.quicknode import QuicknodeClient
 from tonutils.exceptions import (
     BalancerError,
     ClientError,
@@ -50,8 +50,8 @@ class HttpBalancer(BaseClient):
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         clients: t.List[BaseClient],
         request_timeout: float = 12.0,
     ) -> None:
@@ -60,15 +60,15 @@ class HttpBalancer(BaseClient):
 
         Each supported HTTP client requires its own credentials or endpoint
         configuration. You can obtain them from the corresponding provider:
-            - ToncenterHttpClient:
+            - ToncenterClient:
                 API key available via Telegram bot: https://t.me/toncenter
-            - TonapiHttpClient:
+            - TonapiClient:
                 API key available on the Tonconsole website: https://tonconsole.com/
-            - ChainstackHttpClient:
+            - ChainstackClient:
                 Personal endpoint available on: https://chainstack.com/
-            - QuicknodeHttpClient:
+            - QuicknodeClient:
                 Personal endpoint available on: https://www.quicknode.com/
-            - TatumHttpClient:
+            - TatumClient:
                 API key available on: https://tatum.io/
 
         :param network: Target TON network (mainnet or testnet)
@@ -102,7 +102,7 @@ class HttpBalancer(BaseClient):
                 )
 
             if (
-                isinstance(client, QuicknodeHttpClient)
+                isinstance(client, QuicknodeClient)
                 and self.network == NetworkGlobalID.TESTNET
             ):
                 raise ClientError(
@@ -356,15 +356,15 @@ class HttpBalancer(BaseClient):
 
         return await self._with_failover(_call)
 
-    async def _get_contract_transactions(
+    async def _get_transactions(
         self,
         address: str,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
         async def _call(client: BaseClient) -> t.List[Transaction]:
-            return await client._get_contract_transactions(
+            return await client._get_transactions(
                 address=address,
                 limit=limit,
                 from_lt=from_lt,

tonutils-2.0.1b6/tonutils/clients/http/clients/__init__.py

@@ -0,0 +1,13 @@
+from .chainstack import ChainstackClient
+from .quicknode import QuicknodeClient
+from .tatum import TatumClient
+from .tonapi import TonapiClient
+from .toncenter import ToncenterClient
+
+__all__ = [
+    "ChainstackClient",
+    "QuicknodeClient",
+    "TatumClient",
+    "TonapiClient",
+    "ToncenterClient",
+]

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/http/clients/chainstack.py

@@ -2,16 +2,16 @@ import typing as t
 
 from aiohttp import ClientSession
 
-from tonutils.clients.http.clients.toncenter import ToncenterHttpClient
+from tonutils.clients.http.clients.toncenter import ToncenterClient
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
 
-class ChainstackHttpClient(ToncenterHttpClient):
+class ChainstackClient(ToncenterClient):
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID,
+        *,
         http_provider_url: str,
         timeout: float = 10.0,
         session: t.Optional[ClientSession] = None,

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/http/clients/quicknode.py

@@ -2,11 +2,11 @@ import typing as t
 
 from aiohttp import ClientSession
 
-from tonutils.clients.http.clients.toncenter import ToncenterHttpClient
+from tonutils.clients.http.clients.toncenter import ToncenterClient
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
 
-class QuicknodeHttpClient(ToncenterHttpClient):
+class QuicknodeClient(ToncenterClient):
 
     def __init__(
         self,
@@ -33,7 +33,6 @@ class QuicknodeHttpClient(ToncenterHttpClient):
         :param rps_period: Rate limit period in seconds.
         :param retry_policy: Optional retry policy that defines per-error-code retry rules
         """
-
         super().__init__(
             network=NetworkGlobalID.MAINNET,
             base_url=http_provider_url,

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/http/clients/tatum.py

@@ -2,16 +2,16 @@ import typing as t
 
 from aiohttp import ClientSession
 
-from tonutils.clients.http.clients.toncenter import ToncenterHttpClient
+from tonutils.clients.http.clients.toncenter import ToncenterClient
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
 
-class TatumHttpClient(ToncenterHttpClient):
+class TatumClient(ToncenterClient):
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID,
+        *,
         api_key: str,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,

{tonutils-2.0.1b5 → tonutils-2.0.1b6}/tonutils/clients/http/clients/tonapi.py

@@ -6,8 +6,8 @@ from aiohttp import ClientSession
 from pytoniq_core import Cell, Slice, Transaction
 
 from tonutils.clients.base import BaseClient
-from tonutils.clients.http.providers.tonapi.models import BlockchainMessagePayload
-from tonutils.clients.http.providers.tonapi.provider import TonapiHttpProvider
+from tonutils.clients.http.provider.models import BlockchainMessagePayload
+from tonutils.clients.http.provider.tonapi import TonapiHttpProvider
 from tonutils.clients.http.utils import encode_tonapi_stack, decode_tonapi_stack
 from tonutils.exceptions import ClientError, RunGetMethodError
 from tonutils.types import (
@@ -23,15 +23,15 @@ from tonutils.utils import (
 )
 
 
-class TonapiHttpClient(BaseClient):
+class TonapiClient(BaseClient):
     """TON blockchain client using Tonapi HTTP API as transport."""
 
     TYPE = ClientType.HTTP
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         api_key: str,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,
@@ -80,7 +80,7 @@ class TonapiHttpClient(BaseClient):
         session = self._provider.session
         return session is not None and not session.closed
 
-    async def __aenter__(self) -> TonapiHttpClient:
+    async def __aenter__(self) -> TonapiClient:
         await self._provider.connect()
         return self
 
@@ -122,21 +122,20 @@ class TonapiHttpClient(BaseClient):
 
         return contract_info
 
-    async def _get_contract_transactions(
+    async def _get_transactions(
         self,
         address: str,
         limit: int = 100,
         from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
+        to_lt: t.Optional[int] = None,
     ) -> t.List[Transaction]:
-        if from_lt is not None:
-            from_lt += 1
+        before_lt = from_lt + 1 if from_lt is not None else None
 
         result = await self.provider.blockchain_account_transactions(
             address=address,
             limit=limit,
             after_lt=to_lt,
-            before_lt=from_lt,
+            before_lt=before_lt,
         )
 
         transactions = []