cartha-cli 1.0.5__py3-none-any.whl → 1.0.8__py3-none-any.whl

cartha_cli/bt.py

@@ -51,92 +51,100 @@ def register_hotkey(
     """Register a hotkey on the target subnet and return the resulting UID."""
 
     subtensor = get_subtensor(network)
-    wallet = get_wallet(wallet_name, hotkey_name)
-    hotkey_ss58 = wallet.hotkey.ss58_address
-
-    if subtensor.is_hotkey_registered(hotkey_ss58, netuid=netuid):
-        neuron = subtensor.get_neuron_for_pubkey_and_subnet(hotkey_ss58, netuid)
-        uid = None if getattr(neuron, "is_null", False) else getattr(neuron, "uid", None)
-        return RegistrationResult(status="already", success=True, uid=uid, hotkey=hotkey_ss58)
+    try:
+        wallet = get_wallet(wallet_name, hotkey_name)
+        hotkey_ss58 = wallet.hotkey.ss58_address
 
-    # Get balance before registration
-    balance_before = None
-    balance_after = None
-    extrinsic = None
+        if subtensor.is_hotkey_registered(hotkey_ss58, netuid=netuid):
+            neuron = subtensor.get_neuron_for_pubkey_and_subnet(hotkey_ss58, netuid)
+            uid = None if getattr(neuron, "is_null", False) else getattr(neuron, "uid", None)
+            return RegistrationResult(status="already", success=True, uid=uid, hotkey=hotkey_ss58)
 
-    try:
-        balance_obj = subtensor.get_balance(wallet.coldkeypub.ss58_address)
-        # Convert Balance object to float using .tao property
-        balance_before = balance_obj.tao if hasattr(balance_obj, "tao") else float(balance_obj)
-    except Exception:
-        pass  # Balance may not be available, continue anyway
-
-    if burned:
-        # burned_register returns (success, block_info) or just success
-        registration_result = subtensor.burned_register(
-            wallet=wallet,
-            netuid=netuid,
-            wait_for_finalization=wait_for_finalization,
-        )
+        # Get balance before registration
+        balance_before = None
+        balance_after = None
+        extrinsic = None
 
-        # Handle both return types: bool or (bool, message)
-        if isinstance(registration_result, tuple):
-            ok, message = registration_result
-            if isinstance(message, str) and message:
-                extrinsic = message
+        try:
+            balance_obj = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+            # Convert Balance object to float using .tao property
+            balance_before = balance_obj.tao if hasattr(balance_obj, "tao") else float(balance_obj)
+        except Exception:
+            pass  # Balance may not be available, continue anyway
+
+        if burned:
+            # burned_register returns (success, block_info) or just success
+            registration_result = subtensor.burned_register(
+                wallet=wallet,
+                netuid=netuid,
+                wait_for_finalization=wait_for_finalization,
+            )
+
+            # Handle both return types: bool or (bool, message)
+            if isinstance(registration_result, tuple):
+                ok, message = registration_result
+                if isinstance(message, str) and message:
+                    extrinsic = message
+            else:
+                ok = registration_result
+
+            status = "burned"
         else:
-            ok = registration_result
-
-        status = "burned"
-    else:
-        ok = subtensor.register(
-            wallet=wallet,
-            netuid=netuid,
-            wait_for_finalization=wait_for_finalization,
-            wait_for_inclusion=wait_for_inclusion,
-            cuda=cuda,
-            dev_id=dev_id,
-            tpb=tpb,
-            num_processes=num_processes,
-            log_verbose=False,
-        )
-        status = "pow"
-        if isinstance(ok, tuple) and len(ok) == 2:
-            ok, message = ok
-            if isinstance(message, str):
-                extrinsic = message
+            ok = subtensor.register(
+                wallet=wallet,
+                netuid=netuid,
+                wait_for_finalization=wait_for_finalization,
+                wait_for_inclusion=wait_for_inclusion,
+                cuda=cuda,
+                dev_id=dev_id,
+                tpb=tpb,
+                num_processes=num_processes,
+                log_verbose=False,
+            )
+            status = "pow"
+            if isinstance(ok, tuple) and len(ok) == 2:
+                ok, message = ok
+                if isinstance(message, str):
+                    extrinsic = message
+
+        if not ok:
+            return RegistrationResult(
+                status=status,
+                success=False,
+                uid=None,
+                hotkey=hotkey_ss58,
+                balance_before=balance_before,
+                balance_after=balance_after,
+                extrinsic=extrinsic,
+            )
+
+        # Get balance after registration
+        try:
+            balance_obj = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+            # Convert Balance object to float using .tao property
+            balance_after = balance_obj.tao if hasattr(balance_obj, "tao") else float(balance_obj)
+        except Exception:
+            pass
+
+        neuron = subtensor.get_neuron_for_pubkey_and_subnet(hotkey_ss58, netuid)
+        uid = None if getattr(neuron, "is_null", False) else getattr(neuron, "uid", None)
 
-    if not ok:
         return RegistrationResult(
             status=status,
-            success=False,
-            uid=None,
+            success=True,
+            uid=uid,
             hotkey=hotkey_ss58,
             balance_before=balance_before,
             balance_after=balance_after,
             extrinsic=extrinsic,
         )
-
-    # Get balance after registration
-    try:
-        balance_obj = subtensor.get_balance(wallet.coldkeypub.ss58_address)
-        # Convert Balance object to float using .tao property
-        balance_after = balance_obj.tao if hasattr(balance_obj, "tao") else float(balance_obj)
-    except Exception:
-        pass
-
-    neuron = subtensor.get_neuron_for_pubkey_and_subnet(hotkey_ss58, netuid)
-    uid = None if getattr(neuron, "is_null", False) else getattr(neuron, "uid", None)
-
-    return RegistrationResult(
-        status=status,
-        success=True,
-        uid=uid,
-        hotkey=hotkey_ss58,
-        balance_before=balance_before,
-        balance_after=balance_after,
-        extrinsic=extrinsic,
-    )
+    finally:
+        # Clean up subtensor connection
+        try:
+            if hasattr(subtensor, "close"):
+                subtensor.close()
+        except Exception:
+            pass  # Silently ignore cleanup errors
 
 
 def get_burn_cost(network: str, netuid: int) -> float | None:

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/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/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/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/commands/pools.py

@@ -5,33 +5,7 @@ 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
+from ..verifier import VerifierError, fetch_pools
 
 
 def pools(
@@ -48,47 +22,37 @@ def pools(
     
     OUTPUT:
     -------
-    - Pool names: BTCUSD, ETHUSD, EURUSD, etc.
+    - 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 (e.g., 84532 for Base Sepolia)
+    - 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:
-        available_pools = list_pools()
+        # Fetch pools from verifier API
+        pools_list = fetch_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))
+            console.print(json.dumps(pools_list, indent=2))
             return
 
         # Multi-line text output
-        if not available_pools:
+        if not pools_list:
             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)
+        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}"
@@ -96,7 +60,16 @@ def pools(
             # 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[/]"
+            # 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}")
@@ -104,9 +77,13 @@ def pools(
             console.print(f"  [dim]Chain ID:[/]     {chain_display}")
             
             # Add spacing between pools except for the last one
-            if idx < len(available_pools):
+            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/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/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/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/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/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.5.dist-info → cartha_cli-1.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cartha-cli
-Version: 1.0.5
+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
@@ -43,7 +43,7 @@ Cartha CLI makes mining on the Cartha subnet effortless. As the Liquidity Provid
 - **📊 Instant Status Updates** - See all your pools, balances, and expiration dates at a glance
 - **⏰ Smart Expiration Warnings** - Never miss a renewal with color-coded countdowns
 - **💼 Multi-Pool Management** - Track multiple trading pairs in one place
-- **🔑 Secure by Default** - Your password stays hidden until you actually need it
+- **🔒 Secure Authentication** - Session-based authentication with your Bittensor hotkey
 
 ## Installation
 
@@ -64,17 +64,19 @@ cartha miner register --help
 cartha miner status --help
 
 # Check CLI health and connectivity
-cartha health
+cartha utils health
 
 # Or use short aliases
 cartha m status
 cartha v lock
+cartha u health
 ```
 
 ## Requirements
 
 - Python 3.11
-- Bittensor wallet
+- Bittensor wallet within btcli
+    - learn how to create/import one here https://docs.learnbittensor.org/keys/working-with-keys
 
 ## What You Can Do
 
@@ -90,14 +92,12 @@ cartha miner register --wallet-name your-wallet --wallet-hotkey your-hotkey
 cartha miner status --wallet-name your-wallet --wallet-hotkey your-hotkey
 # Or use the short alias: cartha m status
 ```
-
-### Track Your Pools
-
-See all your active trading pairs, balances, and when they expire—all in one command. The CLI shows you:
-- Which pools are active and earning rewards
-- How much you have locked in each pool
-- Days remaining before expiration (with helpful warnings)
-- Which pools are included in the next reward epoch
+> **Track Your Miner Status**
+> See all your active trading pairs, balances, and when they expire—all in one command. The CLI shows you:
+> - Which pools are active and earning rewards
+> - How much you have locked in each pool
+> - Days remaining before expiration (with helpful warnings)
+> - Which pools are included in the next reward epoch
 
 ### View Available Pools
 
@@ -110,14 +110,14 @@ cartha vault pools
 
 This shows you which pools are available, their full pool IDs, vault contract addresses, and chain IDs.
 
-### Lock Your Funds
+### Lock Your Funds to start Mining
 
 Create a new lock position with the streamlined lock flow:
 ```bash
 cartha vault lock \
   --coldkey your-wallet \
   --hotkey your-hotkey \
-  --pool-id "BTCUSD" \
+  --pool-id BTCUSD \
   --amount 1000.0 \
   --lock-days 30 \
   --owner-evm 0xYourEVMAddress \
@@ -136,36 +136,31 @@ The CLI will:
 1. Check your registration on the specified network (subnet 35 for finney, subnet 78 for test)
 2. Authenticate with your Bittensor hotkey
 3. Request a signed LockRequest from the verifier
-4. Automatically open the Cartha Lock UI in your browser with all parameters pre-filled
+4. Automatically open the Cartha Lock UI in your browser with all parameters pre-filled (you can also paste the url into your browser manually)
 5. Guide you through Phase 1 (Approve USDC) and Phase 2 (Lock Position) via the web interface
 6. Automatically detect when approval completes and proceed to Phase 2
 7. The verifier automatically detects your lock and adds you to the upcoming epoch
 
 **Managing Positions**: Visit https://cartha.finance/manage to view all your positions, extend locks, or top up existing positions.
 
-### View Your Password
-
-When you need your password (like for signing transactions):
-```bash
-cartha miner password --wallet-name your-wallet --wallet-hotkey your-hotkey
-```
-
-**Tip:** Use `miner status` for daily checks—it's faster and doesn't require signing. Only use `miner password` when you actually need it.
-
 ### Check Your Setup
 
 Verify your CLI is configured correctly and can reach all services:
 
 ```bash
-cartha health
+cartha utils health
+# Or use the short alias
+cartha u health
 ```
 
 This checks:
 - Verifier connectivity and latency
 - Bittensor network connectivity
 - Configuration validation
+- Subnet metadata
+- Environment variables
 
-Use `cartha health --verbose` for detailed troubleshooting information.
+Use `cartha utils health --verbose` (or `cartha u health --verbose`) for detailed troubleshooting information.
 
 ## Need Help?
 
@@ -179,4 +174,4 @@ We welcome contributions! Please see our [Feedback & Support](docs/FEEDBACK.md)
 
 ---
 
-**Made with ❤ by GTV**
+**Made with ❤ by General Tensor**

{cartha_cli-1.0.5.dist-info → cartha_cli-1.0.8.dist-info}/RECORD

@@ -1,31 +1,32 @@
 cartha_cli/__init__.py,sha256=cSKsPAfHW8_hqJkGMXUh4mFNz9HXsq-UcgRl8G_2KhM,720
-cartha_cli/bt.py,sha256=GGW8QvOgFPFNrIghu7JNygRmTgBeMt2vhEh26ZiPe4Q,6933
-cartha_cli/config.py,sha256=MSHNiRow1tzHUJeMOvQRQsTslntV6DecLTQ-Y_CmB4A,2294
+cartha_cli/bt.py,sha256=UC5n0LpLD2YNOL-xsawrzohXpuHaoClraQh3fu4qI90,7467
+cartha_cli/config.py,sha256=eIrLNzkG6NE7zr2duDAxEuAdTgpJsDz1oymL5RkNwJc,2272
 cartha_cli/display.py,sha256=Krim69DLgiCHSYDuWNjnOep25IAHUebRAceePHfsiRA,2040
 cartha_cli/eth712.py,sha256=5NU0MnvOk89mxWnkDHzoOaSHN8TJGRAHVLGXmCq8jhM,241
 cartha_cli/main.py,sha256=0-G2syhsj2okLblX5WYb5NGqWjOwF5eW2tDn9AF5vaw,6756
 cartha_cli/pair.py,sha256=Y-TAjAK5FeWqKlUK52dHZLdBhDxx1CJbea8mlsQXkqc,6245
+cartha_cli/pool_client.py,sha256=1mUpzeZX5pzOGW4cV4Y9o9Dtkjw1GgytEHoT3vNo4mE,5717
 cartha_cli/utils.py,sha256=LWlJXzWNkIpInWclCJ2PObkG--JEN1mIcvVXsHmFllE,8429
-cartha_cli/verifier.py,sha256=JFtDA9bhecsAUCQEp0SBrZ1Z-48EkDT1Q6y7X4eTK60,10548
+cartha_cli/verifier.py,sha256=sKIjJBwz-Rir-hQNwM8CVgE9fpBu8TnGKQKJ-7Ub4_c,10985
 cartha_cli/wallet.py,sha256=Jha1pONa4Hy2XsHMTrk60eBqdkwJyzsQYgPuI-cxxFo,1770
 cartha_cli/commands/__init__.py,sha256=8CYMVEWJmg2qjLyE3ZeheQtS-E9doltDSfyyumOsET4,345
 cartha_cli/commands/common.py,sha256=tpxKsdzjFtcb0ae7J-J-zxnh32qVXZd8jwjP-frFoio,2099
-cartha_cli/commands/config.py,sha256=XT1LQo7b9vVm_mgwUTJRLCBCHJhtGclBzh_CTBAd280,10539
+cartha_cli/commands/config.py,sha256=1G6q6PU7qj6AA71pH9nUygoU6yLVgU8tbreLPcgd6rU,10539
 cartha_cli/commands/health.py,sha256=NRwmIultxUzAe7udOOBIdkcdGG5KsE_kuCs43LZObGk,20717
 cartha_cli/commands/help.py,sha256=6ubfWtmjXfCtp6L_PYvn7rR7m5C_pp-iEjtRc6BS0GA,1721
-cartha_cli/commands/miner_password.py,sha256=7cbcyrJ9KzCyJ68_174U_CXjBUt9BaYhgKAycRpv7AE,11078
-cartha_cli/commands/miner_status.py,sha256=tWlCWcuwm9NEd4USuCLp_6qObikX2odc2e7m6Y_vNrU,21873
-cartha_cli/commands/pair_status.py,sha256=LoU-fA1MXuWZGHNmeKPMjwvNw30Yn094ZD1EC0-WXVc,19978
-cartha_cli/commands/pools.py,sha256=P02SEp23a7OdrgNj6AaiJTnQ9K_QrI300DzucA6HH8A,3884
-cartha_cli/commands/prove_lock.py,sha256=FkurHtL2i2891ACEV1TejTAgkutIV1grykatx0W-JCI,61168
-cartha_cli/commands/register.py,sha256=sxbYO0V4NucOKLZpaFoVnhFDHLSLDHREoMtN9DjyLsM,10227
+cartha_cli/commands/miner_password.py,sha256=7IZcufDKiBTmnW2pPshQBCEh69nKR-FBWfWXteA0mso,10635
+cartha_cli/commands/miner_status.py,sha256=lw4e8BVhJCA8fPPO7Fr6ZuN46hgkjHGPISFJAs7ULe8,20843
+cartha_cli/commands/pair_status.py,sha256=4NqyO30HAawkzSoCM5SU7KFMCPel-YFP66FMDkKB_es,18905
+cartha_cli/commands/pools.py,sha256=GzYqpJvpTiY7cgTZCZwlzwxPpycV7JZkGwZ1A5n6lno,3225
+cartha_cli/commands/prove_lock.py,sha256=xKQN_ZujZQ5-_6czQpG51CZtSjzfiOmCTmvVSzYBIbI,57104
+cartha_cli/commands/register.py,sha256=3sdQjsLTtwsbF8ILMROTAMdrAneaesM-cBu_P_uEC-w,9262
 cartha_cli/commands/shared_options.py,sha256=itHzJSgxuKQxUVOh1_jVTcMQXjI3PPzexQyhqIbabxc,5874
 cartha_cli/commands/version.py,sha256=u5oeccQzK0LLcCbgZm0U8-Vslk5vB_lVvW3xT5HPeTg,456
 cartha_cli/testnet/README.md,sha256=kWKaLtq6t_46W-mvXkSaLi2fjXDELLk5ntVGkogiUY0,14511
 cartha_cli/testnet/__init__.py,sha256=xreJMXs-ZKTkPtUQBR5xdY7ImOyUiF7WKG6bv9J9aBM,41
 cartha_cli/testnet/pool_ids.py,sha256=0jvQ6tvc6sL0aGKkl31KXM6ngVpUboYiABY5SDMaRCQ,6747
-cartha_cli-1.0.5.dist-info/METADATA,sha256=CpmQxsTilpHMwpDu5xlNnWyU0baoAJkGWAnFOO05eEE,5794
-cartha_cli-1.0.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cartha_cli-1.0.5.dist-info/entry_points.txt,sha256=sTYVMgb9l0fuJibUtWpGnIoDmgHinne97G4Y_cCwC-U,43
-cartha_cli-1.0.5.dist-info/licenses/LICENSE,sha256=B4UCiDn13m4xYwIl4TMKfbuKw7kh9pg4c81rJecxHSo,1076
-cartha_cli-1.0.5.dist-info/RECORD,,
+cartha_cli-1.0.8.dist-info/METADATA,sha256=rtrIH0UTa9mvW2_gq9DERWEr2F3YRnB4mzb087jHxas,5842
+cartha_cli-1.0.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cartha_cli-1.0.8.dist-info/entry_points.txt,sha256=sTYVMgb9l0fuJibUtWpGnIoDmgHinne97G4Y_cCwC-U,43
+cartha_cli-1.0.8.dist-info/licenses/LICENSE,sha256=B4UCiDn13m4xYwIl4TMKfbuKw7kh9pg4c81rJecxHSo,1076
+cartha_cli-1.0.8.dist-info/RECORD,,