WIP check-in

Author: thewhaleking

async_substrate_interface/async_substrate.py

@@ -966,7 +966,6 @@ def load_runtime(self, runtime):
         # Update type registry
         runtime.reload_type_registry(use_remote_preset=False, auto_discover=True)
 
-        runtime.runtime_config.set_active_spec_version_id(runtime.runtime_version)
         runtime.runtime_config.set_active_spec_version_id(runtime.runtime_version)
         if runtime.implements_scaleinfo:
             logger.debug("Adding PortableRegistry from metadata to type registry")
@@ -1032,7 +1031,7 @@ async def init_runtime(
         if self.ss58_format is None:
             # Check and apply runtime constants
             ss58_prefix_constant = await self.get_constant(
-                "System", "SS58Prefix", block_hash=block_hash
+                "System", "SS58Prefix", block_hash=block_hash, runtime=runtime
             )
 
             if ss58_prefix_constant:
@@ -1458,8 +1457,8 @@ async def decode_block(block_data, block_data_hash=None) -> dict[str, Any]:
                         try:
                             extrinsic_decoder = extrinsic_cls(
                                 data=ScaleBytes(extrinsic_data),
-                                metadata=self.runtime.metadata,
-                                runtime_config=self.runtime_config,
+                                metadata=runtime.metadata,
+                                runtime_config=runtime.runtime_config,
                             )
                             extrinsic_decoder.decode(check_remaining=True)
                             block_data["extrinsics"][idx] = extrinsic_decoder
@@ -2299,17 +2298,24 @@ async def rpc_request(
                 params + [block_hash] if block_hash else params,
             )
         ]
-        result = await self._make_rpc_request(payloads, result_handler=result_handler)
+        result = await self._make_rpc_request(
+            payloads, result_handler=result_handler, runtime=runtime
+        )
         if "error" in result[payload_id][0]:
             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."
                 )
-                await self.init_runtime(block_hash=block_hash)
+                runtime = await self.init_runtime(block_hash=block_hash)
                 return await self.rpc_request(
-                    method, params, result_handler, block_hash, reuse_block_hash
+                    method,
+                    params,
+                    result_handler,
+                    block_hash,
+                    reuse_block_hash,
+                    runtime=runtime,
                 )
             elif (
                 "Client error: Api called for an unknown Block: State already discarded"
@@ -3036,7 +3042,13 @@ async def get_metadata_constants(self, block_hash=None) -> list[dict]:
 
         return constant_list
 
-    async def get_metadata_constant(self, module_name, constant_name, block_hash=None):
+    async def get_metadata_constant(
+        self,
+        module_name,
+        constant_name,
+        block_hash=None,
+        runtime: Optional[Runtime] = None,
+    ):
         """
         Retrieves the details of a constant for given module name, call function name and block_hash
         (or chaintip if block_hash is omitted)
@@ -3045,13 +3057,15 @@ async def get_metadata_constant(self, module_name, constant_name, block_hash=Non
             module_name: name of the module you are querying
             constant_name: name of the constant you are querying
             block_hash: hash of the block at which to make the runtime API call
+            runtime: Runtime whose metadata you are querying.
 
         Returns:
             MetadataModuleConstants
         """
-        await self.init_runtime(block_hash=block_hash)
+        if not runtime:
+            runtime = await self.init_runtime(block_hash=block_hash)
 
-        for module in self.runtime.metadata.pallets:
+        for module in runtime.metadata.pallets:
             if module_name == module.name and module.constants:
                 for constant in module.constants:
                     if constant_name == constant.value["name"]:
@@ -3063,6 +3077,7 @@ async def get_constant(
         constant_name: str,
         block_hash: Optional[str] = None,
         reuse_block_hash: bool = False,
+        runtime: Optional[Runtime] = None,
     ) -> Optional[ScaleObj]:
         """
         Returns the decoded `ScaleType` object of the constant for given module name, call function name and block_hash
@@ -3073,18 +3088,22 @@ async def get_constant(
             constant_name: Name of the constant to query
             block_hash: Hash of the block at which to make the runtime API call
             reuse_block_hash: Reuse last-used block hash if set to true
+            runtime: Runtime to use for querying the constant
 
         Returns:
              ScaleType from the runtime call
         """
         block_hash = await self._get_current_block_hash(block_hash, reuse_block_hash)
         constant = await self.get_metadata_constant(
-            module_name, constant_name, block_hash=block_hash
+            module_name, constant_name, block_hash=block_hash, runtime=runtime
         )
         if constant:
             # Decode to ScaleType
             return await self.decode_scale(
-                constant.type, bytes(constant.constant_value), return_scale_obj=True
+                constant.type,
+                bytes(constant.constant_value),
+                return_scale_obj=True,
+                runtime=runtime,
             )
         else:
             return None

async_substrate_interface/sync_substrate.py

@@ -506,6 +506,7 @@ def __init__(
             _log_raw_websockets: whether to log raw websocket requests during RPC requests
 
         """
+        super().__init__(type_registry, type_registry_preset, use_remote_preset)
         self.max_retries = max_retries
         self.retry_timeout = retry_timeout
         self.chain_endpoint = url
@@ -526,9 +527,6 @@ def __init__(
             ss58_format=self.ss58_format, implements_scale_info=True
         )
         self.metadata_version_hex = "0x0f000000"  # v15
-        self.reload_type_registry()
-        self.registry_type_map = {}
-        self.type_id_to_name = {}
         self._mock = _mock
         self.log_raw_websockets = _log_raw_websockets
         if not _mock:

async_substrate_interface/utils/cache.py

@@ -228,7 +228,7 @@ def make_cache_key(self, args: tuple, kwargs: dict) -> Hashable:
 
         if self._cache_key_index is not None:
             key_name = list(bound.arguments)[self._cache_key_index]
-            return bound.arguments[key_name][self._cache_key_index]
+            return bound.arguments[key_name]
 
         return (tuple(bound.arguments.items()),)
 

tests/unit_tests/asyncio_/test_substrate_interface.py

@@ -1,5 +1,5 @@
 import asyncio
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, ANY
 
 import pytest
 from websockets.exceptions import InvalidURI
@@ -64,7 +64,7 @@ async def test_runtime_call(monkeypatch):
 
     # Patch RPC request with correct behavior
     substrate.rpc_request = AsyncMock(
-        side_effect=lambda method, params: {
+        side_effect=lambda method, params, runtime: {
             "result": "0x00" if method == "state_call" else {"parentHash": "0xDEADBEEF"}
         }
     )
@@ -83,14 +83,16 @@ async def test_runtime_call(monkeypatch):
     assert result.value == "decoded_result"
 
     # Check decode_scale called correctly
-    substrate.decode_scale.assert_called_once_with("scale_info::1", b"\x00")
+    substrate.decode_scale.assert_called_once_with(
+        "scale_info::1", b"\x00", runtime=ANY
+    )
 
     # encode_scale should not be called since no inputs
     substrate.encode_scale.assert_not_called()
 
     # Check RPC request called for the state_call
     substrate.rpc_request.assert_any_call(
-        "state_call", ["SubstrateApi_SubstrateMethod", "", None]
+        "state_call", ["SubstrateApi_SubstrateMethod", "", None], runtime=ANY
     )
 
 

tests/unit_tests/test_cache.py

@@ -71,8 +71,11 @@ async def error_method(x):
 @pytest.mark.asyncio
 async def test_cached_fetcher_eviction():
     """Tests that LRU eviction works in CachedFetcher."""
-    mock_method = mock.AsyncMock(side_effect=lambda x: f"val_{x}")
-    fetcher = CachedFetcher(max_size=2, method=mock_method)
+
+    async def side_effect_method(x):
+        return f"val_{x}"
+
+    fetcher = CachedFetcher(max_size=2, method=side_effect_method)
 
     # Fill cache
     await fetcher("key1")