hippius 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

hippius_sdk/cli_parser.py

@@ -520,6 +520,11 @@ def add_account_commands(subparsers):
         help="Account name to show info for (uses active account if not specified)",
     )
 
+    # Account login
+    login_account_parser = account_subparsers.add_parser(
+        "login", help="Login with an account address and seed phrase"
+    )
+
     # Account balance
     balance_account_parser = account_subparsers.add_parser(
         "balance", help="Check account balance"

hippius_sdk/cli_rich.py

@@ -6,14 +6,8 @@ from typing import Any, Dict, List, Optional, Union
 
 from rich.console import Console
 from rich.panel import Panel
-from rich.progress import (
-    BarColumn,
-    Progress,
-    SpinnerColumn,
-    TextColumn,
-    TimeElapsedColumn,
-    TimeRemainingColumn,
-)
+from rich.progress import (BarColumn, Progress, SpinnerColumn, TextColumn,
+                           TimeElapsedColumn, TimeRemainingColumn)
 from rich.table import Table
 from rich.text import Text
 

hippius_sdk/client.py

@@ -64,8 +64,8 @@ class HippiusClient:
                 "substrate", "url", "wss://rpc.hippius.network"
             )
 
-        if substrate_seed_phrase is None:
-            substrate_seed_phrase = get_config_value("substrate", "seed_phrase")
+        # Don't try to get a seed phrase from the legacy location
+        # The substrate_client will handle getting it from the active account
 
         if encrypt_by_default is None:
             encrypt_by_default = get_config_value(
@@ -82,18 +82,13 @@ class HippiusClient:
             encrypt_by_default=encrypt_by_default,
             encryption_key=encryption_key,
         )
-
         # Initialize Substrate client
-        try:
-            self.substrate_client = SubstrateClient(
-                url=substrate_url,
-                seed_phrase=substrate_seed_phrase,
-                password=seed_phrase_password,
-                account_name=account_name,
-            )
-        except Exception as e:
-            print(f"Warning: Could not initialize Substrate client: {e}")
-            self.substrate_client = None
+        self.substrate_client = SubstrateClient(
+            url=substrate_url,
+            seed_phrase=substrate_seed_phrase,
+            password=seed_phrase_password,
+            account_name=account_name,
+        )
 
     async def upload_file(
         self, file_path: str, encrypt: Optional[bool] = None
@@ -375,6 +370,7 @@ class HippiusClient:
         max_retries: int = 3,
         verbose: bool = True,
         progress_callback: Optional[Callable[[str, int, int], None]] = None,
+        publish: bool = True,
     ) -> Dict[str, Any]:
         """
         Erasure code a file, upload the chunks to IPFS, and store in the Hippius marketplace.
@@ -392,9 +388,12 @@ class HippiusClient:
             verbose: Whether to print progress information
             progress_callback: Optional callback function for progress updates
                             Function receives (stage_name, current, total)
+            publish: Whether to publish to the blockchain (True) or just perform local
+                    erasure coding without publishing (False). When False, no password
+                    is needed for seed phrase access.
 
         Returns:
-            dict: Result including metadata CID and transaction hash
+            dict: Result including metadata CID and transaction hash (if published)
 
         Raises:
             ValueError: If parameters are invalid
@@ -411,6 +410,7 @@ class HippiusClient:
             max_retries=max_retries,
             verbose=verbose,
             progress_callback=progress_callback,
+            publish=publish,
         )
 
     async def delete_file(

hippius_sdk/config.py

@@ -278,34 +278,30 @@ def decrypt_with_password(encrypted_data: str, salt: str, password: str) -> str:
     Returns:
         str: Decrypted data
     """
-    try:
-        # Decode the encrypted data and salt
-        encrypted_bytes = base64.b64decode(encrypted_data)
-        salt_bytes = base64.b64decode(salt)
+    # Decode the encrypted data and salt
+    encrypted_bytes = base64.b64decode(encrypted_data)
+    salt_bytes = base64.b64decode(salt)
 
-        # Derive the key from the password and salt
-        key, _ = _derive_key_from_password(password, salt_bytes)
+    # Derive the key from the password and salt
+    key, _ = _derive_key_from_password(password, salt_bytes)
 
-        # Verify NaCl is available (imported at the top)
-        try:
-            if not hasattr(nacl, "secret") or not hasattr(nacl, "utils"):
-                raise ImportError("NaCl modules not available")
-        except ImportError:
-            raise ValueError(
-                "PyNaCl is required for decryption. Install it with: pip install pynacl"
-            )
-
-        # Create a SecretBox with our derived key
-        box = nacl.secret.SecretBox(key)
+    # Verify NaCl is available (imported at the top)
+    try:
+        if not hasattr(nacl, "secret") or not hasattr(nacl, "utils"):
+            raise ImportError("NaCl modules not available")
+    except ImportError:
+        raise ValueError(
+            "PyNaCl is required for decryption. Install it with: pip install pynacl"
+        )
 
-        # Decrypt the data
-        decrypted_data = box.decrypt(encrypted_bytes)
+    # Create a SecretBox with our derived key
+    box = nacl.secret.SecretBox(key)
 
-        # Return the decrypted string
-        return decrypted_data.decode("utf-8")
+    # Decrypt the data
+    decrypted_data = box.decrypt(encrypted_bytes)
 
-    except Exception as e:
-        raise ValueError(f"Error decrypting data with password: {e}")
+    # Return the decrypted string
+    return decrypted_data.decode("utf-8")
 
 
 def encrypt_seed_phrase(
@@ -317,7 +313,7 @@ def encrypt_seed_phrase(
     Args:
         seed_phrase: The plain text seed phrase to encrypt
         password: Optional password (if None, will prompt)
-        account_name: Optional name for the account (if None, uses legacy mode or active account)
+        account_name: Optional name for the account (if None, uses active account)
 
     Returns:
         bool: True if encryption and saving was successful, False otherwise
@@ -344,30 +340,31 @@ def encrypt_seed_phrase(
 
         config = load_config()
 
-        # Check if we're using the new multi-account system
-        if account_name is not None:
-            # Multi-account mode
-            if "accounts" not in config["substrate"]:
-                config["substrate"]["accounts"] = {}
-
-            # Store the account data
-            config["substrate"]["accounts"][account_name] = {
-                "seed_phrase": encrypted_data,
-                "seed_phrase_encoded": True,
-                "seed_phrase_salt": salt,
-                "ss58_address": ss58_address,
-            }
-
-            # Set as active account if no active account exists
-            if not config["substrate"].get("active_account"):
-                config["substrate"]["active_account"] = account_name
-
-        else:
-            # Legacy mode - single account
-            config["substrate"]["seed_phrase"] = encrypted_data
-            config["substrate"]["seed_phrase_encoded"] = True
-            config["substrate"]["seed_phrase_salt"] = salt
-            config["substrate"]["ss58_address"] = ss58_address
+        # Only use multi-account mode
+        # Use active account if no account specified
+        name_to_use = account_name
+        if name_to_use is None:
+            name_to_use = config["substrate"].get("active_account")
+            if not name_to_use:
+                # If no active account, we need a name
+                print("Error: No account name specified and no active account")
+                return False
+
+        # Ensure accounts structure exists
+        if "accounts" not in config["substrate"]:
+            config["substrate"]["accounts"] = {}
+
+        # Store the account data
+        config["substrate"]["accounts"][name_to_use] = {
+            "seed_phrase": encrypted_data,
+            "seed_phrase_encoded": True,
+            "seed_phrase_salt": salt,
+            "ss58_address": ss58_address,
+        }
+
+        # Set as active account if no active account exists
+        if not config["substrate"].get("active_account"):
+            config["substrate"]["active_account"] = name_to_use
 
         return save_config(config)
 
@@ -384,60 +381,43 @@ def decrypt_seed_phrase(
 
     Args:
         password: Optional password (if None, will prompt)
-        account_name: Optional account name (if None, uses active account or legacy mode)
+        account_name: Optional account name (if None, uses active account)
 
     Returns:
         Optional[str]: The decrypted seed phrase, or None if decryption failed
     """
-    try:
-        config = load_config()
-
-        # Determine if we're using multi-account mode
-        if account_name is not None or config["substrate"].get("active_account"):
-            # Multi-account mode
-            name_to_use = account_name or config["substrate"].get("active_account")
-
-            if not name_to_use:
-                print("Error: No account specified and no active account")
-                return None
-
-            if name_to_use not in config["substrate"].get("accounts", {}):
-                print(f"Error: Account '{name_to_use}' not found")
-                return None
-
-            account_data = config["substrate"]["accounts"][name_to_use]
-            is_encoded = account_data.get("seed_phrase_encoded", False)
+    config = load_config()
 
-            if not is_encoded:
-                return account_data.get("seed_phrase")
+    # Only use the multi-account system
+    name_to_use = account_name or config["substrate"].get("active_account")
 
-            encrypted_data = account_data.get("seed_phrase")
-            salt = account_data.get("seed_phrase_salt")
+    if not name_to_use:
+        print("Error: No account specified and no active account")
+        return None
 
-        else:
-            # Legacy mode - single account
-            is_encoded = config["substrate"].get("seed_phrase_encoded", False)
+    if name_to_use not in config["substrate"].get("accounts", {}):
+        print(f"Error: Account '{name_to_use}' not found")
+        return None
 
-            if not is_encoded:
-                return config["substrate"].get("seed_phrase")
+    account_data = config["substrate"]["accounts"][name_to_use]
+    is_encoded = account_data.get("seed_phrase_encoded", False)
 
-            encrypted_data = config["substrate"].get("seed_phrase")
-            salt = config["substrate"].get("seed_phrase_salt")
+    if not is_encoded:
+        return account_data.get("seed_phrase")
 
-        if not encrypted_data or not salt:
-            print("Error: No encrypted seed phrase found or missing salt")
-            return None
+    encrypted_data = account_data.get("seed_phrase")
+    salt = account_data.get("seed_phrase_salt")
 
-        # Get password from user if not provided
-        if password is None:
-            password = getpass.getpass("Enter password to decrypt seed phrase: ")
+    if not encrypted_data or not salt:
+        print("Error: No encrypted seed phrase found or missing salt")
+        return None
 
-        # Decrypt the seed phrase
-        return decrypt_with_password(encrypted_data, salt, password)
+    # Get password from user if not provided
+    if password is None:
+        password = getpass.getpass("Enter password to decrypt seed phrase: \n\n")
 
-    except Exception as e:
-        print(f"Error decrypting seed phrase: {e}")
-        return None
+    # Decrypt the seed phrase
+    return decrypt_with_password(encrypted_data, salt, password)
 
 
 def get_seed_phrase(
@@ -448,45 +428,31 @@ def get_seed_phrase(
 
     Args:
         password: Optional password for decryption (if None and needed, will prompt)
-        account_name: Optional account name (if None, uses active account or legacy mode)
+        account_name: Optional account name (if None, uses active account)
 
     Returns:
         Optional[str]: The seed phrase, or None if not available
     """
     config = load_config()
 
-    # Determine if we're using multi-account mode
-    if account_name is not None or config["substrate"].get("active_account"):
-        # Multi-account mode
-        name_to_use = account_name or config["substrate"].get("active_account")
+    # Only use the multi-account system
+    name_to_use = account_name or config["substrate"].get("active_account")
 
-        if not name_to_use:
-            print("Error: No account specified and no active account")
-            return None
-
-        if name_to_use not in config["substrate"].get("accounts", {}):
-            print(f"Error: Account '{name_to_use}' not found")
-            return None
+    if not name_to_use:
+        print("Error: No account specified and no active account")
+        return None
 
-        account_data = config["substrate"]["accounts"][name_to_use]
-        is_encoded = account_data.get("seed_phrase_encoded", False)
+    if name_to_use not in config["substrate"].get("accounts", {}):
+        print(f"Error: Account '{name_to_use}' not found")
+        return None
 
-    else:
-        # Legacy mode - single account
-        is_encoded = config["substrate"].get("seed_phrase_encoded", False)
+    account_data = config["substrate"]["accounts"][name_to_use]
+    is_encoded = account_data.get("seed_phrase_encoded", False)
 
     if is_encoded:
-        # If encoded, decrypt it
-        return decrypt_seed_phrase(password, account_name)
+        return decrypt_seed_phrase(password, name_to_use)
     else:
-        # If not encoded, just return the plain text seed phrase
-        if account_name is not None or config["substrate"].get("active_account"):
-            # Multi-account mode
-            name_to_use = account_name or config["substrate"].get("active_account")
-            return config["substrate"]["accounts"][name_to_use].get("seed_phrase")
-        else:
-            # Legacy mode
-            return config["substrate"].get("seed_phrase")
+        return account_data.get("seed_phrase")
 
 
 def set_seed_phrase(
@@ -502,7 +468,7 @@ def set_seed_phrase(
         seed_phrase: The seed phrase to store
         encode: Whether to encrypt the seed phrase (requires password)
         password: Optional password for encryption (if None and encode=True, will prompt)
-        account_name: Optional name for the account (if None, uses legacy mode or active account)
+        account_name: Optional name for the account (if None, uses active account)
 
     Returns:
         bool: True if saving was successful, False otherwise
@@ -520,30 +486,31 @@ def set_seed_phrase(
         except Exception as e:
             print(f"Warning: Could not derive SS58 address: {e}")
 
-        # Determine if we're using multi-account mode
-        if account_name is not None:
-            # Multi-account mode
-            if "accounts" not in config["substrate"]:
-                config["substrate"]["accounts"] = {}
-
-            # Store the account data
-            config["substrate"]["accounts"][account_name] = {
-                "seed_phrase": seed_phrase,
-                "seed_phrase_encoded": False,
-                "seed_phrase_salt": None,
-                "ss58_address": ss58_address,
-            }
-
-            # Set as active account if no active account exists
-            if not config["substrate"].get("active_account"):
-                config["substrate"]["active_account"] = account_name
-
-        else:
-            # Legacy mode - single account
-            config["substrate"]["seed_phrase"] = seed_phrase
-            config["substrate"]["seed_phrase_encoded"] = False
-            config["substrate"]["seed_phrase_salt"] = None
-            config["substrate"]["ss58_address"] = ss58_address
+        # Only use multi-account mode
+        # Use active account if no account specified
+        name_to_use = account_name
+        if name_to_use is None:
+            name_to_use = config["substrate"].get("active_account")
+            if not name_to_use:
+                # If no active account, we need a name
+                print("Error: No account name specified and no active account")
+                return False
+
+        # Ensure accounts structure exists
+        if "accounts" not in config["substrate"]:
+            config["substrate"]["accounts"] = {}
+
+        # Store the account data
+        config["substrate"]["accounts"][name_to_use] = {
+            "seed_phrase": seed_phrase,
+            "seed_phrase_encoded": False,
+            "seed_phrase_salt": None,
+            "ss58_address": ss58_address,
+        }
+
+        # Set as active account if no active account exists
+        if not config["substrate"].get("active_account"):
+            config["substrate"]["active_account"] = name_to_use
 
         return save_config(config)
 

hippius_sdk/ipfs.py

@@ -816,6 +816,9 @@ class IPFSClient:
             file_data = self.encrypt_data(file_data)
 
         # Step 2: Split the file into chunks for erasure coding
+        chunk_size = int(chunk_size)
+        chunk_size = max(1, chunk_size)  # Ensure it's at least 1 byte
+
         chunks = []
         chunk_positions = []
         for i in range(0, len(file_data), chunk_size):
@@ -825,7 +828,7 @@ class IPFSClient:
 
         # Pad the last chunk if necessary
         if chunks and len(chunks[-1]) < chunk_size:
-            pad_size = chunk_size - len(chunks[-1])
+            pad_size = int(chunk_size - len(chunks[-1]))
             chunks[-1] = chunks[-1] + b"\0" * pad_size
 
         # If we don't have enough chunks for the requested parameters, adjust
@@ -1386,6 +1389,7 @@ class IPFSClient:
         max_retries: int = 3,
         verbose: bool = True,
         progress_callback: Optional[Callable[[str, int, int], None]] = None,
+        publish: bool = True,
     ) -> Dict[str, Any]:
         """
         Erasure code a file, upload the chunks to IPFS, and store in the Hippius marketplace.
@@ -1404,15 +1408,21 @@ class IPFSClient:
             verbose: Whether to print progress information
             progress_callback: Optional callback function for progress updates
                             Function receives (stage_name, current, total)
+            publish: Whether to publish to the blockchain (True) or just perform local
+                    erasure coding without publishing (False). When False, no password
+                    is needed for seed phrase access.
 
         Returns:
-            dict: Result including metadata CID and transaction hash
+            dict: Result including metadata CID and transaction hash (if published)
 
         Raises:
             ValueError: If parameters are invalid
             RuntimeError: If processing fails
         """
-        # Step 1: Erasure code the file and upload chunks
+        # Step 1: Create substrate client if we need it and are publishing
+        if substrate_client is None and publish:
+            substrate_client = SubstrateClient()
+        # Step 2: Erasure code the file and upload chunks
         metadata = await self.erasure_code_file(
             file_path=file_path,
             k=k,
@@ -1424,50 +1434,52 @@ class IPFSClient:
             progress_callback=progress_callback,
         )
 
-        # Step 2: Create substrate client if we need it
-        if substrate_client is None:
-            substrate_client = SubstrateClient()
-
         original_file = metadata["original_file"]
         metadata_cid = metadata["metadata_cid"]
 
-        # Create a list to hold all the file inputs (metadata + all chunks)
-        all_file_inputs = []
+        # Initialize transaction hash variable
+        tx_hash = None
 
-        # Step 3: Prepare metadata file for storage
-        if verbose:
-            print(
-                f"Preparing to store metadata and {len(metadata['chunks'])} chunks in the Hippius marketplace..."
-            )
+        # Only proceed with blockchain storage if publish is True
+        if publish:
+            # Create a list to hold all the file inputs (metadata + all chunks)
+            all_file_inputs = []
 
-        # Create a file input for the metadata file
-        metadata_file_input = FileInput(
-            file_hash=metadata_cid, file_name=f"{original_file['name']}.ec_metadata"
-        )
-        all_file_inputs.append(metadata_file_input)
+            # Step 3: Prepare metadata file for storage
+            if verbose:
+                print(
+                    f"Preparing to store metadata and {len(metadata['chunks'])} chunks in the Hippius marketplace..."
+                )
 
-        # Step 4: Add all chunks to the storage request
-        if verbose:
-            print("Adding all chunks to storage request...")
-
-        for i, chunk in enumerate(metadata["chunks"]):
-            # Extract the CID string from the chunk's cid dictionary
-            chunk_cid = (
-                chunk["cid"]["cid"]
-                if isinstance(chunk["cid"], dict) and "cid" in chunk["cid"]
-                else chunk["cid"]
+            # Create a file input for the metadata file
+            metadata_file_input = FileInput(
+                file_hash=metadata_cid, file_name=f"{original_file['name']}.ec_metadata"
             )
-            chunk_file_input = FileInput(file_hash=chunk_cid, file_name=chunk["name"])
-            all_file_inputs.append(chunk_file_input)
+            all_file_inputs.append(metadata_file_input)
 
-            # Print progress for large numbers of chunks
-            if verbose and (i + 1) % 50 == 0:
-                print(
-                    f"  Prepared {i + 1}/{len(metadata['chunks'])} chunks for storage"
+            # Step 4: Add all chunks to the storage request
+            if verbose:
+                print("Adding all chunks to storage request...")
+
+            for i, chunk in enumerate(metadata["chunks"]):
+                # Extract the CID string from the chunk's cid dictionary
+                chunk_cid = (
+                    chunk["cid"]["cid"]
+                    if isinstance(chunk["cid"], dict) and "cid" in chunk["cid"]
+                    else chunk["cid"]
+                )
+                chunk_file_input = FileInput(
+                    file_hash=chunk_cid, file_name=chunk["name"]
                 )
+                all_file_inputs.append(chunk_file_input)
 
-        # Step 5: Submit the storage request for all files
-        try:
+                # Print progress for large numbers of chunks
+                if verbose and (i + 1) % 50 == 0:
+                    print(
+                        f"  Prepared {i + 1}/{len(metadata['chunks'])} chunks for storage"
+                    )
+
+            # Step 5: Submit the storage request for all files
             if verbose:
                 print(
                     f"Submitting storage request for 1 metadata file and {len(metadata['chunks'])} chunks..."
@@ -1476,7 +1488,6 @@ class IPFSClient:
             tx_hash = await substrate_client.storage_request(
                 files=all_file_inputs, miner_ids=miner_ids
             )
-
             if verbose:
                 print("Successfully stored all files in marketplace!")
                 print(f"Transaction hash: {tx_hash}")
@@ -1485,17 +1496,27 @@ class IPFSClient:
                     f"Total files stored: {len(all_file_inputs)} (1 metadata + {len(metadata['chunks'])} chunks)"
                 )
 
-            return {
+            result = {
                 "metadata": metadata,
                 "metadata_cid": metadata_cid,
                 "transaction_hash": tx_hash,
                 "total_files_stored": len(all_file_inputs),
             }
+        else:
+            # Not publishing to blockchain (--no-publish flag used)
+            if verbose:
+                print("Not publishing to blockchain (--no-publish flag used)")
+                print(f"Metadata CID: {metadata_cid}")
+                print(f"Total chunks: {len(metadata['chunks'])}")
 
-        except Exception as e:
-            print(f"Error storing files in marketplace: {str(e)}")
-            # Return the metadata even if storage fails
-            return {"metadata": metadata, "metadata_cid": metadata_cid, "error": str(e)}
+            result = {
+                "metadata": metadata,
+                "metadata_cid": metadata_cid,
+                "total_files_stored": len(metadata["chunks"])
+                + 1,  # +1 for metadata file
+            }
+
+        return result
 
     async def delete_file(
         self, cid: str, cancel_from_blockchain: bool = True