hippius 0.2.30__py3-none-any.whl → 0.2.32__py3-none-any.whl

{hippius-0.2.30.dist-info → hippius-0.2.32.dist-info}/METADATA

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

{hippius-0.2.30.dist-info → hippius-0.2.32.dist-info}/RECORD

@@ -1,23 +1,24 @@
-hippius_sdk/__init__.py,sha256=0uGJ165jMUoucM0w6ftBO81B9hDfCEMRdH5mH65MD6o,1474
+hippius_sdk/__init__.py,sha256=8FFxrpAn61D-ViCK1aikqZ6-5TLbGt1T4kTHygQ1nfA,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=ft4gxn3NUvpiWm2R037BbsmJ9xOe8AiQpkrGQo4WUBw,22505
+hippius_sdk/client.py,sha256=4Y2OdoXay2tBOsZVvXyxXccDkmtQ3R8YTUtlAMZBKfU,22545
 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
 hippius_sdk/db/migrations/20241201000001_create_key_storage_tables.sql,sha256=mi4-6OofgsmJq3PTG4ew8VNucoeb7iejyqd-bado7Mc,1613
+hippius_sdk/db/migrations/20241202000001_switch_to_subaccount_encryption.sql,sha256=jBBeo2UYlEQIsyyQRPf0YsAykWpGfafN2E6dlDwAA_E,1399
 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=8OLkBkNV7zEKqrtokAwrvD842qXt8qgFMIc03h_sdN0,94610
+hippius_sdk/ipfs.py,sha256=1kjWAMeGMAn8vpIrrpjAxTHvnCwruhFtWjQ18iGXSU8,95383
 hippius_sdk/ipfs_core.py,sha256=eOOgLoyP9mvwndnCjldnTc7z94ImYCXY3nm7JU3e_Mo,12676
-hippius_sdk/key_storage.py,sha256=oxfRRQXu8XVncUjhKJJ8rsc81JAkaj9MqZEwQa96idc,9474
-hippius_sdk/substrate.py,sha256=n4V2poNUHsXWpXq6va2f8mk5LwN3JgLClWQrYmI4hmw,49671
+hippius_sdk/key_storage.py,sha256=SXFd6aGQw9MDLGX2vSBuAY7rdX-k5EvFm63z7_n-8yQ,8148
+hippius_sdk/substrate.py,sha256=MFQcJARFw-Ej1WDSPGF8ryejXLmda5DdqcwPYS-KI10,49668
 hippius_sdk/utils.py,sha256=rJ611yvwKSyiBpYU3w-SuyQxoghMGU-ePuslrPv5H5g,7388
-hippius-0.2.30.dist-info/METADATA,sha256=Wt_z03c306Pf2pMXxXMljqhh6PKs1QzC4UwGBtEmMWs,30088
-hippius-0.2.30.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-hippius-0.2.30.dist-info/entry_points.txt,sha256=bFAZjW3vndretf9-8s587jA2ebMVI7puhn_lVs8jPc8,149
-hippius-0.2.30.dist-info/RECORD,,
+hippius-0.2.32.dist-info/METADATA,sha256=8nDrlRkci7_eTNeKFQKsn2VDsQVSuAnT6esx9NVYyg8,30088
+hippius-0.2.32.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+hippius-0.2.32.dist-info/entry_points.txt,sha256=bFAZjW3vndretf9-8s587jA2ebMVI7puhn_lVs8jPc8,149
+hippius-0.2.32.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.30"
+__version__ = "0.2.32"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

hippius_sdk/client.py

@@ -516,6 +516,7 @@ class HippiusClient:
         file_path: str,
         encrypt: bool,
         seed_phrase: str,
+        subaccount_id: str,
         store_node: str = "http://localhost:5001",
         pin_node: str = "https://store.hippius.network",
         substrate_url: str = "wss://rpc.hippius.network",
@@ -548,6 +549,7 @@ class HippiusClient:
             file_path,
             encrypt,
             seed_phrase,
+            subaccount_id,
             store_node,
             pin_node,
             substrate_url,
@@ -557,7 +559,7 @@ class HippiusClient:
         self,
         cid: str,
         output_path: str,
-        seed_phrase: str,
+        subaccount_id: str,
         auto_decrypt: bool = True,
         download_node: str = "http://localhost:5001",
     ) -> S3DownloadResult:
@@ -574,7 +576,7 @@ class HippiusClient:
         Args:
             cid: Content Identifier (CID) of the file to download
             output_path: Path where the downloaded file will be saved
-            seed_phrase: Seed phrase to use for retrieving decryption keys
+            subaccount_id: The subaccount id as api key
             auto_decrypt: Whether to attempt automatic decryption (default: True)
             download_node: IPFS node URL for download (default: local node)
 
@@ -587,5 +589,5 @@ class HippiusClient:
             ValueError: If decryption fails
         """
         return await self.ipfs_client.s3_download(
-            cid, output_path, seed_phrase, auto_decrypt, download_node
+            cid, output_path, subaccount_id, auto_decrypt, download_node
         )

hippius_sdk/db/migrations/20241202000001_switch_to_subaccount_encryption.sql

@@ -0,0 +1,34 @@
+-- migrate:up
+
+-- For security reasons, completely drop all existing tables and data
+-- This removes any stored seed phrases from the database
+DROP TABLE IF EXISTS encryption_keys CASCADE;
+DROP TABLE IF EXISTS seed_phrases CASCADE;
+
+-- Create new simplified schema using only subaccount_id
+-- No seed phrases are stored in the database anymore
+CREATE TABLE encryption_keys (
+    id SERIAL PRIMARY KEY,
+    subaccount_id VARCHAR(255) NOT NULL,
+    encryption_key_b64 TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Index for efficient lookups of latest encryption key per subaccount
+CREATE INDEX idx_encryption_keys_subaccount_created 
+ON encryption_keys(subaccount_id, created_at DESC);
+
+-- Comments for documentation
+COMMENT ON TABLE encryption_keys IS 'Stores versioned encryption keys per subaccount ID (never deleted, always use most recent)';
+COMMENT ON COLUMN encryption_keys.subaccount_id IS 'Subaccount identifier for key association';
+COMMENT ON COLUMN encryption_keys.encryption_key_b64 IS 'Base64 encoded encryption key';
+
+-- migrate:down
+
+-- Drop new table
+DROP INDEX IF EXISTS idx_encryption_keys_subaccount_created;
+DROP TABLE IF EXISTS encryption_keys;
+
+-- Note: We do NOT recreate the old seed_phrases table in the down migration
+-- This is intentional for security - once we've removed seed phrases from the DB,
+-- we don't want to accidentally restore them

hippius_sdk/ipfs.py

@@ -21,8 +21,8 @@ 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,
+    generate_and_store_key_for_subaccount,
+    get_key_for_subaccount,
     is_key_storage_enabled,
 )
 from hippius_sdk.substrate import FileInput, SubstrateClient
@@ -1648,6 +1648,7 @@ class IPFSClient:
         self,
         cid: str,
         cancel_from_blockchain: bool = True,
+        unpin: bool = True,
         seed_phrase: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
@@ -1657,6 +1658,7 @@ class IPFSClient:
         Args:
             cid: Content Identifier (CID) of the file/directory to delete
             cancel_from_blockchain: Whether to also cancel the storage request from the blockchain
+            unpin: Whether to unpin the file from IPFS (default: True)
             seed_phrase: Optional seed phrase to use for blockchain interactions (uses config if None)
 
         Returns:
@@ -1709,21 +1711,26 @@ class IPFSClient:
                             ):
                                 # Recursive delete, but don't cancel from blockchain (we'll do that for parent)
                                 await self.delete_file(
-                                    link_hash, cancel_from_blockchain=False
+                                    link_hash, cancel_from_blockchain=False, unpin=unpin
                                 )
                             else:
                                 # Regular file unpin
-                                try:
-                                    await self.client.unpin(link_hash)
-                                    print(
-                                        f"Unpinned file: {link_name} (CID: {link_hash})"
-                                    )
-                                except Exception as unpin_error:
-                                    # Just note the error but don't let it stop the whole process
-                                    # This is common with IPFS servers that may return 500 errors for
-                                    # unpinning content that was never explicitly pinned
+                                if unpin:
+                                    try:
+                                        await self.client.unpin(link_hash)
+                                        print(
+                                            f"Unpinned file: {link_name} (CID: {link_hash})"
+                                        )
+                                    except Exception as unpin_error:
+                                        # Just note the error but don't let it stop the whole process
+                                        # This is common with IPFS servers that may return 500 errors for
+                                        # unpinning content that was never explicitly pinned
+                                        print(
+                                            f"Note: Could not unpin {link_name}: {str(unpin_error).split('For more information')[0]}"
+                                        )
+                                else:
                                     print(
-                                        f"Note: Could not unpin {link_name}: {str(unpin_error).split('For more information')[0]}"
+                                        f"Skipped unpinning file: {link_name} (CID: {link_hash})"
                                     )
                         except Exception as e:
                             print(
@@ -1737,27 +1744,32 @@ class IPFSClient:
             # Continue with regular file unpin
 
         # Now unpin the main file/directory
-        try:
-            print(f"Unpinning from IPFS: {cid}")
-            unpin_result = await self.client.unpin(cid)
-            result["unpin_result"] = unpin_result
-            result["success"] = True
-            print("Successfully unpinned from IPFS")
-        except Exception as e:
-            # Handle 500 errors from IPFS server gracefully - they often occur
-            # when the content wasn't explicitly pinned or was already unpinned
-            error_str = str(e)
-            if "500 Internal Server Error" in error_str:
-                print(
-                    f"Note: IPFS server reported content may already be unpinned: {cid}"
-                )
-                result["unpin_result"] = {"Pins": [cid]}  # Simulate successful unpin
+        if unpin:
+            try:
+                print(f"Unpinning from IPFS: {cid}")
+                unpin_result = await self.client.unpin(cid)
+                result["unpin_result"] = unpin_result
                 result["success"] = True
-            else:
-                print(
-                    f"Warning: Failed to unpin from IPFS: {error_str.split('For more information')[0]}"
-                )
-                result["success"] = False
+                print("Successfully unpinned from IPFS")
+            except Exception as e:
+                # Handle 500 errors from IPFS server gracefully - they often occur
+                # when the content wasn't explicitly pinned or was already unpinned
+                error_str = str(e)
+                if "500 Internal Server Error" in error_str:
+                    print(
+                        f"Note: IPFS server reported content may already be unpinned: {cid}"
+                    )
+                    result["unpin_result"] = {"Pins": [cid]}  # Simulate successful unpin
+                    result["success"] = True
+                else:
+                    print(
+                        f"Warning: Failed to unpin from IPFS: {error_str.split('For more information')[0]}"
+                    )
+                    result["success"] = False
+        else:
+            print(f"Skipped unpinning from IPFS: {cid}")
+            result["unpin_result"] = {"skipped": True}
+            result["success"] = True
 
         # Then, if requested, cancel from blockchain
         if cancel_from_blockchain:
@@ -1939,6 +1951,7 @@ class IPFSClient:
         file_path: str,
         encrypt: bool,
         seed_phrase: str,
+        subaccount_id: str,
         store_node: str = "http://localhost:5001",
         pin_node: str = "https://store.hippius.network",
         substrate_url: str = "wss://rpc.hippius.network",
@@ -1994,17 +2007,19 @@ class IPFSClient:
 
             if key_storage_available:
                 # Try to get existing key for this seed phrase
-                existing_key_b64 = await get_key_for_seed(seed_phrase)
+                existing_key_b64 = await get_key_for_subaccount(subaccount_id)
 
                 if existing_key_b64:
                     # Use existing key
-                    logger.debug("Using existing encryption key for seed phrase")
+                    logger.debug("Using existing encryption key for subaccount")
                     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)
+                    # Generate and store new key for this subaccount
+                    logger.info("Generating new encryption key for subaccount")
+                    new_key_b64 = await generate_and_store_key_for_subaccount(
+                        subaccount_id
+                    )
                     encryption_key_bytes = base64.b64decode(new_key_b64)
                     encryption_key_used = new_key_b64
 
@@ -2120,7 +2135,7 @@ class IPFSClient:
         self,
         cid: str,
         output_path: str,
-        seed_phrase: str,
+        subaccount_id: str,
         auto_decrypt: bool = True,
         download_node: str = "http://localhost:5001",
     ) -> S3DownloadResult:
@@ -2137,7 +2152,7 @@ class IPFSClient:
         Args:
             cid: Content Identifier (CID) of the file to download
             output_path: Path where the downloaded file will be saved
-            seed_phrase: Seed phrase to use for retrieving decryption keys
+            subaccount_id: The subaccount id as api key
             auto_decrypt: Whether to attempt automatic decryption (default: True)
             download_node: IPFS node URL for download (default: local node)
 
@@ -2218,11 +2233,11 @@ class IPFSClient:
                 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)
+                        existing_key_b64 = await get_key_for_subaccount(subaccount_id)
 
                         if existing_key_b64:
                             logger.debug(
-                                "Found encryption key for seed phrase, attempting decryption"
+                                "Found encryption key for subaccount, attempting decryption"
                             )
                             decryption_attempted = True
                             encryption_key_used = existing_key_b64

hippius_sdk/key_storage.py

@@ -1,15 +1,12 @@
 """
-Key storage module for managing encryption keys per seed phrase.
+Key storage module for managing encryption keys per subaccount ID.
 
 This module provides PostgreSQL-backed storage for:
-1. Base64 encoded seed phrases
-2. Encryption keys associated with each seed phrase (versioned, never deleted)
+1. Encryption keys associated with each subaccount ID (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
@@ -30,7 +27,7 @@ class KeyStorageError(Exception):
 
 
 class KeyStorage:
-    """PostgreSQL-backed key storage for seed phrases and encryption keys."""
+    """PostgreSQL-backed key storage for subaccount encryption keys."""
 
     def __init__(self, database_url: Optional[str] = None):
         """
@@ -62,34 +59,23 @@ class KeyStorage:
 
     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,
+            subaccount_id VARCHAR(255) NOT NULL,
             encryption_key_b64 TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            FOREIGN KEY (seed_hash) REFERENCES seed_phrases(seed_hash)
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         );
         """
 
         create_index = """
-        CREATE INDEX IF NOT EXISTS idx_encryption_keys_seed_hash_created 
-        ON encryption_keys(seed_hash, created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_encryption_keys_subaccount_created 
+        ON encryption_keys(subaccount_id, 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:
@@ -97,59 +83,37 @@ class KeyStorage:
         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}")
+    def _hash_subaccount_id(self, subaccount_id: str) -> str:
+        """Create a SHA-256 hash of the subaccount ID for indexing."""
+        return hashlib.sha256(subaccount_id.encode("utf-8")).hexdigest()
 
-    async def set_key_for_seed(self, seed_phrase: str, encryption_key_b64: str) -> None:
+    async def set_key_for_subaccount(
+        self, subaccount_id: str, encryption_key_b64: str
+    ) -> None:
         """
-        Store a new encryption key for a seed phrase.
+        Store a new encryption key for a subaccount.
 
         Creates a new row (doesn't update existing ones) to maintain key history.
 
         Args:
-            seed_phrase: The seed phrase
+            subaccount_id: The subaccount identifier
             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)
+        subaccount_hash = self._hash_subaccount_id(subaccount_id)
 
         try:
             conn = await self._get_connection()
             try:
                 await conn.execute(
                     """
-                    INSERT INTO encryption_keys (seed_hash, encryption_key_b64)
+                    INSERT INTO encryption_keys (subaccount_id, encryption_key_b64)
                     VALUES ($1, $2)
                 """,
-                    seed_hash,
+                    subaccount_hash,
                     encryption_key_b64,
                 )
             finally:
@@ -157,12 +121,12 @@ class KeyStorage:
         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]:
+    async def get_key_for_subaccount(self, subaccount_id: str) -> Optional[str]:
         """
-        Get the most recent encryption key for a seed phrase.
+        Get the most recent encryption key for a subaccount.
 
         Args:
-            seed_phrase: The seed phrase
+            subaccount_id: The subaccount identifier
 
         Returns:
             Base64-encoded encryption key or None if not found
@@ -171,7 +135,7 @@ class KeyStorage:
             KeyStorageError: If database operation fails
         """
         await self._ensure_tables_exist()
-        seed_hash = self._hash_seed_phrase(seed_phrase)
+        subaccount_hash = self._hash_subaccount_id(subaccount_id)
 
         try:
             conn = await self._get_connection()
@@ -180,11 +144,11 @@ class KeyStorage:
                     """
                     SELECT encryption_key_b64 
                     FROM encryption_keys 
-                    WHERE seed_hash = $1 
+                    WHERE subaccount_id = $1 
                     ORDER BY created_at DESC 
                     LIMIT 1
                 """,
-                    seed_hash,
+                    subaccount_hash,
                 )
 
                 return result["encryption_key_b64"] if result else None
@@ -193,12 +157,12 @@ class KeyStorage:
         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:
+    async def generate_and_store_key_for_subaccount(self, subaccount_id: str) -> str:
         """
-        Generate a new encryption key and store it for the seed phrase.
+        Generate a new encryption key and store it for the subaccount.
 
         Args:
-            seed_phrase: The seed phrase
+            subaccount_id: The subaccount identifier
 
         Returns:
             Base64-encoded encryption key that was generated and stored
@@ -206,17 +170,14 @@ class KeyStorage:
         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)
+            await self.set_key_for_subaccount(subaccount_id, key_b64)
 
             return key_b64
         except ImportError:
@@ -261,38 +222,42 @@ def get_default_storage() -> KeyStorage:
     return _default_storage
 
 
-async def get_key_for_seed(seed_phrase: str) -> Optional[str]:
+async def get_key_for_subaccount(subaccount_id: str) -> Optional[str]:
     """
-    Get the most recent encryption key for a seed phrase.
+    Get the most recent encryption key for a subaccount.
 
     Args:
-        seed_phrase: The seed phrase
+        subaccount_id: The subaccount identifier
 
     Returns:
         Base64-encoded encryption key or None if not found
     """
-    return await get_default_storage().get_key_for_seed(seed_phrase)
+    return await get_default_storage().get_key_for_subaccount(subaccount_id)
 
 
-async def set_key_for_seed(seed_phrase: str, encryption_key_b64: str) -> None:
+async def set_key_for_subaccount(subaccount_id: str, encryption_key_b64: str) -> None:
     """
-    Store a new encryption key for a seed phrase.
+    Store a new encryption key for a subaccount.
 
     Args:
-        seed_phrase: The seed phrase
+        subaccount_id: The subaccount identifier
         encryption_key_b64: Base64-encoded encryption key
     """
-    return await get_default_storage().set_key_for_seed(seed_phrase, encryption_key_b64)
+    return await get_default_storage().set_key_for_subaccount(
+        subaccount_id, encryption_key_b64
+    )
 
 
-async def generate_and_store_key_for_seed(seed_phrase: str) -> str:
+async def generate_and_store_key_for_subaccount(subaccount_id: str) -> str:
     """
-    Generate a new encryption key and store it for the seed phrase.
+    Generate a new encryption key and store it for the subaccount.
 
     Args:
-        seed_phrase: The seed phrase
+        subaccount_id: The subaccount identifier
 
     Returns:
         Base64-encoded encryption key that was generated and stored
     """
-    return await get_default_storage().generate_and_store_key_for_seed(seed_phrase)
+    return await get_default_storage().generate_and_store_key_for_subaccount(
+        subaccount_id
+    )

hippius_sdk/substrate.py

@@ -1270,7 +1270,6 @@ class SubstrateClient:
             return result.value
         return None
 
-
     def is_main_account(self, account_id: str, seed_phrase: str) -> bool:
         sub_account = self.query_sub_account(account_id, seed_phrase=seed_phrase)
         return sub_account is None
@@ -1288,8 +1287,6 @@ class SubstrateClient:
         # Return the u128 value (converted to int for Python compatibility)
         return int(result.value) if result and result.value is not None else 0
 
-
-
     def get_account_roles(self, account_id: str, seed_phrase) -> int:
         if not self._substrate:
             self.connect(seed_phrase)