sync_substrate.py: make substrate.runtime a real property, move version dependent properties from substrate to substrate.runtime

Author: µ

async_substrate_interface/sync_substrate.py

@@ -585,7 +585,7 @@ def connect(self, init=False):
 
     def get_storage_item(self, module: str, storage_function: str, block_hash: str = None):
         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
 
@@ -611,9 +611,9 @@ def _load_registry_at_block(self, block_hash: Optional[str]) -> MetadataV15:
         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
 
     def decode_scale(
         self,
@@ -638,25 +638,22 @@ def decode_scale(
             # Decode AccountId bytes to SS58 address
             return ss58_encode(scale_bytes, SS58_FORMAT)
         else:
-            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
 
-    def load_runtime(self,runtime_info=None,metadata=None,metadata_v15=None,registry=None):
+    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")
@@ -702,7 +699,7 @@ 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)
@@ -727,7 +724,7 @@ def init_runtime(
                 )
             )
 
-            metadata_v15 = self._load_registry_at_block(
+            metadata_v15,registry = self._load_registry_at_block(
                 block_hash=runtime_block_hash
             )
             logger.debug(
@@ -743,16 +740,11 @@ 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)
 
-        self.load_runtime(
-                runtime_info=runtime.runtime_info,
-                metadata=runtime.metadata,
-                metadata_v15=runtime.metadata_v15,
-                registry=runtime.registry,
-            )
+        self.load_runtime(runtime)
 
         if self.ss58_format is None:
             # Check and apply runtime constants
@@ -789,7 +781,7 @@ def create_storage_key(
             storage_function,
             params,
             runtime_config=self.runtime_config,
-            metadata=self._metadata,
+            metadata=self.runtime.metadata,
         )
 
     def get_metadata_storage_functions(self, block_hash=None) -> list:
@@ -814,7 +806,7 @@ 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,
                         )
                     )
 
@@ -853,14 +845,14 @@ def get_metadata_errors(self, block_hash=None) -> list[dict[str, Optional[str]]]
 
         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,
                         )
                     )
 
@@ -881,7 +873,7 @@ def get_metadata_error(self, module_name, error_name, block_hash=None):
         """
         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:
@@ -974,7 +966,7 @@ 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)
@@ -1496,7 +1488,7 @@ 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')
@@ -1531,7 +1523,7 @@ def _preprocess(
                 storage_item.value["name"],
                 params,
                 runtime_config=self.runtime_config,
-                metadata=self._metadata,
+                metadata=self.runtime.metadata,
             )
         method = "state_getStorageAt"
         return Preprocessed(
@@ -1778,7 +1770,7 @@ def compose_call(
         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(
@@ -1947,12 +1939,12 @@ 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(
@@ -2041,10 +2033,10 @@ 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",
@@ -2093,9 +2085,9 @@ 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
@@ -2135,7 +2127,7 @@ 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 = {
@@ -2249,7 +2241,7 @@ 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]
@@ -2348,7 +2340,7 @@ def get_metadata_constant(self, module_name, constant_name, block_hash=None):
         """
         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"]:
@@ -2491,7 +2483,7 @@ 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 []),
@@ -2608,7 +2600,7 @@ def query_map(
             self.last_block_hash = block_hash
         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)
@@ -2637,7 +2629,7 @@ 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()
 

async_substrate_interface/types.py

@@ -83,6 +83,8 @@ def __init__(
         self.metadata_v15 = metadata_v15
         self.runtime_info = runtime_info
         self.registry = registry
+        self.runtime_version = runtime_info.get('specVersion')
+        self.transaction_version = runtime_info.get("transactionVersion")
 
     def __str__(self):
         return f"Runtime: {self.chain} | {self.config}"
@@ -352,8 +354,6 @@ def decode(self):
 
 
 class SubstrateMixin(ABC):
-    registry: Optional[PortableRegistry] = None
-    runtime_version = None
     type_registry_preset = None
     transaction_version = None
     block_id: Optional[int] = None
@@ -363,16 +363,14 @@ class SubstrateMixin(ABC):
     _version = None
     _token_decimals = None
     _token_symbol = None
-    _metadata = None
-    metadata_v15 = None
     _chain: str
     runtime_config: RuntimeConfigurationObject
     type_registry: Optional[dict]
     ss58_format: Optional[int]
     ws_max_size = 2**32
     registry_type_map: dict[str, int]
     type_id_to_name: dict[int, str]
-    metadata_v15 = None
+    runtime: Runtime = None
 
     @property
     def chain(self):
@@ -383,22 +381,13 @@ def chain(self):
 
     @property
     def metadata(self):
-        if self._metadata is None:
+        if not self.runtime or self.runtime.metadata is None:
             raise AttributeError(
                 "Metadata not found. This generally indicates that the AsyncSubstrateInterface object "
                 "is not properly async initialized."
             )
         else:
-            return self._metadata
-
-    @property
-    def runtime(self):
-        return Runtime(
-            self.chain,
-            self.runtime_config,
-            self._metadata,
-            self.type_registry,
-        )
+            return self.runtime.metadata
 
     @property
     def implements_scaleinfo(self) -> Optional[bool]:
@@ -409,8 +398,8 @@ def implements_scaleinfo(self) -> Optional[bool]:
         -------
         bool
         """
-        if self._metadata:
-            return self._metadata.portable_registry is not None
+        if self.runtime and self.runtime.metadata:
+            return self.runtime.metadata.portable_registry is not None
         else:
             return None
 
@@ -628,10 +617,10 @@ def serialize_module_error(module, error, spec_version) -> dict:
             "spec_version": spec_version,
         }
 
-    def _load_registry_type_map(self):
+    def _load_registry_type_map(self,registry):
         registry_type_map = {}
         type_id_to_name = {}
-        types = json.loads(self.registry.registry)["types"]
+        types = json.loads(registry.registry)["types"]
         for type_entry in types:
             type_type = type_entry["type"]
             type_id = type_entry["id"]