hippius 0.1.6__py3-none-any.whl → 0.1.9__py3-none-any.whl

hippius_sdk/substrate.py

@@ -6,9 +6,17 @@ Note: This functionality is coming soon and not implemented yet.
 
 import os
 import json
+import uuid
 from typing import Dict, Any, Optional, List, Union
 from substrateinterface import SubstrateInterface, Keypair
 from dotenv import load_dotenv
+from hippius_sdk.config import (
+    get_config_value,
+    get_seed_phrase,
+    set_seed_phrase,
+    get_account_address,
+    get_active_account,
+)
 
 # Load environment variables
 load_dotenv()
@@ -37,32 +45,51 @@ class SubstrateClient:
     """
     Client for interacting with the Hippius Substrate blockchain.
 
+    Provides functionality for storage requests and other blockchain operations.
     Note: This functionality is not fully implemented yet and is under active development.
     """
 
-    def __init__(self, url: str = None, seed_phrase: Optional[str] = None):
+    def __init__(
+        self,
+        url: Optional[str] = None,
+        seed_phrase: Optional[str] = None,
+        password: Optional[str] = None,
+        account_name: Optional[str] = None,
+    ):
         """
         Initialize the Substrate client.
 
         Args:
-            url: WebSocket URL of the Hippius substrate node
-                If not provided, uses SUBSTRATE_URL from environment
-            seed_phrase: Seed phrase for the account (mnemonic)
-                If not provided, uses SUBSTRATE_SEED_PHRASE from environment
+            url: WebSocket URL of the Hippius substrate node (from config if None)
+            seed_phrase: Seed phrase for the account (mnemonic) (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)
         """
-        if not url:
-            url = os.getenv("SUBSTRATE_URL", "wss://rpc.hippius.network")
+        # Load configuration values if not explicitly provided
+        if url is None:
+            url = get_config_value("substrate", "url", "wss://rpc.hippius.network")
 
         # Store URL and initialize variables
         self.url = url
         self._substrate = None
         self._keypair = None
+        self._account_name = account_name or get_active_account()
+        self._account_address = None
+        self._read_only = False
+
+        # Get the account address for read-only operations
+        addr = get_account_address(self._account_name)
+        if addr:
+            self._account_address = addr
 
-        # Set seed phrase if provided or available in environment
+        # Set seed phrase if provided or available in configuration
         if seed_phrase:
             self.set_seed_phrase(seed_phrase)
-        elif os.getenv("SUBSTRATE_SEED_PHRASE"):
-            self.set_seed_phrase(os.getenv("SUBSTRATE_SEED_PHRASE"))
+        else:
+            # Only try to get the seed phrase if we need it for the current operation
+            # We'll defer this to when it's actually needed
+            self._seed_phrase = None
+            self._seed_phrase_password = password
 
         # Don't connect immediately to avoid exceptions during initialization
         # Connection will happen lazily when needed
@@ -84,11 +111,19 @@ class SubstrateClient:
             # Only create keypair if seed phrase is available
             if hasattr(self, "_seed_phrase") and self._seed_phrase:
                 self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
+                self._account_address = self._keypair.ss58_address
                 print(
                     f"Connected successfully. Account address: {self._keypair.ss58_address}"
                 )
+                self._read_only = False
+            elif self._account_address:
+                print(
+                    f"Connected successfully in read-only mode. Account address: {self._account_address}"
+                )
+                self._read_only = True
             else:
-                print("Connected successfully (read-only mode, no keypair)")
+                print("Connected successfully (read-only mode, no account)")
+                self._read_only = True
 
             return True
 
@@ -100,6 +135,48 @@ class SubstrateClient:
 
         return False
 
+    def _ensure_keypair(self) -> bool:
+        """
+        Ensure we have a keypair for signing transactions.
+        Will prompt for password if needed.
+
+        Returns:
+            bool: True if keypair is available, False if it couldn't be created
+        """
+        if self._keypair:
+            return True
+
+        # If we have a seed phrase, create the keypair
+        if hasattr(self, "_seed_phrase") and self._seed_phrase:
+            try:
+                self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
+                self._account_address = self._keypair.ss58_address
+                print(f"Keypair created for account: {self._keypair.ss58_address}")
+                self._read_only = False
+                return True
+            except Exception as e:
+                print(f"Warning: Could not create keypair from seed phrase: {e}")
+                return False
+
+        # Otherwise, try to get the seed phrase from config
+        try:
+            config_seed = get_seed_phrase(
+                self._seed_phrase_password, self._account_name
+            )
+            if config_seed:
+                self._seed_phrase = config_seed
+                self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
+                self._account_address = self._keypair.ss58_address
+                print(f"Keypair created for account: {self._keypair.ss58_address}")
+                self._read_only = False
+                return True
+            else:
+                print("No seed phrase available. Cannot sign transactions.")
+                return False
+        except Exception as e:
+            print(f"Warning: Could not get seed phrase from config: {e}")
+            return False
+
     def set_seed_phrase(self, seed_phrase: str) -> None:
         """
         Set or update the seed phrase used for signing transactions.
@@ -110,17 +187,15 @@ class SubstrateClient:
         if not seed_phrase or not seed_phrase.strip():
             raise ValueError("Seed phrase cannot be empty")
 
-        # Store the seed phrase
+        # Store the seed phrase in memory for this session
         self._seed_phrase = seed_phrase.strip()
+        self._read_only = False
 
         # Try to create the keypair if possible
         try:
-            if hasattr(self, "_substrate") and self._substrate:
-                # If we already have a connection, create the keypair
-                self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
-                print(f"Keypair created for account: {self._keypair.ss58_address}")
-            else:
-                print(f"Seed phrase set (keypair will be created when connecting)")
+            self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
+            self._account_address = self._keypair.ss58_address
+            print(f"Keypair created for account: {self._keypair.ss58_address}")
         except Exception as e:
             print(f"Warning: Could not create keypair from seed phrase: {e}")
             print(f"Keypair will be created when needed")
@@ -131,8 +206,8 @@ class SubstrateClient:
         """
         Submit a storage request for IPFS files to the marketplace.
 
-        This method batches all files into a single transaction to efficiently store
-        multiple files at once.
+        This method creates a JSON file with the list of files to pin, uploads it to IPFS,
+        and submits the CID of this file to the chain.
 
         Args:
             files: List of FileInput objects or dictionaries with fileHash and fileName
@@ -147,6 +222,10 @@ class SubstrateClient:
             ...     FileInput("QmHash2", "file2.jpg")
             ... ])
         """
+        # Check if we have a keypair for signing transactions
+        if not self._ensure_keypair():
+            raise ValueError("Seed phrase must be set before making transactions")
+
         # Convert any dict inputs to FileInput objects
         file_inputs = []
         for file in files:
@@ -163,7 +242,7 @@ class SubstrateClient:
                 file_inputs.append(file)
 
         # Print what is being submitted
-        print(f"Submitting storage request for {len(file_inputs)} files as a batch:")
+        print(f"Preparing storage request for {len(file_inputs)} files:")
         for file in file_inputs:
             print(f"  - {file.file_name}: {file.file_hash}")
 
@@ -183,36 +262,50 @@ class SubstrateClient:
                 )
                 print(f"Connected to Substrate node at {self.url}")
 
-            # Create keypair from seed phrase if not already created
-            if not hasattr(self, "_keypair") or self._keypair is None:
-                if not hasattr(self, "_seed_phrase") or not self._seed_phrase:
-                    raise ValueError(
-                        "Seed phrase must be set before making transactions"
-                    )
-
-                print("Creating keypair from seed phrase...")
-                self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
-                print(f"Keypair created for address: {self._keypair.ss58_address}")
-
-            # Prepare storage request call
-            print("Preparing marketplace.storageRequest batch call...")
-
-            # Format files for the batch call - all files are included in a single array
-            formatted_files = []
+            # Step 1: Create a JSON file with the list of files to pin
+            file_list = []
             for file_input in file_inputs:
-                formatted_files.append(
-                    {
-                        "file_hash": file_input.file_hash,
-                        "file_name": file_input.file_name,
-                    }
+                file_list.append(
+                    {"filename": file_input.file_name, "cid": file_input.file_hash}
                 )
 
-            # Create call parameters with all files in a single batch
+            # Convert to JSON
+            files_json = json.dumps(file_list, indent=2)
+            print(f"Created file list with {len(file_list)} entries")
+
+            # Step 2: Upload the JSON file to IPFS
+            import tempfile
+            from hippius_sdk.ipfs import IPFSClient
+
+            ipfs_client = IPFSClient()
+
+            # Create a temporary file with the JSON content
+            with tempfile.NamedTemporaryFile(
+                mode="w+", suffix=".json", delete=False
+            ) as temp_file:
+                temp_file_path = temp_file.name
+                temp_file.write(files_json)
+
+            try:
+                print("Uploading file list to IPFS...")
+                upload_result = ipfs_client.upload_file(temp_file_path)
+                files_list_cid = upload_result["cid"]
+                print(f"File list uploaded to IPFS with CID: {files_list_cid}")
+            finally:
+                # Clean up the temporary file
+                if os.path.exists(temp_file_path):
+                    os.remove(temp_file_path)
+
+            # Step 3: Submit the CID of the JSON file to the chain
+            # Create call parameters with the CID of the JSON file
             call_params = {
-                "files_input": formatted_files,
-                "miner_ids": miner_ids
-                if miner_ids
-                else [],  # Always include miner_ids, empty array if not specified
+                "files_input": [
+                    {
+                        "file_hash": files_list_cid,
+                        "file_name": f"files_list_{uuid.uuid4()}",  # Generate a unique ID
+                    }
+                ],
+                "miner_ids": miner_ids if miner_ids else [],
             }
 
             # Create the call to the marketplace
@@ -236,7 +329,9 @@ class SubstrateClient:
                 call=call, keypair=self._keypair
             )
 
-            print(f"Submitting batch transaction for {len(formatted_files)} files...")
+            print(
+                f"Submitting transaction to store {len(file_list)} files via file list CID..."
+            )
 
             # Submit the transaction
             response = self._substrate.submit_extrinsic(
@@ -246,11 +341,10 @@ class SubstrateClient:
             # Get the transaction hash
             tx_hash = response.extrinsic_hash
 
-            print(f"Batch transaction submitted successfully!")
+            print(f"Transaction submitted successfully!")
             print(f"Transaction hash: {tx_hash}")
-            print(
-                f"All {len(formatted_files)} files have been stored in a single transaction"
-            )
+            print(f"File list CID: {files_list_cid}")
+            print(f"All {len(file_list)} files will be stored through this request")
 
             return tx_hash
 
@@ -315,6 +409,10 @@ class SubstrateClient:
         Returns:
             str: Transaction hash
         """
+        # This requires a keypair for signing
+        if not self._ensure_keypair():
+            raise ValueError("Seed phrase must be set before making transactions")
+
         raise NotImplementedError("Substrate functionality is not implemented yet.")
 
     def get_storage_fee(self, file_size_mb: float) -> float:
@@ -369,19 +467,17 @@ class SubstrateClient:
                 )
                 print(f"Connected to Substrate node at {self.url}")
 
-            # Use provided account address or default to keypair address
+            # Use provided account address or default to keypair/configured address
             if not account_address:
-                if not hasattr(self, "_keypair") or self._keypair is None:
-                    if not hasattr(self, "_seed_phrase") or not self._seed_phrase:
-                        raise ValueError(
-                            "No account address provided and no seed phrase is set"
-                        )
-
-                    print("Creating keypair from seed phrase to get account address...")
-                    self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
-
-                account_address = self._keypair.ss58_address
-                print(f"Using keypair address: {account_address}")
+                if self._account_address:
+                    account_address = self._account_address
+                    print(f"Using account address: {account_address}")
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+                    print(f"Using keypair address: {account_address}")
 
             # Query the blockchain for free credits
             print(f"Querying free credits for account: {account_address}")
@@ -435,19 +531,17 @@ class SubstrateClient:
                 )
                 print(f"Connected to Substrate node at {self.url}")
 
-            # Use provided account address or default to keypair address
+            # Use provided account address or default to keypair/configured address
             if not account_address:
-                if not hasattr(self, "_keypair") or self._keypair is None:
-                    if not hasattr(self, "_seed_phrase") or not self._seed_phrase:
-                        raise ValueError(
-                            "No account address provided and no seed phrase is set"
-                        )
-
-                    print("Creating keypair from seed phrase to get account address...")
-                    self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
-
-                account_address = self._keypair.ss58_address
-                print(f"Using keypair address: {account_address}")
+                if self._account_address:
+                    account_address = self._account_address
+                    print(f"Using account address: {account_address}")
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+                    print(f"Using keypair address: {account_address}")
 
             # Query the blockchain for user file hashes
             print(f"Querying file hashes for account: {account_address}")
@@ -516,19 +610,17 @@ class SubstrateClient:
                 )
                 print(f"Connected to Substrate node at {self.url}")
 
-            # Use provided account address or default to keypair address
+            # Use provided account address or default to keypair/configured address
             if not account_address:
-                if not hasattr(self, "_keypair") or self._keypair is None:
-                    if not hasattr(self, "_seed_phrase") or not self._seed_phrase:
-                        raise ValueError(
-                            "No account address provided and no seed phrase is set"
-                        )
-
-                    print("Creating keypair from seed phrase to get account address...")
-                    self._keypair = Keypair.create_from_mnemonic(self._seed_phrase)
-
-                account_address = self._keypair.ss58_address
-                print(f"Using keypair address: {account_address}")
+                if self._account_address:
+                    account_address = self._account_address
+                    print(f"Using account address: {account_address}")
+                else:
+                    # Try to get the address from the keypair (requires seed phrase)
+                    if not self._ensure_keypair():
+                        raise ValueError("No account address available")
+                    account_address = self._keypair.ss58_address
+                    print(f"Using keypair address: {account_address}")
 
             # Prepare the JSON-RPC request
             request = {

hippius-0.1.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-hippius_sdk/__init__.py,sha256=SwOREu9EJZ9ZRM-rSPX0o1hhsOUIADuP3CxoF4Mp_qI,288
-hippius_sdk/cli.py,sha256=WfjU9nuUBXN6Tu25PnOpLHftClP_umh6Zl9t4BOzAfo,30576
-hippius_sdk/client.py,sha256=bHsoadw2WMMZDU7D0r02nHeU82PAa4cvmblieDzBw54,13305
-hippius_sdk/ipfs.py,sha256=C9oMTBefCIfWFUsUBxhUkivz5rIUkhHKJtqdVIkMAbc,61475
-hippius_sdk/substrate.py,sha256=mfDxbKn9HdtcK1xEnj_BnnreRw8ITZswtDoBhtliidM,27278
-hippius-0.1.6.dist-info/METADATA,sha256=295Uv9mZq1G0pypT4PibEmTDVNRr7gM_ScFNVPZTfdo,16580
-hippius-0.1.6.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-hippius-0.1.6.dist-info/entry_points.txt,sha256=b1lo60zRXmv1ud-c5BC-cJcAfGE5FD4qM_nia6XeQtM,98
-hippius-0.1.6.dist-info/RECORD,,