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

hippius_sdk/cli_parser.py

@@ -197,12 +197,32 @@ def add_storage_commands(subparsers):
         "store", help="Upload a file to IPFS and store it on Substrate"
     )
     store_parser.add_argument("file_path", help="Path to file to upload")
+    store_parser.add_argument(
+        "--publish",
+        action="store_true",
+        help="Publish file to IPFS and store on the blockchain (default)",
+    )
+    store_parser.add_argument(
+        "--no-publish",
+        action="store_true",
+        help="Don't publish file to IPFS or store on the blockchain (local only)",
+    )
 
     # Store directory command
     store_dir_parser = subparsers.add_parser(
         "store-dir", help="Upload a directory to IPFS and store all files on Substrate"
     )
     store_dir_parser.add_argument("dir_path", help="Path to directory to upload")
+    store_dir_parser.add_argument(
+        "--publish",
+        action="store_true",
+        help="Publish all files to IPFS and store on the blockchain (default)",
+    )
+    store_dir_parser.add_argument(
+        "--no-publish",
+        action="store_true",
+        help="Don't publish files to IPFS or store on the blockchain (local only)",
+    )
 
     # Pinning status command
     pinning_status_parser = subparsers.add_parser(
@@ -520,6 +540,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/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
@@ -153,10 +148,11 @@ class HippiusClient:
     ) -> Dict[str, Any]:
         """
         Download a file from IPFS with optional decryption.
+        Supports downloading directories - in that case, a directory structure will be created.
 
         Args:
             cid: Content Identifier (CID) of the file to download
-            output_path: Path where the downloaded file will be saved
+            output_path: Path where the downloaded file/directory will be saved
             decrypt: Whether to decrypt the file (overrides default)
 
         Returns:
@@ -167,6 +163,7 @@ class HippiusClient:
                 - size_formatted: Human-readable file size
                 - elapsed_seconds: Time taken for the download
                 - decrypted: Whether the file was decrypted
+                - is_directory: Whether the download was a directory
 
         Raises:
             requests.RequestException: If the download fails
@@ -375,6 +372,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 +390,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 +412,7 @@ class HippiusClient:
             max_retries=max_retries,
             verbose=verbose,
             progress_callback=progress_callback,
+            publish=publish,
         )
 
     async def delete_file(
@@ -436,7 +438,7 @@ class HippiusClient:
         metadata_cid: str,
         cancel_from_blockchain: bool = True,
         parallel_limit: int = 20,
-    ) -> Dict[str, Any]:
+    ) -> bool:
         """
         Delete an erasure-coded file, including all its chunks in parallel.
 
@@ -446,7 +448,7 @@ class HippiusClient:
             parallel_limit: Maximum number of concurrent deletion operations
 
         Returns:
-            Dict containing the result of the operation
+            True or false if failed.
 
         Raises:
             RuntimeError: If deletion fails completely

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/errors.py

@@ -0,0 +1,77 @@
+"""
+Custom exceptions for the Hippius SDK.
+"""
+
+
+class HippiusError(Exception):
+    """Base exception for all Hippius-specific errors."""
+
+    pass
+
+
+class HippiusSubstrateError(HippiusError):
+    """Base exception for Substrate-related errors."""
+
+    pass
+
+
+class HippiusIPFSError(HippiusError):
+    """Base exception for IPFS-related errors."""
+
+    pass
+
+
+# Specific blockchain errors
+class HippiusNotFoundError(HippiusSubstrateError):
+    """Raised when a resource is not found on the blockchain."""
+
+    pass
+
+
+class HippiusAlreadyDeletedError(HippiusSubstrateError):
+    """Raised when trying to delete a file that's already deleted from the blockchain."""
+
+    pass
+
+
+class HippiusSubstrateConnectionError(HippiusSubstrateError):
+    """Raised when there's an issue connecting to the Substrate node."""
+
+    pass
+
+
+class HippiusSubstrateAuthError(HippiusSubstrateError):
+    """Raised when there's an authentication issue with the Substrate client."""
+
+    pass
+
+
+class HippiusFailedSubstrateDelete(HippiusSubstrateError):
+    """Raised when deletion from blockchain storage fails."""
+
+    pass
+
+
+# IPFS-specific errors
+class HippiusIPFSConnectionError(HippiusIPFSError):
+    """Raised when there's an issue connecting to IPFS."""
+
+    pass
+
+
+class HippiusFailedIPFSUnpin(HippiusIPFSError):
+    """Raised when unpinning from IPFS fails."""
+
+    pass
+
+
+class HippiusMetadataError(HippiusIPFSError):
+    """Raised when there's an issue with the metadata file."""
+
+    pass
+
+
+class HippiusInvalidCIDError(HippiusIPFSError):
+    """Raised when an invalid CID is provided."""
+
+    pass