hippius 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

hippius_sdk/cli.py

@@ -16,6 +16,8 @@ from typing import Optional, List
 import getpass
 import concurrent.futures
 import threading
+import random
+import uuid
 
 # Import SDK components
 from hippius_sdk import HippiusClient
@@ -431,9 +433,12 @@ def handle_credits(client, account_address):
     return 0
 
 
-def handle_files(client, account_address, debug=False, show_all_miners=False):
-    """Handle the files command"""
-    print("Retrieving file information...")
+def handle_files(client, account_address, show_all_miners=False):
+    """
+    Display files stored by a user in a nice format.
+
+    This command only reads data and doesn't require seed phrase decryption.
+    """
     try:
         # Get the account address we're querying
         if account_address is None:
@@ -457,105 +462,89 @@ def handle_files(client, account_address, debug=False, show_all_miners=False):
                     )
                     return 1
 
-        if debug:
-            print("DEBUG MODE: Will show details about CID decoding")
+        # Get files for the account using the new profile-based method
+        print(f"Retrieving files for account: {account_address}")
+        files = client.substrate_client.get_user_files_from_profile(account_address)
 
-        # Use the enhanced get_user_files method with our preferences
-        max_miners = 0 if show_all_miners else 3  # 0 means show all miners
-        files = client.substrate_client.get_user_files(
-            account_address,
-            truncate_miners=True,  # Always truncate long miner IDs
-            max_miners=max_miners,  # Use 0 for all or 3 for limited
-        )
+        # Check if any files were found
+        if not files:
+            print(f"No files found for account: {account_address}")
+            return 0
 
-        if files:
-            print(f"\nFound {len(files)} files for account: {account_address}")
-            print("\n" + "-" * 80)
+        print(f"\nFound {len(files)} files for account: {account_address}")
+        print("-" * 80)
 
-            for i, file in enumerate(files, 1):
+        for i, file in enumerate(files, 1):
+            try:
                 print(f"File {i}:")
 
-                # Format the CID using the SDK method
+                # Display file hash/CID
                 file_hash = file.get("file_hash", "Unknown")
-                formatted_cid = client.format_cid(file_hash)
-                print(f"  File Hash (CID): {formatted_cid}")
+                if file_hash is not None:
+                    formatted_cid = client.format_cid(file_hash)
+                    print(f"  CID: {formatted_cid}")
+                else:
+                    print(f"  CID: Unknown (None)")
 
                 # Display file name
-                print(f"  File Name: {file.get('file_name', 'Unnamed')}")
+                file_name = file.get("file_name", "Unnamed")
+                print(
+                    f"  File name: {file_name if file_name is not None else 'Unnamed'}"
+                )
 
-                # Display file size with SDK formatting method if needed
-                file_size = file.get("file_size", 0)
-                size_formatted = file.get("size_formatted")
-                if not size_formatted and file_size > 0:
-                    size_formatted = client.format_size(file_size)
-                print(f"  File Size: {file_size:,} bytes ({size_formatted})")
+                # Display file size
+                if "size_formatted" in file and file["size_formatted"] is not None:
+                    size_formatted = file["size_formatted"]
+                    file_size = file.get("file_size", 0)
+                    if file_size is not None:
+                        print(f"  File size: {file_size:,} bytes ({size_formatted})")
+                    else:
+                        print(f"  File size: Unknown")
+                else:
+                    print(f"  File size: Unknown")
 
-                # Display miners
+                # Display miners (if available)
+                miner_ids = file.get("miner_ids", [])
                 miner_count = file.get("miner_count", 0)
-                miners = file.get("miner_ids", [])
 
-                if miner_count > 0:
-                    print(f"  Pinned by {miner_count} miners:")
-
-                    # Show message about truncated list if applicable
-                    if miner_count > len(miners) and not show_all_miners:
-                        print(
-                            f"    (Showing {len(miners)} of {miner_count} miners - use --all-miners to see all)"
+                if miner_ids and show_all_miners:
+                    print(f"  Stored by {len(miner_ids)} miners:")
+                    for miner in miner_ids:
+                        miner_id = (
+                            miner.get("id", miner) if isinstance(miner, dict) else miner
                         )
-                    elif miner_count > 3 and show_all_miners:
-                        print(f"    (Showing all {miner_count} miners)")
-
-                    # Display the miners using their formatted IDs
-                    for miner in miners:
-                        if isinstance(miner, dict) and "formatted" in miner:
-                            print(f"    - {miner['formatted']}")
-                        else:
-                            print(f"    - {miner}")
+                        formatted = (
+                            miner.get("formatted", miner_id)
+                            if isinstance(miner, dict)
+                            else miner_id
+                        )
+                        print(f"    - {formatted}")
+                elif miner_count:
+                    print(f"  Stored by {miner_count} miners")
                 else:
-                    print("  Not pinned by any miners")
+                    print(f"  Storage information not available")
 
                 print("-" * 80)
-        else:
-            print(
-                f"No files found for account: {account_address or client.substrate_client._keypair.ss58_address}"
-            )
+            except Exception as e:
+                print(f"  Error displaying file {i}: {e}")
+                print("-" * 80)
+                continue
+
+        # Add tip for downloading
+        if files:
+            print("\nTo download a file, use:")
+            print(f"  hippius download <CID> <output_filename>")
+
     except Exception as e:
-        print(f"Error retrieving file information: {e}")
+        print(f"Error retrieving files: {e}")
         return 1
 
     return 0
 
 
 def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=False):
-    """
-    Display erasure-coded files stored by a user.
-
-    This command only reads data and doesn't require seed phrase decryption.
-    """
-    # For progress reporting
-    processed_files = 0
-    total_files = 0
-    lock = threading.Lock()
-
-    # Store results from worker threads
-    results = {
-        "ec_files": [],
-        "binary_files": 0,
-        "json_decode_errors": 0,
-        "not_ec_files": 0,
-        "skipped_files": 0,
-    }
-
-    # For quick identification of potential EC files - common naming patterns
-    EC_FILENAME_PATTERNS = ["metadata", "ec-", "erasure"]
-
-    # Debug print function that can be enabled/disabled
-    verbose = get_config_value("cli", "verbose", False)
-
-    def debug_print(msg):
-        if verbose:
-            print(msg)
-
+    """Handle the ec-files command to show only erasure-coded files"""
+    print("Looking for erasure-coded files...")
     try:
         # Get the account address we're querying
         if account_address is None:
@@ -579,251 +568,174 @@ def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=
                     )
                     return 1
 
-        # Get all files for the account
-        print(f"Fetching files for account: {account_address}")
-        files = client.substrate_client.get_user_files(
-            account_address=account_address,
-            truncate_miners=not show_all_miners,
-            max_miners=0 if show_all_miners else 3,
-        )
+        # First, get all user files using the profile method
+        files = client.substrate_client.get_user_files_from_profile(account_address)
 
-        if not files:
-            print(f"No files found for account: {account_address}")
-            return
-
-        total_files = len(files)
-        print(f"Found {total_files} files, analyzing for erasure-coded metadata...")
-
-        # First, do a quick initial filter to identify potential EC files based on name patterns
-        potential_ec_files = []
+        # Filter for metadata files (ending with .ec_metadata)
+        ec_metadata_files = []
         for file in files:
-            cid = file.get("file_hash")
-            if not cid:
-                results["skipped_files"] += 1
-                continue
+            file_name = file.get("file_name", "")
+            if (
+                file_name
+                and isinstance(file_name, str)
+                and file_name.endswith(".ec_metadata")
+            ):
+                ec_metadata_files.append(file)
 
-            # Check if filename contains any of our EC patterns
-            name = file.get("file_name", "").lower()
-            if any(pattern in name for pattern in EC_FILENAME_PATTERNS):
-                # Higher chance this is an EC file
-                debug_print(f"  - Potential EC file based on name: {name}")
-                potential_ec_files.append((0, file))  # Priority 0 = high
-            else:
-                # Still check it, but with lower priority
-                potential_ec_files.append((1, file))  # Priority 1 = lower
-
-        # Sort by priority (check likely EC files first)
-        potential_ec_files.sort(key=lambda x: x[0])
-        priority_files = [f for _, f in potential_ec_files]
-
-        # Progress update function
-        def update_progress():
-            nonlocal processed_files
-            processed_files += 1
-            if processed_files % 5 == 0 or processed_files == total_files:
-                print(
-                    f"  Progress: {processed_files}/{total_files} files analyzed ({(processed_files/total_files)*100:.1f}%)",
-                    end="\r",
-                )
+        if not ec_metadata_files:
+            print(f"No erasure-coded files found for account {account_address}")
+            return 0
 
-        # Function to process a single file - for parallel execution
-        def process_file(file):
-            try:
-                cid = file.get("file_hash")
-                name = file.get("file_name", "")
+        print(f"\nFound {len(ec_metadata_files)} erasure-coded files:")
+        print("-" * 80)
 
-                debug_print(f"  - Processing: {cid} ({name})")
+        for i, file in enumerate(ec_metadata_files, 1):
+            try:
+                print(f"EC File {i}:")
 
-                # Try to fetch metadata to see if it's an erasure-coded file
-                metadata = client.ipfs_client.cat(cid)
-                if not metadata or not metadata.get("content"):
-                    with lock:
-                        results["skipped_files"] += 1
-                        update_progress()
-                    return None
+                # Get the metadata CID
+                metadata_cid = file.get("file_hash", "Unknown")
+                if metadata_cid is not None and metadata_cid != "Unknown":
+                    formatted_cid = client.format_cid(metadata_cid)
+                    print(f"  Metadata CID: {formatted_cid}")
 
-                content = metadata.get("content")
-                if isinstance(content, bytes):
+                    # Fetch and parse the metadata to get original file info
                     try:
-                        # Try to decode the content as UTF-8 text - might fail for binary files
-                        metadata_text = content.decode("utf-8", errors="strict")
-
-                        try:
-                            metadata_obj = json.loads(metadata_text)
-
-                            # Check if this is an erasure-coded file metadata - look for either format
-                            is_ec_file = False
-
-                            # Check primary format
-                            if (
-                                isinstance(metadata_obj, dict)
-                                and metadata_obj.get("chunks")
-                                and metadata_obj.get("original_name")
-                            ):
-                                is_ec_file = True
-
-                            # Check alternative format - different structure used in some versions
-                            elif (
-                                isinstance(metadata_obj, dict)
-                                and metadata_obj.get("erasure_coding")
-                                and metadata_obj.get("original_file")
-                            ):
-                                # This is the newer format with a different structure
-                                metadata_obj = {
-                                    "original_name": metadata_obj.get(
-                                        "original_file", {}
-                                    ).get("name", "unknown"),
-                                    "k": metadata_obj.get("erasure_coding", {}).get(
-                                        "k"
-                                    ),
-                                    "m": metadata_obj.get("erasure_coding", {}).get(
-                                        "m"
-                                    ),
-                                    "original_size": metadata_obj.get(
-                                        "original_file", {}
-                                    ).get("size", 0),
-                                    "encrypted": metadata_obj.get("encrypted", False),
-                                    "chunks": metadata_obj.get("chunks", []),
-                                }
-                                is_ec_file = True
-
-                            if is_ec_file:
-                                # Found an erasure-coded file!
-                                debug_print(
-                                    f"    ✓ Found erasure-coded file: {metadata_obj.get('original_name')}"
+                        # Use the formatted CID, not the raw hex-encoded version
+                        metadata = client.ipfs_client.cat(formatted_cid)
+
+                        # Check if we have text content
+                        if metadata.get("is_text", False):
+                            # Parse the metadata content as JSON
+                            import json
+
+                            metadata_json = json.loads(metadata.get("content", "{}"))
+
+                            # Extract original file info
+                            # Check both possible formats
+                            original_file = metadata_json.get("original_file", {})
+
+                            if original_file:
+                                # New format
+                                print(
+                                    f"  Original file name: {original_file.get('name', 'Unknown')}"
                                 )
 
-                                ec_file = {
-                                    "metadata_cid": cid,
-                                    "original_name": metadata_obj.get(
-                                        "original_name", "unknown"
-                                    ),
-                                    "k": metadata_obj.get("k"),
-                                    "m": metadata_obj.get("m"),
-                                    "total_chunks": len(metadata_obj.get("chunks", [])),
-                                    "original_size_bytes": metadata_obj.get(
-                                        "original_size"
-                                    ),
-                                    "size_formatted": client.format_size(
-                                        metadata_obj.get("original_size", 0)
-                                    ),
-                                    "encrypted": metadata_obj.get("encrypted", False),
-                                    "miner_ids": file.get("miner_ids", []),
-                                    "miner_count": file.get("miner_count", 0),
-                                    "chunks": metadata_obj.get("chunks", []),
-                                }
-                                with lock:
-                                    results["ec_files"].append(ec_file)
-                                    update_progress()
-                                return ec_file
+                                # Show file size
+                                original_size = original_file.get("size", 0)
+                                if original_size:
+                                    size_formatted = client.format_size(original_size)
+                                    print(
+                                        f"  Original file size: {original_size:,} bytes ({size_formatted})"
+                                    )
+                                else:
+                                    print(f"  Original file size: Unknown")
+
+                                # Show hash/CID of original file if available
+                                original_hash = original_file.get("hash", "")
+                                if original_hash:
+                                    print(f"  Original file hash: {original_hash}")
+
+                                # Show extension if available
+                                extension = original_file.get("extension", "")
+                                if extension:
+                                    print(f"  File extension: {extension}")
+                            else:
+                                # Try older format
+                                original_name = metadata_json.get(
+                                    "original_name", "Unknown"
+                                )
+                                print(f"  Original file name: {original_name}")
+
+                                original_size = metadata_json.get("original_size", 0)
+                                if original_size:
+                                    size_formatted = client.format_size(original_size)
+                                    print(
+                                        f"  Original file size: {original_size:,} bytes ({size_formatted})"
+                                    )
+                                else:
+                                    print(f"  Original file size: Unknown")
+
+                            # Show erasure coding parameters if available
+                            ec_params = metadata_json.get("erasure_coding", {})
+                            if ec_params:
+                                k = ec_params.get("k", 0)
+                                m = ec_params.get("m", 0)
+                                if k and m:
+                                    print(
+                                        f"  Erasure coding: k={k}, m={m} (need {k} of {k+m} parts)"
+                                    )
                             else:
-                                with lock:
-                                    results["not_ec_files"] += 1
-                                    update_progress()
-                                return None
-
-                        except json.JSONDecodeError:
-                            # Not a JSON file, so not metadata
-                            with lock:
-                                results["json_decode_errors"] += 1
-                                update_progress()
-                            return None
-                    except UnicodeDecodeError:
-                        # This is a binary file, not UTF-8 text, so not erasure-coded metadata
-                        with lock:
-                            results["binary_files"] += 1
-                            update_progress()
-                        return None
+                                # Check old format
+                                k = metadata_json.get("k", 0)
+                                m = metadata_json.get("m", 0)
+                                if k and m:
+                                    print(
+                                        f"  Erasure coding: k={k}, m={m} (need {k} of {k+m} parts)"
+                                    )
+
+                            # Show encryption status if available
+                            encrypted = metadata_json.get("encrypted", False)
+                            print(f"  Encrypted: {'Yes' if encrypted else 'No'}")
+
+                            # Count chunks
+                            chunks = metadata_json.get("chunks", [])
+                            if chunks:
+                                print(f"  Total chunks: {len(chunks)}")
+
+                                # Show chunk details if requested
+                                if show_chunks:
+                                    print(f"  Chunks:")
+                                    for j, chunk in enumerate(chunks):
+                                        chunk_cid = (
+                                            chunk
+                                            if isinstance(chunk, str)
+                                            else chunk.get("cid", "Unknown")
+                                        )
+                                        print(f"    Chunk {j+1}: {chunk_cid}")
+                        else:
+                            # Couldn't parse metadata as text
+                            print(f"  Error: Metadata is not in text format")
+                    except Exception as e:
+                        print(f"  Error fetching metadata: {e}")
                 else:
-                    with lock:
-                        results["skipped_files"] += 1
-                        update_progress()
-                    return None
-            except Exception as e:
-                # For other unexpected errors
-                debug_print(f"    ✗ Error processing {name}: {str(e)}")
-                with lock:
-                    results["skipped_files"] += 1
-                    update_progress()
-                return None
-
-        # Process files in parallel - significantly speeds up execution
-        max_workers = min(10, len(files))  # Don't create too many threads
-        print(f"Processing files using {max_workers} parallel workers...")
-
-        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-            # Start processing files - higher priority files will be submitted first
-            futures = []
-            # First process files that look like metadata files
-            for file in priority_files:
-                futures.append(executor.submit(process_file, file))
-
-            # Wait for all processing to complete
-            concurrent.futures.wait(futures)
+                    print(f"  Metadata CID: Unknown (None)")
 
-        print(
-            "\nAnalysis complete!                                  "
-        )  # Extra spaces to clear progress line
+                # Display file name (metadata file name)
+                file_name = file.get("file_name", "Unnamed")
+                print(
+                    f"  Metadata file name: {file_name if file_name is not None else 'Unnamed'}"
+                )
 
-        # Print statistics
-        print(f"\nResults:")
-        print(f"  Total files analyzed: {total_files}")
-        print(f"  Erasure-coded files found: {len(results['ec_files'])}")
-        if verbose:
-            print(f"  Binary files (skipped): {results['binary_files']}")
-            print(f"  JSON parse errors: {results['json_decode_errors']}")
-            print(f"  Not erasure-coded: {results['not_ec_files']}")
-            print(f"  Other skipped: {results['skipped_files']}")
-
-        # Print results
-        ec_files = results["ec_files"]
-        if not ec_files:
-            print(f"\nNo erasure-coded files found for this account.")
-            return
-
-        print(f"\nFound {len(ec_files)} erasure-coded files:\n")
-
-        for i, file in enumerate(ec_files):
-            print(f"{i+1}. {file['original_name']} ({file['size_formatted']})")
-            print(f"   Metadata CID: {file['metadata_cid']}")
-            print(
-                f"   Erasure coding: {file['k']}/{file['m']} scheme ({file['total_chunks']} chunks)"
-            )
-            print(f"   Encrypted: {'Yes' if file['encrypted'] else 'No'}")
-            print(f"   Stored by {file['miner_count']} miners")
-
-            if file.get("miner_ids") and show_all_miners:
-                print("\n   Miners:")
-                for miner in file["miner_ids"]:
-                    miner_id = (
-                        miner.get("id", miner) if isinstance(miner, dict) else miner
+                # Show reconstruction command
+                if metadata_cid is not None and metadata_cid != "Unknown":
+                    print(f"  Reconstruction command:")
+                    # Try to extract original name from metadata file name
+                    original_name = (
+                        file_name.replace(".ec_metadata", "") if file_name else "file"
                     )
-                    formatted = (
-                        miner.get("formatted", miner_id)
-                        if isinstance(miner, dict)
-                        else miner_id
+                    # We're already using formatted_cid from above
+                    print(
+                        f"    hippius reconstruct {formatted_cid} reconstructed_{original_name}"
                     )
-                    print(f"     - {formatted}")
-
-            if show_chunks and file.get("chunks"):
-                print("\n   Chunks:")
-                for j, chunk in enumerate(file["chunks"]):
-                    if isinstance(chunk, dict):
-                        print(f"     {j+1}. CID: {chunk.get('cid')}")
-                    else:
-                        print(f"     {j+1}. CID: {chunk}")
+                else:
+                    print(f"  Reconstruction command not available (missing CID)")
 
-            print("")  # Empty line between files
+                print("-" * 80)
+            except Exception as e:
+                print(f"  Error displaying EC file {i}: {e}")
+                print("-" * 80)
+                continue
 
-        print("\nTo reconstruct a file:")
-        print("hippius reconstruct <metadata_cid> <output_file>")
+        # Add helpful tips
+        print("\nTo reconstruct a file, use:")
+        print(f"  hippius reconstruct <Metadata_CID> <output_filename>")
 
     except Exception as e:
-        print(f"Error: {e}")
-        if verbose:
-            import traceback
+        print(f"Error retrieving erasure-coded files: {e}")
+        return 1
 
-            traceback.print_exc()
+    return 0
 
 
 def handle_erasure_code(
@@ -977,8 +889,11 @@ def handle_erasure_code(
         print(f"  1. The metadata CID: {metadata_cid}")
         print("  2. Access to at least k chunks for each original chunk")
         print("\nReconstruction command:")
+
+        # Format the CID for the command
+        formatted_cid = client.format_cid(metadata_cid)
         print(
-            f"  hippius reconstruct {metadata_cid} reconstructed_{original_file.get('name')}"
+            f"  hippius reconstruct {formatted_cid} reconstructed_{original_file.get('name')}"
         )
 
         return 0
@@ -1165,9 +1080,12 @@ def handle_reconstruct(client, metadata_cid, output_file, verbose=True):
     start_time = time.time()
 
     try:
-        # Use the reconstruct_from_erasure_code method
+        # Format the CID to ensure it's properly handled
+        formatted_cid = client.format_cid(metadata_cid)
+
+        # Use the formatted CID for reconstruction
         result = client.reconstruct_from_erasure_code(
-            metadata_cid=metadata_cid, output_file=output_file, verbose=verbose
+            metadata_cid=formatted_cid, output_file=output_file, verbose=verbose
         )
 
         elapsed_time = time.time() - start_time
@@ -1439,125 +1357,316 @@ def handle_seed_phrase_status(account_name=None):
     return 0
 
 
-def handle_account_list():
-    """Handle listing all accounts"""
-    accounts = list_accounts()
+def handle_account_list(args):
+    """Handle listing accounts."""
+    from hippius_sdk.account import AccountManager
 
-    if not accounts:
-        print("No accounts configured")
-        return 0
+    account_manager = AccountManager()
 
-    print(f"Found {len(accounts)} accounts:")
+    if args.type == "coldkey":
+        accounts = account_manager.list_coldkeys()
+        print(f"Found {len(accounts)} coldkeys:")
 
-    for name, data in accounts.items():
-        active_marker = " (active)" if data.get("is_active", False) else ""
-        encoded_status = (
-            "encrypted" if data.get("seed_phrase_encoded", False) else "plain text"
-        )
-        address = data.get("ss58_address", "unknown")
+        for i, account in enumerate(accounts, 1):
+            print(f"{i}. {account['name']}: {account['address']}")
 
-        print(f"  {name}{active_marker}:")
-        print(f"    SS58 Address: {address}")
-        print(f"    Seed phrase: {encoded_status}")
-        print()
+            # If verbose, show associated hotkeys
+            if args.verbose:
+                hotkeys = account_manager.list_hotkeys(account["address"])
+                if hotkeys:
+                    print(f"   Associated hotkeys:")
+                    for j, hotkey in enumerate(hotkeys, 1):
+                        print(f"   {j}. {hotkey['name']}: {hotkey['address']}")
+                else:
+                    print(f"   No associated hotkeys")
 
-    return 0
+    elif args.type == "hotkey":
+        try:
+            if args.coldkey:
+                accounts = account_manager.list_hotkeys(args.coldkey)
+                coldkey_name = None
+                if accounts and "coldkey_name" in accounts[0]:
+                    coldkey_name = accounts[0]["coldkey_name"]
 
+                if coldkey_name:
+                    print(
+                        f"Found {len(accounts)} hotkeys for coldkey {args.coldkey} ({coldkey_name}):"
+                    )
+                else:
+                    print(f"Found {len(accounts)} hotkeys for coldkey {args.coldkey}:")
+            else:
+                accounts = account_manager.list_hotkeys()
+                print(f"Found {len(accounts)} hotkeys:")
+
+            for i, account in enumerate(accounts, 1):
+                coldkey_info = ""
+                if "associated_coldkey" in account:
+                    if "coldkey_name" in account:
+                        coldkey_info = f" → coldkey: {account['coldkey_name']} ({account['associated_coldkey']})"
+                    else:
+                        coldkey_info = f" → coldkey: {account['associated_coldkey']}"
 
-def handle_account_switch(account_name):
-    """Handle switching the active account"""
-    if set_active_account(account_name):
-        print(f"Switched to account '{account_name}'")
+                print(f"{i}. {account['name']}: {account['address']}{coldkey_info}")
 
-        # Show address
-        address = get_account_address(account_name)
-        if address:
-            print(f"SS58 Address: {address}")
+                # If verbose, show more details
+                if args.verbose:
+                    created_at = account.get("created_at", 0)
+                    if created_at:
+                        from datetime import datetime
 
-        return 0
-    else:
-        return 1
+                        created_time = datetime.fromtimestamp(created_at).strftime(
+                            "%Y-%m-%d %H:%M:%S"
+                        )
+                        print(f"   Created: {created_time}")
 
+                    # Show whether there is a blockchain proxy relationship
+                    try:
+                        proxies = account_manager.list_proxies(
+                            account.get("associated_coldkey")
+                        )
+                        has_proxy = any(
+                            proxy["hotkey"] == account["address"] for proxy in proxies
+                        )
+                        if has_proxy:
+                            print(f"   Blockchain proxy: YES (active on-chain)")
+                        else:
+                            print(f"   Blockchain proxy: NO (local association only)")
+                    except Exception:
+                        print(f"   Blockchain proxy: Unknown (could not verify)")
 
-def handle_account_delete(account_name):
-    """Handle deleting an account"""
-    # Ask for confirmation
-    confirm = input(
-        f"Are you sure you want to delete account '{account_name}'? This cannot be undone. (y/N): "
-    )
-    if confirm.lower() not in ("y", "yes"):
-        print("Operation cancelled")
-        return 0
+        except ValueError as e:
+            print(f"Error: {str(e)}")
+            return None
+        except Exception as e:
+            print(f"Error listing hotkeys: {str(e)}")
+            return None
+
+    elif args.type == "proxy":
+        try:
+            proxies = account_manager.list_proxies(args.coldkey)
+            print(f"Found {len(proxies)} proxy relationships on the blockchain:")
+
+            for i, proxy in enumerate(proxies, 1):
+                coldkey = proxy["coldkey"]
+                hotkey = proxy["hotkey"]
+
+                # Try to get human-readable names
+                data = account_manager._load_accounts_data()
+                coldkey_name = (
+                    data.get("coldkeys", {}).get(coldkey, {}).get("name", "Unknown")
+                )
+                hotkey_name = (
+                    data.get("hotkeys", {}).get(hotkey, {}).get("name", "Unknown")
+                )
+
+                print(f"{i}. {coldkey_name} ({coldkey}) → {hotkey_name} ({hotkey})")
+                print(f"   Type: {proxy['proxy_type']}, Delay: {proxy['delay']}")
+        except Exception as e:
+            print(f"Error listing proxies: {str(e)}")
+
+    return accounts
+
+
+def handle_account_proxy_create(args):
+    """Handle creating a proxy relationship."""
+    from hippius_sdk.account import AccountManager
+
+    account_manager = AccountManager()
 
-    if delete_account(account_name):
-        print(f"Account '{account_name}' deleted")
+    try:
+        result = account_manager.create_proxy_relationship(
+            coldkey_address=args.coldkey,
+            hotkey_address=args.hotkey,
+            proxy_type=args.proxy_type,
+            delay=args.delay,
+            password=args.password,  # Pass the password if provided
+        )
 
-        # Show the new active account if any
-        active_account = get_active_account()
-        if active_account:
-            print(f"Active account is now '{active_account}'")
+        if result.get("success"):
+            print(f"Successfully created proxy relationship!")
+            print(f"Coldkey: {result['coldkey']}")
+            print(f"Hotkey:  {result['hotkey']}")
+            print(f"Type:    {result['proxy_type']}")
+            print(f"Tx Hash: {result['transaction_hash']}")
         else:
-            print("No accounts remaining")
+            print(
+                f"Failed to create proxy relationship: {result.get('error', 'Unknown error')}"
+            )
 
-        return 0
-    else:
-        return 1
+        return result
+
+    except Exception as e:
+        print(f"Error creating proxy relationship: {str(e)}")
+        return None
 
 
-def handle_default_address_set(address):
-    """Handle setting the default address for read-only operations"""
-    # Validate SS58 address format (basic check)
-    if not address.startswith("5"):
-        print(
-            f"Warning: '{address}' doesn't look like a valid SS58 address. SS58 addresses typically start with '5'."
+def handle_account_proxy_remove(args):
+    """Handle removing a proxy relationship."""
+    from hippius_sdk.account import AccountManager
+
+    account_manager = AccountManager()
+
+    try:
+        result = account_manager.remove_proxy(
+            coldkey_address=args.coldkey,
+            hotkey_address=args.hotkey,
+            password=args.password,
+            proxy_type=args.proxy_type,
+            delay=args.delay,
         )
-        confirm = input("Do you want to continue anyway? (y/N): ")
-        if confirm.lower() not in ("y", "yes"):
-            print("Operation cancelled")
-            return 1
 
-    config = load_config()
-    config["substrate"]["default_address"] = address
-    save_config(config)
+        if result.get("success"):
+            print(f"Successfully removed proxy relationship!")
+            print(f"Coldkey: {result['coldkey']}")
+            print(f"Hotkey:  {result['hotkey']}")
+            print(f"Tx Hash: {result['transaction_hash']}")
+        else:
+            print(
+                f"Failed to remove proxy relationship: {result.get('error', 'Unknown error')}"
+            )
 
-    print(f"Default address for read-only operations set to: {address}")
-    print(
-        "This address will be used for commands like 'files' and 'ec-files' when no address is explicitly provided."
-    )
-    return 0
+        return result
 
+    except Exception as e:
+        print(f"Error removing proxy relationship: {str(e)}")
+        return None
 
-def handle_default_address_get():
-    """Handle getting the current default address for read-only operations"""
-    config = load_config()
-    address = config["substrate"].get("default_address")
 
-    if address:
-        print(f"Current default address for read-only operations: {address}")
-    else:
-        print("No default address set for read-only operations")
-        print("You can set one with: hippius address set-default <ss58_address>")
+def handle_account_coldkey_create(args):
+    """Handle creating a new coldkey account."""
+    from hippius_sdk.account import AccountManager
 
-    return 0
+    account_manager = AccountManager()
 
+    # Determine if we're creating from a mnemonic
+    mnemonic = None
+    if args.mnemonic:
+        mnemonic = args.mnemonic
+    elif args.generate_mnemonic:
+        # We'll use the keypair generation which automatically creates a mnemonic
+        pass
 
-def handle_default_address_clear():
-    """Handle clearing the default address for read-only operations"""
-    config = load_config()
-    if "default_address" in config["substrate"]:
-        del config["substrate"]["default_address"]
-        save_config(config)
-        print("Default address for read-only operations has been cleared")
-    else:
-        print("No default address was set")
+    try:
+        coldkey = account_manager.create_coldkey(
+            name=args.name if args.name else "hippius_coldkey",
+            mnemonic=mnemonic,
+            encrypt=not args.no_encrypt,  # Default to encrypt=True unless explicitly disabled
+            password=None,  # Let the method handle prompting for password
+        )
 
-    return 0
+        # Success message is already printed in the create_coldkey method
+        # If show_mnemonic was requested and it's not encrypted, show it
+        if args.show_mnemonic and not coldkey.get("encrypted", True):
+            print("\nIMPORTANT: Save this mnemonic phrase to recover your account!")
+            print(f"Mnemonic: {coldkey['mnemonic']}")
+            print("\nWARNING: Never share this mnemonic with anyone!")
 
+        return coldkey
+
+    except Exception as e:
+        print(f"Error creating coldkey: {str(e)}")
+        return None
+
+
+def handle_account_hotkey_create(args):
+    """Handle creating a new hotkey account."""
+    from hippius_sdk.account import AccountManager
+
+    account_manager = AccountManager()
+
+    try:
+        # If no coldkey provided, let the AccountManager handle it
+        # It will use the only coldkey if there's just one, or raise an error
+        hotkey = account_manager.create_hotkey(
+            name=args.name, coldkey_address=args.coldkey
+        )
+
+        # Success message is already printed in create_hotkey
+
+        # If show_mnemonic was requested, show it
+        if args.show_mnemonic and hotkey.get("mnemonic"):
+            print("\nHotkey mnemonic: {0}".format(hotkey["mnemonic"]))
+            print("Note: This mnemonic is only needed if you want to use this hotkey")
+            print("      outside of the Hippius SDK. For normal operations, the proxy")
+            print("      relationship will allow your coldkey to authorize actions.")
+
+        return hotkey
+
+    except ValueError as e:
+        # Handle the specific error case of multiple coldkeys
+        if "multiple coldkeys exist" in str(e):
+            print(f"Error: {e}")
+            print("\nPlease specify which coldkey to use with:")
+            print(
+                "  hippius account hotkey create --coldkey <COLDKEY_ADDRESS> [--name <NAME>]"
+            )
+        else:
+            print(f"Error creating hotkey: {str(e)}")
+
+        return None
+    except Exception as e:
+        print(f"Error creating hotkey: {str(e)}")
+        return None
 
-def get_default_address():
-    """Get the default address for read-only operations"""
-    config = load_config()
-    return config["substrate"].get("default_address")
+
+def handle_account_proxy_create(args):
+    """Handle creating a proxy relationship."""
+    from hippius_sdk.account import AccountManager
+
+    account_manager = AccountManager()
+
+    try:
+        result = account_manager.create_proxy_relationship(
+            coldkey_address=args.coldkey,
+            hotkey_address=args.hotkey,
+            proxy_type=args.proxy_type,
+            delay=args.delay,
+        )
+
+        if result.get("success"):
+            print(f"Successfully created proxy relationship!")
+            print(f"Coldkey: {result['coldkey']}")
+            print(f"Hotkey:  {result['hotkey']}")
+            print(f"Type:    {result['proxy_type']}")
+            print(f"Tx Hash: {result['transaction_hash']}")
+        else:
+            print(
+                f"Failed to create proxy relationship: {result.get('error', 'Unknown error')}"
+            )
+
+        return result
+
+    except Exception as e:
+        print(f"Error creating proxy relationship: {str(e)}")
+        return None
+
+
+def handle_account_proxy_remove(args):
+    """Handle removing a proxy relationship."""
+    from hippius_sdk.account import AccountManager
+
+    account_manager = AccountManager()
+
+    try:
+        result = account_manager.remove_proxy(
+            coldkey_address=args.coldkey, hotkey_address=args.hotkey
+        )
+
+        if result.get("success"):
+            print(f"Successfully removed proxy relationship!")
+            print(f"Coldkey: {result['coldkey']}")
+            print(f"Hotkey:  {result['hotkey']}")
+            print(f"Tx Hash: {result['transaction_hash']}")
+        else:
+            print(
+                f"Failed to remove proxy relationship: {result.get('error', 'Unknown error')}"
+            )
+
+        return result
+
+    except Exception as e:
+        print(f"Error removing proxy relationship: {str(e)}")
+        return None
 
 
 def main():
@@ -1719,42 +1828,50 @@ examples:
 
     # Files command
     files_parser = subparsers.add_parser(
-        "files", help="View detailed information about files stored by a user"
-    )
-    files_parser.add_argument(
-        "account_address",
-        nargs="?",
-        default=None,
-        help="Substrate account address (uses keypair address if not specified)",
+        "files", help="View files stored by you or another account"
     )
     files_parser.add_argument(
-        "--debug", action="store_true", help="Show debug information about CID decoding"
+        "--account_address",
+        help="Substrate account to view files for (defaults to your keyfile account)",
     )
     files_parser.add_argument(
         "--all-miners",
         action="store_true",
-        help="Show all miners for each file instead of only the first 3",
+        help="Show all miners for each file",
+    )
+    files_parser.set_defaults(
+        func=lambda args, client: handle_files(
+            client,
+            args.account_address,
+            show_all_miners=args.all_miners if hasattr(args, "all_miners") else False,
+        )
     )
 
     # Erasure Coded Files command
     ec_files_parser = subparsers.add_parser(
-        "ec-files", help="List only erasure-coded files stored by a user"
+        "ec-files", help="View erasure-coded files stored by you or another account"
     )
     ec_files_parser.add_argument(
-        "account_address",
-        nargs="?",
-        default=None,
-        help="Substrate account address (uses keypair address if not specified)",
+        "--account_address",
+        help="Substrate account to view erasure-coded files for (defaults to your keyfile account)",
     )
     ec_files_parser.add_argument(
         "--all-miners",
         action="store_true",
-        help="Show all miners for each file instead of only the first 3",
+        help="Show all miners for each file",
     )
     ec_files_parser.add_argument(
         "--show-chunks",
         action="store_true",
-        help="Show associated chunks for each erasure-coded file",
+        help="Show chunk details for each erasure-coded file",
+    )
+    ec_files_parser.set_defaults(
+        func=lambda args, client: handle_ec_files(
+            client,
+            args.account_address,
+            show_all_miners=args.all_miners if hasattr(args, "all_miners") else False,
+            show_chunks=args.show_chunks if hasattr(args, "show_chunks") else False,
+        )
     )
 
     # Key generation command
@@ -1798,6 +1915,41 @@ examples:
         "--verbose", action="store_true", help="Enable verbose output", default=True
     )
 
+    # Erasure code directory command
+    erasure_code_dir_parser = subparsers.add_parser(
+        "erasure-code-dir", help="Apply erasure coding to each file in a directory"
+    )
+    erasure_code_dir_parser.add_argument(
+        "dir_path", help="Path to directory to process"
+    )
+    erasure_code_dir_parser.add_argument(
+        "--k",
+        type=int,
+        default=3,
+        help="Number of data chunks needed to reconstruct (default: 3)",
+    )
+    erasure_code_dir_parser.add_argument(
+        "--m", type=int, default=5, help="Total number of chunks to create (default: 5)"
+    )
+    erasure_code_dir_parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=1048576,
+        help="Chunk size in bytes (default: 1MB)",
+    )
+    erasure_code_dir_parser.add_argument(
+        "--miner-ids", help="Comma-separated list of miner IDs"
+    )
+    erasure_code_dir_parser.add_argument(
+        "--encrypt", action="store_true", help="Encrypt the files"
+    )
+    erasure_code_dir_parser.add_argument(
+        "--no-encrypt", action="store_true", help="Do not encrypt the files"
+    )
+    erasure_code_dir_parser.add_argument(
+        "--verbose", action="store_true", help="Enable verbose output", default=True
+    )
+
     # Reconstruct command
     reconstruct_parser = subparsers.add_parser(
         "reconstruct", help="Reconstruct an erasure-coded file"
@@ -1893,55 +2045,139 @@ examples:
     )
 
     # Account subcommand
-    account_parser = subparsers.add_parser("account", help="Manage substrate accounts")
+    account_parser = subparsers.add_parser("account", help="Manage blockchain accounts")
     account_subparsers = account_parser.add_subparsers(
-        dest="account_action", help="Account action"
+        dest="account_action", help="Account management actions"
     )
 
-    # List accounts
-    account_subparsers.add_parser("list", help="List all accounts")
+    # Coldkey subcommands
+    coldkey_parser = account_subparsers.add_parser(
+        "coldkey", help="Manage coldkey accounts"
+    )
+    coldkey_subparsers = coldkey_parser.add_subparsers(
+        dest="coldkey_action", help="Coldkey actions"
+    )
 
-    # Switch active account
-    switch_account_parser = account_subparsers.add_parser(
-        "switch", help="Switch to a different account"
+    # Create coldkey command
+    create_coldkey_parser = coldkey_subparsers.add_parser(
+        "create", help="Create a new coldkey"
     )
-    switch_account_parser.add_argument(
-        "account_name", help="Name of the account to switch to"
+    create_coldkey_parser.add_argument(
+        "--name", help="Name for the coldkey (default: hippius_coldkey)"
+    )
+    mnemonic_group = create_coldkey_parser.add_mutually_exclusive_group()
+    mnemonic_group.add_argument("--mnemonic", help="Mnemonic seed phrase to use")
+    mnemonic_group.add_argument(
+        "--generate-mnemonic",
+        action="store_true",
+        help="Generate a new mnemonic (default if no mnemonic provided)",
+    )
+    create_coldkey_parser.add_argument(
+        "--show-mnemonic",
+        action="store_true",
+        help="Display the mnemonic after creation (USE WITH CAUTION)",
+    )
+    create_coldkey_parser.add_argument(
+        "--no-encrypt",
+        action="store_true",
+        help="Do NOT encrypt the mnemonic with a password (not recommended)",
+    )
+    create_coldkey_parser.set_defaults(func=handle_account_coldkey_create)
+
+    # Hotkey subcommands
+    hotkey_parser = account_subparsers.add_parser(
+        "hotkey", help="Manage hotkey accounts"
+    )
+    hotkey_subparsers = hotkey_parser.add_subparsers(
+        dest="hotkey_action", help="Hotkey actions"
     )
 
-    # Delete account
-    delete_account_parser = account_subparsers.add_parser(
-        "delete", help="Delete an account"
+    # Create hotkey command
+    create_hotkey_parser = hotkey_subparsers.add_parser(
+        "create", help="Create a new hotkey associated with a coldkey"
+    )
+    create_hotkey_parser.add_argument(
+        "--name", help="Name for the hotkey (default: hippius_hotkey_N)"
+    )
+    create_hotkey_parser.add_argument(
+        "--coldkey",
+        help="Coldkey address to associate with (required if multiple coldkeys exist)",
     )
-    delete_account_parser.add_argument(
-        "account_name", help="Name of the account to delete"
+    create_hotkey_parser.add_argument(
+        "--show-mnemonic",
+        action="store_true",
+        help="Display the mnemonic after creation",
     )
+    create_hotkey_parser.set_defaults(func=handle_account_hotkey_create)
 
-    # Address subcommand for read-only operations
-    address_parser = subparsers.add_parser(
-        "address", help="Manage default address for read-only operations"
+    # List accounts command
+    list_accounts_parser = account_subparsers.add_parser("list", help="List accounts")
+    list_accounts_parser.add_argument(
+        "type", choices=["coldkey", "hotkey", "proxy"], help="Type of accounts to list"
     )
-    address_subparsers = address_parser.add_subparsers(
-        dest="address_action", help="Address action"
+    list_accounts_parser.add_argument("--coldkey", help="Coldkey address to filter by")
+    list_accounts_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show more details"
     )
+    list_accounts_parser.set_defaults(func=handle_account_list)
 
-    # Set default address
-    set_default_parser = address_subparsers.add_parser(
-        "set-default", help="Set the default address for read-only operations"
+    # Proxy subcommands
+    proxy_parser = account_subparsers.add_parser(
+        "proxy", help="Manage proxy relationships"
     )
-    set_default_parser.add_argument(
-        "address", help="The SS58 address to use as default"
+    proxy_subparsers = proxy_parser.add_subparsers(
+        dest="proxy_action", help="Proxy actions"
     )
 
-    # Get current default address
-    address_subparsers.add_parser(
-        "get-default", help="Show the current default address for read-only operations"
+    # Create proxy command
+    create_proxy_parser = proxy_subparsers.add_parser(
+        "create", help="Create a proxy relationship"
+    )
+    create_proxy_parser.add_argument(
+        "--coldkey", required=True, help="Coldkey address (delegator)"
+    )
+    create_proxy_parser.add_argument(
+        "--hotkey", required=True, help="Hotkey address (delegate)"
+    )
+    create_proxy_parser.add_argument(
+        "--proxy-type", default="NonTransfer", help="Proxy type (default: NonTransfer)"
+    )
+    create_proxy_parser.add_argument(
+        "--delay",
+        type=int,
+        default=0,
+        help="Delay in blocks before proxy becomes active (default: 0)",
+    )
+    create_proxy_parser.add_argument(
+        "--password",
+        help="Password for the coldkey (will prompt if not provided and needed)",
     )
+    create_proxy_parser.set_defaults(func=handle_account_proxy_create)
 
-    # Clear default address
-    address_subparsers.add_parser(
-        "clear-default", help="Clear the default address for read-only operations"
+    # Remove proxy command
+    remove_proxy_parser = proxy_subparsers.add_parser(
+        "remove", help="Remove a proxy relationship"
     )
+    remove_proxy_parser.add_argument(
+        "--coldkey", required=True, help="Coldkey address (delegator)"
+    )
+    remove_proxy_parser.add_argument(
+        "--hotkey", required=True, help="Hotkey address (delegate)"
+    )
+    remove_proxy_parser.add_argument(
+        "--password",
+        help="Password for the coldkey (will prompt if not provided and needed)",
+    )
+    remove_proxy_parser.add_argument(
+        "--proxy-type", default="NonTransfer", help="Proxy type (default: NonTransfer)"
+    )
+    remove_proxy_parser.add_argument(
+        "--delay",
+        type=int,
+        default=0,
+        help="Delay value used when creating the proxy (default: 0)",
+    )
+    remove_proxy_parser.set_defaults(func=handle_account_proxy_remove)
 
     args = parser.parse_args()
 
@@ -2032,7 +2268,6 @@ examples:
             return handle_files(
                 client,
                 args.account_address,
-                debug=args.debug if hasattr(args, "debug") else False,
                 show_all_miners=args.all_miners
                 if hasattr(args, "all_miners")
                 else False,
@@ -2060,6 +2295,18 @@ examples:
                 verbose=args.verbose,
             )
 
+        elif args.command == "erasure-code-dir":
+            return handle_erasure_code_directory(
+                client,
+                args.dir_path,
+                args.k,
+                args.m,
+                args.chunk_size,
+                miner_ids,
+                encrypt=args.encrypt,
+                verbose=args.verbose,
+            )
+
         elif args.command == "reconstruct":
             return handle_reconstruct(
                 client, args.metadata_cid, args.output_file, verbose=args.verbose