hippius 0.2.14__tar.gz → 0.2.16__tar.gz

{hippius-0.2.14 → hippius-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.14
+Version: 0.2.16
 Summary: Python SDK and CLI for Hippius blockchain storage
 Home-page: https://github.com/thenervelab/hippius-sdk
 Author: Dubs
@@ -15,6 +15,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.9
 Provides-Extra: clipboard
+Provides-Extra: key-storage
+Requires-Dist: asyncpg (>=0.29.0,<0.30.0) ; extra == "key-storage"
 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)

{hippius-0.2.14 → hippius-0.2.16}/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.14"
+__version__ = "0.2.16"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/cli.py

@@ -145,7 +145,7 @@ def main():
                 decrypt=decrypt,
             )
 
-        elif args.command == "store":
+        elif args.command == "store" or args.command == "add":
             return run_async_handler(
                 cli_handlers.handle_store,
                 client,

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/cli_parser.py

@@ -34,6 +34,9 @@ examples:
   # Store a file
   hippius store example.txt
   
+  # Add a file (alias for store)
+  hippius add example.txt
+  
   # Store a directory
   hippius store-dir ./my_directory
   
@@ -78,6 +81,10 @@ examples:
 
   # Delete an erasure-coded file and all its chunks
   hippius ec-delete QmMetadataHash
+  
+  # Configure PostgreSQL key storage
+  hippius config set key_storage database_url 'postgresql://user:pass@localhost:5432/hippius_keys'
+  hippius config set key_storage enabled true
 """,
     )
 
@@ -214,6 +221,23 @@ def add_storage_commands(subparsers):
         help="Don't publish file to IPFS or store on the blockchain (local only)",
     )
 
+    # Add command (alias for store)
+    add_parser = subparsers.add_parser(
+        "add",
+        help="Upload a file to IPFS and store it on Substrate (alias for 'store')",
+    )
+    add_parser.add_argument("file_path", help="Path to file to upload")
+    add_parser.add_argument(
+        "--publish",
+        action="store_true",
+        help="Publish file to IPFS and store on the blockchain (default)",
+    )
+    add_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"
@@ -420,7 +444,7 @@ def add_config_commands(subparsers):
     get_parser = config_subparsers.add_parser("get", help="Get a configuration value")
     get_parser.add_argument(
         "section",
-        help="Configuration section (ipfs, substrate, encryption, erasure_coding, cli)",
+        help="Configuration section (ipfs, substrate, encryption, erasure_coding, cli, key_storage)",
     )
     get_parser.add_argument("key", help="Configuration key")
 
@@ -428,7 +452,7 @@ def add_config_commands(subparsers):
     set_parser = config_subparsers.add_parser("set", help="Set a configuration value")
     set_parser.add_argument(
         "section",
-        help="Configuration section (ipfs, substrate, encryption, erasure_coding, cli)",
+        help="Configuration section (ipfs, substrate, encryption, erasure_coding, cli, key_storage)",
     )
     set_parser.add_argument("key", help="Configuration key")
     set_parser.add_argument("value", help="Configuration value")

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/client.py

@@ -9,7 +9,7 @@ import nacl.secret
 import nacl.utils
 
 from hippius_sdk.config import get_config_value, get_encryption_key
-from hippius_sdk.ipfs import IPFSClient
+from hippius_sdk.ipfs import IPFSClient, S3PublishResult
 from hippius_sdk.substrate import SubstrateClient
 
 
@@ -510,3 +510,25 @@ class HippiusClient:
             parallel_limit,
             seed_phrase=seed_phrase,
         )
+
+    async def s3_publish(
+        self, file_path: str, encrypt: bool, seed_phrase: str
+    ) -> S3PublishResult:
+        """
+        Publish a file to IPFS and the Hippius marketplace in one operation.
+
+        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
+
+        Returns:
+            S3PublishResult: Object containing CID, file info, and transaction hash
+
+        Raises:
+            HippiusIPFSError: If IPFS operations (add or pin) fail
+            HippiusSubstrateError: If substrate call fails
+            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)

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/config.py

@@ -49,6 +49,10 @@ DEFAULT_CONFIG = {
         "verbose": False,
         "max_retries": 3,
     },
+    "key_storage": {
+        "database_url": "postgresql://postgres:password@localhost:5432/hippius_keys",
+        "enabled": False,
+    },
 }
 
 

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/ipfs.py

@@ -2,8 +2,10 @@
 IPFS operations for the Hippius SDK.
 """
 import asyncio
+import base64
 import hashlib
 import json
+import logging
 import os
 import random
 import shutil
@@ -13,8 +15,10 @@ import uuid
 from typing import Any, Callable, Dict, List, Optional
 
 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.substrate import FileInput, SubstrateClient
 from hippius_sdk.utils import format_cid, format_size
@@ -43,6 +47,20 @@ PARALLEL_ORIGINAL_CHUNKS = (
 )
 
 
+class S3PublishResult(BaseModel):
+    """Result model for s3_publish method."""
+
+    cid: str
+    file_name: str
+    size_bytes: int
+    encryption_key: Optional[str]
+    tx_hash: str
+
+
+# Set up logger for this module
+logger = logging.getLogger(__name__)
+
+
 class IPFSClient:
     """Client for interacting with IPFS."""
 
@@ -513,6 +531,9 @@ class IPFSClient:
                 raise RuntimeError(f"Failed to download directory: {str(e)}")
         else:
             # Regular file download
+            # Create parent directories if they don't exist
+            os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+
             retries = 0
             while retries < max_retries:
                 try:
@@ -1890,3 +1911,171 @@ class IPFSClient:
         # In either case, we report success
         print("Delete EC file operation completed successfully")
         return True
+
+    async def s3_publish(
+        self, file_path: str, encrypt: bool, seed_phrase: str
+    ) -> S3PublishResult:
+        """
+        Publish a file to IPFS and the Hippius marketplace in one operation.
+
+        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)
+        - Always uses the most recent key for a seed phrase
+
+        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
+
+        Returns:
+            S3PublishResult: Object containing CID, file info, and transaction hash
+
+        Raises:
+            HippiusIPFSError: If IPFS operations (add or pin) fail
+            HippiusSubstrateError: If substrate call fails
+            FileNotFoundError: If the file doesn't exist
+            ValueError: If encryption is requested but not available
+        """
+        # Check if file exists and get initial info
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File {file_path} not found")
+
+        # Get file info
+        filename = os.path.basename(file_path)
+        size_bytes = os.path.getsize(file_path)
+
+        # Handle encryption if requested with automatic key management
+        encryption_key_used = None
+        if encrypt:
+            # Check if key storage is enabled and available
+            key_storage_available = False
+            try:
+                from hippius_sdk.key_storage import (
+                    generate_and_store_key_for_seed,
+                    get_key_for_seed,
+                    is_key_storage_enabled,
+                )
+
+                key_storage_available = is_key_storage_enabled()
+                logger.debug(f"Key storage enabled: {key_storage_available}")
+            except ImportError:
+                logger.debug("Key storage module not available")
+                key_storage_available = False
+
+            if key_storage_available:
+                # Use PostgreSQL-backed key storage
+                logger.info(f"Using PostgreSQL key storage for seed phrase")
+
+                # Try to get existing key for this seed phrase
+                existing_key_b64 = await get_key_for_seed(seed_phrase)
+
+                if existing_key_b64:
+                    # Use existing key
+                    logger.debug("Using existing encryption key for seed phrase")
+                    encryption_key_bytes = base64.b64decode(existing_key_b64)
+                    encryption_key_used = existing_key_b64
+                else:
+                    # Generate and store new key for this seed phrase
+                    logger.info("Generating new encryption key for seed phrase")
+                    new_key_b64 = await generate_and_store_key_for_seed(seed_phrase)
+                    encryption_key_bytes = base64.b64decode(new_key_b64)
+                    encryption_key_used = new_key_b64
+
+                # Read file content into memory
+                with open(file_path, "rb") as f:
+                    file_data = f.read()
+
+                # Encrypt the data using the key from key storage
+                import nacl.secret
+
+                box = nacl.secret.SecretBox(encryption_key_bytes)
+                encrypted_data = box.encrypt(file_data)
+
+                # Overwrite the original file with encrypted data
+                with open(file_path, "wb") as f:
+                    f.write(encrypted_data)
+            else:
+                # Fallback to the original encryption system if key_storage is not available
+                if not self.encryption_available:
+                    raise ValueError(
+                        "Encryption requested but not available. Either install key storage with 'pip install hippius_sdk[key_storage]' or configure an encryption key with 'hippius keygen --save'"
+                    )
+
+                # Read file content into memory
+                with open(file_path, "rb") as f:
+                    file_data = f.read()
+
+                # Encrypt the data using the client's encryption key
+                encrypted_data = self.encrypt_data(file_data)
+
+                # Overwrite the original file with encrypted data
+                with open(file_path, "wb") as f:
+                    f.write(encrypted_data)
+
+                # Store the encryption key for the result
+                encryption_key_used = (
+                    base64.b64encode(self.encryption_key).decode("utf-8")
+                    if self.encryption_key
+                    else None
+                )
+
+        # Add file to IPFS
+        try:
+            result = await self.client.add_file(file_path)
+            cid = result["Hash"]
+        except Exception as e:
+            raise HippiusIPFSError(f"Failed to add file to IPFS: {str(e)}")
+
+        # Pin the file to IPFS
+        try:
+            pin_result = await self.client.pin(cid)
+        except Exception as e:
+            raise HippiusIPFSError(f"Failed to pin file to IPFS: {str(e)}")
+
+        # Publish to substrate marketplace
+        try:
+            # Pass the seed phrase directly to avoid password prompts for encrypted config
+            substrate_client = SubstrateClient(seed_phrase=seed_phrase)
+            logger.info(
+                f"Submitting storage request to substrate for file: {filename}, CID: {cid}"
+            )
+
+            tx_hash = await substrate_client.storage_request(
+                files=[
+                    FileInput(
+                        file_hash=cid,
+                        file_name=filename,
+                    )
+                ],
+                miner_ids=[],
+                seed_phrase=seed_phrase,
+            )
+
+            logger.debug(f"Substrate call result: {tx_hash}")
+
+            # Check if we got a valid transaction hash
+            if not tx_hash or tx_hash == "0x" or len(tx_hash) < 10:
+                logger.error(f"Invalid transaction hash received: {tx_hash}")
+                raise HippiusSubstrateError(
+                    f"Invalid transaction hash received: {tx_hash}. This might indicate insufficient credits or transaction failure."
+                )
+
+            logger.info(
+                f"Successfully published to substrate with transaction: {tx_hash}"
+            )
+
+        except Exception as e:
+            logger.error(f"Substrate call failed: {str(e)}")
+            logger.debug(
+                "Possible causes: insufficient credits, network issues, invalid seed phrase, or substrate node unavailability"
+            )
+            raise HippiusSubstrateError(f"Failed to publish to substrate: {str(e)}")
+
+        return S3PublishResult(
+            cid=cid,
+            file_name=filename,
+            size_bytes=size_bytes,
+            encryption_key=encryption_key_used,
+            tx_hash=tx_hash,
+        )

hippius-0.2.16/hippius_sdk/key_storage.py

@@ -0,0 +1,281 @@
+"""
+Key storage module for managing encryption keys per seed phrase.
+
+This module provides PostgreSQL-backed storage for:
+1. Base64 encoded seed phrases
+2. Encryption keys associated with each seed phrase (versioned, never deleted)
+"""
+
+import base64
+import hashlib
+import os
+from datetime import datetime
+from typing import Optional
+
+from hippius_sdk.config import get_config_value
+
+# Import asyncpg with fallback
+try:
+    import asyncpg
+
+    ASYNCPG_AVAILABLE = True
+except ImportError:
+    ASYNCPG_AVAILABLE = False
+
+
+class KeyStorageError(Exception):
+    """Base exception for key storage operations."""
+
+    pass
+
+
+class KeyStorage:
+    """PostgreSQL-backed key storage for seed phrases and encryption keys."""
+
+    def __init__(self, database_url: Optional[str] = None):
+        """
+        Initialize key storage with database connection.
+
+        Args:
+            database_url: PostgreSQL connection URL. If None, uses config or defaults to localhost.
+        """
+        if not ASYNCPG_AVAILABLE:
+            raise KeyStorageError(
+                "asyncpg is required for key storage. Install it with: pip install 'hippius_sdk[key_storage]'"
+            )
+
+        if database_url is None:
+            database_url = get_config_value(
+                "key_storage",
+                "database_url",
+                "postgresql://postgres:password@localhost:5432/hippius_keys",
+            )
+
+        self.database_url = database_url
+
+    async def _get_connection(self):
+        """Get a database connection."""
+        try:
+            return await asyncpg.connect(self.database_url)
+        except Exception as e:
+            raise KeyStorageError(f"Failed to connect to database: {e}")
+
+    async def _ensure_tables_exist(self):
+        """Create tables if they don't exist."""
+        create_seed_phrases_table = """
+        CREATE TABLE IF NOT EXISTS seed_phrases (
+            id SERIAL PRIMARY KEY,
+            seed_hash VARCHAR(64) UNIQUE NOT NULL,
+            seed_phrase_b64 TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+
+        create_encryption_keys_table = """
+        CREATE TABLE IF NOT EXISTS encryption_keys (
+            id SERIAL PRIMARY KEY,
+            seed_hash VARCHAR(64) NOT NULL,
+            encryption_key_b64 TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (seed_hash) REFERENCES seed_phrases(seed_hash)
+        );
+        """
+
+        create_index = """
+        CREATE INDEX IF NOT EXISTS idx_encryption_keys_seed_hash_created 
+        ON encryption_keys(seed_hash, created_at DESC);
+        """
+
+        try:
+            conn = await self._get_connection()
+            try:
+                await conn.execute(create_seed_phrases_table)
+                await conn.execute(create_encryption_keys_table)
+                await conn.execute(create_index)
+            finally:
+                await conn.close()
+        except Exception as e:
+            raise KeyStorageError(f"Failed to create tables: {e}")
+
+    def _hash_seed_phrase(self, seed_phrase: str) -> str:
+        """Create a SHA-256 hash of the seed phrase for indexing."""
+        return hashlib.sha256(seed_phrase.encode("utf-8")).hexdigest()
+
+    async def _ensure_seed_phrase_exists(self, seed_phrase: str) -> str:
+        """Ensure seed phrase exists in database and return its hash."""
+        seed_hash = self._hash_seed_phrase(seed_phrase)
+        seed_phrase_b64 = base64.b64encode(seed_phrase.encode("utf-8")).decode("utf-8")
+
+        try:
+            conn = await self._get_connection()
+            try:
+                # Try to insert, ignore if already exists
+                await conn.execute(
+                    """
+                    INSERT INTO seed_phrases (seed_hash, seed_phrase_b64) 
+                    VALUES ($1, $2) 
+                    ON CONFLICT (seed_hash) DO NOTHING
+                """,
+                    seed_hash,
+                    seed_phrase_b64,
+                )
+            finally:
+                await conn.close()
+            return seed_hash
+        except Exception as e:
+            raise KeyStorageError(f"Failed to store seed phrase: {e}")
+
+    async def set_key_for_seed(self, seed_phrase: str, encryption_key_b64: str) -> None:
+        """
+        Store a new encryption key for a seed phrase.
+
+        Creates a new row (doesn't update existing ones) to maintain key history.
+
+        Args:
+            seed_phrase: The seed phrase
+            encryption_key_b64: Base64-encoded encryption key
+
+        Raises:
+            KeyStorageError: If storage fails
+        """
+        await self._ensure_tables_exist()
+        seed_hash = await self._ensure_seed_phrase_exists(seed_phrase)
+
+        try:
+            conn = await self._get_connection()
+            try:
+                await conn.execute(
+                    """
+                    INSERT INTO encryption_keys (seed_hash, encryption_key_b64)
+                    VALUES ($1, $2)
+                """,
+                    seed_hash,
+                    encryption_key_b64,
+                )
+            finally:
+                await conn.close()
+        except Exception as e:
+            raise KeyStorageError(f"Failed to store encryption key: {e}")
+
+    async def get_key_for_seed(self, seed_phrase: str) -> Optional[str]:
+        """
+        Get the most recent encryption key for a seed phrase.
+
+        Args:
+            seed_phrase: The seed phrase
+
+        Returns:
+            Base64-encoded encryption key or None if not found
+
+        Raises:
+            KeyStorageError: If database operation fails
+        """
+        await self._ensure_tables_exist()
+        seed_hash = self._hash_seed_phrase(seed_phrase)
+
+        try:
+            conn = await self._get_connection()
+            try:
+                result = await conn.fetchrow(
+                    """
+                    SELECT encryption_key_b64 
+                    FROM encryption_keys 
+                    WHERE seed_hash = $1 
+                    ORDER BY created_at DESC 
+                    LIMIT 1
+                """,
+                    seed_hash,
+                )
+
+                return result["encryption_key_b64"] if result else None
+            finally:
+                await conn.close()
+        except Exception as e:
+            raise KeyStorageError(f"Failed to retrieve encryption key: {e}")
+
+    async def generate_and_store_key_for_seed(self, seed_phrase: str) -> str:
+        """
+        Generate a new encryption key and store it for the seed phrase.
+
+        Args:
+            seed_phrase: The seed phrase
+
+        Returns:
+            Base64-encoded encryption key that was generated and stored
+
+        Raises:
+            KeyStorageError: If generation or storage fails
+        """
+        # Generate a new encryption key
+        try:
+            import nacl.secret
+            import nacl.utils
+
+            # Generate a random key
+            key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE)
+            key_b64 = base64.b64encode(key).decode("utf-8")
+
+            # Store it
+            await self.set_key_for_seed(seed_phrase, key_b64)
+
+            return key_b64
+        except ImportError:
+            raise KeyStorageError(
+                "PyNaCl is required for key generation. Install it with: pip install pynacl"
+            )
+        except Exception as e:
+            raise KeyStorageError(f"Failed to generate encryption key: {e}")
+
+
+# Module-level convenience functions
+_default_storage = None
+
+
+def is_key_storage_enabled() -> bool:
+    """Check if key storage is enabled in configuration."""
+    return get_config_value("key_storage", "enabled", False)
+
+
+def get_default_storage() -> KeyStorage:
+    """Get the default KeyStorage instance."""
+    global _default_storage
+    if _default_storage is None:
+        _default_storage = KeyStorage()
+    return _default_storage
+
+
+async def get_key_for_seed(seed_phrase: str) -> Optional[str]:
+    """
+    Get the most recent encryption key for a seed phrase.
+
+    Args:
+        seed_phrase: The seed phrase
+
+    Returns:
+        Base64-encoded encryption key or None if not found
+    """
+    return await get_default_storage().get_key_for_seed(seed_phrase)
+
+
+async def set_key_for_seed(seed_phrase: str, encryption_key_b64: str) -> None:
+    """
+    Store a new encryption key for a seed phrase.
+
+    Args:
+        seed_phrase: The seed phrase
+        encryption_key_b64: Base64-encoded encryption key
+    """
+    return await get_default_storage().set_key_for_seed(seed_phrase, encryption_key_b64)
+
+
+async def generate_and_store_key_for_seed(seed_phrase: str) -> str:
+    """
+    Generate a new encryption key and store it for the seed phrase.
+
+    Args:
+        seed_phrase: The seed phrase
+
+    Returns:
+        Base64-encoded encryption key that was generated and stored
+    """
+    return await get_default_storage().generate_and_store_key_for_seed(seed_phrase)

{hippius-0.2.14 → hippius-0.2.16}/hippius_sdk/substrate.py

@@ -69,6 +69,7 @@ class SubstrateClient:
         url: Optional[str] = None,
         password: Optional[str] = None,
         account_name: Optional[str] = None,
+        seed_phrase: Optional[str] = None,
     ):
         """
         Initialize the Substrate client.
@@ -77,6 +78,7 @@ class SubstrateClient:
             url: WebSocket URL of the Hippius substrate node (from config if None)
             password: Optional password to decrypt the seed phrase if it's encrypted
             account_name: Optional name of the account to use (uses active account if None)
+            seed_phrase: Optional unencrypted seed phrase to use directly (bypasses config)
         """
         # Load configuration values if not explicitly provided
         if url is None:
@@ -96,8 +98,7 @@ class SubstrateClient:
         if addr:
             self._account_address = addr
 
-        # For backward compatibility - storing the seed phrase is deprecated but needed for older code
-        self._seed_phrase = None
+        self._seed_phrase = seed_phrase  # Use passed seed phrase if provided
 
         # Don't connect immediately to avoid exceptions during initialization
         # Connection will happen lazily when needed
@@ -595,33 +596,19 @@ class SubstrateClient:
         }
 
         # Create the call to the marketplace
-        try:
-            call = self._substrate.compose_call(
-                call_module="Marketplace",
-                call_function="storage_request",
-                call_params=call_params,
-            )
-        except Exception as e:
-            print(f"Warning: Error composing call: {e}")
-            print("Attempting to use IpfsPallet.storeFile instead...")
-
-            # Try with IpfsPallet.storeFile as an alternative
-            alt_call_params = {
-                "fileHash": files_list_cid,
-                "fileName": f"files_list_{uuid.uuid4()}",  # Generate a unique ID
-            }
-            call = self._substrate.compose_call(
-                call_module="IpfsPallet",
-                call_function="storeFile",
-                call_params=alt_call_params,
-            )
+        call = self._substrate.compose_call(
+            call_module="Marketplace",
+            call_function="storage_request",
+            call_params=call_params,
+        )
 
         # Get payment info to estimate the fee
         payment_info = self._substrate.get_payment_info(
-            call=call, keypair=self._keypair
+            call=call,
+            keypair=self._keypair,
         )
 
-        print(f"Payment info: {json.dumps(payment_info, indent=2)}")
+        print(f"]Payment info: {json.dumps(payment_info, indent=2)}")
 
         # Convert partialFee from Substrate (10^18 units) to a more readable format
         estimated_fee = payment_info.get("partialFee", 0)

{hippius-0.2.14 → hippius-0.2.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hippius"
-version = "0.2.14"
+version = "0.2.16"
 description = "Python SDK and CLI for Hippius blockchain storage"
 authors = ["Dubs <dubs@dubs.rs>"]
 readme = "README.md"
@@ -28,12 +28,14 @@ base58 = "^2.1.1"
 pynacl = "^1.5.0"
 cryptography = "^44.0.0"
 pyperclip = {version = "^1.8.2", optional = true}
+asyncpg = {version = "^0.29.0", optional = true}
 zfec = "^1.5.3"
 mnemonic = "^0.20"
 rich = "^14.0.0"
 
 [tool.poetry.extras]
 clipboard = ["pyperclip"]
+key_storage = ["asyncpg"]
 
 [tool.poetry.scripts]
 hippius = "hippius_sdk.cli:main"