async-substrate-interface 1.2.2__tar.gz → 1.3.1__tar.gz

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-substrate-interface
-Version: 1.2.2
+Version: 1.3.1
 Summary: Asyncio library for interacting with substrate. Mostly API-compatible with py-substrate-interface
 Author: Opentensor Foundation
 Author-email: BD Himes <b@latent.to>

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface/async_substrate.py

@@ -22,7 +22,6 @@ from typing import (
     TYPE_CHECKING,
 )
 
-import asyncstdlib as a
 from bt_decode import MetadataV15, PortableRegistry, decode as decode_by_type_string
 from scalecodec.base import ScaleBytes, ScaleType, RuntimeConfigurationObject
 from scalecodec.types import (
@@ -33,7 +32,7 @@ from scalecodec.types import (
     MultiAccountId,
 )
 from websockets.asyncio.client import connect
-from websockets.exceptions import ConnectionClosed
+from websockets.exceptions import ConnectionClosed, WebSocketException
 
 from async_substrate_interface.const import SS58_FORMAT
 from async_substrate_interface.errors import (
@@ -42,6 +41,7 @@ from async_substrate_interface.errors import (
     BlockNotFound,
     MaxRetriesExceeded,
     MetadataAtVersionNotFound,
+    StateDiscardedError,
 )
 from async_substrate_interface.protocols import Keypair
 from async_substrate_interface.types import (
@@ -58,7 +58,7 @@ from async_substrate_interface.utils import (
     get_next_id,
     rng as random,
 )
-from async_substrate_interface.utils.cache import async_sql_lru_cache
+from async_substrate_interface.utils.cache import async_sql_lru_cache, CachedFetcher
 from async_substrate_interface.utils.decoding import (
     _determine_if_old_runtime_call,
     _bt_decode_to_dict_or_list,
@@ -75,6 +75,7 @@ if TYPE_CHECKING:
 ResultHandler = Callable[[dict, Any], Awaitable[tuple[dict, bool]]]
 
 logger = logging.getLogger("async_substrate_interface")
+raw_websocket_logger = logging.getLogger("raw_websocket")
 
 
 class AsyncExtrinsicReceipt:
@@ -505,6 +506,7 @@ class Websocket:
         max_connections=100,
         shutdown_timer=5,
         options: Optional[dict] = None,
+        _log_raw_websockets: bool = False,
     ):
         """
         Websocket manager object. Allows for the use of a single websocket connection by multiple
@@ -532,6 +534,10 @@ class Websocket:
         self._exit_task = None
         self._open_subscriptions = 0
         self._options = options if options else {}
+        self._log_raw_websockets = _log_raw_websockets
+        self._is_connecting = False
+        self._is_closing = False
+
         try:
             now = asyncio.get_running_loop().time()
         except RuntimeError:
@@ -539,51 +545,80 @@ class Websocket:
                 "You are instantiating the AsyncSubstrateInterface Websocket outside of an event loop. "
                 "Verify this is intended."
             )
-            now = asyncio.new_event_loop().time()
+            # default value for in case there's no running asyncio loop
+            # this really doesn't matter in most cases, as it's only used for comparison on the first call to
+            # see how long it's been since the last call
+            now = 0.0
         self.last_received = now
         self.last_sent = now
+        self._in_use_ids = set()
 
     async def __aenter__(self):
-        async with self._lock:
-            self._in_use += 1
-            await self.connect()
+        self._in_use += 1
+        await self.connect()
         return self
 
     @staticmethod
     async def loop_time() -> float:
         return asyncio.get_running_loop().time()
 
-    async def connect(self, force=False):
-        now = await self.loop_time()
-        self.last_received = now
-        self.last_sent = now
-        if self._exit_task:
-            self._exit_task.cancel()
-        if not self._initialized or force:
-            self._initialized = True
-            try:
-                self._receiving_task.cancel()
-                await self._receiving_task
-                await self.ws.close()
-            except (AttributeError, asyncio.CancelledError):
-                pass
-            self.ws = await asyncio.wait_for(
-                connect(self.ws_url, **self._options), timeout=10
+    async def _cancel(self):
+        try:
+            self._receiving_task.cancel()
+            await self._receiving_task
+            await self.ws.close()
+        except (
+            AttributeError,
+            asyncio.CancelledError,
+            WebSocketException,
+        ):
+            pass
+        except Exception as e:
+            logger.warning(
+                f"{e} encountered while trying to close websocket connection."
             )
-            self._receiving_task = asyncio.create_task(self._start_receiving())
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        async with self._lock:  # TODO is this actually what I want to happen?
-            self._in_use -= 1
-            if self._exit_task is not None:
+    async def connect(self, force=False):
+        self._is_connecting = True
+        try:
+            now = await self.loop_time()
+            self.last_received = now
+            self.last_sent = now
+            if self._exit_task:
                 self._exit_task.cancel()
-                try:
-                    await self._exit_task
-                except asyncio.CancelledError:
-                    pass
-            if self._in_use == 0 and self.ws is not None:
-                self._open_subscriptions = 0
-                self._exit_task = asyncio.create_task(self._exit_with_timer())
+            if not self._is_closing:
+                if not self._initialized or force:
+                    try:
+                        await asyncio.wait_for(self._cancel(), timeout=10.0)
+                    except asyncio.TimeoutError:
+                        pass
+
+                    self.ws = await asyncio.wait_for(
+                        connect(self.ws_url, **self._options), timeout=10.0
+                    )
+                    self._receiving_task = asyncio.get_running_loop().create_task(
+                        self._start_receiving()
+                    )
+                    self._initialized = True
+        finally:
+            self._is_connecting = False
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self._is_closing = True
+        try:
+            if not self._is_connecting:
+                self._in_use -= 1
+                if self._exit_task is not None:
+                    self._exit_task.cancel()
+                    try:
+                        await self._exit_task
+                    except asyncio.CancelledError:
+                        pass
+                if self._in_use == 0 and self.ws is not None:
+                    self._open_subscriptions = 0
+                    self._exit_task = asyncio.create_task(self._exit_with_timer())
+        finally:
+            self._is_closing = False
 
     async def _exit_with_timer(self):
         """
@@ -597,28 +632,27 @@ class Websocket:
             pass
 
     async def shutdown(self):
-        async with self._lock:
-            try:
-                self._receiving_task.cancel()
-                await self._receiving_task
-                await self.ws.close()
-            except (AttributeError, asyncio.CancelledError):
-                pass
-            self.ws = None
-            self._initialized = False
-            self._receiving_task = None
+        self._is_closing = True
+        try:
+            await asyncio.wait_for(self._cancel(), timeout=10.0)
+        except asyncio.TimeoutError:
+            pass
+        self.ws = None
+        self._initialized = False
+        self._receiving_task = None
+        self._is_closing = False
 
     async def _recv(self) -> None:
         try:
             # TODO consider wrapping this in asyncio.wait_for and use that for the timeout logic
-            response = json.loads(await self.ws.recv(decode=False))
+            recd = await self.ws.recv(decode=False)
+            if self._log_raw_websockets:
+                raw_websocket_logger.debug(f"WEBSOCKET_RECEIVE> {recd.decode()}")
+            response = json.loads(recd)
             self.last_received = await self.loop_time()
-            async with self._lock:
-                # note that these 'subscriptions' are all waiting sent messages which have not received
-                # responses, and thus are not the same as RPC 'subscriptions', which are unique
-                self._open_subscriptions -= 1
             if "id" in response:
                 self._received[response["id"]] = response
+                self._in_use_ids.remove(response["id"])
             elif "params" in response:
                 self._received[response["params"]["subscription"]] = response
             else:
@@ -635,8 +669,7 @@ class Websocket:
         except asyncio.CancelledError:
             pass
         except ConnectionClosed:
-            async with self._lock:
-                await self.connect(force=True)
+            await self.connect(force=True)
 
     async def send(self, payload: dict) -> int:
         """
@@ -649,15 +682,20 @@ class Websocket:
             id: the internal ID of the request (incremented int)
         """
         original_id = get_next_id()
+        while original_id in self._in_use_ids:
+            original_id = get_next_id()
+        self._in_use_ids.add(original_id)
         # self._open_subscriptions += 1
         await self.max_subscriptions.acquire()
         try:
-            await self.ws.send(json.dumps({**payload, **{"id": original_id}}))
+            to_send = {**payload, **{"id": original_id}}
+            if self._log_raw_websockets:
+                raw_websocket_logger.debug(f"WEBSOCKET_SEND> {to_send}")
+            await self.ws.send(json.dumps(to_send))
             self.last_sent = await self.loop_time()
             return original_id
         except (ConnectionClosed, ssl.SSLError, EOFError):
-            async with self._lock:
-                await self.connect(force=True)
+            await self.connect(force=True)
 
     async def retrieve(self, item_id: int) -> Optional[dict]:
         """
@@ -674,7 +712,7 @@ class Websocket:
             self.max_subscriptions.release()
             return item
         except KeyError:
-            await asyncio.sleep(0.001)
+            await asyncio.sleep(0.1)
             return None
 
 
@@ -691,6 +729,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
         max_retries: int = 5,
         retry_timeout: float = 60.0,
         _mock: bool = False,
+        _log_raw_websockets: bool = False,
+        ws_shutdown_timer: float = 5.0,
     ):
         """
         The asyncio-compatible version of the subtensor interface commands we use in bittensor. It is important to
@@ -708,6 +748,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
             max_retries: number of times to retry RPC requests before giving up
             retry_timeout: how to long wait since the last ping to retry the RPC request
             _mock: whether to use mock version of the subtensor interface
+            _log_raw_websockets: whether to log raw websocket requests during RPC requests
+            ws_shutdown_timer: how long after the last connection your websocket should close
 
         """
         self.max_retries = max_retries
@@ -715,16 +757,20 @@ class AsyncSubstrateInterface(SubstrateMixin):
         self.chain_endpoint = url
         self.url = url
         self._chain = chain_name
+        self._log_raw_websockets = _log_raw_websockets
         if not _mock:
             self.ws = Websocket(
                 url,
+                _log_raw_websockets=_log_raw_websockets,
                 options={
                     "max_size": self.ws_max_size,
                     "write_limit": 2**16,
                 },
+                shutdown_timer=ws_shutdown_timer,
             )
         else:
             self.ws = AsyncMock(spec=Websocket)
+
         self._lock = asyncio.Lock()
         self.config = {
             "use_remote_preset": use_remote_preset,
@@ -748,6 +794,12 @@ class AsyncSubstrateInterface(SubstrateMixin):
         self.registry_type_map = {}
         self.type_id_to_name = {}
         self._mock = _mock
+        self._block_hash_fetcher = CachedFetcher(512, self._get_block_hash)
+        self._parent_hash_fetcher = CachedFetcher(512, self._get_parent_block_hash)
+        self._runtime_info_fetcher = CachedFetcher(16, self._get_block_runtime_info)
+        self._runtime_version_for_fetcher = CachedFetcher(
+            512, self._get_block_runtime_version_for
+        )
 
     async def __aenter__(self):
         if not self._mock:
@@ -1869,9 +1921,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
 
         return runtime.metadata_v15
 
-    @a.lru_cache(maxsize=512)
     async def get_parent_block_hash(self, block_hash):
-        return await self._get_parent_block_hash(block_hash)
+        return await self._parent_hash_fetcher.execute(block_hash)
 
     async def _get_parent_block_hash(self, block_hash):
         block_header = await self.rpc_request("chain_getHeader", [block_hash])
@@ -1916,9 +1967,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
                 "Unknown error occurred during retrieval of events"
             )
 
-    @a.lru_cache(maxsize=16)
     async def get_block_runtime_info(self, block_hash: str) -> dict:
-        return await self._get_block_runtime_info(block_hash)
+        return await self._runtime_info_fetcher.execute(block_hash)
 
     get_block_runtime_version = get_block_runtime_info
 
@@ -1929,9 +1979,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
         response = await self.rpc_request("state_getRuntimeVersion", [block_hash])
         return response.get("result")
 
-    @a.lru_cache(maxsize=512)
     async def get_block_runtime_version_for(self, block_hash: str):
-        return await self._get_block_runtime_version_for(block_hash)
+        return await self._runtime_version_for_fetcher.execute(block_hash)
 
     async def _get_block_runtime_version_for(self, block_hash: str):
         """
@@ -2137,6 +2186,7 @@ class AsyncSubstrateInterface(SubstrateMixin):
                                 storage_item,
                                 result_handler,
                             )
+
                             request_manager.add_response(
                                 item_id, decoded_response, complete
                             )
@@ -2149,14 +2199,14 @@ class AsyncSubstrateInterface(SubstrateMixin):
                     and current_time - self.ws.last_sent >= self.retry_timeout
                 ):
                     if attempt >= self.max_retries:
-                        logger.warning(
+                        logger.error(
                             f"Timed out waiting for RPC requests {attempt} times. Exiting."
                         )
                         raise MaxRetriesExceeded("Max retries reached.")
                     else:
                         self.ws.last_received = time.time()
                         await self.ws.connect(force=True)
-                        logger.error(
+                        logger.warning(
                             f"Timed out waiting for RPC requests. "
                             f"Retrying attempt {attempt + 1} of {self.max_retries}"
                         )
@@ -2223,9 +2273,8 @@ class AsyncSubstrateInterface(SubstrateMixin):
         ]
         result = await self._make_rpc_request(payloads, result_handler=result_handler)
         if "error" in result[payload_id][0]:
-            if (
-                "Failed to get runtime version"
-                in result[payload_id][0]["error"]["message"]
+            if "Failed to get runtime version" in (
+                err_msg := result[payload_id][0]["error"]["message"]
             ):
                 logger.warning(
                     "Failed to get runtime. Re-fetching from chain, and retrying."
@@ -2234,15 +2283,21 @@ class AsyncSubstrateInterface(SubstrateMixin):
                 return await self.rpc_request(
                     method, params, result_handler, block_hash, reuse_block_hash
                 )
-            raise SubstrateRequestException(result[payload_id][0]["error"]["message"])
+            elif (
+                "Client error: Api called for an unknown Block: State already discarded"
+                in err_msg
+            ):
+                bh = err_msg.split("State already discarded for ")[1].strip()
+                raise StateDiscardedError(bh)
+            else:
+                raise SubstrateRequestException(err_msg)
         if "result" in result[payload_id][0]:
             return result[payload_id][0]
         else:
             raise SubstrateRequestException(result[payload_id][0])
 
-    @a.lru_cache(maxsize=512)
     async def get_block_hash(self, block_id: int) -> str:
-        return await self._get_block_hash(block_id)
+        return await self._block_hash_fetcher.execute(block_id)
 
     async def _get_block_hash(self, block_id: int) -> str:
         return (await self.rpc_request("chain_getBlockHash", [block_id]))["result"]

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface/errors.py

@@ -22,6 +22,16 @@ class MetadataAtVersionNotFound(SubstrateRequestException):
         super().__init__(message)
 
 
+class StateDiscardedError(SubstrateRequestException):
+    def __init__(self, block_hash: str):
+        self.block_hash = block_hash
+        message = (
+            f"State discarded for {block_hash}. This indicates the block is too old, and you should instead "
+            f"make this request using an archive node."
+        )
+        super().__init__(message)
+
+
 class StorageFunctionNotFound(ValueError):
     pass
 

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface/substrate_addons.py

@@ -13,7 +13,7 @@ from typing import Optional
 from websockets.exceptions import ConnectionClosed
 
 from async_substrate_interface.async_substrate import AsyncSubstrateInterface, Websocket
-from async_substrate_interface.errors import MaxRetriesExceeded
+from async_substrate_interface.errors import MaxRetriesExceeded, StateDiscardedError
 from async_substrate_interface.sync_substrate import SubstrateInterface
 
 logger = logging.getLogger("async_substrate_interface")
@@ -117,13 +117,19 @@ class RetrySyncSubstrate(SubstrateInterface):
         max_retries: int = 5,
         retry_timeout: float = 60.0,
         _mock: bool = False,
+        _log_raw_websockets: bool = False,
+        archive_nodes: Optional[list[str]] = None,
     ):
         fallback_chains = fallback_chains or []
+        archive_nodes = archive_nodes or []
         self.fallback_chains = (
             iter(fallback_chains)
             if not retry_forever
             else cycle(fallback_chains + [url])
         )
+        self.archive_nodes = (
+            iter(archive_nodes) if not retry_forever else cycle(archive_nodes)
+        )
         self.use_remote_preset = use_remote_preset
         self.chain_name = chain_name
         self._mock = _mock
@@ -146,6 +152,7 @@ class RetrySyncSubstrate(SubstrateInterface):
                     _mock=_mock,
                     retry_timeout=retry_timeout,
                     max_retries=max_retries,
+                    _log_raw_websockets=_log_raw_websockets,
                 )
                 initialized = True
                 logger.info(f"Connected to {chain_url}")
@@ -174,9 +181,12 @@ class RetrySyncSubstrate(SubstrateInterface):
             EOFError,
             ConnectionClosed,
             TimeoutError,
+            socket.gaierror,
+            StateDiscardedError,
         ) as e:
+            use_archive = isinstance(e, StateDiscardedError)
             try:
-                self._reinstantiate_substrate(e)
+                self._reinstantiate_substrate(e, use_archive=use_archive)
                 return method_(*args, **kwargs)
             except StopIteration:
                 logger.error(
@@ -184,10 +194,19 @@ class RetrySyncSubstrate(SubstrateInterface):
                 )
                 raise MaxRetriesExceeded
 
-    def _reinstantiate_substrate(self, e: Optional[Exception] = None) -> None:
-        next_network = next(self.fallback_chains)
+    def _reinstantiate_substrate(
+        self, e: Optional[Exception] = None, use_archive: bool = False
+    ) -> None:
+        if use_archive:
+            bh = getattr(e, "block_hash", "Unknown Block Hash")
+            logger.info(
+                f"Attempt made to {bh} failed for state discarded. Attempting to switch to archive node."
+            )
+            next_network = next(self.archive_nodes)
+        else:
+            next_network = next(self.fallback_chains)
         self.ws.close()
-        if e.__class__ == MaxRetriesExceeded:
+        if isinstance(e, MaxRetriesExceeded):
             logger.error(
                 f"Max retries exceeded with {self.url}. Retrying with {next_network}."
             )
@@ -243,13 +262,20 @@ class RetryAsyncSubstrate(AsyncSubstrateInterface):
         max_retries: int = 5,
         retry_timeout: float = 60.0,
         _mock: bool = False,
+        _log_raw_websockets: bool = False,
+        archive_nodes: Optional[list[str]] = None,
+        ws_shutdown_timer: float = 5.0,
     ):
         fallback_chains = fallback_chains or []
+        archive_nodes = archive_nodes or []
         self.fallback_chains = (
             iter(fallback_chains)
             if not retry_forever
             else cycle(fallback_chains + [url])
         )
+        self.archive_nodes = (
+            iter(archive_nodes) if not retry_forever else cycle(archive_nodes)
+        )
         self.use_remote_preset = use_remote_preset
         self.chain_name = chain_name
         self._mock = _mock
@@ -265,6 +291,8 @@ class RetryAsyncSubstrate(AsyncSubstrateInterface):
             _mock=_mock,
             retry_timeout=retry_timeout,
             max_retries=max_retries,
+            _log_raw_websockets=_log_raw_websockets,
+            ws_shutdown_timer=ws_shutdown_timer,
         )
         self._original_methods = {
             method: getattr(self, method) for method in RETRY_METHODS
@@ -272,9 +300,18 @@ class RetryAsyncSubstrate(AsyncSubstrateInterface):
         for method in RETRY_METHODS:
             setattr(self, method, partial(self._retry, method))
 
-    async def _reinstantiate_substrate(self, e: Optional[Exception] = None) -> None:
-        next_network = next(self.fallback_chains)
-        if e.__class__ == MaxRetriesExceeded:
+    async def _reinstantiate_substrate(
+        self, e: Optional[Exception] = None, use_archive: bool = False
+    ) -> None:
+        if use_archive:
+            bh = getattr(e, "block_hash", "Unknown Block Hash")
+            logger.info(
+                f"Attempt made to {bh} failed for state discarded. Attempting to switch to archive node."
+            )
+            next_network = next(self.archive_nodes)
+        else:
+            next_network = next(self.fallback_chains)
+        if isinstance(e, MaxRetriesExceeded):
             logger.error(
                 f"Max retries exceeded with {self.url}. Retrying with {next_network}."
             )
@@ -314,11 +351,13 @@ class RetryAsyncSubstrate(AsyncSubstrateInterface):
             ConnectionClosed,
             EOFError,
             socket.gaierror,
+            StateDiscardedError,
         ) as e:
+            use_archive = isinstance(e, StateDiscardedError)
             try:
-                await self._reinstantiate_substrate(e)
+                await self._reinstantiate_substrate(e, use_archive=use_archive)
                 return await method_(*args, **kwargs)
-            except StopAsyncIteration:
+            except StopIteration:
                 logger.error(
                     f"Max retries exceeded with {self.url}. No more fallback chains."
                 )

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface/sync_substrate.py

@@ -24,6 +24,7 @@ from async_substrate_interface.errors import (
     BlockNotFound,
     MaxRetriesExceeded,
     MetadataAtVersionNotFound,
+    StateDiscardedError,
 )
 from async_substrate_interface.protocols import Keypair
 from async_substrate_interface.types import (
@@ -52,6 +53,7 @@ from async_substrate_interface.type_registry import _TYPE_REGISTRY
 ResultHandler = Callable[[dict, Any], tuple[dict, bool]]
 
 logger = logging.getLogger("async_substrate_interface")
+raw_websocket_logger = logging.getLogger("raw_websocket")
 
 
 class ExtrinsicReceipt:
@@ -484,6 +486,7 @@ class SubstrateInterface(SubstrateMixin):
         max_retries: int = 5,
         retry_timeout: float = 60.0,
         _mock: bool = False,
+        _log_raw_websockets: bool = False,
     ):
         """
         The sync compatible version of the subtensor interface commands we use in bittensor. Use this instance only
@@ -500,6 +503,7 @@ class SubstrateInterface(SubstrateMixin):
             max_retries: number of times to retry RPC requests before giving up
             retry_timeout: how to long wait since the last ping to retry the RPC request
             _mock: whether to use mock version of the subtensor interface
+            _log_raw_websockets: whether to log raw websocket requests during RPC requests
 
         """
         self.max_retries = max_retries
@@ -526,6 +530,7 @@ class SubstrateInterface(SubstrateMixin):
         self.registry_type_map = {}
         self.type_id_to_name = {}
         self._mock = _mock
+        self.log_raw_websockets = _log_raw_websockets
         if not _mock:
             self.ws = self.connect(init=True)
             self.initialize()
@@ -1830,12 +1835,18 @@ class SubstrateInterface(SubstrateMixin):
         ws = self.connect(init=False if attempt == 1 else True)
         for payload in payloads:
             item_id = get_next_id()
-            ws.send(json.dumps({**payload["payload"], **{"id": item_id}}))
+            to_send = {**payload["payload"], **{"id": item_id}}
+            if self.log_raw_websockets:
+                raw_websocket_logger.debug(f"WEBSOCKET_SEND> {to_send}")
+            ws.send(json.dumps(to_send))
             request_manager.add_request(item_id, payload["id"])
 
         while True:
             try:
-                response = json.loads(ws.recv(timeout=self.retry_timeout, decode=False))
+                recd = ws.recv(timeout=self.retry_timeout, decode=False)
+                if self.log_raw_websockets:
+                    raw_websocket_logger.debug(f"WEBSOCKET_RECEIVE> {recd.decode()}")
+                response = json.loads(recd)
             except (TimeoutError, ConnectionClosed):
                 if attempt >= self.max_retries:
                     logger.warning(
@@ -1944,9 +1955,8 @@ class SubstrateInterface(SubstrateMixin):
         ]
         result = self._make_rpc_request(payloads, result_handler=result_handler)
         if "error" in result[payload_id][0]:
-            if (
-                "Failed to get runtime version"
-                in result[payload_id][0]["error"]["message"]
+            if "Failed to get runtime version" in (
+                err_msg := result[payload_id][0]["error"]["message"]
             ):
                 logger.warning(
                     "Failed to get runtime. Re-fetching from chain, and retrying."
@@ -1955,7 +1965,14 @@ class SubstrateInterface(SubstrateMixin):
                 return self.rpc_request(
                     method, params, result_handler, block_hash, reuse_block_hash
                 )
-            raise SubstrateRequestException(result[payload_id][0]["error"]["message"])
+            elif (
+                "Client error: Api called for an unknown Block: State already discarded"
+                in err_msg
+            ):
+                bh = err_msg.split("State already discarded for ")[1].strip()
+                raise StateDiscardedError(bh)
+            else:
+                raise SubstrateRequestException(err_msg)
         if "result" in result[payload_id][0]:
             return result[payload_id][0]
         else:
@@ -2497,13 +2514,13 @@ class SubstrateInterface(SubstrateMixin):
         Returns:
              ScaleType from the runtime call
         """
-        self.init_runtime(block_hash=block_hash)
+        runtime = self.init_runtime(block_hash=block_hash)
 
         if params is None:
             params = {}
 
         try:
-            metadata_v15_value = self.runtime.metadata_v15.value()
+            metadata_v15_value = runtime.metadata_v15.value()
 
             apis = {entry["name"]: entry for entry in metadata_v15_value["apis"]}
             api_entry = apis[api]

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface/utils/cache.py

@@ -1,10 +1,15 @@
+import asyncio
+from collections import OrderedDict
 import functools
 import os
 import pickle
 import sqlite3
 from pathlib import Path
+from typing import Callable, Any
+
 import asyncstdlib as a
 
+
 USE_CACHE = True if os.getenv("NO_CACHE") != "1" else False
 CACHE_LOCATION = (
     os.path.expanduser(
@@ -139,3 +144,54 @@ def async_sql_lru_cache(maxsize=None):
         return inner
 
     return decorator
+
+
+class LRUCache:
+    def __init__(self, max_size: int):
+        self.max_size = max_size
+        self.cache = OrderedDict()
+
+    def set(self, key, value):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        self.cache[key] = value
+        if len(self.cache) > self.max_size:
+            self.cache.popitem(last=False)
+
+    def get(self, key):
+        if key in self.cache:
+            # Mark as recently used
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        return None
+
+
+class CachedFetcher:
+    def __init__(self, max_size: int, method: Callable):
+        self._inflight: dict[int, asyncio.Future] = {}
+        self._method = method
+        self._cache = LRUCache(max_size=max_size)
+
+    async def execute(self, single_arg: Any) -> str:
+        if item := self._cache.get(single_arg):
+            return item
+
+        if single_arg in self._inflight:
+            result = await self._inflight[single_arg]
+            return result
+
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        self._inflight[single_arg] = future
+
+        try:
+            result = await self._method(single_arg)
+            self._cache.set(single_arg, result)
+            future.set_result(result)
+            return result
+        except Exception as e:
+            # Propagate errors
+            future.set_exception(e)
+            raise
+        finally:
+            self._inflight.pop(single_arg, None)

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/async_substrate_interface.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: async-substrate-interface
-Version: 1.2.2
+Version: 1.3.1
 Summary: Asyncio library for interacting with substrate. Mostly API-compatible with py-substrate-interface
 Author: Opentensor Foundation
 Author-email: BD Himes <b@latent.to>

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "async-substrate-interface"
-version = "1.2.2"
+version = "1.3.1"
 description = "Asyncio library for interacting with substrate. Mostly API-compatible with py-substrate-interface"
 readme = "README.md"
 license = { file = "LICENSE" }

{async_substrate_interface-1.2.2 → async_substrate_interface-1.3.1}/tests/test_substrate_addons.py

@@ -4,8 +4,12 @@ import subprocess
 import pytest
 import time
 
-from async_substrate_interface.substrate_addons import RetrySyncSubstrate
-from async_substrate_interface.errors import MaxRetriesExceeded
+from async_substrate_interface import AsyncSubstrateInterface, SubstrateInterface
+from async_substrate_interface.substrate_addons import (
+    RetrySyncSubstrate,
+    RetryAsyncSubstrate,
+)
+from async_substrate_interface.errors import MaxRetriesExceeded, StateDiscardedError
 from tests.conftest import start_docker_container
 
 LATENT_LITE_ENTRYPOINT = "wss://lite.sub.latent.to:443"
@@ -70,3 +74,28 @@ def test_retry_sync_substrate_offline():
         RetrySyncSubstrate(
             "ws://127.0.0.1:9945", fallback_chains=["ws://127.0.0.1:9946"]
         )
+
+
+@pytest.mark.asyncio
+async def test_retry_async_subtensor_archive_node():
+    async with AsyncSubstrateInterface("wss://lite.sub.latent.to:443") as substrate:
+        current_block = await substrate.get_block_number()
+        old_block = current_block - 1000
+        with pytest.raises(StateDiscardedError):
+            await substrate.get_block(block_number=old_block)
+    async with RetryAsyncSubstrate(
+        "wss://lite.sub.latent.to:443", archive_nodes=["ws://178.156.172.75:9944"]
+    ) as substrate:
+        assert isinstance((await substrate.get_block(block_number=old_block)), dict)
+
+
+def test_retry_sync_subtensor_archive_node():
+    with SubstrateInterface("wss://lite.sub.latent.to:443") as substrate:
+        current_block = substrate.get_block_number()
+        old_block = current_block - 1000
+        with pytest.raises(StateDiscardedError):
+            substrate.get_block(block_number=old_block)
+    with RetrySyncSubstrate(
+        "wss://lite.sub.latent.to:443", archive_nodes=["ws://178.156.172.75:9944"]
+    ) as substrate:
+        assert isinstance((substrate.get_block(block_number=old_block)), dict)