WIP check-in

Author: thewhaleking

async_substrate_interface/async_substrate.py

@@ -807,7 +807,15 @@ async def initialize(self):
             if not self._chain:
                 chain = await self.rpc_request("system_chain", [])
                 self._chain = chain.get("result")
-            await self.init_runtime()
+            runtime = await self.init_runtime()
+            if self.ss58_format is None:
+                # Check and apply runtime constants
+                ss58_prefix_constant = await self.get_constant(
+                    "System", "SS58Prefix", runtime=runtime
+                )
+
+                if ss58_prefix_constant:
+                    self.ss58_format = ss58_prefix_constant
         self.initialized = True
         self._initializing = False
 
@@ -962,27 +970,6 @@ async def decode_scale(
         else:
             return obj
 
-    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)
-        if runtime.implements_scaleinfo:
-            logger.debug("Adding PortableRegistry from metadata to type registry")
-            runtime.runtime_config.add_portable_registry(runtime.metadata)
-        # Set runtime compatibility flags
-        try:
-            _ = runtime.runtime_config.create_scale_object(
-                "sp_weights::weight_v2::Weight"
-            )
-            runtime.config["is_weight_v2"] = True
-            runtime.runtime_config.update_type_registry_types(
-                {"Weight": "sp_weights::weight_v2::Weight"}
-            )
-        except NotImplementedError:
-            runtime.config["is_weight_v2"] = False
-            runtime.runtime_config.update_type_registry_types({"Weight": "WeightV1"})
-
     async def init_runtime(
         self, block_hash: Optional[str] = None, block_id: Optional[int] = None
     ) -> Runtime:
@@ -1006,37 +993,27 @@ async def init_runtime(
             raise ValueError("Cannot provide block_hash and block_id at the same time")
 
         if block_id is not None:
+            if runtime := self.runtime_cache.retrieve(block=block_id):
+                return runtime
             block_hash = await self.get_block_hash(block_id)
 
         if not block_hash:
             block_hash = await self.get_chain_head()
+        else:
+            self.last_block_hash = block_hash
+            if runtime := self.runtime_cache.retrieve(block_hash=block_hash):
+                return runtime
 
         runtime_version = await self.get_block_runtime_version_for(block_hash)
         if runtime_version is None:
             raise SubstrateRequestException(
                 f"No runtime information for block '{block_hash}'"
             )
 
-        if self.runtime and runtime_version == self.runtime.runtime_version:
-            return self.runtime
-
-        runtime = self.runtime_cache.retrieve(runtime_version=runtime_version)
-        if not runtime:
-            self.last_block_hash = block_hash
-
-            runtime = await self.get_runtime_for_version(runtime_version, block_hash)
-
-        self.load_runtime(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, runtime=runtime
-            )
-
-            if ss58_prefix_constant:
-                self.ss58_format = ss58_prefix_constant
-        return runtime
+        if runtime := self.runtime_cache.retrieve(runtime_version=runtime_version):
+            return runtime
+        else:
+            return await self.get_runtime_for_version(runtime_version, block_hash)
 
     @cached_fetcher(max_size=16, cache_key_index=0)
     async def get_runtime_for_version(
@@ -1056,7 +1033,9 @@ async def get_runtime_for_version(
     async def _get_runtime_for_version(
         self, runtime_version: int, block_hash: Optional[str] = None
     ) -> Runtime:
-        runtime_block_hash = await self.get_parent_block_hash(block_hash)
+        runtime_block_hash, block_number = await asyncio.gather(
+            self.get_parent_block_hash(block_hash), self.get_block_number(block_hash)
+        )
         runtime_info, metadata, (metadata_v15, registry) = await asyncio.gather(
             self.get_block_runtime_info(runtime_block_hash),
             self.get_block_metadata(block_hash=runtime_block_hash, decode=True),
@@ -1080,7 +1059,12 @@ async def _get_runtime_for_version(
             runtime_info=runtime_info,
             registry=registry,
         )
-        self.runtime_cache.add_item(runtime_version=runtime_version, runtime=runtime)
+        self.runtime_cache.add_item(
+            block=block_number,
+            block_hash=block_hash,
+            runtime_version=runtime_version,
+            runtime=runtime,
+        )
         return runtime
 
     async def create_storage_key(

async_substrate_interface/sync_substrate.py

@@ -523,9 +523,6 @@ def __init__(
         self.type_registry = type_registry
         self.type_registry_preset = type_registry_preset
         self.runtime_cache = RuntimeCache()
-        self.runtime_config = RuntimeConfigurationObject(
-            ss58_format=self.ss58_format, implements_scale_info=True
-        )
         self.metadata_version_hex = "0x0f000000"  # v15
         self._mock = _mock
         self.log_raw_websockets = _log_raw_websockets
@@ -650,7 +647,6 @@ def _load_registry_at_block(self, block_hash: Optional[str]) -> MetadataV15:
         metadata_option_bytes = bytes.fromhex(metadata_option_hex_str[2:])
         metadata = MetadataV15.decode_from_metadata_option(metadata_option_bytes)
         registry = PortableRegistry.from_metadata_v15(metadata)
-        self._load_registry_type_map(registry)
         return metadata, registry
 
     def decode_scale(
@@ -686,7 +682,7 @@ def load_runtime(self, runtime):
         self.runtime = runtime
 
         # Update type registry
-        self.reload_type_registry(use_remote_preset=False, auto_discover=True)
+        self.runtime.reload_type_registry(use_remote_preset=False, auto_discover=True)
 
         self.runtime_config.set_active_spec_version_id(runtime.runtime_version)
         if self.implements_scaleinfo:
@@ -695,12 +691,12 @@ def load_runtime(self, runtime):
         # Set runtime compatibility flags
         try:
             _ = self.runtime_config.create_scale_object("sp_weights::weight_v2::Weight")
-            self.config["is_weight_v2"] = True
+            self.runtime.config["is_weight_v2"] = True
             self.runtime_config.update_type_registry_types(
                 {"Weight": "sp_weights::weight_v2::Weight"}
             )
         except NotImplementedError:
-            self.config["is_weight_v2"] = False
+            self.runtime.config["is_weight_v2"] = False
             self.runtime_config.update_type_registry_types({"Weight": "WeightV1"})
 
     def init_runtime(
@@ -764,9 +760,7 @@ def init_runtime(
                 block_hash=runtime_block_hash
             )
             logger.debug(
-                "Retrieved metadata v15 for {} from Substrate node".format(
-                    runtime_version
-                )
+                f"Retrieved metadata v15 for {runtime_version} from Substrate node"
             )
 
             runtime = Runtime(

async_substrate_interface/types.py

@@ -91,8 +91,28 @@ def __init__(
         self.registry = registry
         self.runtime_version = runtime_info.get("specVersion")
         self.transaction_version = runtime_info.get("transactionVersion")
+        self._load_runtime()
         if registry is not None:
-            self._load_registry_type_map(registry)
+            self._load_registry_type_map()
+
+    def _load_runtime(self):
+        # Update type registry
+        self.reload_type_registry(use_remote_preset=False, auto_discover=True)
+
+        self.runtime_config.set_active_spec_version_id(self.runtime_version)
+        if self.implements_scaleinfo:
+            logger.debug("Adding PortableRegistry from metadata to type registry")
+            self.runtime_config.add_portable_registry(self.metadata)
+        # Set runtime compatibility flags
+        try:
+            _ = self.runtime_config.create_scale_object("sp_weights::weight_v2::Weight")
+            self.config["is_weight_v2"] = True
+            self.runtime_config.update_type_registry_types(
+                {"Weight": "sp_weights::weight_v2::Weight"}
+            )
+        except NotImplementedError:
+            self.config["is_weight_v2"] = False
+            self.runtime_config.update_type_registry_types({"Weight": "WeightV1"})
 
     @property
     def implements_scaleinfo(self) -> Optional[bool]:
@@ -188,10 +208,10 @@ def apply_type_registry_presets(
             # Load type registries in runtime configuration
             self.runtime_config.update_type_registry(self.type_registry)
 
-    def _load_registry_type_map(self, registry):
+    def _load_registry_type_map(self):
         registry_type_map = {}
         type_id_to_name = {}
-        types = json.loads(registry.registry)["types"]
+        types = json.loads(self.registry.registry)["types"]
         type_by_id = {entry["id"]: entry for entry in types}
 
         # Pass 1: Gather simple types