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

{hippius-0.2.0.dist-info → hippius-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python SDK and CLI for Hippius blockchain storage
 Home-page: https://github.com/thenervelab/hippius-sdk
 Author: Dubs
@@ -18,6 +18,7 @@ Provides-Extra: clipboard
 Requires-Dist: base58 (>=2.1.1,<3.0.0)
 Requires-Dist: cryptography (>=44.0.0,<45.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: mnemonic (>=0.20,<0.21)
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: pynacl (>=1.5.0,<2.0.0)
 Requires-Dist: pyperclip (>=1.8.2,<2.0.0) ; extra == "clipboard"

hippius-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+hippius_sdk/__init__.py,sha256=-AyvKNLGenve9LKTus1qhOVFFkydlQceUaHr3fNimqQ,1391
+hippius_sdk/cli.py,sha256=rG57m5RU35GiB7pNnZzlrSouyqxiALg2ZgAKcouKBHA,103880
+hippius_sdk/client.py,sha256=mMKX_m2ZwfbGVAU3zasHZQF0ddToqypkxGKTylruB3Y,14901
+hippius_sdk/config.py,sha256=WqocYwx-UomLeZ-iFUNDjg9vRcagOBA1Th68XELbuTs,22950
+hippius_sdk/ipfs.py,sha256=oW3zX2rfdUWBQnh3oxdykrixbOxrB2_DJxRbXOo1v4w,54319
+hippius_sdk/ipfs_core.py,sha256=w6ljgFdUzL-ffKxr4x_W-aYZTNpgyJg5HOFDrLKPILA,6690
+hippius_sdk/substrate.py,sha256=9SkjIkMClkyE004H855C4t2VoJr6ypi87r6geBFEFeA,60091
+hippius_sdk/utils.py,sha256=-N0w0RfXhwxJgSkSroxqFMw-0zJQXvcmxM0OS5UtWEY,4145
+hippius-0.2.1.dist-info/METADATA,sha256=GzaP86Ps_TkJWrh55320bESjK1tdEpRvuFBAfFF_z4g,28032
+hippius-0.2.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+hippius-0.2.1.dist-info/entry_points.txt,sha256=b1lo60zRXmv1ud-c5BC-cJcAfGE5FD4qM_nia6XeQtM,98
+hippius-0.2.1.dist-info/RECORD,,

hippius_sdk/__init__.py

@@ -26,7 +26,7 @@ from hippius_sdk.config import (
 from hippius_sdk.ipfs import IPFSClient
 from hippius_sdk.utils import format_cid, format_size, hex_to_ipfs_cid
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

hippius_sdk/cli.py

@@ -14,12 +14,8 @@ 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
 
@@ -33,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,
@@ -42,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
@@ -55,10 +48,7 @@ except ImportError:
 else:
     ENCRYPTION_AVAILABLE = True
 
-# Load environment variables
 load_dotenv()
-
-# Initialize configuration from environment variables
 initialize_from_env()
 
 
@@ -414,7 +404,7 @@ async 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:
@@ -450,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
@@ -793,7 +783,15 @@ async def handle_ec_files(
 
 
 async def handle_erasure_code(
-    client, file_path, k, m, chunk_size, miner_ids, encrypt=None, verbose=True
+    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):
@@ -823,7 +821,6 @@ async 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
 
@@ -835,7 +832,15 @@ async def handle_erasure_code(
 
             if choice in ("y", "yes"):
                 return await handle_erasure_code_directory(
-                    client, file_path, k, m, chunk_size, miner_ids, encrypt, verbose
+                    client,
+                    file_path,
+                    k,
+                    m,
+                    chunk_size,
+                    miner_ids,
+                    encrypt,
+                    publish,
+                    verbose,
                 )
         else:
             print(f"   No files found in directory {file_path}")
@@ -865,11 +870,6 @@ async 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)
 
@@ -878,7 +878,7 @@ async 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"
         )
@@ -910,27 +910,73 @@ async 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:
@@ -943,9 +989,13 @@ async 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
 
@@ -966,7 +1016,15 @@ async def handle_erasure_code(
 
 
 async def handle_erasure_code_directory(
-    client, dir_path, k, m, chunk_size, miner_ids, encrypt=None, verbose=True
+    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):
@@ -1056,16 +1114,38 @@ async 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:
@@ -1132,13 +1212,12 @@ async def handle_reconstruct(client, metadata_cid, output_file, verbose=True):
 
     try:
         # Use the reconstruct_from_erasure_code method
-        result = await 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
 
@@ -1405,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()
@@ -1813,6 +2086,9 @@ examples:
   # 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
 """,
@@ -2049,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
     )
@@ -2156,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"
@@ -2290,7 +2642,7 @@ examples:
             )
 
         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 run_async_handler(
@@ -2335,6 +2687,7 @@ examples:
                 args.chunk_size,
                 miner_ids,
                 encrypt=args.encrypt,
+                publish=args.publish,
                 verbose=args.verbose,
             )
 
@@ -2398,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":