Converts all AccountIds from bt-decode to SS58

Author: thewhaleking

async_substrate_interface/async_substrate.py

@@ -64,6 +64,7 @@
     _determine_if_old_runtime_call,
     _bt_decode_to_dict_or_list,
     legacy_scale_decode,
+    convert_account_ids,
 )
 from async_substrate_interface.utils.storage import StorageKey
 from async_substrate_interface.type_registry import _TYPE_REGISTRY
@@ -816,6 +817,7 @@ async def initialize(self):
 
                 if ss58_prefix_constant:
                     self.ss58_format = ss58_prefix_constant.value
+                    runtime.ss58_format = ss58_prefix_constant.value
         self.initialized = True
         self._initializing = False
 
@@ -994,6 +996,12 @@ async def decode_scale(
                 runtime = await self.init_runtime(block_hash=block_hash)
             if runtime.metadata_v15 is not None or force_legacy is True:
                 obj = decode_by_type_string(type_string, runtime.registry, scale_bytes)
+                try:
+                    type_str_int = int(type_string.split("::")[1])
+                    decoded_type_str = runtime.type_id_to_name[type_str_int]
+                    obj = convert_account_ids(obj, decoded_type_str)
+                except (ValueError, KeyError):
+                    pass
             else:
                 obj = legacy_scale_decode(type_string, scale_bytes, runtime)
         if return_scale_obj:
@@ -1105,6 +1113,7 @@ async def _get_runtime_for_version(
             metadata_v15=metadata_v15,
             runtime_info=runtime_info,
             registry=registry,
+            ss58_format=self.ss58_format,
         )
         self.runtime_cache.add_item(
             block=block_number,

async_substrate_interface/sync_substrate.py

@@ -834,6 +834,7 @@ def get_runtime_for_version(
             metadata_v15=metadata_v15,
             runtime_info=runtime_info,
             registry=registry,
+            ss58_format=self.ss58_format,
         )
         self.runtime_cache.add_item(
             block=block_number,

async_substrate_interface/types.py

@@ -116,7 +116,9 @@ def __init__(
         metadata_v15=None,
         runtime_info=None,
         registry=None,
+        ss58_format=SS58_FORMAT,
     ):
+        self.ss58_format = ss58_format
         self.config = {}
         self.chain = chain
         self.type_registry = type_registry

async_substrate_interface/utils/decoding.py

@@ -1,7 +1,7 @@
-from typing import Union, TYPE_CHECKING
+from typing import Union, TYPE_CHECKING, Any
 
 from bt_decode import AxonInfo, PrometheusInfo, decode_list
-from scalecodec import ScaleBytes
+from scalecodec import ScaleBytes, ss58_encode
 
 from async_substrate_interface.utils import hex_to_bytes
 from async_substrate_interface.types import ScaleObj
@@ -120,24 +120,35 @@ def concat_hash_len(key_hasher: str) -> int:
     )
     middl_index = len(all_decoded) // 2
     decoded_keys = all_decoded[:middl_index]
-    decoded_values = [ScaleObj(x) for x in all_decoded[middl_index:]]
-    for dk, dv in zip(decoded_keys, decoded_values):
+    decoded_values = all_decoded[middl_index:]
+    for (kts, vts), (dk, dv) in zip(
+        zip(pre_decoded_key_types, pre_decoded_value_types),
+        zip(decoded_keys, decoded_values),
+    ):
         try:
             # strip key_hashers to use as item key
             if len(param_types) - len(params) == 1:
                 item_key = dk[1]
+                if kts[kts.index(", ") + 2 : kts.index(")")] == "scale_info::0":
+                    item_key = ss58_encode(bytes(item_key[0]), runtime.ss58_format)
+
             else:
                 item_key = tuple(
                     dk[key + 1] for key in range(len(params), len(param_types) + 1, 2)
                 )
+                # TODO handle decoding here, but first figure out what triggers this
 
         except Exception as _:
             if not ignore_decoding_errors:
                 raise
             item_key = None
-
-        item_value = dv
-        result.append([item_key, item_value])
+        try:
+            value_type_str_int = int(vts.split("::")[1])
+            decoded_type_str = runtime.type_id_to_name[value_type_str_int]
+            item_value = convert_account_ids(dv, decoded_type_str, runtime.ss58_format)
+        except (ValueError, KeyError) as e:
+            item_value = dv
+        result.append([item_key, ScaleObj(item_value)])
     return result
 
 
@@ -154,3 +165,68 @@ def legacy_scale_decode(
     obj.decode(check_remaining=runtime.config.get("strict_scale_decode"))
 
     return obj.value
+
+
+def is_accountid32(value: Any) -> bool:
+    return (
+        isinstance(value, tuple)
+        and len(value) == 32
+        and all(isinstance(b, int) and 0 <= b <= 255 for b in value)
+    )
+
+
+def convert_account_ids(value: Any, type_str: str, ss58_format=42) -> Any:
+    if "AccountId32" not in type_str:
+        return value
+
+    # Option<T>
+    if type_str.startswith("Option<") and value is not None:
+        inner_type = type_str[7:-1]
+        return convert_account_ids(value, inner_type)
+    # Vec<T>
+    if type_str.startswith("Vec<") and isinstance(value, (list, tuple)):
+        inner_type = type_str[4:-1]
+        return tuple(convert_account_ids(v, inner_type) for v in value)
+
+    # Vec<Vec<T>>
+    if type_str.startswith("Vec<Vec<") and isinstance(value, (list, tuple)):
+        inner_type = type_str[8:-2]
+        return tuple(
+            tuple(convert_account_ids(v2, inner_type) for v2 in v1) for v1 in value
+        )
+
+    # Tuple
+    if type_str.startswith("(") and isinstance(value, (list, tuple)):
+        inner_parts = split_tuple_type(type_str)
+        return tuple(convert_account_ids(v, t) for v, t in zip(value, inner_parts))
+
+    # AccountId32
+    if type_str == "AccountId32" and is_accountid32(value[0]):
+        return ss58_encode(bytes(value[0]), ss58_format=ss58_format)
+
+    # Fallback
+    return value
+
+
+def split_tuple_type(type_str: str) -> list[str]:
+    """
+    Splits a type string like '(AccountId32, Vec<StakeInfo>)' into ['AccountId32', 'Vec<StakeInfo>']
+    Handles nested generics.
+    """
+    s = type_str[1:-1]
+    parts = []
+    depth = 0
+    current = ""
+    for char in s:
+        if char == "," and depth == 0:
+            parts.append(current.strip())
+            current = ""
+        else:
+            if char == "<":
+                depth += 1
+            elif char == ">":
+                depth -= 1
+            current += char
+    if current:
+        parts.append(current.strip())
+    return parts