htcli 1.1.0__py3-none-any.whl

src/htcli/utils/blockchain/patches.py

@@ -0,0 +1,286 @@
+"""
+Temporary patches for blockchain SCALE encoding quirks.
+"""
+
+from collections.abc import Iterable
+from contextlib import contextmanager
+from typing import Any
+
+from scalecodec.types import CompactU32, Map
+
+# Import logger for debugging
+try:
+    from ...utils.logging import get_logger
+
+    logger = get_logger(__name__)
+except ImportError:
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+_ORIGINAL_MAP_PROCESS_ENCODE = Map.process_encode
+
+
+def _should_patch_btreemap_accountid_u32(value: Any, map_instance: Map) -> bool:
+    """
+    Determine whether we need to patch the Map encoder for BTreeMap<AccountId, u32>.
+
+    The issue arises when map_instance.map_key/map_value are None because the
+    runtime metadata does not correctly expose the key/value types, which happens
+    for BTreeMap<AccountId, u32> in the Hypertensor runtime.
+    """
+    if map_instance.map_key and map_instance.map_value:
+        return False
+
+    # Value must be a list/tuple of 2-tuples
+    if not isinstance(value, Iterable):
+        return False
+
+    try:
+        first_item = next(iter(value))
+    except StopIteration:
+        # Empty map - no need to patch
+        return False
+
+    if not isinstance(first_item, (tuple, list)) or len(first_item) != 2:
+        return False
+
+    key_candidate, value_candidate = first_item
+
+    # Keys should be 20-byte addresses (bytes)
+    if not isinstance(key_candidate, (bytes, bytearray)) or len(key_candidate) != 20:
+        return False
+
+    # Values should be ints (u32)
+    if not isinstance(value_candidate, int):
+        return False
+
+    return True
+
+
+def _should_patch_btreemap_u32_u32(value: Any, map_instance: Map) -> bool:
+    """Detect BTreeMap<u32, u32> values when metadata lacks key/value types."""
+    if map_instance.map_key and map_instance.map_value:
+        return False
+
+    if not isinstance(value, Iterable):
+        return False
+
+    try:
+        first_item = next(iter(value))
+    except StopIteration:
+        return False
+
+    if not isinstance(first_item, (tuple, list)) or len(first_item) != 2:
+        return False
+
+    key_candidate, value_candidate = first_item
+    return isinstance(key_candidate, int) and isinstance(value_candidate, int)
+
+
+def _should_patch_btreemap_bytes_bytes(value: Any, map_instance: Map) -> bool:
+    """
+    Detect BTreeMap<PeerId, BoundedVec<u8, ...>> values when metadata lacks types.
+
+    Both PeerId and BoundedVec<u8, ...> are encoded like Vec<u8> in the deployed
+    Hypertensor runtime metadata.
+    """
+    if map_instance.map_key and map_instance.map_value:
+        return False
+
+    if not isinstance(value, Iterable):
+        return False
+
+    try:
+        first_item = next(iter(value))
+    except StopIteration:
+        return False
+
+    if not isinstance(first_item, (tuple, list)) or len(first_item) != 2:
+        return False
+
+    key_candidate, value_candidate = first_item
+    return isinstance(key_candidate, (bytes, bytearray)) and isinstance(
+        value_candidate, (bytes, bytearray)
+    )
+
+
+def _encode_compact_bytes(value: bytes | bytearray) -> bytes:
+    element_count_compact = CompactU32()
+    element_count_compact.encode(len(value))
+    return element_count_compact.data + bytes(value)
+
+
+def _patched_process_encode(self: Map, value: Any) -> bytes:
+    """
+    Patched Map.process_encode that handles BTreeMap<AccountId, u32>.
+
+    This patch is needed because substrate-interface/scalecodec may not correctly
+    identify BTreeMap<AccountId, u32> from runtime metadata, especially when
+    AccountId is defined as [u8; 20].
+
+    Encoding format:
+    - Compact<u32> length
+    - For each entry (sorted by key):
+      - [u8; 20] AccountId (20 raw bytes)
+      - u32 value (4 bytes, little-endian)
+    """
+    if _should_patch_btreemap_u32_u32(value, self):
+        value_list = list(value)
+        value_list.sort(key=lambda x: x[0])
+
+        element_count_compact = CompactU32()
+        element_count_compact.encode(len(value_list))
+        data = element_count_compact.data
+
+        self.map_key = "u32"
+        self.map_value = "u32"
+
+        for idx, item in enumerate(value_list):
+            if not isinstance(item, (tuple, list)) or len(item) != 2:
+                raise ValueError(
+                    f"BTreeMap entry {idx} must be (key, value) tuple, got: {type(item)}"
+                )
+
+            item_key, item_value = item
+            if not isinstance(item_key, int) or not isinstance(item_value, int):
+                raise ValueError(
+                    f"BTreeMap<u32, u32> entry {idx} must contain ints, got: {item}"
+                )
+            if not 0 <= item_key <= 4294967295:
+                raise ValueError(f"u32 key at index {idx} out of range: {item_key}")
+            if not 0 <= item_value <= 4294967295:
+                raise ValueError(f"u32 value at index {idx} out of range: {item_value}")
+
+            data += item_key.to_bytes(4, byteorder="little", signed=False)
+            data += item_value.to_bytes(4, byteorder="little", signed=False)
+
+        return data
+
+    if _should_patch_btreemap_bytes_bytes(value, self):
+        value_list = list(value)
+        value_list.sort(key=lambda x: bytes(x[0]))
+
+        element_count_compact = CompactU32()
+        element_count_compact.encode(len(value_list))
+        data = element_count_compact.data
+
+        self.map_key = "Vec<u8>"
+        self.map_value = "Vec<u8>"
+
+        for idx, item in enumerate(value_list):
+            if not isinstance(item, (tuple, list)) or len(item) != 2:
+                raise ValueError(
+                    f"BTreeMap entry {idx} must be (key, value) tuple, got: {type(item)}"
+                )
+
+            item_key, item_value = item
+            if not isinstance(item_key, (bytes, bytearray)) or not isinstance(
+                item_value, (bytes, bytearray)
+            ):
+                raise ValueError(
+                    f"BTreeMap<bytes, bytes> entry {idx} must contain bytes, got: {item}"
+                )
+
+            data += _encode_compact_bytes(item_key)
+            data += _encode_compact_bytes(item_value)
+
+        return data
+
+    if not _should_patch_btreemap_accountid_u32(value, self):
+        return _ORIGINAL_MAP_PROCESS_ENCODE(self, value)
+
+    logger.debug("Patching BTreeMap<AccountId, u32> encoding")
+
+    # Ensure we have a concrete list (value might be set, generator, etc.)
+    # BTreeMap entries must be sorted by key for deterministic encoding
+    value_list = list(value)
+
+    # Sort by key (address bytes) to match BTreeMap ordering
+    # This is critical - BTreeMap is always sorted!
+    value_list.sort(
+        key=lambda x: x[0] if isinstance(x, (tuple, list)) and len(x) >= 1 else b""
+    )
+
+    logger.debug(f"Encoding BTreeMap with {len(value_list)} entries")
+
+    # Encode length as Compact<u32>
+    element_count_compact = CompactU32()
+    element_count_compact.encode(len(value_list))
+    data = element_count_compact.data
+
+    # Set type information for scalecodec
+    self.map_key = "[u8; 20]"
+    self.map_value = "u32"
+
+    # Encode each entry
+    for idx, item in enumerate(value_list):
+        if not isinstance(item, (tuple, list)) or len(item) != 2:
+            raise ValueError(
+                f"BTreeMap entry {idx} must be (key, value) tuple, got: {type(item)}"
+            )
+
+        item_key, item_value = item
+
+        # Encode key: [u8; 20] AccountId
+        if isinstance(item_key, bytes):
+            if len(item_key) != 20:
+                raise ValueError(
+                    f"AccountId at index {idx} must be exactly 20 bytes, got {len(item_key)} bytes"
+                )
+            # [u8; 20] is encoded as raw 20 bytes (no length prefix)
+            data += item_key
+        elif isinstance(item_key, bytearray):
+            if len(item_key) != 20:
+                raise ValueError(
+                    f"AccountId at index {idx} must be exactly 20 bytes, got {len(item_key)} bytes"
+                )
+            data += bytes(item_key)
+        else:
+            # Try to use scalecodec to encode (fallback)
+            try:
+                key_obj = self.runtime_config.create_scale_object(
+                    type_string="[u8; 20]", metadata=self.metadata
+                )
+                data += key_obj.encode(item_key)
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to encode AccountId key at index {idx}: {item_key}, error: {e}"
+                ) from e
+
+        # Encode value: u32 (4 bytes, little-endian)
+        if isinstance(item_value, int):
+            # Ensure it fits in u32 range
+            if item_value < 0 or item_value > 4294967295:
+                raise ValueError(
+                    f"u32 value at index {idx} must be 0-4294967295, got {item_value}"
+                )
+            # u32 is 4 bytes, little-endian
+            data += item_value.to_bytes(4, byteorder="little", signed=False)
+        else:
+            # Try to use scalecodec to encode (fallback)
+            try:
+                value_obj = self.runtime_config.create_scale_object(
+                    type_string="u32", metadata=self.metadata
+                )
+                data += value_obj.encode(item_value)
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to encode u32 value at index {idx}: {item_value}, error: {e}"
+                ) from e
+
+    logger.debug(f"Successfully encoded BTreeMap<AccountId, u32> ({len(data)} bytes)")
+    return data
+
+
+@contextmanager
+def patch_btreemap_accountid_u32_encoder():
+    """
+    Context manager that patches scalecodec Map.process_encode to handle
+    BTreeMap<AccountId, u32> encoding when metadata lacks type information.
+    """
+    Map.process_encode = _patched_process_encode
+    try:
+        yield
+    finally:
+        Map.process_encode = _ORIGINAL_MAP_PROCESS_ENCODE

src/htcli/utils/blockchain/peer_id.py

@@ -0,0 +1,186 @@
+"""
+Peer ID encoding utilities for Hypertensor blockchain.
+
+Handles proper encoding of libp2p peer IDs which are base58-encoded multihashes.
+"""
+
+from typing import Union
+
+import base58
+
+
+def encode_peer_id(peer_id: Union[str, bytes]) -> bytes:
+    """
+    Encode a peer ID for blockchain submission.
+
+    Args:
+        peer_id: Peer ID as string (base58 multihash) or bytes
+
+    Returns:
+        Encoded peer ID as bytes for blockchain submission
+
+    Raises:
+        ValueError: If peer ID format is invalid
+    """
+    if isinstance(peer_id, bytes):
+        # Already bytes, validate it's base58 decodable
+        try:
+            # Try to decode and re-encode to validate
+            decoded = base58.b58decode(peer_id)
+            return peer_id
+        except Exception:
+            raise ValueError(f"Invalid peer ID bytes: {peer_id}")
+
+    if isinstance(peer_id, str):
+        # String peer ID - should be base58 multihash
+        if not peer_id:
+            raise ValueError("Peer ID cannot be empty")
+
+        # Validate it's a valid base58 string
+        try:
+            decoded = base58.b58decode(peer_id)
+            # Re-encode to get proper bytes representation
+            return peer_id.encode("utf-8")
+        except Exception as e:
+            raise ValueError(f"Invalid peer ID format '{peer_id}': {e}")
+
+    raise ValueError(f"Peer ID must be string or bytes, got {type(peer_id)}")
+
+
+def decode_peer_id(encoded_peer_id: bytes) -> str:
+    """
+    Decode a peer ID from blockchain response.
+
+    Args:
+        encoded_peer_id: Peer ID bytes from blockchain
+
+    Returns:
+        Peer ID as base58 string
+
+    Raises:
+        ValueError: If decoding fails
+    """
+    if not isinstance(encoded_peer_id, bytes):
+        raise ValueError(f"Encoded peer ID must be bytes, got {type(encoded_peer_id)}")
+
+    try:
+        # Try to decode as UTF-8 first (most common case)
+        peer_id_str = encoded_peer_id.decode("utf-8")
+
+        # Validate it's a valid base58 string
+        base58.b58decode(peer_id_str)
+        return peer_id_str
+
+    except UnicodeDecodeError:
+        # If not UTF-8, treat as raw bytes and encode to base58
+        return base58.b58encode(encoded_peer_id).decode("ascii")
+    except Exception as e:
+        raise ValueError(f"Failed to decode peer ID: {e}")
+
+
+def validate_peer_id_format(peer_id: str) -> bool:
+    """
+    Validate that a peer ID is in correct format.
+
+    Args:
+        peer_id: Peer ID string to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    if not isinstance(peer_id, str) or not peer_id:
+        return False
+
+    try:
+        # Check if it's a valid base58 string
+        decoded = base58.b58decode(peer_id)
+
+        # Basic validation - peer IDs are typically 34-46 characters
+        # and start with 'Qm' for SHA256 multihash
+        if len(peer_id) < 30 or len(peer_id) > 60:
+            return False
+
+        # Common peer ID prefixes for libp2p
+        valid_prefixes = ["Qm", "12D3", "16Uiu2HA"]
+        if not any(peer_id.startswith(prefix) for prefix in valid_prefixes):
+            return False
+
+        return True
+
+    except Exception:
+        return False
+
+
+def generate_test_peer_id(seed: int = 0) -> str:
+    """
+    Generate a test peer ID for testing purposes.
+
+    Args:
+        seed: Seed for deterministic generation
+
+    Returns:
+        Valid test peer ID string
+    """
+    import hashlib
+
+    # Generate deterministic test data
+    test_data = f"test_peer_id_{seed}".encode()
+    hash_bytes = hashlib.sha256(test_data).digest()
+
+    # Create a valid multihash (Qm prefix indicates SHA256)
+    # Format: [0x12, 0x20, <32-byte-hash>]
+    multihash = b"\x12\x20" + hash_bytes
+
+    # Encode as base58
+    peer_id = base58.b58encode(multihash).decode("ascii")
+
+    return peer_id
+
+
+# Common peer ID patterns for testing
+TEST_PEER_IDS = {
+    "alice": "QmAliceTest1234567890abcdefghijklmnopqrstuvwxyz",
+    "bob": "QmBobTest1234567890abcdefghijklmnopqrstuvwxyz",
+    "charlie": "QmCharlieTest1234567890abcdefghijklmnopqrstuvwxyz",
+    "bootnode": "QmBootnodeTest1234567890abcdefghijklmnopqrstuvwxyz",
+}
+
+
+def get_test_peer_id(name: str = "alice") -> str:
+    """
+    Get a predefined test peer ID.
+
+    Args:
+        name: Name of test peer (alice, bob, charlie, bootnode)
+
+    Returns:
+        Test peer ID string
+    """
+    return TEST_PEER_IDS.get(name, generate_test_peer_id(hash(name) % 1000))
+
+
+# Example usage and validation
+if __name__ == "__main__":
+    # Test the utilities
+    test_peer = "QmTestPeerID1234567890abcdefghijklmnopqrstuvwxyz"
+
+    print("Testing peer ID utilities...")
+
+    # Test encoding
+    encoded = encode_peer_id(test_peer)
+    print(f"Original: {test_peer}")
+    print(f"Encoded: {encoded}")
+
+    # Test decoding
+    decoded = decode_peer_id(encoded)
+    print(f"Decoded: {decoded}")
+
+    # Test validation
+    is_valid = validate_peer_id_format(test_peer)
+    print(f"Valid: {is_valid}")
+
+    # Test generation
+    generated = generate_test_peer_id(42)
+    print(f"Generated: {generated}")
+
+    print("✅ All tests passed!")