hippius 0.2.15__tar.gz → 0.2.17__tar.gz

{hippius-0.2.15 → hippius-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.15
+Version: 0.2.17
 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.15 → hippius-0.2.17}/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.15"
+__version__ = "0.2.17"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.15 → hippius-0.2.17}/hippius_sdk/cli_parser.py

@@ -81,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
 """,
     )
 
@@ -219,7 +223,8 @@ def add_storage_commands(subparsers):
 
     # 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",
+        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(
@@ -439,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")
 
@@ -447,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.15 → hippius-0.2.17}/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.15 → hippius-0.2.17}/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.17/hippius_sdk/db/README.md

@@ -0,0 +1,86 @@
+# Database Migrations for Hippius Key Storage
+
+This directory contains database migrations for the Hippius SDK key storage feature.
+
+## Setup for End Users
+
+If you've installed hippius-sdk as a dependency, you can set up the database files in your project:
+
+```bash
+# Copy database files to your project
+hippius-setup-db
+
+# Edit the database URL
+cp env.db.template .env.db
+# Edit .env.db with your database credentials
+
+# Run the setup
+./setup_database.sh
+```
+
+## Development Setup
+
+1. **Install dbmate**:
+   ```bash
+   brew install dbmate
+   # or download directly
+   curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-macos-amd64
+   chmod +x /usr/local/bin/dbmate
+   ```
+
+2. **Run the setup script**:
+   ```bash
+   ./setup_database.sh
+   ```
+
+## Manual Setup
+
+If you prefer to run migrations manually:
+
+```bash
+# Set database URL
+export DATABASE_URL=postgresql://postgres:postgres@localhost:5432/hippius_keys?sslmode=disable
+
+# Create database
+createdb hippius_keys
+
+# Run migrations
+dbmate up
+
+# Configure SDK
+hippius config set key_storage database_url "postgresql://postgres:postgres@localhost:5432/hippius_keys?sslmode=disable"
+hippius config set key_storage enabled true
+```
+
+## Database Schema
+
+### Tables
+
+- **`seed_phrases`**: Stores hashed seed phrases with base64 encoded values
+- **`encryption_keys`**: Stores versioned encryption keys per seed phrase (never deleted)
+
+### Key Features
+
+- **Versioned keys**: New keys create new rows, old keys are never deleted
+- **Efficient lookups**: Index on `(seed_hash, created_at DESC)` for fast retrieval of latest key
+- **Secure storage**: Seed phrases are hashed for indexing, stored base64 encoded
+- **Foreign key constraints**: Ensures data integrity between tables
+
+## Migration Commands
+
+```bash
+# Check migration status
+dbmate status
+
+# Create new migration
+dbmate new migration_name
+
+# Run migrations
+dbmate up
+
+# Rollback last migration
+dbmate down
+
+# Reset database (drop and recreate)
+dbmate drop && dbmate up
+```

hippius-0.2.17/hippius_sdk/db/env.db.template

@@ -0,0 +1,9 @@
+# Database connection parameters for Hippius key storage
+# Edit these values to match your PostgreSQL setup
+
+DB_HOST=localhost
+DB_PORT=5432
+DB_USER=postgres
+DB_PASSWORD=postgres
+DB_NAME=hippius_keys
+DB_SSLMODE=disable

hippius-0.2.17/hippius_sdk/db/migrations/20241201000001_create_key_storage_tables.sql

@@ -0,0 +1,37 @@
+-- migrate:up
+
+-- Table to store base64 encoded seed phrases (hashed for indexing)
+CREATE TABLE 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
+);
+
+-- Table to store encryption keys associated with each seed phrase (versioned, never deleted)
+CREATE TABLE 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) ON DELETE CASCADE
+);
+
+-- Index for efficient lookups of latest encryption key per seed phrase
+CREATE INDEX idx_encryption_keys_seed_hash_created 
+ON encryption_keys(seed_hash, created_at DESC);
+
+-- Comments for documentation
+COMMENT ON TABLE seed_phrases IS 'Stores hashed seed phrases with base64 encoded values';
+COMMENT ON TABLE encryption_keys IS 'Stores versioned encryption keys per seed phrase (never deleted, always use most recent)';
+COMMENT ON COLUMN seed_phrases.seed_hash IS 'SHA-256 hash of the seed phrase for indexing';
+COMMENT ON COLUMN seed_phrases.seed_phrase_b64 IS 'Base64 encoded seed phrase';
+COMMENT ON COLUMN encryption_keys.seed_hash IS 'Reference to the seed phrase hash';
+COMMENT ON COLUMN encryption_keys.encryption_key_b64 IS 'Base64 encoded encryption key';
+
+-- migrate:down
+
+-- Drop tables in reverse order due to foreign key constraints
+DROP INDEX IF EXISTS idx_encryption_keys_seed_hash_created;
+DROP TABLE IF EXISTS encryption_keys;
+DROP TABLE IF EXISTS seed_phrases;

hippius-0.2.17/hippius_sdk/db/setup_database.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# Database setup script for Hippius key storage
+
+set -e
+
+echo "🗄️  Setting up Hippius key storage database..."
+
+# Check if .env.db exists, if not create from template
+if [ ! -f .env.db ]; then
+    if [ -f hippius_sdk/db/env.db.template ]; then
+        echo "📋 Creating .env.db from template..."
+        cp hippius_sdk/db/env.db.template .env.db
+        echo "✏️  Please edit .env.db with your database credentials"
+    elif [ -f env.db.template ]; then
+        cp env.db.template .env.db
+        echo "✏️  Please edit .env.db with your database credentials"
+    else
+        echo "❌ No .env.db file found and no template available"
+        echo "Please create .env.db with your database connection parameters:"
+        echo "DB_HOST=localhost"
+        echo "DB_PORT=5432"
+        echo "DB_USER=postgres"
+        echo "DB_PASSWORD=your_password"
+        echo "DB_NAME=hippius_keys"
+        echo "DB_SSLMODE=disable"
+        exit 1
+    fi
+fi
+
+# Load database connection parameters from env file
+source .env.db
+
+echo "📊 Database connection details:"
+echo "  Host: $DB_HOST"
+echo "  Port: $DB_PORT"
+echo "  User: $DB_USER"
+echo "  Database: $DB_NAME"
+echo "  SSL Mode: $DB_SSLMODE"
+
+# Construct DATABASE_URL for dbmate
+export DATABASE_URL="postgresql://$DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME?sslmode=$DB_SSLMODE"
+
+# Create database if it doesn't exist
+echo "📝 Creating database $DB_NAME..."
+PGPASSWORD=$DB_PASSWORD createdb -h $DB_HOST -p $DB_PORT -U $DB_USER $DB_NAME 2>/dev/null || echo "Database $DB_NAME already exists"
+
+# Run migrations with dbmate
+echo "🚀 Running database migrations..."
+if command -v dbmate &> /dev/null; then
+    dbmate up
+    echo "✅ Database migrations completed successfully!"
+else
+    echo "❌ dbmate not found. Please install it first:"
+    echo "   brew install dbmate"
+    echo "   # or"
+    echo "   curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64"
+    echo "   chmod +x /usr/local/bin/dbmate"
+    exit 1
+fi
+
+# Configure Hippius SDK to use the database
+echo "⚙️  Configuring Hippius SDK..."
+if [ -f venv/bin/activate ]; then
+    source venv/bin/activate
+    python -c "
+from hippius_sdk.config import set_config_value
+set_config_value('key_storage', 'database_url', '$DATABASE_URL')
+set_config_value('key_storage', 'enabled', True)
+print('✅ Hippius SDK configured for key storage')
+"
+else
+    echo "⚠️  No virtual environment found. Please configure manually:"
+    echo "hippius config set key_storage database_url '$DATABASE_URL'"
+    echo "hippius config set key_storage enabled true"
+fi
+
+echo "🎉 Setup complete! Key storage is ready to use."
+echo ""
+echo "📋 What was set up:"
+echo "   - Database: hippius_keys"
+echo "   - Tables: seed_phrases, encryption_keys"
+echo "   - SDK config: key_storage enabled"
+echo ""
+echo "🧪 Test with: python test_key_storage.py"

hippius-0.2.17/hippius_sdk/db_utils.py

@@ -0,0 +1,59 @@
+"""
+Database utilities for Hippius SDK key storage.
+"""
+
+import shutil
+from pathlib import Path
+
+
+def get_db_path() -> Path:
+    """Get the path to the database files."""
+    return Path(__file__).parent / "db"
+
+
+def setup_db_cli() -> None:
+    """CLI command to set up database files in current directory."""
+    db_path = get_db_path()
+
+    print("🗄️  Setting up Hippius database files...")
+
+    # Copy database files to current directory
+    current_dir = Path.cwd()
+
+    # Copy migrations to hippius_s3/sql/sdk_migrations
+    migrations_dest = current_dir / "hippius_s3" / "sql" / "sdk_migrations"
+    migrations_dest.mkdir(parents=True, exist_ok=True)
+
+    migrations_src = db_path / "migrations"
+    if migrations_src.exists():
+        for migration_file in migrations_src.glob("*.sql"):
+            shutil.copy2(migration_file, migrations_dest)
+        print(f"📁 Copied migrations to {migrations_dest}")
+
+    # Copy setup script
+    setup_script_src = db_path / "setup_database.sh"
+    setup_script_dest = current_dir / "setup_database.sh"
+    if setup_script_src.exists():
+        shutil.copy2(setup_script_src, setup_script_dest)
+        setup_script_dest.chmod(0o755)
+        print(f"🔧 Copied setup script to {setup_script_dest}")
+
+    # Copy env template
+    env_template_src = db_path / "env.db.template"
+    env_template_dest = current_dir / "env.db.template"
+    if env_template_src.exists():
+        shutil.copy2(env_template_src, env_template_dest)
+        print(f"📝 Copied env template to {env_template_dest}")
+
+    print()
+    print("✅ Database setup files copied successfully!")
+    print()
+    print("🚀 Next steps:")
+    print(
+        "  1. Copy env.db.template to .env.db and edit with your database credentials"
+    )
+    print("  2. Run: ./setup_database.sh")
+
+
+if __name__ == "__main__":
+    setup_db_cli()

{hippius-0.2.15 → hippius-0.2.17}/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.17/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.15 → hippius-0.2.17}/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.15 → hippius-0.2.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hippius"
-version = "0.2.15"
+version = "0.2.17"
 description = "Python SDK and CLI for Hippius blockchain storage"
 authors = ["Dubs <dubs@dubs.rs>"]
 readme = "README.md"
@@ -16,6 +16,9 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
 ]
 packages = [{include = "hippius_sdk"}]
+include = [
+    "hippius_sdk/db/**/*",
+]
 
 [tool.poetry.dependencies]
 python = ">=3.8,<3.9.0 || >3.9.1,<3.14"
@@ -28,16 +31,19 @@ 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"
 hippius-keygen = "hippius_sdk.cli:key_generation_cli"
+hippius-setup-db = "hippius_sdk.db_utils:setup_db_cli"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.0.0"