make asyncsubstrate.runtime a real property, move version dependent properties from asyncsubstrate to asyncsubstrate.runtime

Author: µ

async_substrate_interface/async_substrate.py

@@ -777,7 +777,7 @@ async def name(self):
 
     async def get_storage_item(self, module: str, storage_function: str, block_hash: str = None):
         await self.init_runtime(block_hash=block_hash)
-        metadata_pallet = self._metadata.get_metadata_pallet(module)
+        metadata_pallet = self.runtime.metadata.get_metadata_pallet(module)
         storage_item = metadata_pallet.get_storage_function(storage_function)
         return storage_item
 
@@ -815,18 +815,18 @@ async def _load_registry_at_block(self, block_hash: Optional[str]) -> MetadataV1
         metadata_option_hex_str = metadata_rpc_result["result"]
         metadata_option_bytes = bytes.fromhex(metadata_option_hex_str[2:])
         metadata = MetadataV15.decode_from_metadata_option(metadata_option_bytes)
-        self.registry = PortableRegistry.from_metadata_v15(metadata)
-        self._load_registry_type_map()
-        return metadata
+        registry = PortableRegistry.from_metadata_v15(metadata)
+        self._load_registry_type_map(registry)
+        return metadata,registry
 
     async def _wait_for_registry(self, _attempt: int = 1, _retries: int = 3) -> None:
         async def _waiter():
-            while self.registry is None:
+            while self.runtime.registry is None:
                 await asyncio.sleep(0.1)
             return
 
         try:
-            if not self.registry:
+            if not self.runtime.registry:
                 await asyncio.wait_for(_waiter(), timeout=10)
         except TimeoutError:
             # indicates that registry was never loaded
@@ -893,25 +893,22 @@ async def decode_scale(
             return ss58_encode(scale_bytes, SS58_FORMAT)
         else:
             await self._wait_for_registry(_attempt, _retries)
-            obj = decode_by_type_string(type_string, self.registry, scale_bytes)
+            obj = decode_by_type_string(type_string, self.runtime.registry, scale_bytes)
         if return_scale_obj:
             return ScaleObj(obj)
         else:
             return obj
 
-    async def load_runtime(self,runtime_info=None,metadata=None,metadata_v15=None,registry=None):
+    async def load_runtime(self,runtime):
         # Update type registry
         self.reload_type_registry(use_remote_preset=False, auto_discover=True)
 
-        self.metadata_v15 = metadata_v15
-        self.registry = registry
-        self.runtime_version = runtime_info.get("specVersion")
-        self._metadata = metadata
-        self.runtime_config.set_active_spec_version_id(self.runtime_version)
-        self.transaction_version = runtime_info.get("transactionVersion")
+        self.runtime = runtime
+
+        self.runtime_config.set_active_spec_version_id(runtime.runtime_version)
         if self.implements_scaleinfo:
             logger.debug("Add PortableRegistry from metadata to type registry")
-            self.runtime_config.add_portable_registry(metadata)
+            self.runtime_config.add_portable_registry(runtime.metadata)
         # Set runtime compatibility flags
         try:
             _ = self.runtime_config.create_scale_object("sp_weights::weight_v2::Weight")
@@ -957,7 +954,7 @@ async def init_runtime(
                 f"No runtime information for block '{block_hash}'"
             )
 
-        if runtime_version == self.runtime_version:
+        if self.runtime and runtime_version == self.runtime.runtime_version:
             return
 
         runtime = self.runtime_cache.retrieve(runtime_version=runtime_version)
@@ -984,7 +981,7 @@ async def init_runtime(
                 )
             )
 
-            metadata_v15 = await self._load_registry_at_block(block_hash=runtime_block_hash)
+            metadata_v15,registry = await self._load_registry_at_block(block_hash=runtime_block_hash)
             logger.debug(
                 "Retrieved metadata v15 for {} from Substrate node".format(
                     runtime_version
@@ -998,16 +995,11 @@ async def init_runtime(
                     type_registry=self.type_registry,
                     metadata_v15=metadata_v15,
                     runtime_info=runtime_info,
-                    registry=self.registry,
+                    registry=registry,
                 )
             self.runtime_cache.add_item(runtime_version=runtime_version, runtime=runtime)
 
-        await self.load_runtime(
-                runtime_info=runtime.runtime_info,
-                metadata=runtime.metadata,
-                metadata_v15=runtime.metadata_v15,
-                registry=runtime.registry,
-            )
+        await self.load_runtime(runtime)
 
         if self.ss58_format is None:
             # Check and apply runtime constants
@@ -1044,7 +1036,7 @@ async def create_storage_key(
             storage_function,
             params,
             runtime_config=self.runtime_config,
-            metadata=self._metadata,
+            metadata=self.runtime.metadata,
         )
 
     async def get_metadata_storage_functions(self, block_hash=None) -> list:
@@ -1069,7 +1061,7 @@ async def get_metadata_storage_functions(self, block_hash=None) -> list:
                         self.serialize_storage_item(
                             storage_item=storage,
                             module=module,
-                            spec_version_id=self.runtime_version,
+                            spec_version_id=self.runtime.runtime_version,
                         )
                     )
 
@@ -1112,14 +1104,14 @@ async def get_metadata_errors(
 
         error_list = []
 
-        for module_idx, module in enumerate(self._metadata.pallets):
+        for module_idx, module in enumerate(self.runtime.metadata.pallets):
             if module.errors:
                 for error in module.errors:
                     error_list.append(
                         self.serialize_module_error(
                             module=module,
                             error=error,
-                            spec_version=self.runtime_version,
+                            spec_version=self.runtime.runtime_version,
                         )
                     )
 
@@ -1140,7 +1132,7 @@ async def get_metadata_error(self, module_name, error_name, block_hash=None):
         """
         await self.init_runtime(block_hash=block_hash)
 
-        for module_idx, module in enumerate(self._metadata.pallets):
+        for module_idx, module in enumerate(self.runtime.metadata.pallets):
             if module.name == module_name and module.errors:
                 for error in module.errors:
                     if error_name == error.name:
@@ -1233,7 +1225,7 @@ async def decode_block(block_data, block_data_hash=None) -> dict[str, Any]:
                         try:
                             extrinsic_decoder = extrinsic_cls(
                                 data=ScaleBytes(extrinsic_data),
-                                metadata=self._metadata,
+                                metadata=self.runtime.metadata,
                                 runtime_config=self.runtime_config,
                             )
                             extrinsic_decoder.decode(check_remaining=True)
@@ -1761,7 +1753,7 @@ async def _preprocess(
         """
         params = query_for if query_for else []
         # Search storage call in metadata
-        metadata_pallet = self._metadata.get_metadata_pallet(module)
+        metadata_pallet = self.runtime.metadata.get_metadata_pallet(module)
 
         if not metadata_pallet:
             raise SubstrateRequestException(f'Pallet "{module}" not found')
@@ -1797,7 +1789,7 @@ async def _preprocess(
                 storage_item.value["name"],
                 params,
                 runtime_config=self.runtime_config,
-                metadata=self._metadata,
+                metadata=self.runtime.metadata,
             )
         method = "state_getStorageAt"
         return Preprocessed(
@@ -2048,7 +2040,7 @@ async def compose_call(
         await self.init_runtime(block_hash=block_hash)
 
         call = self.runtime_config.create_scale_object(
-            type_string="Call", metadata=self._metadata
+            type_string="Call", metadata=self.runtime.metadata
         )
 
         call.encode(
@@ -2227,12 +2219,12 @@ async def generate_signature_payload(
         )
 
         # Process signed extensions in metadata
-        if "signed_extensions" in self._metadata[1][1]["extrinsic"]:
+        if "signed_extensions" in self.runtime.metadata[1][1]["extrinsic"]:
             # Base signature payload
             signature_payload.type_mapping = [["call", "CallBytes"]]
 
             # Add signed extensions to payload
-            signed_extensions = self._metadata.get_signed_extensions()
+            signed_extensions = self.runtime.metadata.get_signed_extensions()
 
             if "CheckMortality" in signed_extensions:
                 signature_payload.type_mapping.append(
@@ -2321,10 +2313,10 @@ async def generate_signature_payload(
             "era": era,
             "nonce": nonce,
             "tip": tip,
-            "spec_version": self.runtime_version,
+            "spec_version": self.runtime.runtime_version,
             "genesis_hash": genesis_hash,
             "block_hash": block_hash,
-            "transaction_version": self.transaction_version,
+            "transaction_version": self.runtime.transaction_version,
             "asset_id": {"tip": tip, "asset_id": tip_asset_id},
             "metadata_hash": None,
             "mode": "Disabled",
@@ -2373,9 +2365,9 @@ async def create_signed_extrinsic(
             raise TypeError("'call' must be of type Call")
 
         # Check if extrinsic version is supported
-        if self._metadata[1][1]["extrinsic"]["version"] != 4:  # type: ignore
+        if self.runtime.metadata[1][1]["extrinsic"]["version"] != 4:  # type: ignore
             raise NotImplementedError(
-                f"Extrinsic version {self._metadata[1][1]['extrinsic']['version']} not supported"  # type: ignore
+                f"Extrinsic version {self.runtime.metadata[1][1]['extrinsic']['version']} not supported"  # type: ignore
             )
 
         # Retrieve nonce
@@ -2417,7 +2409,7 @@ async def create_signed_extrinsic(
 
         # Create extrinsic
         extrinsic = self.runtime_config.create_scale_object(
-            type_string="Extrinsic", metadata=self._metadata
+            type_string="Extrinsic", metadata=self.runtime.metadata
         )
 
         value = {
@@ -2533,7 +2525,7 @@ async def runtime_call(
             params = {}
 
         try:
-            metadata_v15_value = self.metadata_v15.value()
+            metadata_v15_value = self.runtime.metadata_v15.value()
 
             apis = {entry["name"]: entry for entry in metadata_v15_value["apis"]}
             api_entry = apis[api]
@@ -2641,7 +2633,7 @@ async def get_metadata_constant(self, module_name, constant_name, block_hash=Non
         """
         await self.init_runtime(block_hash=block_hash)
 
-        for module in self._metadata.pallets:
+        for module in self.runtime.metadata.pallets:
             if module_name == module.name and module.constants:
                 for constant in module.constants:
                     if constant_name == constant.value["name"]:
@@ -2790,7 +2782,7 @@ async def get_metadata_modules(self, block_hash=None) -> list[dict[str, Any]]:
                 "metadata_index": idx,
                 "module_id": module.get_identifier(),
                 "name": module.name,
-                "spec_version": self.runtime_version,
+                "spec_version": self.runtime.runtime_version,
                 "count_call_functions": len(module.calls or []),
                 "count_storage_functions": len(module.storage or []),
                 "count_events": len(module.events or []),
@@ -2907,7 +2899,7 @@ async def query_map(
             self.last_block_hash = block_hash
         await self.init_runtime(block_hash=block_hash)
 
-        metadata_pallet = self._metadata.get_metadata_pallet(module)
+        metadata_pallet = self.runtime.metadata.get_metadata_pallet(module)
         if not metadata_pallet:
             raise ValueError(f'Pallet "{module}" not found')
         storage_item = metadata_pallet.get_storage_function(storage_function)
@@ -2935,7 +2927,7 @@ async def query_map(
             storage_item.value["name"],
             params,
             runtime_config=self.runtime_config,
-            metadata=self._metadata,
+            metadata=self.runtime.metadata,
         )
         prefix = storage_key.to_hex()