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

tonutils/clients/http/clients/toncenter.py

@@ -7,32 +7,29 @@ from aiohttp import ClientSession
 from pytoniq_core import Cell, Slice, Transaction
 
 from tonutils.clients.base import BaseClient
-from tonutils.clients.http.providers.toncenter.models import (
-    SendBocPayload,
-    RunGetMethodPayload,
-)
-from tonutils.clients.http.providers.toncenter.provider import ToncenterHttpProvider
+from tonutils.clients.http.provider.models import SendBocPayload, RunGetMethodPayload
+from tonutils.clients.http.provider.toncenter import ToncenterHttpProvider
 from tonutils.clients.http.utils import decode_toncenter_stack, encode_toncenter_stack
 from tonutils.exceptions import ClientError, RunGetMethodError
 from tonutils.types import (
     ClientType,
     ContractState,
-    ContractStateInfo,
+    ContractInfo,
     NetworkGlobalID,
     RetryPolicy,
 )
 from tonutils.utils import cell_to_hex, parse_stack_config
 
 
-class ToncenterHttpClient(BaseClient):
+class ToncenterClient(BaseClient):
     """TON blockchain client using Toncenter HTTP API as transport."""
 
     TYPE = ClientType.HTTP
 
     def __init__(
         self,
-        *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
+        *,
         api_key: t.Optional[str] = None,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,
@@ -73,56 +70,44 @@ class ToncenterHttpClient(BaseClient):
         )
 
     @property
-    def provider(self) -> ToncenterHttpProvider:
-        return self._provider
-
-    @property
-    def is_connected(self) -> bool:
+    def connected(self) -> bool:
         session = self._provider.session
         return session is not None and not session.closed
 
-    async def __aenter__(self) -> ToncenterHttpClient:
+    @property
+    def provider(self) -> ToncenterHttpProvider:
+        return self._provider
+
+    async def connect(self) -> None:
         await self._provider.connect()
-        return self
 
-    async def __aexit__(
-        self,
-        exc_type: t.Optional[t.Type[BaseException]],
-        exc_value: t.Optional[BaseException],
-        traceback: t.Optional[t.Any],
-    ) -> None:
+    async def close(self) -> None:
         await self._provider.close()
 
-    async def _send_boc(self, boc: str) -> None:
+    async def _send_message(self, boc: str) -> None:
         payload = SendBocPayload(boc=boc)
         return await self.provider.send_boc(payload=payload)
 
-    async def _get_blockchain_config(self) -> t.Dict[int, t.Any]:
+    async def _get_config(self) -> t.Dict[int, t.Any]:
         request = await self.provider.get_config_all()
 
         if request.result is None:
-            raise ClientError(
-                "Invalid get_config_all response: missing 'result' field."
-            )
+            raise ClientError("Invalid get_config response: missing `result`.")
 
         if request.result.config is None:
-            raise ClientError(
-                "Invalid config response: missing 'config' section in result."
-            )
+            raise ClientError("Invalid config response: missing `config` in `result`.")
 
         if request.result.config.bytes is None:
-            raise ClientError(
-                "Invalid config response: missing 'bytes' field in 'config' section."
-            )
+            raise ClientError("Invalid config response: missing `config.bytes`.")
 
         config_cell = Cell.one_from_boc(request.result.config.bytes)
         config_slice = config_cell.begin_parse()
         return parse_stack_config(config_slice)
 
-    async def _get_contract_info(self, address: str) -> ContractStateInfo:
+    async def _get_info(self, address: str) -> ContractInfo:
         request = await self.provider.get_address_information(address)
 
-        contract_info = ContractStateInfo(
+        contract_info = ContractInfo(
             balance=int(request.result.balance),
             state=ContractState(request.result.state),
         )
@@ -166,28 +151,58 @@ class ToncenterHttpClient(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
+        to_lt = 0 if to_lt is None else to_lt
+        transactions: t.List[Transaction] = []
 
-        request = await self.provider.get_transaction(
-            address=address,
-            limit=limit,
-            from_lt=from_lt,
-            to_lt=to_lt,
-        )
+        curr_lt: t.Optional[int] = None
+        curr_hash: t.Optional[str] = None
+
+        while len(transactions) < limit:
+            request = await self.provider.get_transactions(
+                address=address,
+                limit=100,
+                lt=curr_lt,
+                from_hash=curr_hash,
+                to_lt=to_lt if to_lt > 0 else None,
+            )
+
+            batch = []
+            for tx in request.result or []:
+                if tx.data is not None:
+                    tx_slice = Slice.one_from_boc(tx.data)
+                    batch.append(Transaction.deserialize(tx_slice))
+
+            if not batch:
+                break
+
+            for tx in batch:
+                # Skip transactions above from_lt (if specified)
+                if from_lt is not None and tx.lt > from_lt:
+                    continue
+
+                # Stop if we've reached the lower bound
+                if to_lt > 0 and tx.lt <= to_lt:
+                    return transactions[:limit]
 
-        transactions = []
-        for tx in request.result or []:
-            if tx.data is not None:
-                tx_slice = Slice.one_from_boc(tx.data)
-                transactions.append(Transaction.deserialize(tx_slice))
+                transactions.append(tx)
+
+                if len(transactions) >= limit:
+                    return transactions
+
+            # Setup for next iteration
+            last_tx = batch[-1]
+            if last_tx.prev_trans_lt == 0:
+                break
+
+            curr_lt = last_tx.prev_trans_lt
+            curr_hash = last_tx.prev_trans_hash.hex()
 
         return transactions
 
@@ -214,9 +229,3 @@ class ToncenterHttpClient(BaseClient):
             )
 
         return decode_toncenter_stack(request.result.stack or [])
-
-    async def connect(self) -> None:
-        await self._provider.connect()
-
-    async def close(self) -> None:
-        await self._provider.close()

tonutils/clients/http/{providers → provider}/__init__.py

@@ -1,4 +1,7 @@
 from .tonapi import TonapiHttpProvider
 from .toncenter import ToncenterHttpProvider
 
-__all__ = ["TonapiHttpProvider", "ToncenterHttpProvider"]
+__all__ = [
+    "TonapiHttpProvider",
+    "ToncenterHttpProvider",
+]

tonutils/clients/http/{providers → provider}/base.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import typing as t
 
 import aiohttp
+from pydantic import BaseModel, ValidationError
 
-from tonutils.clients.http.providers.response import HttpResponse
 from tonutils.clients.limiter import RateLimiter
 from tonutils.exceptions import (
     NotConnectedError,
     ProviderResponseError,
     ProviderTimeoutError,
     RetryLimitError,
+    CDN_CHALLENGE_MARKERS,
+    TransportError,
+    ProviderError,
 )
 from tonutils.types import RetryPolicy
 
@@ -64,17 +68,77 @@ class HttpProvider:
         return self._session
 
     @property
-    def is_connected(self) -> bool:
+    def connected(self) -> bool:
         """Check whether the provider session is initialized and open."""
         return self._session is not None and not self._session.closed
 
+    @staticmethod
+    def _model(model: t.Type[BaseModel], data: t.Any) -> t.Any:
+        try:
+            return model.model_validate(data)
+        except ValidationError as e:
+            raise ProviderError(
+                f"invalid response: {model.__name__} validation failed"
+            ) from e
+
+    async def send_http_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: t.Any = None,
+        json_data: t.Any = None,
+    ) -> t.Any:
+        """Send an HTTP request with retry handling.
+
+        On provider error, retries the request according to the retry policy
+        matched by error code and message. If no rule matches, or retry attempts
+        are exhausted, the error is raised.
+
+        :param method: HTTP method.
+        :param path: Endpoint path relative to base_url.
+        :param params: Optional query parameters.
+        :param json_data: Optional JSON body.
+        :return: Parsed response payload.
+        """
+        attempts: t.Dict[int, int] = {}
+
+        while True:
+            try:
+                return await self._send_once(
+                    method,
+                    path,
+                    params=params,
+                    json_data=json_data,
+                )
+            except ProviderResponseError as e:
+                policy = self._retry_policy
+                if policy is None:
+                    raise
+
+                rule = policy.rule_for(e.code, e.message)
+                if rule is None:
+                    raise
+
+                key = id(rule)
+                attempts[key] = attempts.get(key, 0) + 1
+
+                if attempts[key] >= rule.attempts:
+                    raise RetryLimitError(
+                        attempts=attempts[key],
+                        max_attempts=rule.attempts,
+                        last_error=e,
+                    ) from e
+
+                await asyncio.sleep(rule.delay(attempts[key] - 1))
+
     async def connect(self) -> None:
         """Initialize HTTP session if not already connected."""
-        if self.is_connected:
+        if self.connected:
             return
 
         async with self._connect_lock:
-            if self.is_connected:
+            if self.connected:
                 return
 
             self._session = aiohttp.ClientSession(
@@ -90,6 +154,34 @@ class HttpProvider:
                 await self._session.close()
             self._session = None
 
+    @classmethod
+    async def _read_response(cls, resp: aiohttp.ClientResponse) -> t.Any:
+        body = await resp.read()
+        if not body:
+            return ""
+
+        data = body.decode("utf-8", errors="replace").strip()
+        if not data:
+            return ""
+
+        try:
+            return json.loads(data)
+        except (Exception,):
+            return data
+
+    @classmethod
+    def _raise_error(cls, status: int, url: str, data: t.Any) -> None:
+        exc = cls._detect_proxy_error(data, status=status, url=url)
+        if exc is not None:
+            raise exc
+
+        message = cls._extract_error_message(data)
+        raise ProviderResponseError(
+            code=status,
+            message=message,
+            endpoint=url,
+        )
+
     async def _send_once(
         self,
         method: str,
@@ -110,8 +202,12 @@ class HttpProvider:
         :param json_data: Optional JSON body.
         :return: Parsed response payload.
         """
-        if not self.is_connected:
-            raise NotConnectedError()
+        if not self.connected:
+            raise NotConnectedError(
+                component="HttpProvider",
+                endpoint=self._base_url,
+                operation=f"{method} {path}",
+            )
 
         assert self._session is not None
         url = f"{self._base_url}/{path.lstrip('/')}"
@@ -126,13 +222,9 @@ class HttpProvider:
                 params=params,
                 json=json_data,
             ) as resp:
-                data = await HttpResponse.read(resp)
+                data = await self._read_response(resp)
                 if resp.status >= 400:
-                    HttpResponse.raise_error(
-                        status=int(resp.status),
-                        url=url,
-                        data=data,
-                    )
+                    self._raise_error(int(resp.status), url, data)
                 return data
 
         except asyncio.TimeoutError as exc:
@@ -141,61 +233,48 @@ class HttpProvider:
                 endpoint=url,
                 operation="http request",
             ) from exc
-
         except aiohttp.ClientError as exc:
-            raise ProviderResponseError(
-                code=0,
-                message=str(exc),
+            raise TransportError(
                 endpoint=url,
+                operation="http request",
+                reason=str(exc),
             ) from exc
 
-    async def send_http_request(
-        self,
-        method: str,
-        path: str,
-        *,
-        params: t.Any = None,
-        json_data: t.Any = None,
-    ) -> t.Any:
-        """Send an HTTP request with retry handling.
-
-        On provider error, retries the request according to the retry policy
-        matched by error code and message. If no rule matches, or retry attempts
-        are exhausted, the error is raised.
-
-        :param method: HTTP method.
-        :param path: Endpoint path relative to base_url.
-        :param params: Optional query parameters.
-        :param json_data: Optional JSON body.
-        :return: Parsed response payload.
-        """
-        attempts: t.Dict[int, int] = {}
+    @classmethod
+    def _detect_proxy_error(
+        cls,
+        data: t.Any,
+        status: int,
+        url: str,
+    ) -> t.Optional[ProviderResponseError]:
+        body = (
+            " ".join(str(v) for v in data.values())
+            if isinstance(data, dict)
+            else str(data)
+        ).lower()
 
-        while True:
-            try:
-                return await self._send_once(
-                    method,
-                    path,
-                    params=params,
-                    json_data=json_data,
+        for marker, message in CDN_CHALLENGE_MARKERS.items():
+            if marker in body:
+                return ProviderResponseError(
+                    code=status,
+                    message=message,
+                    endpoint=url,
                 )
-            except ProviderResponseError as e:
-                policy = self._retry_policy
-                if policy is None:
-                    raise
 
-                rule = policy.rule_for(e.code, e.message)
-                if rule is None:
-                    raise
+        return None
 
-                key = id(rule)
-                attempts[key] = attempts.get(key, 0) + 1
+    @staticmethod
+    def _extract_error_message(data: t.Any) -> str:
+        if isinstance(data, dict):
+            lowered = {k.lower(): v for k, v in data.items()}
+            for key in ("error", "message", "detail", "description"):
+                if key in lowered and isinstance(lowered[key], str):
+                    return lowered[key]
+            string_values = [str(v) for v in data.values() if isinstance(v, str)]
+            return "; ".join(string_values) if string_values else str(data)
 
-                if attempts[key] >= rule.attempts:
-                    raise RetryLimitError(
-                        attempts=attempts[key],
-                        max_attempts=rule.attempts,
-                        last_error=e,
-                    ) from e
-
-                await asyncio.sleep(rule.delay(attempts[key] - 1))
+        if isinstance(data, list):
+            return "; ".join(map(str, data))
+        if isinstance(data, str):
+            return data
+        return repr(data)

tonutils/clients/http/{providers/toncenter → provider}/models.py

@@ -6,6 +6,48 @@ from tonutils.types import ContractState
 from tonutils.utils import to_cell, cell_to_b64
 
 
+class BlockchainMessagePayload(BaseModel):
+    """Payload for /blockchain/message endpoint."""
+
+    boc: str
+
+
+class BlockchainConfigResult(BaseModel):
+    """Result model for /blockchain/config."""
+
+    raw: t.Optional[str] = None
+
+
+class BlockchainAccountResult(BaseModel):
+    """Result model for /blockchain/accounts/{address}."""
+
+    balance: int = 0
+    status: str = ContractState.NONEXIST.value
+    code: t.Optional[str] = None
+    data: t.Optional[str] = None
+    last_transaction_lt: t.Optional[int] = None
+    last_transaction_hash: t.Optional[str] = None
+
+
+class _BlockchainAccountTransaction(BaseModel):
+    """Single account transaction with raw BoC payload."""
+
+    raw: t.Optional[str] = None
+
+
+class BlockchainAccountTransactionsResult(BaseModel):
+    """Result model for /blockchain/accounts/{address}/transactions."""
+
+    transactions: t.Optional[t.List[_BlockchainAccountTransaction]] = None
+
+
+class BlockchainAccountMethodResult(BaseModel):
+    """Result model for /blockchain/accounts/{address}/methods/{method_name}."""
+
+    stack: t.Optional[t.List[t.Any]] = None
+    exit_code: int
+
+
 class SendBocPayload(BaseModel):
     """
     Payload for /sendBoc endpoint.
@@ -77,7 +119,7 @@ class _Transaction(BaseModel):
     data: t.Optional[str] = None
 
 
-class GetTransactionResult(BaseModel):
+class GetTransactionsResult(BaseModel):
     """Result wrapper for /getTransactions."""
 
     result: t.Optional[t.List[_Transaction]] = None
@@ -98,7 +140,7 @@ class RunGetMethodPayload(BaseModel):
     stack: t.List[t.Any]
 
 
-class RunGetMethodResul(BaseModel):
+class RunGetMethodResult(BaseModel):
     """Response wrapper for /runGetMethod."""
 
     result: t.Optional[_GetMethod] = None

tonutils/clients/http/{providers/tonapi/provider.py → provider/tonapi.py}

@@ -3,15 +3,14 @@ from __future__ import annotations
 import typing as t
 
 import aiohttp
-from pydantic import BaseModel
 
-from tonutils.clients.http.providers.base import HttpProvider
-from tonutils.clients.http.providers.tonapi.models import (
-    BlockchainAccountMethodResult,
+from tonutils.clients.http.provider.base import HttpProvider
+from tonutils.clients.http.provider.models import (
+    BlockchainMessagePayload,
+    BlockchainConfigResult,
     BlockchainAccountResult,
     BlockchainAccountTransactionsResult,
-    BlockchainConfigResult,
-    BlockchainMessagePayload,
+    BlockchainAccountMethodResult,
 )
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
@@ -21,6 +20,7 @@ class TonapiHttpProvider(HttpProvider):
     def __init__(
         self,
         network: NetworkGlobalID,
+        *,
         api_key: str,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,
@@ -49,10 +49,6 @@ class TonapiHttpProvider(HttpProvider):
             retry_policy=retry_policy,
         )
 
-    @staticmethod
-    def _model(model: t.Type[BaseModel], data: t.Any) -> t.Any:
-        return model.model_validate(data)
-
     async def blockchain_message(
         self,
         payload: BlockchainMessagePayload,
@@ -92,12 +88,11 @@ class TonapiHttpProvider(HttpProvider):
         limit: int = 100,
         after_lt: t.Optional[int] = None,
         before_lt: t.Optional[int] = None,
-        sort_order: str = "desc",
     ) -> BlockchainAccountTransactionsResult:
-        params = {"limit": limit, "sort_order": sort_order}
+        params = {"limit": limit}
         if after_lt is not None:
             params["after_lt"] = after_lt
-        if before_lt is not None and before_lt > 0:
+        if before_lt is not None:
             params["before_lt"] = before_lt
 
         return self._model(

tonutils/clients/http/{providers/toncenter/provider.py → provider/toncenter.py}

@@ -1,16 +1,15 @@
 import typing as t
 
 import aiohttp
-from pydantic import BaseModel
 
-from tonutils.clients.http.providers.base import HttpProvider
-from tonutils.clients.http.providers.toncenter.models import (
-    GetAddressInformationResult,
-    GetConfigAllResult,
-    GetTransactionResult,
-    RunGetMethodResul,
+from tonutils.clients.http.provider.base import HttpProvider
+from tonutils.clients.http.provider.models import (
     SendBocPayload,
+    GetConfigAllResult,
+    GetAddressInformationResult,
+    GetTransactionsResult,
     RunGetMethodPayload,
+    RunGetMethodResult,
 )
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
@@ -20,6 +19,7 @@ class ToncenterHttpProvider(HttpProvider):
     def __init__(
         self,
         network: NetworkGlobalID,
+        *,
         api_key: t.Optional[str] = None,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,
@@ -36,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,
@@ -47,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,
@@ -85,19 +82,26 @@ class ToncenterHttpProvider(HttpProvider):
             ),
         )
 
-    async def get_transaction(
+    async def get_transactions(
         self,
         address: str,
         limit: int = 100,
-        from_lt: t.Optional[int] = None,
-        to_lt: int = 0,
-    ) -> GetTransactionResult:
-        params = {"address": address, "limit": limit, "to_lt": to_lt}
-        if from_lt is not None:
-            params["from_lt"] = from_lt
+        lt: t.Optional[int] = None,
+        from_hash: t.Optional[str] = None,
+        to_lt: t.Optional[int] = None,
+    ) -> GetTransactionsResult:
+        params = {"address": address, "limit": limit, "archival": "true"}
+
+        # lt and hash must be used together
+        if lt is not None and from_hash is not None:
+            params["lt"] = lt
+            params["hash"] = from_hash
+
+        if to_lt is not None:
+            params["to_lt"] = to_lt
 
         return self._model(
-            GetTransactionResult,
+            GetTransactionsResult,
             await self.send_http_request(
                 "GET",
                 "/getTransactions",
@@ -108,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",