hippius 0.2.20__py3-none-any.whl → 0.2.21__py3-none-any.whl

{hippius-0.2.20.dist-info → hippius-0.2.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.20
+Version: 0.2.21
 Summary: Python SDK and CLI for Hippius blockchain storage
 Home-page: https://github.com/thenervelab/hippius-sdk
 Author: Dubs

{hippius-0.2.20.dist-info → hippius-0.2.21.dist-info}/RECORD

@@ -1,10 +1,10 @@
-hippius_sdk/__init__.py,sha256=9rPlh9Ob5xHhR9owW4IxihHaanA0vxuMrDidpW5l0Fw,1474
+hippius_sdk/__init__.py,sha256=GR_6lzziCmPq3cvSasIrT3n2Px3l6Jv1OXAEXDZ0fX0,1474
 hippius_sdk/cli.py,sha256=aqKOYSBSWt7UhcpFt7wf9yIPJ3bznpsJ6ehOnuZ4usI,18235
 hippius_sdk/cli_assets.py,sha256=V3MX63QTiex6mCp0VDXQJ7cagm5v1s4xtsu8c1O4G_k,371
 hippius_sdk/cli_handlers.py,sha256=TQNE9os87gRzRKLEO-SIwhFnBtEFMiaSESv-Bu7omfo,128909
 hippius_sdk/cli_parser.py,sha256=z7UvgWvvy04ey-R56qZiCqYc_9RaNq1rVDkQyXoK3JU,21100
 hippius_sdk/cli_rich.py,sha256=_jTBYMdHi2--fIVwoeNi-EtkdOb6Zy_O2TUiGvU3O7s,7324
-hippius_sdk/client.py,sha256=k8K3__zDtWJhCbHPAPYu9FopSNXsrw1HpVAX6fV7pnI,21462
+hippius_sdk/client.py,sha256=ktlv-s7H53h4zWcdz1EYf6fAqioohcFAxhRDKtljlEg,22252
 hippius_sdk/config.py,sha256=Hf_aUYzG9ylzqauA_ABUSSB5mBTYbp-VtB36VQt2XDw,21981
 hippius_sdk/db/README.md,sha256=okDeI1qgkaZqXSlJ8L0xIE4UpuxO-qEGPIbXUvSHQjU,2030
 hippius_sdk/db/env.db.template,sha256=_6hEC3IvkzCDOAzG1_yJUKRUfCTMciNaJUicZpMCat4,217
@@ -12,12 +12,12 @@ hippius_sdk/db/migrations/20241201000001_create_key_storage_tables.sql,sha256=mi
 hippius_sdk/db/setup_database.sh,sha256=bDeIiTnMuX0AYCdefAfEI1CyXho6A6kLzufsDZFSXpE,3118
 hippius_sdk/db_utils.py,sha256=-x0rbN0as7Tn3PJPZBYCgreZe52FLH40ppA1TLxsg90,1851
 hippius_sdk/errors.py,sha256=LScJJmawVAx7aRzqqQguYSkf9iazSjEQEBNlD_GXZ6Y,1589
-hippius_sdk/ipfs.py,sha256=Bp-f4QjrPeLKy61SxNsmB_YWvVjcYVBJlTt4NN6mGWo,90907
+hippius_sdk/ipfs.py,sha256=QjqBYnhqzAiST3CNCCLxwPxEMGaV2iLwk_IBTp740wg,93188
 hippius_sdk/ipfs_core.py,sha256=eOOgLoyP9mvwndnCjldnTc7z94ImYCXY3nm7JU3e_Mo,12676
-hippius_sdk/key_storage.py,sha256=-f4pEUvkczY_yw3lYJ_kM2iDDOAtKOgrexWxVgIo78w,9486
+hippius_sdk/key_storage.py,sha256=oxfRRQXu8XVncUjhKJJ8rsc81JAkaj9MqZEwQa96idc,9474
 hippius_sdk/substrate.py,sha256=AqfQNl5Qv_s6roOESSdwleX0-VGyu5sh3m5-dYZp5ek,49079
 hippius_sdk/utils.py,sha256=rJ611yvwKSyiBpYU3w-SuyQxoghMGU-ePuslrPv5H5g,7388
-hippius-0.2.20.dist-info/METADATA,sha256=-mfl3cVtxZhaYbQvq-yt2aR96T1szZxnCb_R3Xbhx5I,30088
-hippius-0.2.20.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-hippius-0.2.20.dist-info/entry_points.txt,sha256=bFAZjW3vndretf9-8s587jA2ebMVI7puhn_lVs8jPc8,149
-hippius-0.2.20.dist-info/RECORD,,
+hippius-0.2.21.dist-info/METADATA,sha256=iBEURRYrrokbmCufUVrac5PlnWErQ72on4cycxevlqU,30088
+hippius-0.2.21.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+hippius-0.2.21.dist-info/entry_points.txt,sha256=bFAZjW3vndretf9-8s587jA2ebMVI7puhn_lVs8jPc8,149
+hippius-0.2.21.dist-info/RECORD,,

hippius_sdk/__init__.py

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

hippius_sdk/client.py

@@ -512,15 +512,26 @@ class HippiusClient:
         )
 
     async def s3_publish(
-        self, file_path: str, encrypt: bool, seed_phrase: str
+        self,
+        file_path: str,
+        encrypt: bool,
+        seed_phrase: str,
+        store_node: str = "http://localhost:5001",
+        pin_node: str = "https://store.hippius.network"
     ) -> S3PublishResult:
         """
         Publish a file to IPFS and the Hippius marketplace in one operation.
 
+        Uses a two-node architecture for optimal performance:
+        1. Uploads to store_node (local) for immediate availability
+        2. Pins to pin_node (remote) for persistence and backup
+
         Args:
             file_path: Path to the file to publish
             encrypt: Whether to encrypt the file before uploading
             seed_phrase: Seed phrase for blockchain transaction signing
+            store_node: IPFS node URL for initial upload (default: local node)
+            pin_node: IPFS node URL for backup pinning (default: remote service)
 
         Returns:
             S3PublishResult: Object containing CID, file info, and transaction hash
@@ -531,16 +542,22 @@ class HippiusClient:
             FileNotFoundError: If the file doesn't exist
             ValueError: If encryption is requested but not available
         """
-        return await self.ipfs_client.s3_publish(file_path, encrypt, seed_phrase)
+        return await self.ipfs_client.s3_publish(file_path, encrypt, seed_phrase, store_node, pin_node)
 
     async def s3_download(
-        self, cid: str, output_path: str, seed_phrase: str, auto_decrypt: bool = True
+        self,
+        cid: str,
+        output_path: str,
+        seed_phrase: str,
+        auto_decrypt: bool = True,
+        download_node: str = "http://localhost:5001"
     ) -> S3DownloadResult:
         """
         Download a file from IPFS with automatic decryption.
 
-        This method automatically manages decryption keys per seed phrase:
-        - Downloads the file from IPFS
+        This method uses the download_node for immediate availability and automatically
+        manages decryption keys per seed phrase:
+        - Downloads the file from the specified download_node (local by default)
         - If auto_decrypt=True, attempts to decrypt using stored keys for the seed phrase
         - Falls back to client encryption key if key storage is not available
         - Returns the file in decrypted form if decryption succeeds
@@ -550,6 +567,7 @@ class HippiusClient:
             output_path: Path where the downloaded file will be saved
             seed_phrase: Seed phrase to use for retrieving decryption keys
             auto_decrypt: Whether to attempt automatic decryption (default: True)
+            download_node: IPFS node URL for download (default: local node)
 
         Returns:
             S3DownloadResult: Object containing download info and decryption status
@@ -559,4 +577,4 @@ class HippiusClient:
             FileNotFoundError: If the output directory doesn't exist
             ValueError: If decryption fails
         """
-        return await self.ipfs_client.s3_download(cid, output_path, seed_phrase, auto_decrypt)
+        return await self.ipfs_client.s3_download(cid, output_path, seed_phrase, auto_decrypt, download_node)

hippius_sdk/ipfs.py

@@ -13,17 +13,18 @@ import tempfile
 import time
 import uuid
 from typing import Any, Callable, Dict, List, Optional
-from hippius_sdk.key_storage import (
-    generate_and_store_key_for_seed,
-    get_key_for_seed,
-    is_key_storage_enabled,
-)
+
 import httpx
 from pydantic import BaseModel
 
 from hippius_sdk.config import get_config_value, get_encryption_key
 from hippius_sdk.errors import HippiusIPFSError, HippiusSubstrateError
 from hippius_sdk.ipfs_core import AsyncIPFSClient
+from hippius_sdk.key_storage import (
+    generate_and_store_key_for_seed,
+    get_key_for_seed,
+    is_key_storage_enabled,
+)
 from hippius_sdk.substrate import FileInput, SubstrateClient
 from hippius_sdk.utils import format_cid, format_size
 
@@ -1805,9 +1806,6 @@ class IPFSClient:
         """
         print(f"Starting deletion process for metadata CID: {metadata_cid}")
 
-        # Try to download and process metadata file and chunks
-        ipfs_failure = False
-        metadata_error = False
         chunks = []
 
         try:
@@ -1929,11 +1927,21 @@ class IPFSClient:
         return True
 
     async def s3_publish(
-        self, file_path: str, encrypt: bool, seed_phrase: str
+        self,
+        file_path: str,
+        encrypt: bool,
+        seed_phrase: str,
+        store_node: str = "http://localhost:5001",
+        pin_node: str = "https://store.hippius.network"
     ) -> S3PublishResult:
         """
         Publish a file to IPFS and the Hippius marketplace in one operation.
 
+        This method uses a two-node architecture for optimal performance:
+        1. Uploads to store_node (local) for immediate availability
+        2. Pins to pin_node (remote) for persistence and backup
+        3. Publishes to substrate marketplace
+
         This method automatically manages encryption keys per seed phrase:
         - If encrypt=True, it will get or generate an encryption key for the seed phrase
         - Keys are stored in PostgreSQL and versioned (never deleted)
@@ -1943,6 +1951,8 @@ class IPFSClient:
             file_path: Path to the file to publish
             encrypt: Whether to encrypt the file before uploading
             seed_phrase: Seed phrase for blockchain transaction signing
+            store_node: IPFS node URL for initial upload (default: local node)
+            pin_node: IPFS node URL for backup pinning (default: remote service)
 
         Returns:
             S3PublishResult: Object containing CID, file info, and transaction hash
@@ -2026,18 +2036,22 @@ class IPFSClient:
                     else None
                 )
 
-        # Add file to IPFS
+        # Step 1: Upload to store_node (local) for immediate availability
         try:
-            result = await self.client.add_file(file_path)
+            store_client = AsyncIPFSClient(api_url=store_node)
+            result = await store_client.add_file(file_path)
             cid = result["Hash"]
+            logger.info(f"File uploaded to store node {store_node} with CID: {cid}")
         except Exception as e:
-            raise HippiusIPFSError(f"Failed to add file to IPFS: {str(e)}")
+            raise HippiusIPFSError(f"Failed to upload file to store node {store_node}: {str(e)}")
 
-        # Pin the file to IPFS
+        # Step 2: Pin to pin_node (remote) for persistence and backup
         try:
-            pin_result = await self.client.pin(cid)
+            pin_client = AsyncIPFSClient(api_url=pin_node)
+            await pin_client.pin(cid)
+            logger.info(f"File pinned to backup node {pin_node}")
         except Exception as e:
-            raise HippiusIPFSError(f"Failed to pin file to IPFS: {str(e)}")
+            raise HippiusIPFSError(f"Failed to pin file to store node {store_node}: {str(e)}")
 
         # Publish to substrate marketplace
         try:
@@ -2087,13 +2101,19 @@ class IPFSClient:
         )
 
     async def s3_download(
-        self, cid: str, output_path: str, seed_phrase: str, auto_decrypt: bool = True
+        self,
+        cid: str,
+        output_path: str,
+        seed_phrase: str,
+        auto_decrypt: bool = True,
+        download_node: str = "http://localhost:5001"
     ) -> S3DownloadResult:
         """
         Download a file from IPFS with automatic decryption.
 
-        This method automatically manages decryption keys per seed phrase:
-        - Downloads the file from IPFS
+        This method uses the download_node for immediate availability and automatically
+        manages decryption keys per seed phrase:
+        - Downloads the file from the specified download_node (local by default)
         - If auto_decrypt=True, attempts to decrypt using stored keys for the seed phrase
         - Falls back to client encryption key if key storage is not available
         - Returns the file in decrypted form if decryption succeeds
@@ -2103,6 +2123,7 @@ class IPFSClient:
             output_path: Path where the downloaded file will be saved
             seed_phrase: Seed phrase to use for retrieving decryption keys
             auto_decrypt: Whether to attempt automatic decryption (default: True)
+            download_node: IPFS node URL for download (default: local node)
 
         Returns:
             S3DownloadResult: Object containing download info and decryption status
@@ -2114,24 +2135,25 @@ class IPFSClient:
         """
         start_time = time.time()
 
-        # Download the file first using the existing download_file method
+        # Download the file directly from the specified download_node
         try:
             # Create parent directories if they don't exist
             os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
 
-            # Download without decryption first
-            download_result = await self.download_file(
-                cid=cid,
-                output_path=output_path,
-                skip_directory_check=False,
-                seed_phrase=seed_phrase,
-            )
+            download_client = AsyncIPFSClient(api_url=download_node)
 
-            if not download_result.get("success", False):
-                raise HippiusIPFSError("Download failed")
+            download_url = f"{download_node.rstrip('/')}/api/v0/cat?arg={cid}"
+            async with download_client.client.stream("POST", download_url) as response:
+                response.raise_for_status()
+
+                with open(output_path, "wb") as f:
+                    async for chunk in response.aiter_bytes(chunk_size=8192):
+                        f.write(chunk)
+
+            logger.info(f"File downloaded from {download_node} with CID: {cid}")
 
         except Exception as e:
-            raise HippiusIPFSError(f"Failed to download file from IPFS: {str(e)}")
+            raise HippiusIPFSError(f"Failed to download file from {download_node}: {str(e)}")
 
         # Get file info after download
         size_bytes = os.path.getsize(output_path)
@@ -2154,77 +2176,91 @@ class IPFSClient:
             with open(output_path, "rb") as f:
                 file_data = f.read()
 
-            decryption_attempted = False
-            decryption_successful = False
+            # Check if file is empty - this indicates a problem
+            if len(file_data) == 0:
+                logger.error(f"Downloaded file is empty (0 bytes) for CID: {cid}")
+                raise HippiusIPFSError(
+                    f"File not available: Downloaded 0 bytes for CID {cid}. "
+                    f"File may not exist on download node {download_node}. "
+                    f"Download URL: {download_url}"
+                )
+            elif len(file_data) < 40:  # PyNaCl encrypted data is at least 40 bytes (24-byte nonce + 16-byte auth tag + data)
+                logger.info(f"File too small to be encrypted ({len(file_data)} bytes), treating as plaintext")
+                decrypted = False
+                encryption_key_used = None
+            else:
+                # File has content, attempt decryption if requested
+                decryption_attempted = False
+                decryption_successful = False
 
-            if key_storage_available:
-                # Try to get the encryption key for this seed phrase
-                try:
-                    existing_key_b64 = await get_key_for_seed(seed_phrase)
+                if key_storage_available:
+                    # Try to get the encryption key for this seed phrase
+                    try:
+                        existing_key_b64 = await get_key_for_seed(seed_phrase)
 
-                    if existing_key_b64:
-                        logger.debug("Found encryption key for seed phrase, attempting decryption")
-                        decryption_attempted = True
-                        encryption_key_used = existing_key_b64
+                        if existing_key_b64:
+                            logger.debug("Found encryption key for seed phrase, attempting decryption")
+                            decryption_attempted = True
+                            encryption_key_used = existing_key_b64
 
-                        # Attempt decryption with the stored key
-                        try:
-                            import nacl.secret
+                            # Attempt decryption with the stored key
+                            try:
+                                import nacl.secret
 
-                            encryption_key_bytes = base64.b64decode(existing_key_b64)
-                            box = nacl.secret.SecretBox(encryption_key_bytes)
-                            decrypted_data = box.decrypt(file_data)
+                                encryption_key_bytes = base64.b64decode(existing_key_b64)
+                                box = nacl.secret.SecretBox(encryption_key_bytes)
+                                decrypted_data = box.decrypt(file_data)
 
-                            # Write the decrypted data back to the file
-                            with open(output_path, "wb") as f:
-                                f.write(decrypted_data)
+                                # Write the decrypted data back to the file
+                                with open(output_path, "wb") as f:
+                                    f.write(decrypted_data)
 
-                            decryption_successful = True
-                            decrypted = True
-                            size_bytes = len(decrypted_data)  # Update size to decrypted size
-                            logger.info("Successfully decrypted file using stored key")
+                                decryption_successful = True
+                                decrypted = True
+                                size_bytes = len(decrypted_data)  # Update size to decrypted size
+                                logger.info("Successfully decrypted file using stored key")
 
-                        except Exception as decrypt_error:
-                            logger.debug(f"Decryption failed with stored key: {decrypt_error}")
-                            # Continue to try fallback decryption
-                    else:
-                        logger.debug("No encryption key found for seed phrase")
+                            except Exception as decrypt_error:
+                                logger.debug(f"Decryption failed with stored key: {decrypt_error}")
+                                # Continue to try fallback decryption
+                        else:
+                            logger.debug("No encryption key found for seed phrase")
 
-                except Exception as e:
-                    logger.debug(f"Error retrieving key from storage: {e}")
+                    except Exception as e:
+                        logger.debug(f"Error retrieving key from storage: {e}")
 
-            # If key storage decryption failed or wasn't available, try client encryption key
-            if not decryption_successful and self.encryption_available:
-                logger.debug("Attempting decryption with client encryption key")
-                decryption_attempted = True
+                # If key storage decryption failed or wasn't available, try client encryption key
+                if not decryption_successful and self.encryption_available:
+                    logger.debug("Attempting decryption with client encryption key")
+                    decryption_attempted = True
 
-                try:
-                    decrypted_data = self.decrypt_data(file_data)
-
-                    # Write the decrypted data back to the file
-                    with open(output_path, "wb") as f:
-                        f.write(decrypted_data)
-
-                    decryption_successful = True
-                    decrypted = True
-                    size_bytes = len(decrypted_data)  # Update size to decrypted size
-                    
-                    # Store the encryption key for the result
-                    encryption_key_used = (
-                        base64.b64encode(self.encryption_key).decode("utf-8")
-                        if self.encryption_key
-                        else None
-                    )
-                    logger.info("Successfully decrypted file using client encryption key")
+                    try:
+                        decrypted_data = self.decrypt_data(file_data)
+
+                        # Write the decrypted data back to the file
+                        with open(output_path, "wb") as f:
+                            f.write(decrypted_data)
+
+                        decryption_successful = True
+                        decrypted = True
+                        size_bytes = len(decrypted_data)  # Update size to decrypted size
+
+                        # Store the encryption key for the result
+                        encryption_key_used = (
+                            base64.b64encode(self.encryption_key).decode("utf-8")
+                            if self.encryption_key
+                            else None
+                        )
+                        logger.info("Successfully decrypted file using client encryption key")
 
-                except Exception as decrypt_error:
-                    logger.debug(f"Decryption failed with client key: {decrypt_error}")
+                    except Exception as decrypt_error:
+                        logger.debug(f"Decryption failed with client key: {decrypt_error}")
 
-            # Log final decryption status
-            if decryption_attempted and not decryption_successful:
-                logger.info("File may not be encrypted or decryption keys don't match")
-            elif not decryption_attempted:
-                logger.debug("No decryption attempted - no keys available")
+                # Log final decryption status
+                if decryption_attempted and not decryption_successful:
+                    logger.info("File may not be encrypted or decryption keys don't match")
+                elif not decryption_attempted:
+                    logger.debug("No decryption attempted - no keys available")
 
         return S3DownloadResult(
             cid=cid,

hippius_sdk/key_storage.py

@@ -234,7 +234,7 @@ _default_storage = None
 def is_key_storage_enabled() -> bool:
     """
     Check if key storage is enabled and available.
-    
+
     Returns True if:
     1. Explicitly enabled in config, OR
     2. asyncpg is available (key_storage extra installed) AND not explicitly disabled
@@ -243,11 +243,11 @@ def is_key_storage_enabled() -> bool:
     config_value = get_config_value("key_storage", "enabled", None)
     if config_value is False:
         return False
-    
+
     # If explicitly enabled, return True
     if config_value is True:
         return True
-    
+
     # If not set in config, auto-detect based on asyncpg availability
     # This allows users who install [key_storage] extra to use it without manual config
     return ASYNCPG_AVAILABLE