hippius 0.1.14__py3-none-any.whl → 0.2.1__py3-none-any.whl

hippius_sdk/substrate.py

@@ -1,24 +1,25 @@
-"""
-Substrate operations for the Hippius SDK.
-
-Note: This functionality is coming soon and not implemented yet.
-"""
-
+import datetime
 import json
 import os
+import tempfile
+import time
 import uuid
 from typing import Any, Dict, List, Optional, Union
 
 from dotenv import load_dotenv
+from mnemonic import Mnemonic
 from substrateinterface import Keypair, SubstrateInterface
 
 from hippius_sdk.config import (
     get_account_address,
     get_active_account,
+    get_all_config,
     get_config_value,
     get_seed_phrase,
+    set_active_account,
     set_seed_phrase,
 )
+from hippius_sdk.utils import hex_to_ipfs_cid
 
 # Load environment variables
 load_dotenv()
@@ -179,6 +180,300 @@ class SubstrateClient:
             print(f"Warning: Could not get seed phrase from config: {e}")
             return False
 
+    def generate_mnemonic(self) -> str:
+        """
+        Generate a new random 12-word mnemonic phrase.
+
+        Returns:
+            str: A 12-word mnemonic seed phrase
+        """
+        try:
+            mnemo = Mnemonic("english")
+            return mnemo.generate(strength=128)  # 128 bits = 12 words
+        except Exception as e:
+            raise ValueError(f"Error generating mnemonic: {e}")
+
+    def create_account(
+        self, name: str, encode: bool = False, password: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a new account with a generated seed phrase.
+
+        Args:
+            name: Name for the new account
+            encode: Whether to encrypt the seed phrase with a password
+            password: Optional password for encryption (will prompt if not provided and encode=True)
+
+        Returns:
+            Dict[str, Any]: Dictionary with new account details
+        """
+        # Check if account name already exists
+        config = get_all_config()
+        if name in config["substrate"].get("accounts", {}):
+            raise ValueError(f"Account with name '{name}' already exists")
+
+        # Generate a new mnemonic seed phrase
+        mnemonic = self.generate_mnemonic()
+
+        # Create a keypair from the mnemonic
+        keypair = Keypair.create_from_mnemonic(mnemonic)
+        ss58_address = keypair.ss58_address
+
+        # Save the seed phrase to configuration
+        if encode:
+            result = set_seed_phrase(
+                mnemonic, encode=True, password=password, account_name=name
+            )
+        else:
+            result = set_seed_phrase(mnemonic, encode=False, account_name=name)
+
+        if not result:
+            raise RuntimeError("Failed to save account to configuration")
+
+        # Set this as the active account
+        set_active_account(name)
+
+        # Update the client's state to use this account
+        self._account_name = name
+        self._account_address = ss58_address
+        self._seed_phrase = mnemonic
+        self._keypair = keypair
+        self._read_only = False
+
+        # Return the new account details
+        return {
+            "name": name,
+            "address": ss58_address,
+            "mnemonic": mnemonic,
+            "is_active": True,
+            "creation_date": datetime.datetime.now().isoformat(),
+        }
+
+    def export_account(
+        self, account_name: Optional[str] = None, file_path: Optional[str] = None
+    ) -> str:
+        """
+        Export an account to a JSON file.
+
+        Args:
+            account_name: Name of the account to export (uses active account if None)
+            file_path: Path to save the exported account file (auto-generated if None)
+
+        Returns:
+            str: Path to the exported account file
+        """
+        # Determine which account to export
+        name_to_use = account_name or self._account_name or get_active_account()
+        if not name_to_use:
+            raise ValueError("No account specified and no active account")
+
+        # Get the seed phrase and address
+        seed_phrase = get_seed_phrase(account_name=name_to_use)
+        if not seed_phrase:
+            raise ValueError(
+                f"Could not retrieve seed phrase for account '{name_to_use}'"
+            )
+
+        address = get_account_address(name_to_use)
+        if not address:
+            # Generate the address from the seed phrase
+            keypair = Keypair.create_from_mnemonic(seed_phrase)
+            address = keypair.ss58_address
+
+        # Create the export data structure
+        export_data = {
+            "name": name_to_use,
+            "address": address,
+            "mnemonic": seed_phrase,
+            "meta": {
+                "exported_at": datetime.datetime.now().isoformat(),
+                "description": "Hippius SDK exported account",
+            },
+        }
+
+        # Determine the file path if not provided
+        if not file_path:
+            file_path = f"{name_to_use}_account_export_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+
+        # Write the export file
+        try:
+            with open(file_path, "w") as f:
+                json.dump(export_data, f, indent=2)
+            print(f"Account '{name_to_use}' exported to {file_path}")
+            return file_path
+        except Exception as e:
+            raise ValueError(f"Failed to export account: {e}")
+
+    def import_account(
+        self, file_path: str, password: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Import an account from a JSON file.
+
+        Args:
+            file_path: Path to the account export file
+            password: Optional password to use for encrypting the imported seed phrase
+
+        Returns:
+            Dict[str, Any]: Dictionary with imported account details
+        """
+        try:
+            # Read the export file
+            with open(file_path, "r") as f:
+                import_data = json.load(f)
+
+            # Validate the import data structure
+            required_fields = ["name", "address", "mnemonic"]
+            for field in required_fields:
+                if field not in import_data:
+                    raise ValueError(
+                        f"Invalid account file format: missing '{field}' field"
+                    )
+
+            # Extract account details
+            name = import_data["name"]
+            address = import_data["address"]
+            mnemonic = import_data["mnemonic"]
+
+            # Check if the account name already exists
+            config = get_all_config()
+            if name in config["substrate"].get("accounts", {}):
+                # Modify the name to avoid conflicts
+                original_name = name
+                name = f"{name}_imported_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                print(
+                    f"Account name '{original_name}' already exists, using '{name}' instead"
+                )
+
+            # Save the account to configuration
+            if password:
+                # Encrypt the seed phrase with the provided password
+                result = set_seed_phrase(
+                    mnemonic, encode=True, password=password, account_name=name
+                )
+            else:
+                # Store the seed phrase in plain text
+                result = set_seed_phrase(mnemonic, encode=False, account_name=name)
+
+            if not result:
+                raise RuntimeError("Failed to save imported account to configuration")
+
+            # Set this as the active account
+            set_active_account(name)
+
+            # Update the client's state to use this account
+            self._account_name = name
+            self._account_address = address
+            self._seed_phrase = mnemonic
+            self._keypair = Keypair.create_from_mnemonic(mnemonic)
+            self._read_only = False
+
+            # Return the imported account details
+            return {
+                "name": name,
+                "address": address,
+                "is_active": True,
+                "imported_at": datetime.datetime.now().isoformat(),
+                "original_name": import_data.get("name"),
+            }
+        except Exception as e:
+            raise ValueError(f"Failed to import account: {e}")
+
+    async def get_account_info(
+        self, account_name: Optional[str] = None, include_history: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get detailed information about an account.
+
+        Args:
+            account_name: Name of the account to get info for (uses active account if None)
+            include_history: Whether to include usage history in the results
+
+        Returns:
+            Dict[str, Any]: Detailed account information
+        """
+        # Determine which account to get info for
+        name_to_use = account_name or self._account_name or get_active_account()
+        if not name_to_use:
+            raise ValueError("No account specified and no active account")
+
+        # Get the configuration to extract account data
+        config = get_all_config()
+
+        # Check if the account exists
+        if name_to_use not in config["substrate"].get("accounts", {}):
+            raise ValueError(f"Account '{name_to_use}' not found")
+
+        # Get account data from config
+        account_data = config["substrate"]["accounts"][name_to_use]
+        is_active = name_to_use == config["substrate"].get("active_account")
+        is_encoded = account_data.get("seed_phrase_encoded", False)
+        address = account_data.get("ss58_address")
+
+        # Create the account info object
+        account_info = {
+            "name": name_to_use,
+            "address": address,
+            "is_active": is_active,
+            "seed_phrase_encrypted": is_encoded,
+        }
+
+        # Query storage statistics for this account
+        try:
+            # Get files stored by this account - use await since this is an async method
+            files = await self.get_user_files_from_profile(address)
+
+            # Calculate storage statistics
+            total_files = len(files)
+            total_size_bytes = sum(file.get("file_size", 0) for file in files)
+
+            # Add storage stats to account info
+            account_info["storage_stats"] = {
+                "files": total_files,
+                "bytes_used": total_size_bytes,
+                "size_formatted": self._format_size(total_size_bytes)
+                if total_size_bytes
+                else "0 B",
+            }
+
+            # Include file list if requested
+            if include_history:
+                account_info["files"] = files
+
+                # Try to get account balance
+                try:
+                    account_info["balance"] = await self.get_account_balance(address)
+                except Exception as e:
+                    # Ignore balance errors, it's optional information
+                    print(f"Could not fetch balance: {e}")
+                    pass
+
+                # Try to get free credits
+                try:
+                    account_info["free_credits"] = await self.get_free_credits(address)
+                except Exception as e:
+                    # Ignore credits errors, it's optional information
+                    print(f"Could not fetch free credits: {e}")
+                    pass
+        except Exception as e:
+            # Add a note about the error but don't fail the whole operation
+            account_info["storage_stats"] = {
+                "error": f"Could not fetch storage statistics: {str(e)}"
+            }
+
+        return account_info
+
+    def _format_size(self, size_bytes: int) -> str:
+        """Format file size in human-readable format"""
+        if size_bytes < 1024:
+            return f"{size_bytes} B"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes / 1024:.2f} KB"
+        elif size_bytes < 1024 * 1024 * 1024:
+            return f"{size_bytes / (1024 * 1024):.2f} MB"
+        else:
+            return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
+
     def set_seed_phrase(self, seed_phrase: str) -> None:
         """
         Set or update the seed phrase used for signing transactions.
@@ -202,7 +497,7 @@ class SubstrateClient:
             print(f"Warning: Could not create keypair from seed phrase: {e}")
             print(f"Keypair will be created when needed")
 
-    def storage_request(
+    async def storage_request(
         self, files: List[Union[FileInput, Dict[str, str]]], miner_ids: List[str] = None
     ) -> str:
         """
@@ -276,8 +571,7 @@ class SubstrateClient:
             print(f"Created file list with {len(file_list)} entries")
 
             # Step 2: Upload the JSON file to IPFS
-            import tempfile
-
+            # Defer import to avoid circular imports
             from hippius_sdk.ipfs import IPFSClient
 
             ipfs_client = IPFSClient()
@@ -291,7 +585,7 @@ class SubstrateClient:
 
             try:
                 print("Uploading file list to IPFS...")
-                upload_result = ipfs_client.upload_file(temp_file_path)
+                upload_result = await ipfs_client.upload_file(temp_file_path)
                 files_list_cid = upload_result["cid"]
                 print(f"File list uploaded to IPFS with CID: {files_list_cid}")
             finally:
@@ -313,19 +607,42 @@ class SubstrateClient:
 
             # Create the call to the marketplace
             print(f"Call parameters: {json.dumps(call_params, indent=2)}")
-            call = self._substrate.compose_call(
-                call_module="Marketplace",
-                call_function="storage_request",
-                call_params=call_params,
-            )
+            try:
+                call = self._substrate.compose_call(
+                    call_module="Marketplace",
+                    call_function="storage_request",
+                    call_params=call_params,
+                )
+            except Exception as e:
+                print(f"Warning: Error composing call: {e}")
+                print("Attempting to use IpfsPallet.storeFile instead...")
+
+                # Try with IpfsPallet.storeFile as an alternative
+                alt_call_params = {
+                    "fileHash": files_list_cid,
+                    "fileName": f"files_list_{uuid.uuid4()}",  # Generate a unique ID
+                }
+                call = self._substrate.compose_call(
+                    call_module="IpfsPallet",
+                    call_function="storeFile",
+                    call_params=alt_call_params,
+                )
 
             # Get payment info to estimate the fee
             payment_info = self._substrate.get_payment_info(
                 call=call, keypair=self._keypair
             )
 
+            print(f"Payment info: {json.dumps(payment_info, indent=2)}")
+
+            # Convert partialFee from Substrate (10^18 units) to a more readable format
             estimated_fee = payment_info.get("partialFee", 0)
-            print(f"Estimated transaction fee: {estimated_fee}")
+            estimated_fee_formatted = (
+                float(estimated_fee) / 1_000_000_000_000_000_000 if estimated_fee else 0
+            )
+            print(
+                f"Estimated transaction fee: {estimated_fee} ({estimated_fee_formatted:.10f} tokens)"
+            )
 
             # Create a signed extrinsic
             extrinsic = self._substrate.create_signed_extrinsic(
@@ -361,7 +678,7 @@ class SubstrateClient:
 
         return "simulated-tx-hash"
 
-    def store_cid(
+    async def store_cid(
         self, cid: str, filename: str = None, metadata: Optional[Dict[str, Any]] = None
     ) -> str:
         """
@@ -376,7 +693,7 @@ class SubstrateClient:
             str: Transaction hash
         """
         file_input = FileInput(file_hash=cid, file_name=filename or "unnamed_file")
-        return self.storage_request([file_input])
+        return await self.storage_request([file_input])
 
     def get_cid_metadata(self, cid: str) -> Dict[str, Any]:
         """
@@ -430,7 +747,7 @@ class SubstrateClient:
         """
         raise NotImplementedError("Substrate functionality is not implemented yet.")
 
-    def get_account_balance(
+    async def get_account_balance(
         self, account_address: Optional[str] = None
     ) -> Dict[str, float]:
         """
@@ -442,9 +759,174 @@ class SubstrateClient:
         Returns:
             Dict[str, float]: Account balances (free, reserved, total)
         """
-        raise NotImplementedError("Substrate functionality is not implemented yet.")
+        try:
+            # Initialize Substrate connection if not already connected
+            if not hasattr(self, "_substrate") or self._substrate is None:
+                print("Initializing Substrate connection...")
+                self._substrate = SubstrateInterface(
+                    url=self.url,
+                    ss58_format=42,  # Substrate default
+                    type_registry_preset="substrate-node-template",
+                )
+                print(f"Connected to Substrate node at {self.url}")
+
+            # Use provided account address or default to keypair/configured address
+            if not account_address:
+                if self._account_address:
+                    account_address = self._account_address
+                    print(f"Using account address: {account_address}")
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+                    print(f"Using keypair address: {account_address}")
+
+            # Query the blockchain for account balance
+            print(f"Querying balance for account: {account_address}")
+            result = self._substrate.query(
+                module="System",
+                storage_function="Account",
+                params=[account_address],
+            )
+
+            # If account exists, extract the balance information
+            if result.value:
+                data = result.value
+                print(data)
+                # Extract balance components
+                free_balance = data.get("data", {}).get("free", 0)
+                reserved_balance = data.get("data", {}).get("reserved", 0)
+                frozen_balance = data.get("data", {}).get("frozen", 0)
+
+                # Convert from blockchain units to float (divide by 10^18)
+                divisor = 1_000_000_000_000_000_000  # 18 zeros for decimals
+
+                free = float(free_balance) / divisor
+                reserved = float(reserved_balance) / divisor
+                frozen = float(frozen_balance) / divisor
+
+                # Calculate total (free + reserved - frozen)
+                total = free + reserved - frozen
+
+                return {
+                    "free": free,
+                    "reserved": reserved,
+                    "frozen": frozen,
+                    "total": total,
+                    "raw": {
+                        "free": free_balance,
+                        "reserved": reserved_balance,
+                        "frozen": frozen_balance,
+                    },
+                }
+            else:
+                print(f"No account data found for: {account_address}")
+                return {
+                    "free": 0.0,
+                    "reserved": 0.0,
+                    "frozen": 0.0,
+                    "total": 0.0,
+                    "raw": {"free": 0, "reserved": 0, "frozen": 0},
+                }
 
-    def get_free_credits(self, account_address: Optional[str] = None) -> float:
+        except Exception as e:
+            error_msg = f"Error querying account balance: {str(e)}"
+            print(error_msg)
+            raise ValueError(error_msg)
+
+    async def watch_account_balance(
+        self, account_address: Optional[str] = None, interval: int = 5
+    ) -> None:
+        """
+        Watch account balance in real-time, updating at specified intervals.
+
+        The function runs until interrupted with Ctrl+C.
+
+        Args:
+            account_address: Substrate account address (uses keypair address if not specified)
+            interval: Polling interval in seconds (default: 5)
+        """
+        try:
+            # Use provided account address or default to keypair/configured address
+            if not account_address:
+                if self._account_address:
+                    account_address = self._account_address
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+
+            print(f"Watching balance for account: {account_address}")
+            print(f"Updates every {interval} seconds. Press Ctrl+C to stop.")
+            print("-" * 80)
+
+            # Keep track of previous balance to show changes
+            previous_balance = None
+
+            try:
+                while True:
+                    # Get current time for display
+                    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+                    # Get current balance
+                    try:
+                        balance = await self.get_account_balance(account_address)
+
+                        # Clear screen (ANSI escape sequence)
+                        print("\033c", end="")
+
+                        # Display header
+                        print(f"Account Balance Watch for: {account_address}")
+                        print(f"Last update: {current_time}")
+                        print("-" * 80)
+
+                        # Display current balance
+                        print(f"Free:     {balance['free']:.6f}")
+                        print(f"Reserved: {balance['reserved']:.6f}")
+                        print(f"Frozen:   {balance['frozen']:.6f}")
+                        print(f"Total:    {balance['total']:.6f}")
+
+                        # Show changes since last update if available
+                        if previous_balance:
+                            print("\nChanges since last update:")
+                            free_change = balance["free"] - previous_balance["free"]
+                            reserved_change = (
+                                balance["reserved"] - previous_balance["reserved"]
+                            )
+                            total_change = balance["total"] - previous_balance["total"]
+
+                            # Format changes with + or - sign
+                            print(f"Free:     {free_change:+.6f}")
+                            print(f"Reserved: {reserved_change:+.6f}")
+                            print(f"Total:    {total_change:+.6f}")
+
+                        # Store current balance for next comparison
+                        previous_balance = balance
+
+                        # Show instructions at the bottom
+                        print(
+                            "\nUpdating every",
+                            interval,
+                            "seconds. Press Ctrl+C to stop.",
+                        )
+
+                    except Exception as e:
+                        # Show error but continue watching
+                        print(f"Error: {e}")
+                        print(f"Will try again in {interval} seconds...")
+
+                    # Wait for next update
+                    time.sleep(interval)
+
+            except KeyboardInterrupt:
+                print("\nBalance watch stopped.")
+
+        except Exception as e:
+            print(f"Error in watch_account_balance: {e}")
+
+    async def get_free_credits(self, account_address: Optional[str] = None) -> float:
         """
         Get the free credits available for an account in the marketplace.
 
@@ -569,7 +1051,7 @@ class SubstrateClient:
             print(error_msg)
             raise ValueError(error_msg)
 
-    def get_user_files(
+    async def get_user_files(
         self,
         account_address: Optional[str] = None,
         truncate_miners: bool = True,
@@ -604,9 +1086,9 @@ class SubstrateClient:
         """
         # For backward compatibility, this method now calls get_user_files_from_profile
         # with appropriate conversions
-        return self.get_user_files_from_profile(account_address)
+        return await self.get_user_files_from_profile(account_address)
 
-    def get_user_files_from_profile(
+    async def get_user_files_from_profile(
         self,
         account_address: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
@@ -680,12 +1162,13 @@ class SubstrateClient:
             print(f"Decoded IPFS CID: {profile_cid}")
 
             # Fetch the profile JSON from IPFS
+            # Defer import to avoid circular imports
             from hippius_sdk.ipfs import IPFSClient
 
             ipfs_client = IPFSClient()
 
             print(f"Fetching user profile from IPFS: {profile_cid}")
-            profile_data = ipfs_client.cat(profile_cid)
+            profile_data = await ipfs_client.cat(profile_cid)
 
             # Parse the JSON content
             if not profile_data.get("is_text", False):
@@ -797,56 +1280,205 @@ class SubstrateClient:
             print(error_msg)
             raise ValueError(error_msg)
 
-    def _hex_to_ipfs_cid(self, hex_string: str) -> str:
+    def get_pinning_status(
+        self, account_address: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
         """
-        Convert a hex-encoded IPFS CID to a regular IPFS CID.
+        Get the status of file pinning requests for an account.
+
+        This method queries the blockchain for all storage requests made by the user
+        to check their pinning status.
 
         Args:
-            hex_string: Hex string representation of an IPFS CID
+            account_address: Substrate account address (uses keypair address if not specified)
+                             Format: 5HoreGVb17XhY3wanDvzoAWS7yHYbc5uMteXqRNTiZ6Txkqq
 
         Returns:
-            str: Regular IPFS CID
+            List[Dict[str, Any]]: List of storage requests with their status information:
+                {
+                    "cid": str,              # The IPFS CID of the file
+                    "file_name": str,        # The name of the file
+                    "total_replicas": int,   # Total number of replicas requested
+                    "owner": str,            # Owner's address
+                    "created_at": int,       # Block number when request was created
+                    "last_charged_at": int,  # Block number when last charged
+                    "miner_ids": List[str],  # List of miners assigned to pin the file
+                    "selected_validator": str, # Selected validator address
+                    "is_assigned": bool,     # Whether request has been assigned to miners
+                }
+
+        Raises:
+            ConnectionError: If connection to Substrate fails
+            ValueError: If query fails or no requests found
         """
-        # First, try to decode as ASCII if it's a hex representation of ASCII characters
         try:
-            if hex_string.startswith("0x"):
-                hex_string = hex_string[2:]
+            # Initialize Substrate connection if not already connected
+            if not hasattr(self, "_substrate") or self._substrate is None:
+                print("Initializing Substrate connection...")
+                self._substrate = SubstrateInterface(
+                    url=self.url,
+                    ss58_format=42,  # Substrate default
+                    type_registry_preset="substrate-node-template",
+                )
+                print(f"Connected to Substrate node at {self.url}")
+
+            # Use provided account address or default to keypair/configured address
+            if not account_address:
+                if self._account_address:
+                    account_address = self._account_address
+                    print(f"Using account address: {account_address}")
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+                    print(f"Using keypair address: {account_address}")
+
+            # Query the blockchain for storage requests
+            print(f"Querying storage requests for account: {account_address}")
+            try:
+                # First, try with query_map which is more suitable for iterating over collections
+                result = self._substrate.query_map(
+                    module="IpfsPallet",
+                    storage_function="UserStorageRequests",
+                    params=[account_address],
+                )
+                results_list = list(result)
+            except Exception as e:
+                print(f"Error with query_map: {e}")
+                try:
+                    # Try again with query to double check storage function requirements
+                    result = self._substrate.query(
+                        module="IpfsPallet",
+                        storage_function="UserStorageRequests",
+                        params=[
+                            account_address,
+                            None,
+                        ],  # Try with a None second parameter
+                    )
 
-            bytes_data = bytes.fromhex(hex_string)
-            ascii_str = bytes_data.decode("ascii")
+                    # If the query returns a nested structure, extract it
+                    if result.value and isinstance(result.value, list):
+                        # Convert to a list format similar to query_map for processing
+                        results_list = []
+                        for item in result.value:
+                            if isinstance(item, list) and len(item) >= 2:
+                                key = item[0]
+                                value = item[1]
+                                results_list.append((key, value))
+                    else:
+                        # If it's not a nested structure, use a simpler format
+                        results_list = [(None, result.value)] if result.value else []
+                except Exception as e_inner:
+                    print(f"Error with fallback query: {e_inner}")
+                    # If both methods fail, return an empty list
+                    results_list = []
+
+            # Process the storage requests
+            storage_requests = []
+
+            if not results_list:
+                print(f"No storage requests found for account: {account_address}")
+                return []
 
-            # If the decoded string starts with a valid CID prefix, return it
-            if ascii_str.startswith(("Qm", "bafy", "bafk", "bafyb", "bafzb", "b")):
-                return ascii_str
-        except Exception:
-            # If ASCII decoding fails, continue with other methods
-            pass
+            print(f"Found {len(results_list)} storage request entries")
+
+            for i, (key, value) in enumerate(results_list):
+                try:
+                    # For debugging, print raw data
+                    print(f"Entry {i+1}:")
+                    print(f"  Raw key: {key}, type: {type(key)}")
+                    print(f"  Raw value: {value}, type: {type(value)}")
+
+                    # Extract file hash from key if possible
+                    file_hash_hex = None
+                    if key is not None:
+                        if hasattr(key, "hex"):
+                            file_hash_hex = key.hex()
+                        elif isinstance(key, bytes):
+                            file_hash_hex = key.hex()
+                        elif isinstance(key, str) and key.startswith("0x"):
+                            file_hash_hex = key[2:]
+                        else:
+                            file_hash_hex = str(key)
+
+                    # Try to extract value data
+                    request_data = None
+                    if isinstance(value, dict):
+                        request_data = value
+                    elif hasattr(value, "get"):
+                        request_data = value
+                    elif hasattr(value, "__dict__"):
+                        # Convert object to dict
+                        request_data = {
+                            k: getattr(value, k)
+                            for k in dir(value)
+                            if not k.startswith("_") and not callable(getattr(value, k))
+                        }
+
+                    # If we can't extract data, just use value as string for debugging
+                    if request_data is None:
+                        request_data = {"raw_value": str(value)}
+
+                    # Create formatted request with available data
+                    formatted_request = {"raw_key": str(key), "raw_value": str(value)}
+
+                    # Directly extract file_name from the value if it's a dict-like object
+                    if hasattr(value, "get"):
+                        if value.get("file_name"):
+                            formatted_request["file_name"] = value.get("file_name")
+                        elif value.get("fileName"):
+                            formatted_request["file_name"] = value.get("fileName")
+
+                    # Add CID if we have it
+                    if file_hash_hex:
+                        file_cid = self._hex_to_ipfs_cid(file_hash_hex)
+                        formatted_request["cid"] = file_cid
+
+                    # Add other fields from request_data if available
+                    for source_field, target_field in [
+                        ("fileName", "file_name"),
+                        ("totalReplicas", "total_replicas"),
+                        ("owner", "owner"),
+                        ("createdAt", "created_at"),
+                        ("lastChargedAt", "last_charged_at"),
+                        ("minerIds", "miner_ids"),
+                        ("selectedValidator", "selected_validator"),
+                        ("isAssigned", "is_assigned"),
+                        # Add variants that might appear differently in the chain storage
+                        ("file_name", "file_name"),
+                        ("file_hash", "file_hash"),
+                        ("total_replicas", "total_replicas"),
+                    ]:
+                        if source_field in request_data:
+                            formatted_request[target_field] = request_data[source_field]
+                        # Fallback to attribute access for different types of objects
+                        elif hasattr(value, source_field):
+                            formatted_request[target_field] = getattr(
+                                value, source_field
+                            )
+
+                    storage_requests.append(formatted_request)
+
+                except Exception as e:
+                    print(f"Error processing request entry {i+1}: {e}")
+
+            print(f"Successfully processed {len(storage_requests)} storage requests")
+            return storage_requests
 
-        # Try to decode as a binary CID
-        try:
-            import base58
-
-            if hex_string.startswith("0x"):
-                hex_string = hex_string[2:]
-
-            binary_data = bytes.fromhex(hex_string)
-
-            # Check if it matches CIDv0 pattern (starts with 0x12, 0x20)
-            if (
-                len(binary_data) > 2
-                and binary_data[0] == 0x12
-                and binary_data[1] == 0x20
-            ):
-                # CIDv0 (Qm...)
-                return base58.b58encode(binary_data).decode("utf-8")
-
-            # If it doesn't match CIDv0, for CIDv1 just return the hex without 0x prefix
-            # since adding 0x breaks IPFS gateway URLs
-            return hex_string
-        except ImportError:
-            # If base58 is not available
-            print("Warning: base58 module not available for proper CID conversion")
-            return hex_string
         except Exception as e:
-            print(f"Error converting hex to CID: {e}")
-            return hex_string
+            error_msg = f"Error querying storage requests: {str(e)}"
+            print(error_msg)
+            raise ValueError(error_msg)
+
+    def _hex_to_ipfs_cid(self, hex_string: str) -> str:
+        """
+        Convert a hex-encoded IPFS CID to a regular IPFS CID.
+
+        Args:
+            hex_string: Hex string representation of an IPFS CID
+
+        Returns:
+            str: Regular IPFS CID
+        """
+        return hex_to_ipfs_cid(hex_string)