cartha-cli 1.0.7__tar.gz → 1.0.8__tar.gz

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cartha-cli
-Version: 1.0.7
+Version: 1.0.8
 Summary: CLI utilities for Cartha subnet miners.
 Project-URL: Homepage, https://cartha.finance
 Project-URL: Repository, https://github.com/General-Tao-Ventures/cartha-cli

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/config.py

@@ -17,7 +17,7 @@ from .common import console
 ENV_VAR_DOCS: dict[str, dict[str, Any]] = {
     "CARTHA_VERIFIER_URL": {
         "description": "URL of the Cartha verifier service",
-        "default": "https://cartha-verifier-826542474079.us-central1.run.app",
+        "default": "https://cartha-verifier-193291340038.us-central1.run.app",
         "required": False,
     },
     "CARTHA_NETWORK": {

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/miner_password.py

@@ -69,13 +69,6 @@ def miner_password(
             netuid = 78
         elif network == "finney":
             netuid = 35
-            # Warn that mainnet is not live yet
-            console.print()
-            console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
-            console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78).[/]")
-            console.print("[yellow]Mainnet (subnet 35) has not been announced yet.[/]")
-            console.print("[dim]Use --network test to access testnet.[/]")
-            console.print()
         # Note: netuid parameter is kept for backwards compatibility / explicit override
         
         from ..config import get_verifier_url_for_network

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/miner_status.py

@@ -79,13 +79,6 @@ def miner_status(
             netuid = 78
         elif network == "finney":
             netuid = 35
-            # Warn that mainnet is not live yet
-            console.print()
-            console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
-            console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78).[/]")
-            console.print("[yellow]Mainnet (subnet 35) has not been announced yet.[/]")
-            console.print("[dim]Use --network test to access testnet.[/]")
-            console.print()
         # Note: netuid parameter is kept for backwards compatibility / explicit override
         
         from ..config import get_verifier_url_for_network
@@ -488,25 +481,14 @@ def miner_status(
 
             console.print(pool_table)
 
-        # Concise reminder
-        console.print()
-        console.print("[bold cyan]━━━ Reminders ━━━[/]")
-        console.print(
-            "• Lock expiration: USDC returned automatically, emissions stop for that pool."
-        )
-        console.print(
-            "• Top-ups/extensions: Happen automatically on-chain. No CLI action needed."
-        )
-        if pools and len(pools) > 1:
-            console.print(
-                "• Multiple pools: Each pool is tracked separately. Expired pools stop earning, others continue."
-            )
-        
         # Link to web interface
         console.print()
         console.print("[bold cyan]━━━ Web Interface ━━━[/]")
         console.print(
-            "[cyan]🌐 View and manage your positions:[/] [bold]https://cartha.finance[/]"
+            "[cyan]🌐 Manage your positions:[/] [bold]https://cartha.finance[/]"
+        )
+        console.print(
+            "[dim]  • Deposit new lock positions[/]"
         )
         console.print(
             "[dim]  • View all your lock positions[/]"
@@ -517,8 +499,5 @@ def miner_status(
         console.print(
             "[dim]  • Top up existing positions[/]"
         )
-        console.print(
-            "[dim]  • Claim testnet USDC from faucet[/]"
-        )
 
     return

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/pair_status.py

@@ -34,26 +34,8 @@ from .shared_options import (
     json_output_option,
 )
 
-# Import pool name helper
-# Initialize fallback function first to ensure it's always defined
-def _fallback_pool_id_to_name(pool_id: str) -> str | None:
-    """Simple fallback to decode pool ID."""
-    try:
-        hex_str = pool_id.lower().removeprefix("0x")
-        pool_bytes = bytes.fromhex(hex_str)
-        name = pool_bytes.rstrip(b"\x00").decode("utf-8", errors="ignore")
-        if name and name.isprintable():
-            return name
-    except Exception:
-        pass
-    return None
-
-# Try to import from testnet module, fallback to default if not available
-try:
-    from ..testnet.pool_ids import pool_id_to_name
-except (ImportError, ModuleNotFoundError):
-    # Use fallback function
-    pool_id_to_name = _fallback_pool_id_to_name
+# Import pool name helper from pool_client (fetches from verifier API)
+from ..pool_client import pool_id_to_name
 
 
 def pair_status(
@@ -100,13 +82,6 @@ def pair_status(
             netuid = 78
         elif network == "finney":
             netuid = 35
-            # Warn that mainnet is not live yet
-            console.print()
-            console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
-            console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78).[/]")
-            console.print("[yellow]Mainnet (subnet 35) has not been announced yet.[/]")
-            console.print("[dim]Use --network test to access testnet.[/]")
-            console.print()
         # Note: netuid parameter is kept for backwards compatibility / explicit override
         
         from ..config import get_verifier_url_for_network

cartha_cli-1.0.8/cartha_cli/commands/pools.py

@@ -0,0 +1,89 @@
+"""Pools command - show current available pools."""
+
+from __future__ import annotations
+
+import typer
+
+from .common import console
+from ..verifier import VerifierError, fetch_pools
+
+
+def pools(
+    json_output: bool = typer.Option(
+        False, "--json", help="Emit responses as JSON."
+    ),
+) -> None:
+    """Show all available pools with their names, IDs, vault addresses, and chain IDs.
+    
+    USAGE:
+    ------
+    cartha vault pools (or: cartha v pools)
+    cartha vault pools --json (for JSON output)
+    
+    OUTPUT:
+    -------
+    - Pool names: BTC/USD, ETH/USD, EUR/USD, etc.
+    - Pool IDs: Full hex identifiers (0x...)
+    - Vault addresses: Contract addresses for each pool
+    - Chain IDs: Which blockchain network (8453 for Base Mainnet, 84532 for Base Sepolia)
+    
+    Use these pool names directly in 'cartha vault lock -p BTCUSD ...'
+    """
+    try:
+        # Fetch pools from verifier API
+        pools_list = fetch_pools()
+
+        if json_output:
+            # JSON output format
+            import json
+            console.print(json.dumps(pools_list, indent=2))
+            return
+
+        # Multi-line text output
+        if not pools_list:
+            console.print("[yellow]No pools available.[/]")
+            return
+
+        console.print("\n[bold cyan]Available Pools[/]\n")
+
+        for idx, pool in enumerate(pools_list, 1):
+            pool_name = pool.get("name", "Unknown")
+            # Verifier returns camelCase keys
+            pool_id_hex = pool.get("poolId", "")
+            vault_addr = pool.get("vaultAddress")
+            chain_id = pool.get("chainId")
+            network = pool.get("network", "")
+
+            # Ensure full pool ID is displayed (normalize to ensure 0x prefix)
+            pool_id_display = pool_id_hex if pool_id_hex.startswith("0x") else f"0x{pool_id_hex}"
+            
+            # Ensure full vault address is displayed
+            vault_display = vault_addr if vault_addr else "[dim]N/A[/]"
+            
+            # Format chain display with network name
+            if chain_id:
+                if chain_id == 8453:
+                    chain_display = f"{chain_id} (Base Mainnet)"
+                elif chain_id == 84532:
+                    chain_display = f"{chain_id} (Base Sepolia)"
+                else:
+                    chain_display = str(chain_id)
+            else:
+                chain_display = "[dim]N/A[/]"
+
+            console.print(f"[bold cyan]Pool {idx}:[/] {pool_name}")
+            console.print(f"  [yellow]Pool ID:[/]      {pool_id_display}")
+            console.print(f"  [green]Vault Address:[/] {vault_display}")
+            console.print(f"  [dim]Chain ID:[/]     {chain_display}")
+            
+            # Add spacing between pools except for the last one
+            if idx < len(pools_list):
+                console.print()
+
+    except VerifierError as exc:
+        console.print(f"[bold red]Error:[/] Failed to fetch pools from verifier: {exc}")
+        console.print("[dim]Tip: Check your network connection and verifier URL configuration.[/]")
+        raise typer.Exit(code=1)
+    except Exception as exc:
+        console.print(f"[bold red]Error:[/] Failed to list pools: {exc}")
+        raise typer.Exit(code=1)

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/prove_lock.py

@@ -42,71 +42,17 @@ from .shared_options import (
     json_output_option,
 )
 
-# Import pool helpers for pool_id conversion
-# Initialize fallback functions first to ensure they're always defined
-def _fallback_pool_name_to_id(pool_name: str) -> str:
-    """Fallback: encode pool name as hex."""
-    name_bytes = pool_name.encode("utf-8")
-    padded = name_bytes.ljust(32, b"\x00")
-    return "0x" + padded.hex()
-
-def _fallback_pool_id_to_name(pool_id: str) -> str | None:
-    """Fallback: try to decode."""
-    try:
-        hex_str = pool_id.lower().removeprefix("0x")
-        pool_bytes = bytes.fromhex(hex_str)
-        name = pool_bytes.rstrip(b"\x00").decode("utf-8", errors="ignore")
-        return name if name and name.isprintable() else None
-    except Exception:
-        return None
-
-def _fallback_format_pool_id(pool_id: str) -> str:
-    """Fallback: return pool_id as-is."""
-    return pool_id
-
-def _fallback_list_pools() -> dict[str, str]:
-    """Fallback: return empty dict."""
-    return {}
-
-def _fallback_pool_id_to_vault_address(pool_id: str) -> str | None:
-    """Fallback: return None."""
-    return None
-
-def _fallback_vault_address_to_pool_id(vault_address: str) -> str | None:
-    """Fallback: return None."""
-    return None
-
-def _fallback_pool_id_to_chain_id(pool_id: str) -> int | None:
-    """Fallback: return None."""
-    return None
-
-def _fallback_vault_address_to_chain_id(vault_address: str) -> int | None:
-    """Fallback: return None."""
-    return None
-
-# Try to import from testnet module, fallback to defaults if not available
-try:
-    # Import from cartha_cli.testnet (works both in development and when installed)
-    from ..testnet.pool_ids import (
-        format_pool_id,
-        list_pools,
-        pool_id_to_chain_id,
-        pool_id_to_name,
-        pool_id_to_vault_address,
-        pool_name_to_id,
-        vault_address_to_chain_id,
-        vault_address_to_pool_id,
-    )
-except (ImportError, ModuleNotFoundError):
-    # Use fallback functions if import failed
-    pool_name_to_id = _fallback_pool_name_to_id
-    pool_id_to_name = _fallback_pool_id_to_name
-    format_pool_id = _fallback_format_pool_id
-    list_pools = _fallback_list_pools
-    pool_id_to_vault_address = _fallback_pool_id_to_vault_address
-    vault_address_to_pool_id = _fallback_vault_address_to_pool_id
-    pool_id_to_chain_id = _fallback_pool_id_to_chain_id
-    vault_address_to_chain_id = _fallback_vault_address_to_chain_id
+# Import pool helpers from pool_client (fetches from verifier API)
+from ..pool_client import (
+    format_pool_id,
+    list_pools,
+    pool_id_to_chain_id,
+    pool_id_to_name,
+    pool_id_to_vault_address,
+    pool_name_to_id,
+    vault_address_to_chain_id,
+    vault_address_to_pool_id,
+)
 
 
 def prove_lock(
@@ -153,22 +99,6 @@ def prove_lock(
             netuid = 78
         elif network == "finney":
             netuid = 35
-            # Warn that mainnet is not live yet
-            console.print()
-            console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
-            console.print()
-            console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78 on test network).[/]")
-            console.print("[yellow]Mainnet (subnet 35 on finney network) has not been announced yet.[/]")
-            console.print()
-            console.print("[bold cyan]To use testnet:[/]")
-            console.print("  cartha vault lock --network test ...")
-            console.print()
-            console.print("[dim]If you continue with finney network, the CLI will attempt to connect[/]")
-            console.print("[dim]but the subnet may not be operational yet.[/]")
-            console.print()
-            if not Confirm.ask("[yellow]Continue with finney network anyway?[/]", default=False):
-                console.print("[yellow]Cancelled. Use --network test for testnet.[/]")
-                raise typer.Exit(code=0)
         else:
             # Default to finney settings if unknown network
             netuid = 35
@@ -386,72 +316,51 @@ def prove_lock(
             if not pool_id_normalized.startswith("0x"):
                 pool_id_normalized = "0x" + pool_id_normalized
             
-            try:
-                auto_chain_id = pool_id_to_chain_id(pool_id_normalized)
-            except (NameError, AttributeError, TypeError):
-                # Function not available - this shouldn't happen if imports worked
-                # But handle gracefully by trying to import it
-                try:
-                    from ..testnet.pool_ids import pool_id_to_chain_id
-                    auto_chain_id = pool_id_to_chain_id(pool_id_normalized)
-                except (ImportError, ModuleNotFoundError, TypeError):
-                    pass
+            auto_chain_id = pool_id_to_chain_id(pool_id_normalized)
             
             if not auto_chain_id:
                 # Fallback: try to get from vault address
-                try:
-                    auto_chain_id = vault_address_to_chain_id(vault)
-                except (NameError, AttributeError, TypeError):
-                    try:
-                        from ..testnet.pool_ids import vault_address_to_chain_id
-                        auto_chain_id = vault_address_to_chain_id(vault)
-                    except (ImportError, ModuleNotFoundError, TypeError):
-                        pass
+                auto_chain_id = vault_address_to_chain_id(vault)
             
             if auto_chain_id:
                 chain = auto_chain_id
-                chain_name = "Base Sepolia" if chain == 84532 else f"Chain {chain}"
+                if chain == 8453:
+                    chain_name = "Base Mainnet"
+                elif chain == 84532:
+                    chain_name = "Base Sepolia"
+                else:
+                    chain_name = f"Chain {chain}"
                 console.print(
                     f"[bold green]✓ Auto-matched chain ID[/] - {chain_name} (chain ID: {chain})"
                 )
             else:
-                # Fallback: if on testnet and we have a vault, default to Base Sepolia (84532)
-                if network == "test" and vault:
-                    chain = 84532
-                    console.print(
-                        f"[bold green]✓ Auto-matched chain ID[/] - Base Sepolia (chain ID: 84532) [dim](testnet default)[/]"
-                    )
-                else:
-                    # Prompt for chain ID if no mapping found
-                    console.print(
-                        "[yellow]⚠ No chain ID mapping found. Please provide chain ID.[/]"
-                    )
-                    while True:
-                        try:
-                            chain_input = typer.prompt("Chain ID", show_default=False)
-                            chain = int(chain_input)
-                            if chain <= 0:
-                                console.print(
-                                    "[bold red]Error:[/] Chain ID must be a positive integer"
-                                )
-                                continue
-                            break
-                        except ValueError:
-                            console.print("[bold red]Error:[/] Chain ID must be a valid integer")
+                # Prompt for chain ID if no mapping found
+                console.print(
+                    "[yellow]⚠ No chain ID mapping found. Please provide chain ID.[/]"
+                )
+                while True:
+                    try:
+                        chain_input = typer.prompt("Chain ID", show_default=False)
+                        chain = int(chain_input)
+                        if chain <= 0:
+                            console.print(
+                                "[bold red]Error:[/] Chain ID must be a positive integer"
+                            )
+                            continue
+                        break
+                    except ValueError:
+                        console.print("[bold red]Error:[/] Chain ID must be a valid integer")
         else:
             # Chain ID was provided, verify it matches vault if possible
-            expected_chain_id = None
-            try:
-                expected_chain_id = vault_address_to_chain_id(vault)
-            except (NameError, AttributeError):
-                try:
-                    from ..testnet.pool_ids import vault_address_to_chain_id
-                    expected_chain_id = vault_address_to_chain_id(vault)
-                except (ImportError, ModuleNotFoundError):
-                    pass
+            expected_chain_id = vault_address_to_chain_id(vault)
             
             if expected_chain_id and expected_chain_id != chain:
-                chain_name = "Base Sepolia" if expected_chain_id == 84532 else f"Chain {expected_chain_id}"
+                if expected_chain_id == 8453:
+                    chain_name = "Base Mainnet"
+                elif expected_chain_id == 84532:
+                    chain_name = "Base Sepolia"
+                else:
+                    chain_name = f"Chain {expected_chain_id}"
                 console.print(
                     f"[bold yellow]⚠ Warning:[/] Vault {vault} is on {chain_name} (chain ID: {expected_chain_id}), "
                     f"but you specified chain ID {chain}"
@@ -674,8 +583,11 @@ def prove_lock(
             "\n[bold yellow]⚠️  Execute these transactions to complete your lock:[/]\n"
         )
 
-        # USDC contract address for Base Sepolia
-        usdc_contract_address = "0x2340D09c348930A76c8c2783EDa8610F699A51A8"
+        # USDC contract address based on chain ID
+        if chain == 8453:  # Base Mainnet
+            usdc_contract_address = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+        else:  # Base Sepolia (default)
+            usdc_contract_address = "0x2340D09c348930A76c8c2783EDa8610F699A51A8"
         
         console.print("[bold cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/]")
         console.print("[bold]Phase 1: Approve USDC[/]")
@@ -694,7 +606,7 @@ def prove_lock(
         phase1_params = {
             "phase": "1",
             "chainId": str(chain),
-            "usdcAddress": "0x2340D09c348930A76c8c2783EDa8610F699A51A8",
+            "usdcAddress": usdc_contract_address,
             "vaultAddress": vault,
             "spender": vault,
             "amount": str(amount_base_units),
@@ -714,8 +626,11 @@ def prove_lock(
         console.print("[dim]The CLI will automatically detect when the approval is complete.[/]")
         console.print("[dim]You can also press Ctrl+C to skip and continue manually.[/]")
         
-        # Base Sepolia RPC endpoint
-        base_sepolia_rpc = "https://sepolia.base.org"
+        # RPC endpoint based on chain ID
+        if chain == 8453:  # Base Mainnet
+            rpc_endpoint = "https://mainnet.base.org"
+        else:  # Base Sepolia (default)
+            rpc_endpoint = "https://sepolia.base.org"
         
         # ERC20 ABI for allowance function and Approval event
         erc20_abi = [
@@ -746,7 +661,7 @@ def prove_lock(
         
         approval_detected = False
         try:
-            w3 = Web3(Web3.HTTPProvider(base_sepolia_rpc))
+            w3 = Web3(Web3.HTTPProvider(rpc_endpoint))
             usdc_contract = w3.eth.contract(
                 address=Web3.to_checksum_address(usdc_contract_address),
                 abi=erc20_abi
@@ -941,13 +856,15 @@ def prove_lock(
             }
         ]
         
-        # Get RPC endpoint for Base Sepolia
+        # Get RPC endpoint based on chain ID
         rpc_url = None
-        if chain == 84532:  # Base Sepolia
+        if chain == 8453:  # Base Mainnet
+            rpc_url = "https://mainnet.base.org"
+        elif chain == 84532:  # Base Sepolia
             rpc_url = "https://sepolia.base.org"
         else:
-            # Only Base Sepolia is supported for auto-detection
-            console.print(f"[yellow]Warning:[/] Auto-detection only supports Base Sepolia (chain ID 84532), but chain ID {chain} was specified.")
+            # Unsupported chain for auto-detection
+            console.print(f"[yellow]Warning:[/] Auto-detection only supports Base Mainnet (8453) and Base Sepolia (84532), but chain ID {chain} was specified.")
             console.print("[dim]You'll need to enter the transaction hash manually.[/]")
             rpc_url = None
         

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/commands/register.py

@@ -79,22 +79,6 @@ def register(
         netuid = 78
     elif network == "finney":
         netuid = 35
-        # Warn that mainnet is not live yet
-        console.print()
-        console.print("[bold yellow]⚠️  MAINNET NOT AVAILABLE YET[/]")
-        console.print()
-        console.print("[yellow]Cartha subnet is currently in testnet phase (subnet 78 on test network).[/]")
-        console.print("[yellow]Mainnet (subnet 35 on finney network) has not been announced yet.[/]")
-        console.print()
-        console.print("[bold cyan]To use testnet:[/]")
-        console.print("  cartha miner register --network test")
-        console.print()
-        console.print("[dim]If you continue with finney network, registration will attempt[/]")
-        console.print("[dim]subnet 35 but the subnet may not be operational yet.[/]")
-        console.print()
-        if not Confirm.ask("[yellow]Continue with finney network anyway?[/]", default=False):
-            console.print("[yellow]Cancelled. Use --network test for testnet.[/]")
-            raise typer.Exit(code=0)
     # Note: netuid parameter is kept for backwards compatibility / explicit override
     
     from ..config import get_verifier_url_for_network

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/config.py

@@ -13,7 +13,7 @@ from pydantic_settings import BaseSettings
 # Network to verifier URL mapping
 NETWORK_VERIFIER_MAP = {
     "test": "https://cartha-verifier-826542474079.us-central1.run.app",
-    "finney": None,  # No mainnet verifier yet - use default or env var
+    "finney": "https://cartha-verifier-193291340038.us-central1.run.app",
 }
 
 
@@ -36,13 +36,13 @@ def get_verifier_url_for_network(network: str) -> str:
     if mapped_url:
         return mapped_url
     
-    # Default fallback (testnet for now since no mainnet)
-    return "https://cartha-verifier-826542474079.us-central1.run.app"
+    # Default fallback to mainnet
+    return "https://cartha-verifier-193291340038.us-central1.run.app"
 
 
 class Settings(BaseSettings):
     verifier_url: str = Field(
-        "https://cartha-verifier-826542474079.us-central1.run.app", alias="CARTHA_VERIFIER_URL"
+        "https://cartha-verifier-193291340038.us-central1.run.app", alias="CARTHA_VERIFIER_URL"
     )
     network: str = Field("finney", alias="CARTHA_NETWORK")
     netuid: int = Field(35, alias="CARTHA_NETUID")

cartha_cli-1.0.8/cartha_cli/pool_client.py

@@ -0,0 +1,214 @@
+"""Pool client - fetches pool data from verifier API with caching."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Any
+
+from .verifier import VerifierError, fetch_pools
+
+
+# Cache pool data for 5 minutes (300 seconds)
+# Using a module-level cache that can be cleared if needed
+_pools_cache: dict[str, Any] | None = None
+_cache_timestamp: float = 0
+_CACHE_TTL_SECONDS = 300
+
+
+def _get_cached_pools() -> list[dict[str, Any]]:
+    """Get pools with caching (5 minute TTL)."""
+    global _pools_cache, _cache_timestamp
+    import time
+    
+    now = time.time()
+    if _pools_cache is None or (now - _cache_timestamp) > _CACHE_TTL_SECONDS:
+        try:
+            _pools_cache = fetch_pools()
+            _cache_timestamp = now
+        except VerifierError:
+            # If fetch fails and we have cached data, use it
+            if _pools_cache is not None:
+                return _pools_cache
+            # Otherwise return empty list
+            return []
+    
+    return _pools_cache or []
+
+
+def clear_cache() -> None:
+    """Clear the pools cache."""
+    global _pools_cache, _cache_timestamp
+    _pools_cache = None
+    _cache_timestamp = 0
+
+
+def list_pools() -> dict[str, str]:
+    """List all available pools from verifier.
+    
+    Returns:
+        Dictionary mapping pool names (e.g., "BTCUSD") to hex pool IDs
+    """
+    pools = _get_cached_pools()
+    result = {}
+    for pool in pools:
+        name = pool.get("name", "")
+        # Verifier returns camelCase keys
+        pool_id = pool.get("poolId", "")
+        if name and pool_id:
+            # Normalize name: "BTC/USD" -> "BTCUSD"
+            normalized_name = name.replace("/", "").upper()
+            result[normalized_name] = pool_id.lower()
+    return result
+
+
+def pool_name_to_id(pool_name: str) -> str:
+    """Convert a readable pool name to hex pool ID.
+    
+    Args:
+        pool_name: Readable name (e.g., "BTCUSD", "BTC/USD")
+        
+    Returns:
+        Hex pool ID (bytes32 format)
+    """
+    normalized = pool_name.replace("/", "").upper()
+    pools = list_pools()
+    
+    if normalized in pools:
+        return pools[normalized]
+    
+    # Fallback: encode the name as hex (for unknown pools)
+    name_bytes = pool_name.encode("utf-8")
+    if len(name_bytes) > 32:
+        raise ValueError(f"Pool name too long: {pool_name} (max 32 bytes)")
+    padded = name_bytes.rjust(32, b"\x00")
+    return "0x" + padded.hex()
+
+
+def pool_id_to_name(pool_id: str) -> str | None:
+    """Convert a hex pool ID to readable name if available.
+    
+    Args:
+        pool_id: Hex pool ID (bytes32 format)
+        
+    Returns:
+        Readable name if found, None otherwise
+    """
+    pools = _get_cached_pools()
+    pool_id_lower = pool_id.lower()
+    
+    for pool in pools:
+        # Verifier returns camelCase keys
+        if pool.get("poolId", "").lower() == pool_id_lower:
+            name = pool.get("name", "")
+            # Return normalized name without slash
+            return name.replace("/", "").upper() if name else None
+    
+    return None
+
+
+def format_pool_id(pool_id: str) -> str:
+    """Format a pool ID for display (shows readable name if available).
+    
+    Args:
+        pool_id: Hex pool ID
+        
+    Returns:
+        Formatted string: "BTCUSD (0x...)" or just "0x..." if no name found
+    """
+    name = pool_id_to_name(pool_id)
+    if name:
+        return f"{name} ({pool_id})"
+    return pool_id
+
+
+def pool_id_to_vault_address(pool_id: str) -> str | None:
+    """Get vault address for a given pool ID.
+    
+    Args:
+        pool_id: Pool ID in hex format (bytes32)
+        
+    Returns:
+        Vault address if found, None otherwise
+    """
+    pools = _get_cached_pools()
+    pool_id_lower = pool_id.lower()
+    
+    for pool in pools:
+        # Verifier returns camelCase keys
+        if pool.get("poolId", "").lower() == pool_id_lower:
+            return pool.get("vaultAddress")
+    
+    return None
+
+
+def vault_address_to_pool_id(vault_address: str) -> str | None:
+    """Get pool ID for a given vault address.
+    
+    Args:
+        vault_address: Vault contract address
+        
+    Returns:
+        Pool ID if found, None otherwise
+    """
+    pools = _get_cached_pools()
+    vault_lower = vault_address.lower()
+    
+    for pool in pools:
+        # Verifier returns camelCase keys
+        if pool.get("vaultAddress", "").lower() == vault_lower:
+            return pool.get("poolId", "").lower()
+    
+    return None
+
+
+def pool_id_to_chain_id(pool_id: str) -> int | None:
+    """Get chain ID for a given pool ID.
+    
+    Args:
+        pool_id: Pool ID in hex format (bytes32)
+        
+    Returns:
+        Chain ID if found, None otherwise
+    """
+    pools = _get_cached_pools()
+    pool_id_lower = pool_id.lower()
+    
+    for pool in pools:
+        # Verifier returns camelCase keys
+        if pool.get("poolId", "").lower() == pool_id_lower:
+            return pool.get("chainId")
+    
+    return None
+
+
+def vault_address_to_chain_id(vault_address: str) -> int | None:
+    """Get chain ID for a given vault address.
+    
+    Args:
+        vault_address: Vault contract address
+        
+    Returns:
+        Chain ID if found, None otherwise
+    """
+    pools = _get_cached_pools()
+    vault_lower = vault_address.lower()
+    
+    for pool in pools:
+        # Verifier returns camelCase keys
+        if pool.get("vaultAddress", "").lower() == vault_lower:
+            return pool.get("chainId")
+    
+    return None
+
+
+__all__ = [
+    "clear_cache",
+    "list_pools",
+    "pool_name_to_id",
+    "pool_id_to_name",
+    "format_pool_id",
+    "pool_id_to_vault_address",
+    "vault_address_to_pool_id",
+    "pool_id_to_chain_id",
+    "vault_address_to_chain_id",
+]

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/cartha_cli/verifier.py

@@ -324,6 +324,20 @@ def process_lock_transaction(
     )
 
 
+def fetch_pools() -> list[dict[str, Any]]:
+    """Fetch available pools from verifier.
+    
+    Returns list of pools with:
+    - name: Human-readable pool name (e.g., "BTC/USD")
+    - pool_id: Hex pool ID (bytes32)
+    - vault_address: Vault contract address
+    - chain_id: Chain ID
+    - network: Network name ("mainnet" or "testnet")
+    """
+    data = _request("GET", "/pools")
+    return data.get("pools", [])
+
+
 # REMOVED: Old endpoints - replaced by new lock flow
 # fetch_pair_password, register_pair_password, submit_lock_proof removed
 
@@ -339,4 +353,5 @@ __all__ = [
     "request_lock_signature",
     "get_lock_status",
     "process_lock_transaction",
+    "fetch_pools",
 ]

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cartha-cli"
-version = "1.0.7"
+version = "1.0.8"
 description = "CLI utilities for Cartha subnet miners."
 readme = "README.md"
 requires-python = ">=3.11,<3.12"

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/tests/test_cli.py

@@ -1466,37 +1466,32 @@ def test_prove_lock_eip712_signature_without_lock_days(monkeypatch):
 
 def test_vault_pools_command(monkeypatch):
     """Test vault pools command."""
-    # Mock list_pools to return test data
-    def fake_list_pools():
-        return {
-            "BTCUSD": "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489",
-            "ETHUSD": "0x0b43555ace6b39aae1b894097d0a9fc17f504c62fea598fa206cc6f5088e6e45",
-        }
-
-    def fake_pool_id_to_vault_address(pool_id: str):
-        vaults = {
-            "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489": "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69",
-            "0x0b43555ace6b39aae1b894097d0a9fc17f504c62fea598fa206cc6f5088e6e45": "0xdB74B44957A71c95406C316f8d3c5571FA588248",
-        }
-        return vaults.get(pool_id.lower())
-
-    def fake_pool_id_to_chain_id(pool_id: str):
-        return 84532
+    # Mock fetch_pools to return test data (verifier API response format with camelCase keys)
+    def fake_fetch_pools():
+        return [
+            {
+                "name": "BTC/USD",
+                "poolId": "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489",
+                "vaultAddress": "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69",
+                "chainId": 84532,
+                "network": "testnet",
+            },
+            {
+                "name": "ETH/USD",
+                "poolId": "0x0b43555ace6b39aae1b894097d0a9fc17f504c62fea598fa206cc6f5088e6e45",
+                "vaultAddress": "0xdB74B44957A71c95406C316f8d3c5571FA588248",
+                "chainId": 84532,
+                "network": "testnet",
+            },
+        ]
 
-    monkeypatch.setattr("cartha_cli.commands.pools.list_pools", fake_list_pools)
-    monkeypatch.setattr(
-        "cartha_cli.commands.pools.pool_id_to_vault_address",
-        fake_pool_id_to_vault_address,
-    )
-    monkeypatch.setattr(
-        "cartha_cli.commands.pools.pool_id_to_chain_id", fake_pool_id_to_chain_id
-    )
+    monkeypatch.setattr("cartha_cli.commands.pools.fetch_pools", fake_fetch_pools)
 
     result = runner.invoke(app, ["vault", "pools"])
     assert result.exit_code == 0
     assert "Available Pools" in result.stdout
-    assert "BTCUSD" in result.stdout
-    assert "ETHUSD" in result.stdout
+    assert "BTC/USD" in result.stdout
+    assert "ETH/USD" in result.stdout
     assert "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489" in result.stdout
     assert "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69" in result.stdout
     assert "84532" in result.stdout
@@ -1504,29 +1499,19 @@ def test_vault_pools_command(monkeypatch):
 
 def test_vault_pools_command_json(monkeypatch):
     """Test vault pools command with JSON output."""
-    # Mock list_pools to return test data
-    def fake_list_pools():
-        return {
-            "BTCUSD": "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489",
-        }
-
-    def fake_pool_id_to_vault_address(pool_id: str):
-        vaults = {
-            "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489": "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69",
-        }
-        return vaults.get(pool_id.lower())
-
-    def fake_pool_id_to_chain_id(pool_id: str):
-        return 84532
+    # Mock fetch_pools to return test data (verifier API response format with camelCase keys)
+    def fake_fetch_pools():
+        return [
+            {
+                "name": "BTC/USD",
+                "poolId": "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489",
+                "vaultAddress": "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69",
+                "chainId": 84532,
+                "network": "testnet",
+            },
+        ]
 
-    monkeypatch.setattr("cartha_cli.commands.pools.list_pools", fake_list_pools)
-    monkeypatch.setattr(
-        "cartha_cli.commands.pools.pool_id_to_vault_address",
-        fake_pool_id_to_vault_address,
-    )
-    monkeypatch.setattr(
-        "cartha_cli.commands.pools.pool_id_to_chain_id", fake_pool_id_to_chain_id
-    )
+    monkeypatch.setattr("cartha_cli.commands.pools.fetch_pools", fake_fetch_pools)
 
     result = runner.invoke(app, ["vault", "pools", "--json"])
     assert result.exit_code == 0
@@ -1535,10 +1520,11 @@ def test_vault_pools_command_json(monkeypatch):
     json_end = stdout.rfind("]")
     payload = json.loads(stdout[json_start : json_end + 1])
     assert len(payload) == 1
-    assert payload[0]["name"] == "BTCUSD"
-    assert payload[0]["pool_id"] == "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489"
-    assert payload[0]["vault_address"] == "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69"
-    assert payload[0]["chain_id"] == 84532
+    # JSON output uses camelCase keys from verifier response
+    assert payload[0]["name"] == "BTC/USD"
+    assert payload[0]["poolId"] == "0xee62665949c883f9e0f6f002eac32e00bd59dfe6c34e92a91c37d6a8322d6489"
+    assert payload[0]["vaultAddress"] == "0x471D86764B7F99b894ee38FcD3cEFF6EAB321b69"
+    assert payload[0]["chainId"] == 84532
 
 
 def test_miner_status_with_refresh_already_verified(monkeypatch):

{cartha_cli-1.0.7 → cartha_cli-1.0.8}/uv.lock

@@ -238,7 +238,7 @@ wheels = [
 
 [[package]]
 name = "cartha-cli"
-version = "0.1.0"
+version = "1.0.8"
 source = { editable = "." }
 dependencies = [
     { name = "bittensor" },

cartha_cli-1.0.7/cartha_cli/commands/pools.py

@@ -1,112 +0,0 @@
-"""Pools command - show current available pools."""
-
-from __future__ import annotations
-
-import typer
-
-from .common import console
-
-# Import pool helpers for pool_id conversion
-# Initialize fallback functions first to ensure they're always defined
-def _fallback_list_pools() -> dict[str, str]:
-    """Fallback: return empty dict."""
-    return {}
-
-def _fallback_pool_id_to_vault_address(pool_id: str) -> str | None:
-    """Fallback: return None."""
-    return None
-
-def _fallback_pool_id_to_chain_id(pool_id: str) -> int | None:
-    """Fallback: return None."""
-    return None
-
-# Try to import from testnet module, fallback to defaults if not available
-try:
-    from ..testnet.pool_ids import (
-        list_pools,
-        pool_id_to_chain_id,
-        pool_id_to_vault_address,
-    )
-except (ImportError, ModuleNotFoundError):
-    # Use fallback functions if import failed
-    list_pools = _fallback_list_pools
-    pool_id_to_vault_address = _fallback_pool_id_to_vault_address
-    pool_id_to_chain_id = _fallback_pool_id_to_chain_id
-
-
-def pools(
-    json_output: bool = typer.Option(
-        False, "--json", help="Emit responses as JSON."
-    ),
-) -> None:
-    """Show all available pools with their names, IDs, vault addresses, and chain IDs.
-    
-    USAGE:
-    ------
-    cartha vault pools (or: cartha v pools)
-    cartha vault pools --json (for JSON output)
-    
-    OUTPUT:
-    -------
-    - Pool names: BTCUSD, ETHUSD, EURUSD, etc.
-    - Pool IDs: Full hex identifiers (0x...)
-    - Vault addresses: Contract addresses for each pool
-    - Chain IDs: Which blockchain network (e.g., 84532 for Base Sepolia)
-    
-    Use these pool names directly in 'cartha vault lock -p BTCUSD ...'
-    """
-    try:
-        available_pools = list_pools()
-
-        if json_output:
-            # JSON output format
-            import json
-
-            pools_data = []
-            for pool_name, pool_id_hex in sorted(available_pools.items()):
-                vault_addr = pool_id_to_vault_address(pool_id_hex)
-                chain_id = pool_id_to_chain_id(pool_id_hex)
-                pool_data = {
-                    "name": pool_name,
-                    "pool_id": pool_id_hex,
-                }
-                if vault_addr:
-                    pool_data["vault_address"] = vault_addr
-                if chain_id:
-                    pool_data["chain_id"] = chain_id
-                pools_data.append(pool_data)
-
-            console.print(json.dumps(pools_data, indent=2))
-            return
-
-        # Multi-line text output
-        if not available_pools:
-            console.print("[yellow]No pools available.[/]")
-            return
-
-        console.print("\n[bold cyan]Available Pools[/]\n")
-
-        for idx, (pool_name, pool_id_hex) in enumerate(sorted(available_pools.items()), 1):
-            vault_addr = pool_id_to_vault_address(pool_id_hex)
-            chain_id = pool_id_to_chain_id(pool_id_hex)
-
-            # Ensure full pool ID is displayed (normalize to ensure 0x prefix)
-            pool_id_display = pool_id_hex if pool_id_hex.startswith("0x") else f"0x{pool_id_hex}"
-            
-            # Ensure full vault address is displayed
-            vault_display = vault_addr if vault_addr else "[dim]N/A[/]"
-            
-            chain_display = str(chain_id) if chain_id else "[dim]N/A[/]"
-
-            console.print(f"[bold cyan]Pool {idx}:[/] {pool_name}")
-            console.print(f"  [yellow]Pool ID:[/]      {pool_id_display}")
-            console.print(f"  [green]Vault Address:[/] {vault_display}")
-            console.print(f"  [dim]Chain ID:[/]     {chain_display}")
-            
-            # Add spacing between pools except for the last one
-            if idx < len(available_pools):
-                console.print()
-
-    except Exception as exc:
-        console.print(f"[bold red]Error:[/] Failed to list pools: {exc}")
-        raise typer.Exit(code=1)