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

tonutils/clients/http/clients/toncenter.py

@@ -7,11 +7,8 @@ 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 (
@@ -24,15 +21,15 @@ from tonutils.types import (
 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,
@@ -81,7 +78,7 @@ class ToncenterHttpClient(BaseClient):
         session = self._provider.session
         return session is not None and not session.closed
 
-    async def __aenter__(self) -> ToncenterHttpClient:
+    async def __aenter__(self) -> ToncenterClient:
         await self._provider.connect()
         return self
 
@@ -166,28 +163,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.append(tx)
+
+                if len(transactions) >= limit:
+                    return transactions
+
+            # Setup for next iteration
+            last_tx = batch[-1]
+            if last_tx.prev_trans_lt == 0:
+                break
 
-        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))
+            curr_lt = last_tx.prev_trans_lt
+            curr_hash = last_tx.prev_trans_hash.hex()
 
         return transactions
 

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,18 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import typing as t
 
 import aiohttp
 
-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,
 )
 from tonutils.types import RetryPolicy
 
@@ -90,6 +91,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,
@@ -126,13 +155,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:
@@ -199,3 +224,42 @@ class HttpProvider:
                     ) from e
 
                 await asyncio.sleep(rule.delay(attempts[key] - 1))
+
+    @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()
+
+        for marker, message in CDN_CHALLENGE_MARKERS.items():
+            if marker in body:
+                return ProviderResponseError(
+                    code=status,
+                    message=message,
+                    endpoint=url,
+                )
+
+        return None
+
+    @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 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

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

@@ -5,13 +5,13 @@ 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 +21,7 @@ class TonapiHttpProvider(HttpProvider):
     def __init__(
         self,
         network: NetworkGlobalID,
+        *,
         api_key: str,
         base_url: t.Optional[str] = None,
         timeout: float = 10.0,
@@ -92,12 +93,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}

@@ -3,14 +3,14 @@ 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,
+    RunGetMethodResul,
 )
 from tonutils.types import NetworkGlobalID, RetryPolicy
 
@@ -20,6 +20,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,
@@ -85,19 +86,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",

tonutils/clients/limiter.py

@@ -4,11 +4,10 @@ import time
 
 class RateLimiter:
     """
-    Asynchronous token-bucket rate limiter with optional priority acquisition.
+    Asynchronous token-bucket rate limiter with priority support.
 
-    Limits the number of acquire operations per time period and supports
-    priority waiters that can bypass non-priority requests when tokens
-    become available.
+    Priority requests are served before non-priority requests when
+    tokens become available.
     """
 
     __slots__ = (
@@ -26,7 +25,7 @@ class RateLimiter:
 
         :param max_rate: Maximum number of acquisitions allowed per period.
         :param period: Period length in seconds.
-        :raises ValueError: If ``max_rate`` or ``period`` is not positive.
+        :raises ValueError: If max_rate or period is not positive.
         """
         if max_rate <= 0:
             raise ValueError("max_rate must be > 0")
@@ -40,76 +39,79 @@ class RateLimiter:
         self._cond = asyncio.Condition()
         self._priority_waiters = 0
 
-    def when_ready(self) -> float:
-        """
-        Calculate delay until the next token becomes available.
-
-        :return: Number of seconds to wait before a token can be acquired,
-            or ``0`` if a token is available immediately.
-        """
+    def _refill(self) -> None:
+        """Refill tokens based on elapsed time."""
         now = time.monotonic()
-        tokens = self._peek_tokens(now)
-        if tokens >= 1.0:
+        elapsed = now - self._updated_at
+        if elapsed > 0:
+            rate = self._max_rate / self._period
+            self._tokens = min(float(self._max_rate), self._tokens + elapsed * rate)
+            self._updated_at = now
+
+    def _seconds_to_token(self) -> float:
+        """Calculate seconds until next token is available."""
+        if self._tokens >= 1.0:
             return 0.0
-        return self._seconds_to_one_token(tokens)
+        missing = 1.0 - self._tokens
+        rate = self._max_rate / self._period
+        return missing / rate
 
     async def acquire(self, priority: bool = False) -> None:
         """
-        Acquire a single token, waiting asynchronously if necessary.
+        Acquire a single token, waiting if necessary.
 
-        Priority acquisitions are allowed to bypass non-priority waiters
-        when tokens become available.
+        Priority requests bypass non-priority waiters when tokens
+        become available.
 
-        :param priority: Whether to acquire the token with priority.
+        :param priority: Whether to acquire with priority.
         """
-        if priority:
-            async with self._cond:
-                self._priority_waiters += 1
+        async with self._cond:
+            is_waiting = False
 
             try:
-                await self._acquire(priority=True)
+                while True:
+                    self._refill()
+
+                    # Check if token available
+                    if self._tokens >= 1.0:
+                        # Priority always takes; non-priority only if no priority waiting
+                        if priority or self._priority_waiters == 0:
+                            self._tokens -= 1.0
+                            self._cond.notify_all()
+                            return
+
+                    # Register as priority waiter only when actually waiting
+                    if priority and not is_waiting:
+                        self._priority_waiters += 1
+                        is_waiting = True
+
+                    # Wait for token
+                    wait_time = self._seconds_to_token()
+                    if wait_time > 0:
+                        try:
+                            await asyncio.wait_for(self._cond.wait(), timeout=wait_time)
+                        except asyncio.TimeoutError:
+                            pass  # Expected — token should be ready now
+                    else:
+                        # Token available but blocked by priority — wait for notify
+                        await self._cond.wait()
+
             finally:
-                async with self._cond:
+                if is_waiting:
                     self._priority_waiters -= 1
                     self._cond.notify_all()
-            return
 
-        await self._acquire(priority=False)
-
-    async def _acquire(self, priority: bool) -> None:
-        while True:
-            async with self._cond:
-                now = time.monotonic()
-                self._refill(now)
-
-                if self._tokens >= 1.0 and (priority or self._priority_waiters == 0):
-                    self._tokens -= 1.0
-                    self._cond.notify_all()
-                    return
-
-                if self._tokens < 1.0:
-                    timeout = self._seconds_to_one_token(self._tokens)
-                    await asyncio.wait_for(self._cond.wait(), timeout=timeout)
-                else:
-                    await self._cond.wait()
+    def when_ready(self) -> float:
+        """
+        Calculate delay until the next token becomes available.
 
-    def _peek_tokens(self, now: float) -> float:
+        :return: Seconds to wait, or 0 if ready immediately.
+        """
+        now = time.monotonic()
         elapsed = now - self._updated_at
-        if elapsed <= 0.0:
-            return self._tokens
-
         rate = self._max_rate / self._period
-        tokens = self._tokens + elapsed * rate
-        return min(float(self._max_rate), tokens)
-
-    def _refill(self, now: float) -> None:
-        self._tokens = self._peek_tokens(now)
-        self._updated_at = now
+        tokens = min(float(self._max_rate), self._tokens + elapsed * rate)
 
-    def _seconds_to_one_token(self, tokens: float) -> float:
-        missing = 1.0 - tokens
-        if missing <= 0.0:
+        if tokens >= 1.0:
             return 0.0
-
-        rate = self._max_rate / self._period
-        return missing / rate
+        return (1.0 - tokens) / rate

tonutils/clients/protocol.py

@@ -55,12 +55,12 @@ class ClientProtocol(t.Protocol):
     ) -> ContractStateInfo:
         """Fetch basic contract state information."""
 
-    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 contract transactions."""
 

tonutils/contracts/wallet/base.py

@@ -29,7 +29,7 @@ from tonutils.types import (
     WorkchainID,
     DEFAULT_SENDMODE,
 )
-from tonutils.utils import resolve_wallet_address, to_cell
+from tonutils.utils import to_cell
 
 _D = t.TypeVar("_D", bound=BaseWalletData)
 _C = t.TypeVar("_C", bound=BaseWalletConfig)
@@ -325,7 +325,7 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         """
         Build and send a transfer to a single destination.
 
-        :param destination: Recipient address (Address, string, or domain)
+        :param destination: Recipient address
         :param amount: Amount to send in nanotons
         :param body: Optional message body (Cell or text comment)
         :param state_init: Optional StateInit for contract deployment
@@ -334,7 +334,6 @@ class BaseWallet(BaseContract, WalletProtocol[_D, _C, _P], abc.ABC):
         :param params: Optional transaction parameters
         :return: Signed external message that was sent
         """
-        destination = await resolve_wallet_address(self.client, destination)
         message = TONTransferBuilder(
             destination=destination,
             amount=amount,

tonutils/contracts/wallet/messages.py

@@ -23,7 +23,6 @@ from tonutils.utils import (
     cell_to_b64,
     normalize_hash,
     to_nano,
-    resolve_wallet_address,
 )
 
 
@@ -191,7 +190,7 @@ class TONTransferBuilder(BaseMessageBuilder):
         """
         Initialize TON transfer builder.
 
-        :param destination: Recipient address (Address, string, or domain)
+        :param destination: Recipient address
         :param amount: Amount to send in nanotons
         :param body: Optional message body (Cell or text comment string)
         :param state_init: Optional StateInit for contract deployment
@@ -214,11 +213,10 @@ class TONTransferBuilder(BaseMessageBuilder):
         :param wallet: Wallet instance to build message for
         :return: WalletMessage with TON transfer
         """
-        destination = await resolve_wallet_address(wallet.client, self.destination)
         return WalletMessage(
             send_mode=self.send_mode,
             message=InternalMessage(
-                dest=destination,
+                dest=self.destination,
                 value=self.amount,
                 body=self.body,
                 state_init=self.state_init,
@@ -277,9 +275,8 @@ class NFTTransferBuilder(BaseMessageBuilder):
         :param wallet: Wallet instance to build message for
         :return: WalletMessage with NFT transfer
         """
-        destination = await resolve_wallet_address(wallet.client, self.destination)
         body = NFTTransferBody(
-            destination=destination,
+            destination=self.destination,
             response_address=self.response_address or wallet.address,
             custom_payload=self.custom_payload,
             forward_payload=self.forward_payload,
@@ -358,7 +355,6 @@ class JettonTransferBuilder(BaseMessageBuilder):
         :param wallet: Wallet instance to build message for
         :return: WalletMessage with jetton transfer
         """
-        destination = await resolve_wallet_address(wallet.client, self.destination)
         jetton_wallet_address = self.jetton_wallet_address
         if self.jetton_wallet_address is None:
             jetton_wallet_address = await get_wallet_address_get_method(
@@ -367,7 +363,7 @@ class JettonTransferBuilder(BaseMessageBuilder):
                 owner_address=wallet.address,
             )
         body = JettonTransferBody(
-            destination=destination,
+            destination=self.destination,
             jetton_amount=self.jetton_amount,
             response_address=self.response_address or wallet.address,
             custom_payload=self.custom_payload,