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

hippius_sdk/cli.py

@@ -7,17 +7,15 @@ utilities for encryption key generation, file operations, and marketplace intera
 """
 
 import argparse
+import asyncio
 import base64
 import concurrent.futures
 import getpass
+import inspect
 import json
 import os
-import random
 import sys
-import threading
 import time
-import uuid
-from typing import List, Optional
 
 from dotenv import load_dotenv
 
@@ -31,7 +29,6 @@ from hippius_sdk import (
     get_active_account,
     get_all_config,
     get_config_value,
-    get_encryption_key,
     get_seed_phrase,
     initialize_from_env,
     list_accounts,
@@ -40,10 +37,8 @@ from hippius_sdk import (
     save_config,
     set_active_account,
     set_config_value,
-    set_encryption_key,
     set_seed_phrase,
 )
-from hippius_sdk.substrate import FileInput
 
 try:
     import nacl.secret
@@ -53,10 +48,7 @@ except ImportError:
 else:
     ENCRYPTION_AVAILABLE = True
 
-# Load environment variables
 load_dotenv()
-
-# Initialize configuration from environment variables
 initialize_from_env()
 
 
@@ -181,12 +173,12 @@ def create_client(args):
     return client
 
 
-def handle_download(client, cid, output_path, decrypt=None):
+async def handle_download(client, cid, output_path, decrypt=None):
     """Handle the download command"""
     print(f"Downloading {cid} to {output_path}...")
 
     # Use the enhanced download method which returns formatted information
-    result = client.download_file(cid, output_path, decrypt=decrypt)
+    result = await client.download_file(cid, output_path, decrypt=decrypt)
 
     print(f"Download successful in {result['elapsed_seconds']} seconds!")
     print(f"Saved to: {result['output_path']}")
@@ -198,10 +190,10 @@ def handle_download(client, cid, output_path, decrypt=None):
     return 0
 
 
-def handle_exists(client, cid):
+async def handle_exists(client, cid):
     """Handle the exists command"""
     print(f"Checking if CID {cid} exists on IPFS...")
-    result = client.exists(cid)
+    result = await client.exists(cid)
 
     # Use the formatted CID from the result
     formatted_cid = result["formatted_cid"]
@@ -217,12 +209,12 @@ def handle_exists(client, cid):
     return 0
 
 
-def handle_cat(client, cid, max_size, decrypt=None):
+async def handle_cat(client, cid, max_size, decrypt=None):
     """Handle the cat command"""
     print(f"Retrieving content of CID {cid}...")
     try:
         # Use the enhanced cat method with formatting
-        result = client.cat(cid, max_display_bytes=max_size, decrypt=decrypt)
+        result = await client.cat(cid, max_display_bytes=max_size, decrypt=decrypt)
 
         # Display file information
         print(
@@ -255,7 +247,7 @@ def handle_cat(client, cid, max_size, decrypt=None):
     return 0
 
 
-def handle_store(client, file_path, miner_ids, encrypt=None):
+async def handle_store(client, file_path, miner_ids, encrypt=None):
     """Handle the store command"""
     if not os.path.exists(file_path):
         print(f"Error: File {file_path} not found")
@@ -265,7 +257,7 @@ def handle_store(client, file_path, miner_ids, encrypt=None):
     start_time = time.time()
 
     # Use the enhanced upload_file method that returns formatted information
-    result = client.upload_file(file_path, encrypt=encrypt)
+    result = await client.upload_file(file_path, encrypt=encrypt)
 
     ipfs_elapsed_time = time.time() - start_time
 
@@ -282,11 +274,23 @@ def handle_store(client, file_path, miner_ids, encrypt=None):
     start_time = time.time()
 
     try:
+        # Check if we have credits
+        try:
+            if hasattr(client.substrate_client, "get_free_credits"):
+                credits = client.substrate_client.get_free_credits()
+                print(f"Account credits: {credits}")
+                if credits <= 0:
+                    print(
+                        f"Warning: Account has no free credits (current: {credits}). Transaction may fail."
+                    )
+        except Exception as e:
+            print(f"Warning: Could not check free credits: {e}")
+
         # Create a file input object for the marketplace
         file_input = {"fileHash": result["cid"], "fileName": result["filename"]}
 
-        # Store on Substrate
-        client.substrate_client.storage_request([file_input], miner_ids)
+        # Store on Substrate - now it's an async call
+        tx_hash = await client.substrate_client.storage_request([file_input], miner_ids)
 
         substrate_elapsed_time = time.time() - start_time
         print(
@@ -307,7 +311,7 @@ def handle_store(client, file_path, miner_ids, encrypt=None):
     return 0
 
 
-def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
+async def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
     """Handle the store-dir command"""
     if not os.path.isdir(dir_path):
         print(f"Error: Directory {dir_path} not found")
@@ -331,7 +335,7 @@ def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
     for file_path, rel_path in all_files:
         try:
             print(f"  Uploading: {rel_path}")
-            file_result = client.upload_file(file_path, encrypt=encrypt)
+            file_result = await client.upload_file(file_path, encrypt=encrypt)
             individual_cids.append(
                 {
                     "path": rel_path,
@@ -351,7 +355,7 @@ def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
             print(f"    Error uploading {rel_path}: {e}")
 
     # Now upload the entire directory
-    result = client.upload_directory(dir_path, encrypt=encrypt)
+    result = await client.upload_directory(dir_path, encrypt=encrypt)
 
     ipfs_elapsed_time = time.time() - start_time
 
@@ -384,7 +388,7 @@ def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
             file_inputs.append({"fileHash": item["cid"], "fileName": item["filename"]})
 
         # Store all files in a single batch request
-        client.substrate_client.storage_request(file_inputs, miner_ids)
+        tx_hash = await client.substrate_client.storage_request(file_inputs, miner_ids)
 
         substrate_elapsed_time = time.time() - start_time
         print(
@@ -400,7 +404,7 @@ def handle_store_dir(client, dir_path, miner_ids, encrypt=None):
     return 0
 
 
-def handle_credits(client, account_address):
+async def handle_credits(client, account_address):
     """Handle the credits command"""
     print("Checking free credits for the account...")
     try:
@@ -436,7 +440,7 @@ def handle_credits(client, account_address):
 
                     return 1
 
-        credits = client.substrate_client.get_free_credits(account_address)
+        credits = await client.substrate_client.get_free_credits(account_address)
         print(f"\nFree credits: {credits:.6f}")
         raw_value = int(
             credits * 1_000_000_000_000_000_000
@@ -450,7 +454,7 @@ def handle_credits(client, account_address):
     return 0
 
 
-def handle_files(client, account_address, show_all_miners=False):
+async def handle_files(client, account_address, show_all_miners=False):
     """
     Display files stored by a user in a nice format.
 
@@ -490,7 +494,9 @@ def handle_files(client, account_address, show_all_miners=False):
 
         # 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)
+        files = await client.substrate_client.get_user_files_from_profile(
+            account_address
+        )
 
         # Check if any files were found
         if not files:
@@ -568,7 +574,9 @@ def handle_files(client, account_address, show_all_miners=False):
     return 0
 
 
-def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=False):
+async def handle_ec_files(
+    client, account_address, show_all_miners=False, show_chunks=False
+):
     """Handle the ec-files command to show only erasure-coded files"""
     print("Looking for erasure-coded files...")
     try:
@@ -604,7 +612,9 @@ def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=
                     return 1
 
         # First, get all user files using the profile method
-        files = client.substrate_client.get_user_files_from_profile(account_address)
+        files = await client.substrate_client.get_user_files_from_profile(
+            account_address
+        )
 
         # Filter for metadata files (ending with .ec_metadata)
         ec_metadata_files = []
@@ -637,7 +647,7 @@ def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=
                     # Fetch and parse the metadata to get original file info
                     try:
                         # Use the formatted CID, not the raw hex-encoded version
-                        metadata = client.ipfs_client.cat(formatted_cid)
+                        metadata = await client.ipfs_client.cat(formatted_cid)
 
                         # Check if we have text content
                         if metadata.get("is_text", False):
@@ -772,8 +782,16 @@ def handle_ec_files(client, account_address, show_all_miners=False, show_chunks=
     return 0
 
 
-def handle_erasure_code(
-    client, file_path, k, m, chunk_size, miner_ids, encrypt=None, verbose=True
+async def handle_erasure_code(
+    client,
+    file_path,
+    k,
+    m,
+    chunk_size,
+    miner_ids,
+    encrypt=None,
+    publish=False,
+    verbose=True,
 ):
     """Handle the erasure-code command"""
     if not os.path.exists(file_path):
@@ -803,7 +821,6 @@ def handle_erasure_code(
             for root, _, files in os.walk(file_path):
                 if files:
                     example_file = os.path.join(root, files[0])
-                    rel_path = os.path.relpath(example_file, os.path.dirname(file_path))
                     print(f'   hippius erasure-code "{example_file}" --k {k} --m {m}')
                     break
 
@@ -814,8 +831,16 @@ def handle_erasure_code(
             choice = input("> ").strip().lower()
 
             if choice in ("y", "yes"):
-                return handle_erasure_code_directory(
-                    client, file_path, k, m, chunk_size, miner_ids, encrypt, verbose
+                return await handle_erasure_code_directory(
+                    client,
+                    file_path,
+                    k,
+                    m,
+                    chunk_size,
+                    miner_ids,
+                    encrypt,
+                    publish,
+                    verbose,
                 )
         else:
             print(f"   No files found in directory {file_path}")
@@ -845,11 +870,6 @@ def handle_erasure_code(
 
     print(f"Processing {file_path} ({file_size_mb:.2f} MB) with erasure coding...")
 
-    # Check if the file is too small for the current chunk size and k value
-    original_k = k
-    original_m = m
-    original_chunk_size = chunk_size
-
     # Calculate how many chunks we would get with current settings
     potential_chunks = max(1, file_size // chunk_size)
 
@@ -858,7 +878,7 @@ def handle_erasure_code(
         # Calculate a new chunk size that would give us exactly k chunks
         new_chunk_size = max(1024, file_size // k)  # Ensure at least 1KB chunks
 
-        print(f"Warning: File is too small for the requested parameters.")
+        print("Warning: File is too small for the requested parameters.")
         print(
             f"Original parameters: k={k}, m={m}, chunk size={chunk_size/1024/1024:.2f} MB"
         )
@@ -879,7 +899,7 @@ def handle_erasure_code(
 
     try:
         # Use the store_erasure_coded_file method directly from HippiusClient
-        result = client.store_erasure_coded_file(
+        result = await client.store_erasure_coded_file(
             file_path=file_path,
             k=k,
             m=m,
@@ -890,27 +910,73 @@ def handle_erasure_code(
             verbose=verbose,
         )
 
+        # Store the original result before potentially overwriting it with publish result
+        storage_result = result.copy()
+        metadata_cid = storage_result.get("metadata_cid", "unknown")
+
+        # If publish flag is set, publish to the global IPFS network
+        if publish:
+            if metadata_cid != "unknown":
+                print("\nPublishing to global IPFS network...")
+                try:
+                    # Publish the metadata to the global IPFS network
+                    publish_result = await client.ipfs_client.publish_global(
+                        metadata_cid
+                    )
+                    if publish_result.get("published", False):
+                        print("Successfully published to global IPFS network")
+                        print(f"Access URL: https://ipfs.io/ipfs/{metadata_cid}")
+                    else:
+                        print(
+                            f"Warning: {publish_result.get('message', 'Failed to publish to global network')}"
+                        )
+                except Exception as e:
+                    print(f"Warning: Failed to publish to global IPFS network: {e}")
+
         elapsed_time = time.time() - start_time
 
         print(f"\nErasure coding and storage completed in {elapsed_time:.2f} seconds!")
 
         # Display metadata
-        metadata = result.get("metadata", {})
-        metadata_cid = result.get("metadata_cid", "unknown")
-        total_files_stored = result.get("total_files_stored", 0)
+        metadata = storage_result.get("metadata", {})
+        total_files_stored = storage_result.get("total_files_stored", 0)
 
         original_file = metadata.get("original_file", {})
         erasure_coding = metadata.get("erasure_coding", {})
 
-        print("\nErasure Coding Summary:")
-        print(
-            f"  Original file: {original_file.get('name')} ({original_file.get('size', 0)/1024/1024:.2f} MB)"
-        )
-        print(f"  File ID: {erasure_coding.get('file_id')}")
-        print(f"  Parameters: k={erasure_coding.get('k')}, m={erasure_coding.get('m')}")
-        print(f"  Total chunks: {len(metadata.get('chunks', []))}")
-        print(f"  Total files stored in marketplace: {total_files_stored}")
-        print(f"  Metadata CID: {metadata_cid}")
+        # If metadata_cid is known but metadata is empty, try to get file info from result directly
+        if metadata_cid != "unknown" and not original_file:
+            file_name = os.path.basename(file_path)
+            file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
+
+            # Use direct values from input parameters when metadata is not available
+            print("\nErasure Coding Summary:")
+            print(f"  Original file: {file_name} ({file_size/1024/1024:.2f} MB)")
+            print(f"  Parameters: k={k}, m={m}")
+            print(f"  Total files stored in marketplace: {total_files_stored}")
+            print(f"  Metadata CID: {metadata_cid}")
+
+            # Add publish status if applicable
+            if publish:
+                print(f"  Published to global IPFS: Yes")
+                print(f"  Global access URL: https://ipfs.io/ipfs/{metadata_cid}")
+        else:
+            print("\nErasure Coding Summary:")
+            print(
+                f"  Original file: {original_file.get('name')} ({original_file.get('size', 0)/1024/1024:.2f} MB)"
+            )
+            print(f"  File ID: {erasure_coding.get('file_id')}")
+            print(
+                f"  Parameters: k={erasure_coding.get('k')}, m={erasure_coding.get('m')}"
+            )
+            print(f"  Total chunks: {len(metadata.get('chunks', []))}")
+            print(f"  Total files stored in marketplace: {total_files_stored}")
+            print(f"  Metadata CID: {metadata_cid}")
+
+            # Add publish status if applicable
+            if publish:
+                print(f"  Published to global IPFS: Yes")
+                print(f"  Global access URL: https://ipfs.io/ipfs/{metadata_cid}")
 
         # If we stored in the marketplace
         if "transaction_hash" in result:
@@ -923,9 +989,13 @@ 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:")
-        print(
-            f"  hippius reconstruct {metadata_cid} reconstructed_{original_file.get('name')}"
-        )
+
+        # Get file name, either from metadata or directly from file path
+        output_filename = original_file.get("name")
+        if not output_filename:
+            output_filename = os.path.basename(file_path)
+
+        print(f"  hippius reconstruct {metadata_cid} reconstructed_{output_filename}")
 
         return 0
 
@@ -945,8 +1015,16 @@ def handle_erasure_code(
         return 1
 
 
-def handle_erasure_code_directory(
-    client, dir_path, k, m, chunk_size, miner_ids, encrypt=None, verbose=True
+async def handle_erasure_code_directory(
+    client,
+    dir_path,
+    k,
+    m,
+    chunk_size,
+    miner_ids,
+    encrypt=None,
+    publish=False,
+    verbose=True,
 ):
     """Apply erasure coding to each file in a directory individually"""
     if not os.path.isdir(dir_path):
@@ -1025,7 +1103,7 @@ def handle_erasure_code_directory(
 
         try:
             # Use the store_erasure_coded_file method directly from HippiusClient
-            result = client.store_erasure_coded_file(
+            result = await client.store_erasure_coded_file(
                 file_path=file_path,
                 k=k,
                 m=m,
@@ -1036,16 +1114,38 @@ def handle_erasure_code_directory(
                 verbose=False,  # Less verbose for batch processing
             )
 
-            # Store basic result info
+            metadata_cid = result.get("metadata_cid", "unknown")
+            publishing_status = "Not published"
+
+            # If publish flag is set, publish to the global IPFS network
+            if publish and metadata_cid != "unknown":
+                try:
+                    # Publish the metadata to the global IPFS network
+                    publish_result = await client.ipfs_client.publish_global(
+                        metadata_cid
+                    )
+                    if publish_result.get("published", False):
+                        publishing_status = "Published to global IPFS"
+                    else:
+                        publishing_status = f"Failed to publish: {publish_result.get('message', 'Unknown error')}"
+                except Exception as e:
+                    publishing_status = f"Failed to publish: {str(e)}"
+
+            # Store basic result info with additional publish info
             results.append(
                 {
                     "file_path": file_path,
-                    "metadata_cid": result.get("metadata_cid", "unknown"),
+                    "metadata_cid": metadata_cid,
                     "success": True,
+                    "published": publish
+                    and publishing_status == "Published to global IPFS",
                 }
             )
 
-            print(f"Success! Metadata CID: {result.get('metadata_cid', 'unknown')}")
+            status_msg = f"Success! Metadata CID: {metadata_cid}"
+            if publish:
+                status_msg += f" ({publishing_status})"
+            print(status_msg)
             successful += 1
 
         except Exception as e:
@@ -1093,7 +1193,7 @@ def handle_erasure_code_directory(
     return 0 if failed == 0 else 1
 
 
-def handle_reconstruct(client, metadata_cid, output_file, verbose=True):
+async def handle_reconstruct(client, metadata_cid, output_file, verbose=True):
     """Handle the reconstruct command for erasure-coded files"""
     # Check if zfec is installed
     try:
@@ -1112,13 +1212,12 @@ def handle_reconstruct(client, metadata_cid, output_file, verbose=True):
 
     try:
         # Use the reconstruct_from_erasure_code method
-        result = client.reconstruct_from_erasure_code(
+        await client.reconstruct_from_erasure_code(
             metadata_cid=metadata_cid, output_file=output_file, verbose=verbose
         )
 
         elapsed_time = time.time() - start_time
         print(f"\nFile reconstruction completed in {elapsed_time:.2f} seconds!")
-        print(f"Reconstructed file saved to: {result}")
 
         return 0
 
@@ -1385,6 +1484,200 @@ def handle_seed_phrase_status(account_name=None):
     return 0
 
 
+def handle_account_create(client, name, encrypt=False):
+    """Handle creating a new account with a generated seed phrase"""
+    print(f"Creating new account '{name}'...")
+
+    # Get password if encryption is requested
+    password = None
+    if encrypt:
+        try:
+            password = getpass.getpass("Enter password to encrypt seed phrase: ")
+            password_confirm = getpass.getpass("Confirm password: ")
+
+            if password != password_confirm:
+                print("Error: Passwords do not match")
+                return 1
+        except KeyboardInterrupt:
+            print("\nOperation cancelled")
+            return 1
+
+    try:
+        # Create the account
+        result = client.substrate_client.create_account(
+            name, encode=encrypt, password=password
+        )
+
+        print(f"Account created successfully!")
+        print(f"Name: {result['name']}")
+        print(f"Address: {result['address']}")
+        print(f"Seed phrase: {result['mnemonic']}")
+        print()
+        print(
+            "IMPORTANT: Please write down your seed phrase and store it in a safe place."
+        )
+        print(
+            "It is the only way to recover your account if you lose access to this configuration."
+        )
+
+        return 0
+    except Exception as e:
+        print(f"Error creating account: {e}")
+        return 1
+
+
+def handle_account_export(client, name=None, file_path=None):
+    """Handle exporting an account to a file"""
+    try:
+        # Export the account
+        exported_file = client.substrate_client.export_account(
+            account_name=name, file_path=file_path
+        )
+
+        print(f"Account exported successfully to: {exported_file}")
+        print("The exported file contains your seed phrase in plain text.")
+        print("Please keep this file secure and do not share it with anyone.")
+
+        return 0
+    except Exception as e:
+        print(f"Error exporting account: {e}")
+        return 1
+
+
+def handle_account_import(client, file_path, encrypt=False):
+    """Handle importing an account from a file"""
+    # Get password if encryption is requested
+    password = None
+    if encrypt:
+        try:
+            password = getpass.getpass("Enter password to encrypt seed phrase: ")
+            password_confirm = getpass.getpass("Confirm password: ")
+
+            if password != password_confirm:
+                print("Error: Passwords do not match")
+                return 1
+        except KeyboardInterrupt:
+            print("\nOperation cancelled")
+            return 1
+
+    try:
+        # Import the account
+        result = client.substrate_client.import_account(
+            file_path, password=password if encrypt else None
+        )
+
+        print(f"Account imported successfully!")
+        print(f"Name: {result['name']}")
+        print(f"Address: {result['address']}")
+
+        if (
+            result.get("original_name")
+            and result.get("original_name") != result["name"]
+        ):
+            print(
+                f"Note: Original name '{result['original_name']}' was already in use, renamed to '{result['name']}'"
+            )
+
+        return 0
+    except Exception as e:
+        print(f"Error importing account: {e}")
+        return 1
+
+
+async def handle_account_info(client, account_name=None, include_history=False):
+    """Handle showing account information"""
+    try:
+        # Get account info - properly await the async method
+        info = await client.substrate_client.get_account_info(
+            account_name, include_history=include_history
+        )
+
+        active_marker = " (active)" if info.get("is_active", False) else ""
+        encoded_status = (
+            "encrypted" if info.get("seed_phrase_encrypted", False) else "plain text"
+        )
+
+        print(f"Account: {info['name']}{active_marker}")
+        print(f"Address: {info['address']}")
+        print(f"Seed phrase: {encoded_status}")
+
+        # Show storage statistics if available
+        if "storage_stats" in info:
+            stats = info["storage_stats"]
+            if "error" in stats:
+                print(f"Storage stats: Error - {stats['error']}")
+            else:
+                print(f"Files stored: {stats['files']}")
+                print(f"Total storage: {stats['size_formatted']}")
+
+        # Show balance if available
+        if "balance" in info:
+            balance = info["balance"]
+            print("\nAccount Balance:")
+            print(f"  Free:     {balance['free']:.6f}")
+            print(f"  Reserved: {balance['reserved']:.6f}")
+            print(f"  Total:    {balance['total']:.6f}")
+
+        # Show free credits if available
+        if "free_credits" in info:
+            print(f"Free credits: {info['free_credits']:.6f}")
+
+        # Show file list if requested and available
+        if include_history and "files" in info and info["files"]:
+            print(f"\nStored Files ({len(info['files'])}):")
+            for i, file in enumerate(info["files"], 1):
+                print(f"  {i}. {file.get('file_name', 'Unnamed')}")
+                print(f"     CID: {file.get('file_hash', 'Unknown')}")
+                print(f"     Size: {file.get('size_formatted', 'Unknown')}")
+
+        return 0
+    except Exception as e:
+        print(f"Error retrieving account info: {e}")
+        return 1
+
+
+async def handle_account_balance(client, account_name=None, watch=False, interval=5):
+    """Handle checking or watching account balance"""
+    try:
+        # Get the account address
+        if account_name:
+            address = get_account_address(account_name)
+            if not address:
+                print(f"Error: Could not find address for account '{account_name}'")
+                return 1
+        else:
+            if client.substrate_client._account_address:
+                address = client.substrate_client._account_address
+            else:
+                print("Error: No account address available")
+                return 1
+
+        if watch:
+            # Watch mode - continuous updates
+            # Note: watch_account_balance may need to be modified to be async-compatible
+            await client.substrate_client.watch_account_balance(address, interval)
+        else:
+            # One-time check
+            balance = await client.substrate_client.get_account_balance(address)
+
+            print(f"Account Balance for: {address}")
+            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 raw values
+            print("\nRaw Values:")
+            print(f"Free:     {balance['raw']['free']:,}")
+            print(f"Reserved: {balance['raw']['reserved']:,}")
+            print(f"Frozen:   {balance['raw']['frozen']:,}")
+
+        return 0
+    except Exception as e:
+        print(f"Error checking account balance: {e}")
+        return 1
+
+
 def handle_account_list():
     """Handle listing all accounts"""
     accounts = list_accounts()
@@ -1500,6 +1793,261 @@ def handle_default_address_clear():
     return 0
 
 
+async def handle_pinning_status(
+    client, account_address, verbose=False, show_contents=True
+):
+    """Handle the pinning-status command"""
+    print("Checking file pinning status...")
+    try:
+        # Get the account address we're querying
+        if account_address is None:
+            # If no address provided, first try to get from keypair (if available)
+            if (
+                hasattr(client.substrate_client, "_keypair")
+                and client.substrate_client._keypair is not None
+            ):
+                account_address = client.substrate_client._keypair.ss58_address
+            else:
+                # Try to get the default address
+                default_address = get_default_address()
+                if default_address:
+                    account_address = default_address
+                else:
+                    has_default = get_default_address() is not None
+                    print(
+                        "Error: No account address provided, and client has no keypair."
+                    )
+                    if has_default:
+                        print(
+                            "Please provide an account address with '--account_address' or the default address may be invalid."
+                        )
+                    else:
+                        print(
+                            "Please provide an account address with '--account_address' or set a default with:"
+                        )
+                        print("  hippius address set-default <your_account_address>")
+                    return 1
+
+        storage_requests = client.substrate_client.get_pinning_status(account_address)
+
+        # Check if any storage requests were found
+        if not storage_requests:
+            print(f"No pinning requests found for account: {account_address}")
+            return 0
+
+        print(
+            f"\nFound {len(storage_requests)} pinning requests for account: {account_address}"
+        )
+        print("-" * 80)
+
+        # Format and display each storage request
+        for i, request in enumerate(storage_requests, 1):
+            try:
+                print(f"Request {i}:")
+
+                # Display CID if available
+                cid = None
+                if "cid" in request:
+                    cid = request.get("cid", "Unknown")
+                    print(f"  CID: {cid}")
+
+                # Display file name if available
+                if "file_name" in request:
+                    file_name = request.get("file_name", "Unknown")
+                    print(f"  File name: {file_name}")
+                elif "raw_value" in request and "file_name" in request["raw_value"]:
+                    # Try to extract from raw value if it's available
+                    try:
+                        raw_value = request["raw_value"]
+                        if isinstance(raw_value, str) and "{" in raw_value:
+                            # It's a string representation of a dict, try to extract the file_name
+                            if "'file_name': " in raw_value:
+                                start_idx = raw_value.find("'file_name': '") + len(
+                                    "'file_name': '"
+                                )
+                                end_idx = raw_value.find("'", start_idx)
+                                if start_idx > 0 and end_idx > start_idx:
+                                    file_name = raw_value[start_idx:end_idx]
+                                    print(f"  File name: {file_name}")
+                    except Exception:
+                        pass
+
+                # Display total replicas if available
+                if "total_replicas" in request:
+                    total_replicas = request.get("total_replicas", 0)
+                    print(f"  Total replicas: {total_replicas}")
+
+                # Display owner if available
+                if "owner" in request:
+                    owner = request.get("owner", "Unknown")
+                    print(f"  Owner: {owner}")
+
+                # Display timestamps if available
+                if "created_at" in request:
+                    created_at = request.get("created_at", 0)
+                    if created_at > 0:
+                        print(f"  Created at block: {created_at}")
+
+                if "last_charged_at" in request:
+                    last_charged_at = request.get("last_charged_at", 0)
+                    if last_charged_at > 0:
+                        print(f"  Last charged at block: {last_charged_at}")
+
+                # Display assignment status and progress info
+                status_text = "Awaiting validator"
+                if "is_assigned" in request:
+                    is_assigned = request.get("is_assigned", False)
+                    if is_assigned:
+                        status_text = "Assigned to miners"
+
+                # Enhanced status info
+                if "miner_ids" in request and "total_replicas" in request:
+                    miner_ids = request.get("miner_ids", [])
+                    total_replicas = request.get("total_replicas", 0)
+
+                    if len(miner_ids) > 0:
+                        if len(miner_ids) == total_replicas:
+                            status_text = "Fully pinned"
+                        else:
+                            status_text = "Partially pinned"
+
+                print(f"  Status: {status_text}")
+
+                # Display validator if available
+                if "selected_validator" in request:
+                    validator = request.get("selected_validator", "")
+                    if validator:
+                        print(f"  Selected validator: {validator}")
+
+                # Display miners if available
+                if "miner_ids" in request:
+                    miner_ids = request.get("miner_ids", [])
+                    if miner_ids:
+                        print(f"  Assigned miners: {len(miner_ids)}")
+                        for miner in miner_ids[:3]:  # Show first 3 miners
+                            print(f"    - {miner}")
+                        if len(miner_ids) > 3:
+                            print(f"    ... and {len(miner_ids) - 3} more")
+                    else:
+                        print(f"  Assigned miners: None")
+
+                    # Calculate pinning percentage if we have total_replicas
+                    if "total_replicas" in request and request["total_replicas"] > 0:
+                        total_replicas = request["total_replicas"]
+                        pinning_pct = (len(miner_ids) / total_replicas) * 100
+                        print(
+                            f"  Pinning progress: {pinning_pct:.1f}% ({len(miner_ids)}/{total_replicas} miners)"
+                        )
+
+                # Display raw data for debugging
+                if verbose:
+                    print("  Raw data:")
+                    if "raw_key" in request:
+                        print(f"    Key: {request['raw_key']}")
+                    if "raw_value" in request:
+                        print(f"    Value: {request['raw_value']}")
+
+                # Try to fetch the content and determine if it's a file list by inspecting its contents
+                if show_contents and cid:
+                    try:
+                        print("\n  Fetching contents from IPFS...")
+                        # Fetch the contents from IPFS
+                        file_data = await client.ipfs_client.cat(cid)
+
+                        if file_data and file_data.get("is_text", False):
+                            try:
+                                # Try to parse as JSON
+                                content_json = json.loads(
+                                    file_data.get("content", "{}")
+                                )
+
+                                # Detect if this is a file list by checking if it's a list of file objects
+                                is_file_list = False
+                                if (
+                                    isinstance(content_json, list)
+                                    and len(content_json) > 0
+                                ):
+                                    # Check if it looks like a file list
+                                    sample_item = content_json[0]
+                                    if isinstance(sample_item, dict) and (
+                                        "cid" in sample_item
+                                        or "fileHash" in sample_item
+                                        or "filename" in sample_item
+                                        or "fileName" in sample_item
+                                    ):
+                                        is_file_list = True
+
+                                if is_file_list:
+                                    # It's a file list - display the files
+                                    print(
+                                        f"  Content is a file list with {len(content_json)} files:"
+                                    )
+                                    print("  " + "-" * 40)
+                                    for j, file_info in enumerate(content_json, 1):
+                                        filename = file_info.get(
+                                            "filename"
+                                        ) or file_info.get("fileName", "Unknown")
+                                        file_cid = file_info.get(
+                                            "cid"
+                                        ) or file_info.get("fileHash", "Unknown")
+                                        print(f"    File {j}: {filename}")
+                                        print(f"    CID: {file_cid}")
+
+                                        # Show size if available
+                                        if "size" in file_info:
+                                            size = file_info["size"]
+                                            size_formatted = (
+                                                client.format_size(size)
+                                                if hasattr(client, "format_size")
+                                                else f"{size} bytes"
+                                            )
+                                            print(f"    Size: {size_formatted}")
+
+                                        print("  " + "-" * 40)
+                                else:
+                                    # Not a file list, show a compact summary
+                                    content_type = type(content_json).__name__
+                                    preview = str(content_json)
+                                    if len(preview) > 100:
+                                        preview = preview[:100] + "..."
+                                    print(f"  Content type: JSON {content_type}")
+                                    print(f"  Content preview: {preview}")
+                            except json.JSONDecodeError:
+                                # Not JSON, just show text preview
+                                content = file_data.get("content", "")
+                                preview = (
+                                    content[:100] + "..."
+                                    if len(content) > 100
+                                    else content
+                                )
+                                print(f"  Content type: Text")
+                                print(f"  Content preview: {preview}")
+                        else:
+                            # Binary data
+                            content_size = len(file_data.get("content", b""))
+                            size_formatted = (
+                                client.format_size(content_size)
+                                if hasattr(client, "format_size")
+                                else f"{content_size} bytes"
+                            )
+                            print(f"  Content type: Binary data")
+                            print(f"  Content size: {size_formatted}")
+                    except Exception as e:
+                        print(f"  Error fetching file list contents: {e}")
+
+                print("-" * 80)
+            except Exception as e:
+                print(f"  Error displaying request {i}: {e}")
+                print("-" * 80)
+                continue
+
+    except Exception as e:
+        print(f"Error retrieving pinning status: {e}")
+        return 1
+
+    return 0
+
+
 def main():
     """Main CLI entry point for hippius command."""
     # Set up the argument parser
@@ -1532,9 +2080,15 @@ examples:
   # View all miners for stored files
   hippius files --all-miners
   
+  # Check file pinning status
+  hippius pinning-status
+  
   # Erasure code a file (Reed-Solomon)
   hippius erasure-code large_file.mp4 --k 3 --m 5
   
+  # Erasure code and publish to global IPFS network
+  hippius erasure-code large_file.avi --publish
+  
   # Reconstruct an erasure-coded file
   hippius reconstruct QmMetadataHash reconstructed_file.mp4
 """,
@@ -1678,6 +2232,32 @@ examples:
         )
     )
 
+    # Pinning status command
+    pinning_status_parser = subparsers.add_parser(
+        "pinning-status", help="Check the status of file pinning requests"
+    )
+    pinning_status_parser.add_argument(
+        "--account_address",
+        help="Substrate account to check pinning status for (defaults to your keyfile account)",
+    )
+    pinning_status_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed debug information",
+    )
+    pinning_status_parser.add_argument(
+        "--show-contents",
+        action="store_true",
+        default=True,
+        help="Show the contents of file lists (defaults to true)",
+    )
+    pinning_status_parser.add_argument(
+        "--no-contents",
+        action="store_true",
+        help="Don't show the contents of file lists",
+    )
+
     # Erasure Coded Files command
     ec_files_parser = subparsers.add_parser(
         "ec-files", help="View erasure-coded files stored by you or another account"
@@ -1712,6 +2292,9 @@ examples:
     keygen_parser.add_argument(
         "--copy", action="store_true", help="Copy the generated key to the clipboard"
     )
+    keygen_parser.add_argument(
+        "--save", action="store_true", help="Save the key to the Hippius configuration"
+    )
 
     # Erasure code command
     erasure_code_parser = subparsers.add_parser(
@@ -1742,6 +2325,11 @@ examples:
     erasure_code_parser.add_argument(
         "--no-encrypt", action="store_true", help="Do not encrypt the file"
     )
+    erasure_code_parser.add_argument(
+        "--publish",
+        action="store_true",
+        help="Upload and publish the erasure-coded file to the global IPFS network",
+    )
     erasure_code_parser.add_argument(
         "--verbose", action="store_true", help="Enable verbose output", default=True
     )
@@ -1849,6 +2437,77 @@ examples:
     # List accounts
     account_subparsers.add_parser("list", help="List all accounts")
 
+    # Create account
+    create_account_parser = account_subparsers.add_parser(
+        "create", help="Create a new account with a generated seed phrase"
+    )
+    create_account_parser.add_argument(
+        "--name", required=True, help="Name for the new account"
+    )
+    create_account_parser.add_argument(
+        "--encrypt", action="store_true", help="Encrypt the seed phrase with a password"
+    )
+
+    # Export account
+    export_account_parser = account_subparsers.add_parser(
+        "export", help="Export an account to a file"
+    )
+    export_account_parser.add_argument(
+        "--name",
+        help="Name of the account to export (uses active account if not specified)",
+    )
+    export_account_parser.add_argument(
+        "--file",
+        help="Path to save the exported account file (auto-generated if not specified)",
+    )
+
+    # Import account
+    import_account_parser = account_subparsers.add_parser(
+        "import", help="Import an account from a file"
+    )
+    import_account_parser.add_argument(
+        "--file", required=True, help="Path to the account file to import"
+    )
+    import_account_parser.add_argument(
+        "--encrypt",
+        action="store_true",
+        help="Encrypt the imported seed phrase with a password",
+    )
+
+    # Account info
+    info_account_parser = account_subparsers.add_parser(
+        "info", help="Display detailed information about an account"
+    )
+    info_account_parser.add_argument(
+        "account_name",
+        nargs="?",
+        help="Name of the account to show (uses active account if not specified)",
+    )
+    info_account_parser.add_argument(
+        "--history", action="store_true", help="Include usage history in the output"
+    )
+
+    # Account balance
+    balance_account_parser = account_subparsers.add_parser(
+        "balance", help="Check account balance"
+    )
+    balance_account_parser.add_argument(
+        "account_name",
+        nargs="?",
+        help="Name of the account to check (uses active account if not specified)",
+    )
+    balance_account_parser.add_argument(
+        "--watch",
+        action="store_true",
+        help="Watch account balance in real-time until Ctrl+C is pressed",
+    )
+    balance_account_parser.add_argument(
+        "--interval",
+        type=int,
+        default=5,
+        help="Update interval in seconds for watch mode (default: 5)",
+    )
+
     # Switch active account
     switch_account_parser = account_subparsers.add_parser(
         "switch", help="Switch to a different account"
@@ -1897,16 +2556,6 @@ examples:
         parser.print_help()
         return 1
 
-    # Special case for keygen which doesn't need client initialization
-    if args.command == "keygen":
-        # Handle key generation separately
-        if args.copy:
-            return key_generation_cli()
-        else:
-            # Create a new argparse namespace with just the copy flag for compatibility
-            keygen_args = argparse.Namespace(copy=False)
-            return key_generation_cli()
-
     try:
         # Parse miner IDs if provided
         miner_ids = None
@@ -1957,27 +2606,47 @@ examples:
             encryption_key=encryption_key,
         )
 
-        # Handle commands
+        # Handle commands - separate async and sync handlers
+        # Create a helper function to handle async handlers
+        def run_async_handler(handler_func, *args, **kwargs):
+            # Check if the handler is async
+            if inspect.iscoroutinefunction(handler_func):
+                # Run the async handler in the event loop
+                return asyncio.run(handler_func(*args, **kwargs))
+            else:
+                # Run the handler directly
+                return handler_func(*args, **kwargs)
+
+        # Handle commands with the helper function
         if args.command == "download":
-            return handle_download(client, args.cid, args.output_path, decrypt=decrypt)
+            return run_async_handler(
+                handle_download, client, args.cid, args.output_path, decrypt=decrypt
+            )
 
         elif args.command == "exists":
-            return handle_exists(client, args.cid)
+            return run_async_handler(handle_exists, client, args.cid)
 
         elif args.command == "cat":
-            return handle_cat(client, args.cid, args.max_size, decrypt=decrypt)
+            return run_async_handler(
+                handle_cat, client, args.cid, args.max_size, decrypt=decrypt
+            )
 
         elif args.command == "store":
-            return handle_store(client, args.file_path, miner_ids, encrypt=encrypt)
+            return run_async_handler(
+                handle_store, client, args.file_path, miner_ids, encrypt=encrypt
+            )
 
         elif args.command == "store-dir":
-            return handle_store_dir(client, args.dir_path, miner_ids, encrypt=encrypt)
+            return run_async_handler(
+                handle_store_dir, client, args.dir_path, miner_ids, encrypt=encrypt
+            )
 
         elif args.command == "credits":
-            return handle_credits(client, args.account_address)
+            return run_async_handler(handle_credits, client, args.account_address)
 
         elif args.command == "files":
-            return handle_files(
+            return run_async_handler(
+                handle_files,
                 client,
                 args.account_address,
                 show_all_miners=(
@@ -1985,8 +2654,21 @@ examples:
                 ),
             )
 
+        elif args.command == "pinning-status":
+            show_contents = (
+                not args.no_contents if hasattr(args, "no_contents") else True
+            )
+            return run_async_handler(
+                handle_pinning_status,
+                client,
+                args.account_address,
+                verbose=args.verbose,
+                show_contents=show_contents,
+            )
+
         elif args.command == "ec-files":
-            return handle_ec_files(
+            return run_async_handler(
+                handle_ec_files,
                 client,
                 args.account_address,
                 show_all_miners=(
@@ -1996,7 +2678,8 @@ examples:
             )
 
         elif args.command == "erasure-code":
-            return handle_erasure_code(
+            return run_async_handler(
+                handle_erasure_code,
                 client,
                 args.file_path,
                 args.k,
@@ -2004,14 +2687,34 @@ examples:
                 args.chunk_size,
                 miner_ids,
                 encrypt=args.encrypt,
+                publish=args.publish,
                 verbose=args.verbose,
             )
 
         elif args.command == "reconstruct":
-            return handle_reconstruct(
-                client, args.metadata_cid, args.output_file, verbose=args.verbose
+            return run_async_handler(
+                handle_reconstruct,
+                client,
+                args.metadata_cid,
+                args.output_file,
+                verbose=args.verbose,
             )
 
+        elif args.command == "keygen":
+            # Generate and save an encryption key
+            client = HippiusClient()
+            encryption_key = client.generate_encryption_key()
+            print(f"Generated encryption key: {encryption_key}")
+
+            # Save to config if requested
+            if hasattr(args, "save") and args.save:
+                print("Saving encryption key to configuration...")
+                handle_config_set("encryption", "encryption_key", encryption_key)
+                print(
+                    "Encryption key saved. Files will not be automatically encrypted unless you set encryption.encrypt_by_default to true"
+                )
+            return 0
+
         elif args.command == "config":
             if args.config_action == "get":
                 return handle_config_get(args.section, args.key)
@@ -2048,6 +2751,24 @@ examples:
         elif args.command == "account":
             if args.account_action == "list":
                 return handle_account_list()
+            elif args.account_action == "create":
+                return handle_account_create(client, args.name, args.encrypt)
+            elif args.account_action == "export":
+                return handle_account_export(client, args.name, args.file)
+            elif args.account_action == "import":
+                return handle_account_import(client, args.file, args.encrypt)
+            elif args.account_action == "info":
+                return run_async_handler(
+                    handle_account_info, client, args.account_name, args.history
+                )
+            elif args.account_action == "balance":
+                return run_async_handler(
+                    handle_account_balance,
+                    client,
+                    args.account_name,
+                    args.watch,
+                    args.interval,
+                )
             elif args.account_action == "switch":
                 return handle_account_switch(args.account_name)
             elif args.account_action == "delete":