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

tonutils/clients/adnl/balancer.py

@@ -7,42 +7,54 @@ from contextlib import suppress
 from dataclasses import dataclass
 from itertools import cycle
 
-from pytoniq_core import Address, Transaction
+from pytoniq_core import Address, BlockIdExt, Block, Transaction
 
-from tonutils.clients.adnl.client import AdnlClient
+from tonutils.clients.adnl.client import LiteClient
 from tonutils.clients.adnl.provider import AdnlProvider
-from tonutils.clients.adnl.provider.config import TONClient
-from tonutils.clients.adnl.provider.limiter import PriorityLimiter
-from tonutils.clients.adnl.provider.models import GlobalConfig
-from tonutils.clients.adnl.stack import decode_stack, encode_stack
+from tonutils.clients.adnl.provider.config import (
+    get_mainnet_global_config,
+    get_testnet_global_config,
+)
+from tonutils.clients.adnl.provider.models import GlobalConfig, MasterchainInfo
+from tonutils.clients.adnl.utils import decode_stack, encode_stack
 from tonutils.clients.base import BaseClient
+from tonutils.clients.limiter import RateLimiter
 from tonutils.exceptions import (
-    AdnlBalancerConnectionError,
-    ClientNotConnectedError,
-    RateLimitExceededError,
     ClientError,
+    BalancerError,
+    RunGetMethodError,
+    ProviderResponseError,
+    TransportError,
+    ProviderError,
+    ProviderTimeoutError,
+)
+from tonutils.types import (
+    ClientType,
+    ContractStateInfo,
+    NetworkGlobalID,
+    RetryPolicy,
+    WorkchainID,
 )
-from tonutils.types import ClientType, ContractStateInfo, NetworkGlobalID
 
 _T = t.TypeVar("_T")
 
 
 @dataclass
-class AdnlClientState:
+class LiteClientState:
     """
-    Internal state container for an ADNL client.
+    Internal state container for a lite-server client.
 
     Tracks error count and cooldown timeout for retry scheduling.
     """
 
-    client: AdnlClient
+    client: LiteClient
     retry_after: t.Optional[float] = None
     error_count: int = 0
 
 
-class AdnlBalancer(BaseClient):
+class LiteBalancer(BaseClient):
     """
-    Multi-provider ADNL client with automatic failover and load balancing.
+    Multi-client lite-server balancer with automatic failover and load balancing.
 
     Selects the best available lite-server using height, ping metrics and
     round-robin tie-breaking.
@@ -54,13 +66,14 @@ class AdnlBalancer(BaseClient):
         self,
         *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
-        clients: t.List[AdnlClient],
-        connect_timeout: int = 2,
+        clients: t.List[LiteClient],
+        connect_timeout: float = 2.0,
+        request_timeout: float = 12.0,
     ) -> None:
         """
-        Initialize ADNL balancer.
+        Initialize lite-server balancer.
 
-        It is recommended to build underlying AdnlClient instances from
+        It is recommended to build underlying LiteClient instances from
         private lite-server configurations for better stability and performance.
         You can obtain private lite-server configs from:
             - Tonconsole website: https://tonconsole.com/
@@ -69,17 +82,21 @@ class AdnlBalancer(BaseClient):
         Public free lite-server data may also be used via `from_network_config()`.
 
         :param network: Target TON network (mainnet or testnet)
-        :param clients: List of AdnlClient instances to balance between
-        :param connect_timeout: Timeout in seconds for connect/reconnect
+        :param clients: List of LiteClient instances to balance between
+        :param connect_timeout: Timeout in seconds for connect/reconnect attempts
+        :param request_timeout: Maximum total time in seconds for a balancer operation,
+            including all failover attempts across lite-servers
         """
         self.network: NetworkGlobalID = network
 
-        self._clients: t.List[AdnlClient] = []
-        self._states: t.List[AdnlClientState] = []
+        self._clients: t.List[LiteClient] = []
+        self._states: t.List[LiteClientState] = []
         self.__init_clients(clients)
 
         self._rr = cycle(self._clients)
+
         self._connect_timeout = connect_timeout
+        self._request_timeout = request_timeout
 
         self._health_interval = 5.5
         self._health_task: t.Optional[asyncio.Task] = None
@@ -89,41 +106,60 @@ class AdnlBalancer(BaseClient):
 
     def __init_clients(
         self,
-        clients: t.List[AdnlClient],
+        clients: t.List[LiteClient],
     ) -> None:
         """
-        Validate and register input ADNL clients.
+        Validate and register input lite-server clients.
 
         Ensures correct client type and network assignment.
         """
         for client in clients:
             if client.TYPE != ClientType.ADNL:
                 raise ClientError(
-                    "AdnlBalancer can work only with ADNL clients, "
+                    "LiteBalancer can work only with LiteClient instances, "
                     f"got {client.__class__.__name__}."
                 )
 
             client.network = self.network
 
-            state = AdnlClientState(client=client)
+            state = LiteClientState(client=client)
             self._clients.append(client)
             self._states.append(state)
 
     @property
-    def clients(self) -> t.Tuple[AdnlClient, ...]:
+    def provider(self) -> AdnlProvider:
+        """
+        Provider of the currently selected lite-server client.
+
+        :return: AdnlProvider instance of chosen client
+        """
+        c = self._pick_client()
+        return c.provider
+
+    @property
+    def is_connected(self) -> bool:
+        """
+        Check whether at least one underlying lite-server client is connected.
+
+        :return: True if any client is connected, otherwise False
+        """
+        return any(c.is_connected for c in self._clients)
+
+    @property
+    def clients(self) -> t.Tuple[LiteClient, ...]:
         """
-        List of all registered ADNL clients.
+        List of all registered lite-server clients.
 
-        :return: Tuple of AdnlClient objects
+        :return: Tuple of LiteClient objects
         """
         return tuple(self._clients)
 
     @property
-    def alive_clients(self) -> t.Tuple[AdnlClient, ...]:
+    def alive_clients(self) -> t.Tuple[LiteClient, ...]:
         """
-        ADNL clients that are allowed to send requests now.
+        Lite-server clients that are allowed to send requests now.
 
-        :return: Tuple of available AdnlClient instances
+        :return: Tuple of available LiteClient instances
         """
         now = time.monotonic()
         return tuple(
@@ -134,11 +170,11 @@ class AdnlBalancer(BaseClient):
         )
 
     @property
-    def dead_clients(self) -> t.Tuple[AdnlClient, ...]:
+    def dead_clients(self) -> t.Tuple[LiteClient, ...]:
         """
-        ADNL clients currently in cooldown or disconnected.
+        Lite-server clients currently in cooldown or disconnected.
 
-        :return: Tuple of unavailable AdnlClient instances
+        :return: Tuple of unavailable LiteClient instances
         """
         now = time.monotonic()
         return tuple(
@@ -148,29 +184,7 @@ class AdnlBalancer(BaseClient):
             or (state.retry_after is not None and state.retry_after > now)
         )
 
-    @property
-    def provider(self) -> AdnlProvider:
-        """
-        Provider of the currently selected ADNL client.
-
-        :return: AdnlProvider instance of chosen client
-        :raises ClientNotConnectedError: If no clients are connected
-        """
-        if not self.is_connected:
-            raise ClientNotConnectedError(self)
-        c = self._pick_client()
-        return c.provider
-
-    @property
-    def is_connected(self) -> bool:
-        """
-        Check whether at least one underlying ADNL client is connected.
-
-        :return: True if any client is connected, otherwise False
-        """
-        return any(c.is_connected for c in self._clients)
-
-    async def __aenter__(self) -> AdnlBalancer:
+    async def __aenter__(self) -> LiteBalancer:
         """
         Enter async context manager and connect underlying clients.
 
@@ -195,15 +209,17 @@ class AdnlBalancer(BaseClient):
         *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
         config: t.Union[GlobalConfig, t.Dict[str, t.Any]],
-        timeout: int = 10,
-        connect_timeout: int = 2,
+        connect_timeout: float = 2.0,
+        request_timeout: float = 12.0,
+        client_connect_timeout: float = 1.5,
+        client_request_timeout: float = 5.0,
         rps_limit: t.Optional[int] = None,
         rps_period: float = 1.0,
-        rps_retries: int = 2,
-        rps_per_provider: bool = False,
-    ) -> AdnlBalancer:
+        rps_per_client: bool = False,
+        retry_policy: t.Optional[RetryPolicy] = None,
+    ) -> LiteBalancer:
         """
-        Build ADNL balancer from a lite-server config.
+        Build lite-server balancer from a configuration.
 
         For best performance, it is recommended to use a private lite-server
         configuration. You can obtain private configs from:
@@ -214,67 +230,74 @@ class AdnlBalancer(BaseClient):
 
         :param network: Target TON network
         :param config: GlobalConfig instance or raw dict
-        :param timeout: Lite-server request timeout in seconds
-        :param connect_timeout: Timeout in seconds for connect/reconnect attempts
-        :param rps_limit: Optional shared requests-per-second limit
+        :param connect_timeout: Timeout in seconds for a single connect/reconnect attempt
+            performed by the balancer during failover.
+        :param request_timeout: Maximum total time in seconds for a single balancer operation,
+            including all failover attempts across clients.
+        :param client_connect_timeout: Timeout in seconds for connect/handshake performed by an
+            individual lite-server client.
+        :param client_request_timeout: Timeout in seconds for a single request executed by an
+            individual lite-server client.
+        :param rps_limit: Optional requests-per-second limit
         :param rps_period: Time window in seconds for RPS limit
-        :param rps_retries: Number of retries on rate limiting
-        :param rps_per_provider: Whether to create per-provider limiters
-        :return: Configured AdnlBalancer instance
+        :param rps_per_client: Whether to create per-client limiters
+        :param retry_policy: Optional retry policy that defines per-error-code retry rules
+        :return: Configured LiteBalancer instance
         """
         if isinstance(config, dict):
             config = GlobalConfig(**config)
 
-        shared_limiter: t.Optional[PriorityLimiter] = None
-        if rps_limit is not None and not rps_per_provider:
-            shared_limiter = PriorityLimiter(rps_limit, rps_period)
-
-        clients: t.List[AdnlClient] = []
-        for node in config.liteservers:
-            if rps_per_provider:
-                _limiter = (
-                    PriorityLimiter(rps_limit, rps_period)
-                    if rps_limit is not None
-                    else None
+        shared_limiter: t.Optional[RateLimiter] = None
+        if rps_limit is not None and not rps_per_client:
+            shared_limiter = RateLimiter(rps_limit, rps_period)
+
+        clients: t.List[LiteClient] = []
+        for ls in config.liteservers:
+            limiter = (
+                RateLimiter(rps_limit, rps_period)
+                if rps_per_client and rps_limit is not None
+                else shared_limiter
+            )
+            client_rps_limit = rps_limit if rps_per_client else None
+
+            clients.append(
+                LiteClient(
+                    network=network,
+                    ip=ls.host,
+                    port=ls.port,
+                    public_key=ls.id,
+                    connect_timeout=client_connect_timeout,
+                    request_timeout=client_request_timeout,
+                    rps_limit=client_rps_limit,
+                    rps_period=rps_period,
+                    limiter=limiter,
+                    retry_policy=retry_policy,
                 )
-                _rps_limit = rps_limit
-            else:
-                _limiter = shared_limiter
-                _rps_limit = None
-
-            client = AdnlClient(
-                network=network,
-                ip=node.host,
-                port=node.port,
-                public_key=node.id,
-                timeout=timeout,
-                rps_limit=_rps_limit,
-                rps_retries=rps_retries,
-                rps_period=rps_period,
-                limiter=_limiter,
             )
-            clients.append(client)
 
         return cls(
             network=network,
             clients=clients,
             connect_timeout=connect_timeout,
+            request_timeout=request_timeout,
         )
 
     @classmethod
-    async def from_network_config(
+    def from_network_config(
         cls,
         *,
         network: NetworkGlobalID = NetworkGlobalID.MAINNET,
-        timeout: int = 10,
-        connect_timeout: int = 2,
+        connect_timeout: float = 2.0,
+        request_timeout: float = 12.0,
+        client_connect_timeout: float = 1.5,
+        client_request_timeout: float = 5.0,
         rps_limit: t.Optional[int] = None,
         rps_period: float = 1.0,
-        rps_retries: int = 2,
-        rps_per_provider: bool = False,
-    ) -> AdnlBalancer:
+        rps_per_client: bool = False,
+        retry_policy: t.Optional[RetryPolicy] = None,
+    ) -> LiteBalancer:
         """
-        Build ADNL balancer using global config fetched from ton.org.
+        Build lite-server balancer using global config fetched from ton.org.
 
         Public lite-servers available in the global network configuration are
         free to use but may be unstable under load. For higher reliability and
@@ -284,56 +307,62 @@ class AdnlBalancer(BaseClient):
             - dTON telegram bot: https://t.me/dtontech_bot (https://dton.io/)
 
         :param network: Target TON network
-        :param timeout: Lite-server request timeout in seconds
-        :param connect_timeout: Timeout in seconds for connect/reconnect attempts
-        :param rps_limit: Optional shared requests-per-second limit
+        :param connect_timeout: Timeout in seconds for a single connect/reconnect attempt
+            performed by the balancer during failover.
+        :param request_timeout: Maximum total time in seconds for a single balancer operation,
+            including all failover attempts across clients.
+        :param client_connect_timeout: Timeout in seconds for connect/handshake performed by an
+            individual lite-server client.
+        :param client_request_timeout: Timeout in seconds for a single request executed by an
+            individual lite-server client.
+        :param rps_limit: Optional requests-per-second limit
         :param rps_period: Time window in seconds for RPS limit
-        :param rps_retries: Number of retries on rate limiting
-        :param rps_per_provider: Whether to create per-provider limiters
-        :return: Configured AdnlBalancer instance
+        :param rps_per_client: Whether to create per-client limiters
+        :param retry_policy: Optional retry policy that defines per-error-code retry rules
+        :return: Configured LiteBalancer instance
         """
-        ton_client = TONClient()
         config_getters = {
-            NetworkGlobalID.MAINNET: ton_client.mainnet_global_config,
-            NetworkGlobalID.TESTNET: ton_client.testnet_global_config,
+            NetworkGlobalID.MAINNET: get_mainnet_global_config,
+            NetworkGlobalID.TESTNET: get_testnet_global_config,
         }
-        async with ton_client:
-            config = await config_getters[network]()
+        config = config_getters[network]()
         return cls.from_config(
             network=network,
             config=config,
-            timeout=timeout,
+            connect_timeout=connect_timeout,
+            request_timeout=request_timeout,
+            client_connect_timeout=client_connect_timeout,
+            client_request_timeout=client_request_timeout,
             rps_limit=rps_limit,
             rps_period=rps_period,
-            rps_retries=rps_retries,
-            rps_per_provider=rps_per_provider,
-            connect_timeout=connect_timeout,
+            rps_per_client=rps_per_client,
+            retry_policy=retry_policy,
         )
 
-    def _pick_client(self) -> AdnlClient:
+    def _pick_client(self) -> LiteClient:
         """
-        Select the best available ADNL client.
+        Select the best available lite-server client.
 
         Selection criteria:
         - highest known masterchain seqno
         - minimal ping RTT and age among same-height clients
         - round-robin fallback if no height information
         """
-        alive_clients = list(self.alive_clients)
+        alive = list(self.alive_clients)
 
-        if not alive_clients:
-            raise AdnlBalancerConnectionError("No alive lite-server clients available.")
+        if not alive:
+            raise BalancerError("no alive lite-server clients available")
 
         height_candidates: t.List[
             t.Tuple[
                 int,
                 t.Optional[float],
                 t.Optional[float],
-                AdnlClient,
+                LiteClient,
             ]
         ] = []
 
-        for client in alive_clients:
+        for client in alive:
             mc_block = client.provider.last_mc_block
             if mc_block is None:
                 continue
@@ -357,12 +386,12 @@ class AdnlBalancer(BaseClient):
 
         for _ in range(len(self._clients)):
             candidate = next(self._rr)
-            if candidate in alive_clients and candidate.is_connected:
+            if candidate in alive and candidate.is_connected:
                 return candidate
 
-        return alive_clients[0]
+        return alive[0]
 
-    def _mark_success(self, client: AdnlClient) -> None:
+    def _mark_success(self, client: LiteClient) -> None:
         """
         Reset error state for a successful client.
 
@@ -374,7 +403,7 @@ class AdnlBalancer(BaseClient):
                 state.retry_after = None
                 break
 
-    def _mark_error(self, client: AdnlClient, is_rate_limit: bool) -> None:
+    def _mark_error(self, client: LiteClient, is_rate_limit: bool) -> None:
         """
         Update error state and schedule retry cooldown.
 
@@ -408,50 +437,63 @@ class AdnlBalancer(BaseClient):
         Execute a provider operation with automatic failover.
 
         Iterates through available lite-servers until one succeeds
-        or all providers fail.
+        or all fail.
 
         :param func: Callable performing an operation using an AdnlProvider
         :return: Result of the successful invocation
         """
-        last_exc: t.Optional[BaseException] = None
 
-        for _ in range(len(self._clients)):
-            if not self.alive_clients:
-                break
+        async def _run() -> _T:
+            last_exc: t.Optional[BaseException] = None
+
+            for _ in range(len(self._clients)):
+                if not self.alive_clients:
+                    break
+
+                client = self._pick_client()
 
-            client = self._pick_client()
+                if not client.provider.is_connected:
+                    try:
+                        await asyncio.wait_for(
+                            client.provider.reconnect(),
+                            timeout=self._connect_timeout,
+                        )
+                    except Exception as e:
+                        self._mark_error(client, is_rate_limit=False)
+                        last_exc = e
+                        continue
 
-            if not client.provider.is_connected:
                 try:
-                    await asyncio.wait_for(
-                        client.provider.reconnect(),
-                        timeout=self._connect_timeout,
-                    )
-                except Exception as e:
+                    result = await func(client.provider)
+
+                except RunGetMethodError:
+                    raise
+                except ProviderResponseError as e:
+                    is_rate_limit = e.code in {228, 5556}
+                    self._mark_error(client, is_rate_limit=is_rate_limit)
+                    last_exc = e
+                    continue
+                except (TransportError, ProviderError) as e:
                     self._mark_error(client, is_rate_limit=False)
                     last_exc = e
                     continue
 
-            try:
-                result = await func(client.provider)
-            except RateLimitExceededError as e:
-                self._mark_error(client, is_rate_limit=True)
-                last_exc = e
-                continue
-            except Exception as e:
-                self._mark_error(client, is_rate_limit=False)
-                last_exc = e
-                continue
+                self._mark_success(client)
+                return result
 
-            self._mark_success(client)
-            return result
+            if last_exc is not None:
+                raise last_exc
 
-        if last_exc is not None:
-            raise last_exc
+            raise BalancerError("all lite-servers failed to process request")
 
-        raise AdnlBalancerConnectionError(
-            "All lite-server providers failed to process request"
-        )
+        try:
+            return await asyncio.wait_for(_run(), timeout=self._request_timeout)
+        except asyncio.TimeoutError as exc:
+            raise ProviderTimeoutError(
+                timeout=self._request_timeout,
+                endpoint="lite balancer",
+                operation="failover request",
+            ) from exc
 
     async def _send_boc(self, boc: str) -> None:
         async def _call(provider: AdnlProvider) -> None:
@@ -486,12 +528,12 @@ class AdnlBalancer(BaseClient):
 
         curr_lt = state.last_transaction_lt
         curr_hash = state.last_transaction_hash
-        transactions: list[Transaction] = []
+        transactions: t.List[Transaction] = []
 
         while len(transactions) < limit and curr_lt != 0:
             batch_size = min(16, limit - len(transactions))
 
-            async def _call(provider: AdnlProvider) -> list[Transaction]:
+            async def _call(provider: AdnlProvider) -> t.List[Transaction]:
                 return await provider.get_transactions(
                     account=account,
                     count=batch_size,
@@ -504,7 +546,7 @@ class AdnlBalancer(BaseClient):
                 break
 
             if to_lt > 0 and txs[-1].lt <= to_lt:
-                trimmed: list[Transaction] = []
+                trimmed: t.List[Transaction] = []
                 for tx in txs:
                     if tx.lt <= to_lt:
                         break
@@ -541,6 +583,12 @@ class AdnlBalancer(BaseClient):
         return await self._with_failover(_call)
 
     def _ensure_health_task(self) -> None:
+        """
+        Ensure background health check task is running.
+
+        Starts a periodic reconnect loop for unavailable clients
+        if it is not already active.
+        """
         if self._health_task is not None and not self._health_task.done():
             return
 
@@ -551,8 +599,13 @@ class AdnlBalancer(BaseClient):
         )
 
     async def _health_loop(self) -> None:
+        """
+        Periodically attempt to reconnect dead lite-server clients.
 
-        async def _recon(c: AdnlClient) -> None:
+        Runs until cancelled.
+        """
+
+        async def _recon(c: LiteClient) -> None:
             with suppress(Exception):
                 await asyncio.wait_for(
                     c.reconnect(),
@@ -576,7 +629,7 @@ class AdnlBalancer(BaseClient):
             self._ensure_health_task()
             return
 
-        async def _con(client: AdnlClient) -> None:
+        async def _con(client: LiteClient) -> None:
             with suppress(asyncio.TimeoutError):
                 await asyncio.wait_for(
                     client.connect(),
@@ -590,9 +643,7 @@ class AdnlBalancer(BaseClient):
             self._ensure_health_task()
             return
 
-        raise AdnlBalancerConnectionError(
-            "All lite-servers failed to establish connection."
-        )
+        raise BalancerError("all lite-servers failed to establish connection")
 
     async def close(self) -> None:
         task, self._health_task = self._health_task, None
@@ -604,3 +655,146 @@ class AdnlBalancer(BaseClient):
 
         tasks = [client.close() for client in self._clients]
         await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def get_time(self) -> int:
+        """
+        Fetch current network time from lite-server.
+
+        :return: Current UNIX timestamp
+        """
+
+        async def _call(provider: AdnlProvider) -> int:
+            return await provider.get_time()
+
+        return await self._with_failover(_call)
+
+    async def get_version(self) -> int:
+        """
+        Fetch lite-server protocol version.
+
+        :return: Version number
+        """
+
+        async def _call(provider: AdnlProvider) -> int:
+            return await provider.get_version()
+
+        return await self._with_failover(_call)
+
+    async def wait_masterchain_seqno(
+        self,
+        seqno: int,
+        timeout_ms: int,
+        schema_name: str,
+        data: t.Optional[dict] = None,
+    ) -> dict:
+        """
+        Combine waitMasterchainSeqno with another lite-server query.
+
+        :param seqno: Masterchain seqno to wait for
+        :param timeout_ms: Wait timeout in milliseconds
+        :param schema_name: Lite-server TL method name without prefix
+        :param data: Additional method arguments
+        :return: Lite-server response as dictionary
+        """
+
+        async def _call(provider: AdnlProvider) -> dict:
+            return await provider.wait_masterchain_seqno(
+                seqno=seqno,
+                timeout_ms=timeout_ms,
+                schema_name=schema_name,
+                data=data,
+            )
+
+        return await self._with_failover(_call)
+
+    async def get_masterchain_info(self) -> MasterchainInfo:
+        """
+        Fetch basic masterchain information.
+
+        :return: MasterchainInfo instance
+        """
+
+        async def _call(provider: AdnlProvider) -> MasterchainInfo:
+            return await provider.get_masterchain_info()
+
+        return await self._with_failover(_call)
+
+    async def lookup_block(
+        self,
+        workchain: WorkchainID,
+        shard: int,
+        seqno: t.Optional[int] = None,
+        lt: t.Optional[int] = None,
+        utime: t.Optional[int] = None,
+    ) -> t.Tuple[BlockIdExt, Block]:
+        """
+        Locate a block by workchain/shard and one of seqno/lt/utime.
+
+        :param workchain: Workchain identifier
+        :param shard: Shard identifier
+        :param seqno: Block sequence number
+        :param lt: Logical time filter
+        :param utime: UNIX time filter
+        :return: Tuple of BlockIdExt and deserialized Block
+        """
+
+        async def _call(provider: AdnlProvider) -> t.Tuple[BlockIdExt, Block]:
+            return await provider.lookup_block(
+                workchain=workchain,
+                shard=shard,
+                seqno=seqno,
+                lt=lt,
+                utime=utime,
+            )
+
+        return await self._with_failover(_call)
+
+    async def get_block_header(
+        self,
+        block: BlockIdExt,
+    ) -> t.Tuple[BlockIdExt, Block]:
+        """
+        Fetch and deserialize block header by BlockIdExt.
+
+        :param block: BlockIdExt to query
+        :return: Tuple of BlockIdExt and deserialized Block
+        """
+
+        async def _call(provider: AdnlProvider) -> t.Tuple[BlockIdExt, Block]:
+            return await provider.get_block_header(block)
+
+        return await self._with_failover(_call)
+
+    async def get_block_transactions_ext(
+        self,
+        block: BlockIdExt,
+        count: int = 1024,
+    ) -> t.List[Transaction]:
+        """
+        Fetch extended block transactions list.
+
+        :param block: Target block identifier
+        :param count: Maximum number of transactions per request
+        :return: List of deserialized Transaction objects
+        """
+
+        async def _call(provider: AdnlProvider) -> t.List[Transaction]:
+            return await provider.get_block_transactions_ext(block, count=count)
+
+        return await self._with_failover(_call)
+
+    async def get_all_shards_info(
+        self,
+        block: t.Optional[BlockIdExt] = None,
+    ) -> t.List[BlockIdExt]:
+        """
+        Fetch shard info for all workchains at a given masterchain block.
+
+        :param block: Masterchain block ID or None to use latest
+        :return: List of shard BlockIdExt objects
+        """
+
+        async def _call(provider: AdnlProvider) -> t.List[BlockIdExt]:
+            return await provider.get_all_shards_info(block)
+
+        return await self._with_failover(_call)