primecli 0.5.2__tar.gz → 0.5.4__tar.gz

{primecli-0.5.2 → primecli-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.2
+Version: 0.5.4
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -28,7 +28,6 @@ Requires-Dist: eth-account>=0.13
 Requires-Dist: eth-keys>=0.5
 Requires-Dist: eth-abi<7,>=5.0
 Requires-Dist: requests>=2.31
-Dynamic: license-file
 
 # primecli
 

{primecli-0.5.2 → primecli-0.5.4}/primecli/arbprime.py

@@ -57,6 +57,13 @@ prime-summary reports live solvency (health ratio, total value, debt, solvent fl
 SolvencyFacetProdArbitrum, read via eth_call with a RedStone price payload appended (falls
 back to balances-only if the gateway is unreachable).
 
+NOTE: prime-summary shows TWO health metrics — don't confuse them:
+  - "Health ratio (chain)":  on-chain getHealthRatio. 1.0 = liquidation, >1.0 = solvent.
+  - "Health (0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
+    borrowing power used, 100% = no debt.
+  Formula for the latter: equity=supplied-debt, max_debt=equity*(tier-1),
+  pct=(max_debt-debt)/max_debt*100. tier=5 (BASIC) or 10 (PREMIUM).
+
 Collateral withdrawal is a two-step, time-delayed flow on the Prime Account (there is NO
 instant withdraw of in-account collateral). The savings-pool `withdraw` above is a separate
 two-step intent flow on the pool itself, not the Prime Account. Step 1: `withdraw --pool X
@@ -227,7 +234,7 @@ EXPLORER = "https://arbiscan.io"  # display/links only — never used for ABI fe
 CHAIN_ID = 42161
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # ── Agent / wallet selection ─────────────────────────────────────────────────
-# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another of Bruno's) runs
+# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another authorized agent) runs
 # this same tool with its OWN wallet. The Prime Account is derived on-chain from the
 # wallet owner (getLoanForOwner), so each agent automatically operates on its own
 # Prime Account — no per-agent addresses are hardcoded. The same EVM key works on
@@ -310,8 +317,8 @@ REDSTONE_GATEWAYS = [
 ]
 
 # Active pool proxies — LIVE Arbitrum deployment, on-chain verified 2026-06-03.
-# getAllPoolAssets live = [USDC, DAI, BTC, ARB, ETH]; the DAI pool is DROPPED per
-# Bruno, leaving 4. The native-wrapped pool is `eth` (underlying WETH, account symbol
+# getAllPoolAssets live = [USDC, DAI, BTC, ARB, ETH]; the DAI pool is DROPPED,
+# leaving 4. The native-wrapped pool is `eth` (underlying WETH, account symbol
 # "ETH"): its native deposit path uses depositNativeToken() (wraps ETH -> WETH).
 POOLS = {
     "eth": {
@@ -1961,6 +1968,49 @@ def gather_lending(w3, account):
             r["usd"] = None
     return out
 
+def _compute_health_pct(data: dict, tier_code: int = 0) -> dict:
+    """Compute equity-based health (0-100%) from gather_lending data + tier.
+
+    DeltaPrime has *two* health metrics that agents must not confuse:
+
+      1. health_ratio (on-chain, getHealthRatio): 1.0 = liquidation, >1.0 = solvent.
+         This is the raw weighted-collateral / debt ratio from the SolvencyFacet.
+
+      2. health_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
+         and the account-health-monitor cron. 0% = liquidation, 100% = no debt.
+         Formula:
+           equity    = supplied_usd - debt_usd
+           max_mult  = 10 if PREMIUM tier else 5 if BASIC
+           max_debt  = equity * (max_mult - 1)
+           health_pct = (max_debt - debt_usd) / max_debt * 100
+
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt,
+    tier_label, or error.
+    """
+    supplied_usd = sum(r.get("usd", 0) or 0 for r in data.get("supplied", []))
+    debt_usd = sum(r.get("usd", 0) or 0 for r in data.get("borrowed", []))
+    equity = supplied_usd - debt_usd
+    tier_labels = {0: "BASIC", 1: "PREMIUM", 2: "_NON_EXISTENT"}
+    tier_label = tier_labels.get(tier_code, str(tier_code))
+    max_mult = {0: 5, 1: 10}.get(tier_code, 5)
+
+    if equity <= 0.01:
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+                "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+                "max_debt": 0.0, "tier": tier_label, "error": "equity near zero"}
+
+    max_debt = equity * (max_mult - 1)
+    if max_debt > 0 and debt_usd >= 0:
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
+    else:
+        health_pct = 100.0
+
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
+            "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+            "max_debt": round(max_debt, 2), "tier": tier_label}
+
+
 def cmd_prime_summary():
     w3 = get_w3()
     acct = get_account()
@@ -2004,7 +2054,23 @@ def cmd_prime_summary():
         # gather_lending nulls the ratio when debt is negligible (the raw value is
         # astronomically large there); render that as ">1000" rather than a junk number.
         ratio_str = ">1000.00 (negligible debt)" if ratio is None else f"{ratio:.4f}"
-        print(f"  Health ratio:       {ratio_str}  (>1.0 = solvent)")
+        print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio! See _compute_health_pct docstring.
+        # Get tier from the Prime Account (oracle-free view)
+        try:
+            tier_info = gather_prime_tier(w3, acct, account)
+            tier_code = tier_info.get("tier_code", 0)
+        except Exception:
+            tier_code = 0
+        hp = _compute_health_pct(data, tier_code)
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp['tier']})")
+            print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
+        else:
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if data['solvent'] else 'NO — liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({data.get('solvency_error', 'error')}); "
@@ -5005,9 +5071,12 @@ def gather_defi() -> dict:
         result["total_usd"] = lending["total_value_usd"]
         result["health_ratio"] = lending["health_ratio"]
         result["solvent"] = lending["solvent"]
+        # Compute equity-based health (0-100%) from lending data + tier
+        result["health_pct"] = _compute_health_pct(lending, tier.get("tier_code", 0)).get("health_pct")
         if lending["supplied"] or lending["borrowed"]:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": lending["health_ratio"],
+                "health_pct": result["health_pct"],
                 "supplied": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
                              for r in lending["supplied"]],
                 "borrowed": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}

{primecli-0.5.2 → primecli-0.5.4}/primecli/degenprime.py

@@ -112,6 +112,7 @@ health_monitor = _hm
 BASE_RPC = os.environ.get("DEGENPRIME_RPC", "https://base.publicnode.com")
 EXPLORER = "https://basescan.org"
 CHAIN_ID = 8453
+DEGEN_MAX_MULT = 5  # Fixed max leverage multiplier (no tier system on DegenPrime)
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 # ── Signing key resolution ──────────────────────────────────────────────────
@@ -570,6 +571,41 @@ def _asset_meta(w3, symbol: str):
 # gateway once instead of per-feed-symbol. Cleared implicitly when the process exits.
 _redstone_gateway_cache = None
 
+def _compute_health_pct(supplied: list, borrowed: list, max_mult: int = None) -> dict:
+    """Compute equity-based health (0-100%) from per-asset supplied/borrowed data.
+
+    0% = liquidation, 50% = half borrowing power used, 100% = no debt.
+    Formula:
+      equity    = supplied_usd - debt_usd
+      max_mult  = 5 (fixed for DegenPrime; no tier system)
+      max_debt  = equity * (max_mult - 1)
+      health_pct = (max_debt - debt_usd) / max_debt * 100
+
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt, or error.
+    """
+    if max_mult is None:
+        max_mult = DEGEN_MAX_MULT
+    supplied_usd = sum(r.get("usd", 0) or 0 for r in supplied)
+    debt_usd = sum(r.get("usd", 0) or 0 for r in borrowed)
+    equity = supplied_usd - debt_usd
+
+    if equity <= 0.01:
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+                "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+                "max_debt": 0.0, "error": "equity near zero"}
+
+    max_debt = equity * (max_mult - 1)
+    if max_debt > 0 and debt_usd >= 0:
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
+    else:
+        health_pct = 100.0
+
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
+            "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+            "max_debt": round(max_debt, 2), "tier": "FIXED_5X"}
+
+
 def _redstone_fetch_packages(use_cache: bool = True) -> dict:
     """Fetch the latest signed price packages from the RedStone gateway. Returns the
     per-feed map: {feedSymbol: [package, ...]} with one package per signer. The per-run
@@ -1458,11 +1494,19 @@ def gather_defi() -> dict:
                 row["usd"] = round(amt * usd, 2)
             return row
 
+        _rows_supplied = [_row(r) for r in supplied]
+        _rows_borrowed = [_row(r) for r in borrowed]
+
+        # Compute equity-based health (0-100%)
+        _hp = _compute_health_pct(_rows_supplied, _rows_borrowed)
+        result["health_pct"] = _hp.get("health_pct")
+
         if supplied or borrowed:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": solvency["ratio"],
-                "supplied": [_row(r) for r in supplied],
-                "borrowed": [_row(r) for r in borrowed],
+                "health_pct": result["health_pct"],
+                "supplied": _rows_supplied,
+                "borrowed": _rows_borrowed,
             })
 
     # Savings: the EOA's own pool deposits ("Diamond Hands"), independent of the Degen
@@ -1578,16 +1622,22 @@ def cmd_summary(as_json: bool = False):
                 row["usd"] = round(row["amount"] * usd, 2)
             return row
 
+        # Compute equity-based health (0-100%)
+        _hp_rows = [_asset_row(r) for r in supplied]
+        _hp_borrowed = [_asset_row(r) for r in borrowed]
+        _hp = _compute_health_pct(_hp_rows, _hp_borrowed)
+
         out = {
             "wallet": acct.address,
             "account": pa,
             "nativeBalance": pa_eth if pa_eth >= 1e-9 else None,
-            "supplied": [_asset_row(r) for r in supplied],
-            "borrowed": [_asset_row(r) for r in borrowed],
+            "supplied": _hp_rows,
+            "borrowed": _hp_borrowed,
             "poolDeposits": [_asset_row(r) for r in pool_deposits],
             "totalValueUsd": solvency["total"],
             "debtUsd": solvency["debt"],
             "healthRatio": solvency["ratio"],
+            "healthPct": _hp.get("health_pct"),
             "solvent": solvency["solvent"],
             "solvencyError": solvency["error"],
         }
@@ -1626,7 +1676,22 @@ def cmd_summary(as_json: bool = False):
         print(f"  Total value:        ${solvency['total']:,.2f}")
         print(f"  Debt:               ${solvency['debt']:,.2f}")
         ratio_str = ">1000.00 (negligible debt)" if solvency["ratio"] is None else f"{solvency['ratio']:.4f}"
-        print(f"  Health ratio:       {ratio_str}  (>1.0 = solvent)")
+        print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio!
+        hp = _compute_health_pct(
+            [{"symbol": r["symbol"], "balance": "0", "usd": (r["raw"] / 10**r["decimals"]) * solvency["prices"].get(r["symbol"], 0)}
+             for r in supplied if solvency["prices"].get(r["symbol"])],
+            [{"symbol": r["symbol"], "balance": "0", "usd": (r["raw"] / 10**r["decimals"]) * solvency["prices"].get(r["symbol"], 0)}
+             for r in borrowed if solvency["prices"].get(r["symbol"])],
+        )
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp.get('tier','')})")
+            print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
+        else:
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if solvency['solvent'] else 'NO - liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({solvency['error']}); showing balances only")

{primecli-0.5.2 → primecli-0.5.4}/primecli/deltaprime.py

@@ -50,6 +50,13 @@ prime-summary reports live solvency (health ratio, total value, debt, solvent fl
 SolvencyFacetProdAvalanche, read via eth_call with a RedStone price payload appended (falls
 back to balances-only if the gateway is unreachable).
 
+NOTE: prime-summary shows TWO health metrics — don't confuse them:
+  - "Health ratio (chain)":  on-chain getHealthRatio. 1.0 = liquidation, >1.0 = solvent.
+  - "Health (0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
+    borrowing power used, 100% = no debt.
+  Formula for the latter: equity=supplied-debt, max_debt=equity*(tier-1),
+  pct=(max_debt-debt)/max_debt*100. tier=5 (BASIC) or 10 (PREMIUM).
+
 Collateral withdrawal is a two-step, time-delayed flow on the Prime Account (there is NO
 instant withdraw of in-account collateral). The savings-pool `withdraw` above is a separate
 two-step intent flow on the pool itself, not the Prime Account. Step 1: `withdraw --pool X
@@ -235,7 +242,7 @@ EXPLORER = "https://snowtrace.io"
 CHAIN_ID = 43114
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # ── Agent / wallet selection ─────────────────────────────────────────────────
-# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another of Bruno's) runs
+# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another authorized agent) runs
 # this same tool with its OWN wallet. The Prime Account is derived on-chain from the
 # wallet owner (getLoanForOwner), so each agent automatically operates on its own
 # Prime Account — no per-agent addresses are hardcoded.
@@ -434,12 +441,12 @@ TJ_ROUTER_V21 = "0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30"
 TJ_ROUTER_V22 = "0x18556DA13313f3532c54711497A8FedAC273220E"
 TJ_MAX_BINS = 80
 
-# Whitelisted LB pairs exposed as tool keys, matching Bruno's live frontend (bin step in
+# Whitelisted LB pairs exposed as tool keys, matching the live frontend (bin step in
 # the key suffix where a pair exists at two steps). For each: the LBPair address, the
 # router version the pair belongs to, the canonical (tokenX, tokenY) order read on-chain,
 # and the binStep. tokenX/tokenY carry the ERC20 address, the account bytes32 symbol (for
 # the in-account balance read + RedStone feed), and decimals. The 13 source-whitelisted
-# pairs include 4 aUSD pairs not on Bruno's frontend; those are omitted (no clean
+# pairs include 4 aUSD pairs not on the live frontend; those are omitted (no clean
 # symbol/decimals + out of scope).
 _WAVAX = {"addr": "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7", "symbol": "AVAX", "decimals": 18}
 _USDC = {"addr": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", "symbol": "USDC", "decimals": 6}
@@ -658,33 +665,42 @@ def _tx_gas_price(w3) -> int:
 
 def _set_gas_price(w3, tx_dict):
     """Set appropriate gas price fields for the chain, replacing the legacy gasPrice approach.
-    On EIP-1559 chains (Arbitrum, Base): sets maxFeePerGas + maxPriorityFeePerGas with a 2x
-    base-fee hedge (base + prio + 1 gwei buffer). On Avalanche (legacy): sets gasPrice at
-    2x base fee with a 1 gwei floor. (25 gwei was the pre-Etna C-chain minimum;
-    ACP-125 (Dec 2024) lowered the min base fee to 1 nAVAX — base now sits at ~0.01
-    nAVAX, so a 25 gwei floor overpaid ~2500x and inflated the upfront balance
-    requirement past small EOAs.)"""
+    On EIP-1559 chains (Arbitrum, Base, Avalanche post-Etna): sets maxFeePerGas +
+    maxPriorityFeePerGas with a 2x base-fee hedge (base + prio + 1 gwei buffer).
+    Falls back to legacy gasPrice only if the tx dict already lacks EIP-1559 fields
+    and the chain doesn't support max_priority_fee.
+    (25 gwei was the pre-Etna C-chain minimum; ACP-125 (Dec 2024) lowered the min base
+    fee to 1 nAVAX — base now sits at ~0.01 nAVAX, so a 25 gwei floor overpaid ~2500x
+    and inflated the upfront balance requirement past small EOAs.)"""
+    # If build_transaction already set EIP-1559 fields, don't touch them
+    if "maxFeePerGas" in tx_dict or "maxPriorityFeePerGas" in tx_dict:
+        tx_dict.pop("gasPrice", None)
+        return
     tx_dict.pop("gasPrice", None)
-    if CHAIN_ID in (42161, 8453):  # Arbitrum, Base — EIP-1559
+    try:
         base = w3.eth.gas_price
         prio = w3.eth.max_priority_fee
         tx_dict["maxFeePerGas"] = max(int(base * 2), base + prio + 10**9)
         tx_dict["maxPriorityFeePerGas"] = prio
-    else:  # Avalanche (43114) — legacy gasPrice
+    except Exception:
+        # Legacy chain — use gasPrice instead
         tx_dict["gasPrice"] = max(int(w3.eth.gas_price * 2), 1 * 10**9)
 
 def _set_gas_price_for(chain_id, w3, tx_dict):
     """Set gas fields for an EXPLICIT chain_id rather than the module CHAIN_ID. Needed by
     cross-chain flows (prime-bridge) where a tx may target Avalanche or Arbitrum regardless
-    of which tool built it. Arbitrum/Base (EIP-1559): maxFeePerGas + maxPriorityFeePerGas;
-    Avalanche (legacy): gasPrice with a 1 gwei floor (post-Etna; see _set_gas_price)."""
+    of which tool built it."""
+    # If build_transaction already set EIP-1559 fields, don't touch them
+    if "maxFeePerGas" in tx_dict or "maxPriorityFeePerGas" in tx_dict:
+        tx_dict.pop("gasPrice", None)
+        return
     tx_dict.pop("gasPrice", None)
-    if chain_id in (42161, 8453):  # Arbitrum, Base — EIP-1559
+    try:
         base = w3.eth.gas_price
         prio = w3.eth.max_priority_fee
         tx_dict["maxFeePerGas"] = max(int(base * 2), base + prio + 10**9)
         tx_dict["maxPriorityFeePerGas"] = prio
-    else:  # Avalanche (43114) — legacy gasPrice
+    except Exception:
         tx_dict["gasPrice"] = max(int(w3.eth.gas_price * 2), 1 * 10**9)
 
 def _read_env_var(path, var):
@@ -1979,6 +1995,49 @@ def gather_lending(w3, account):
             r["usd"] = None
     return out
 
+def _compute_health_pct(data: dict, tier_code: int = 0) -> dict:
+    """Compute equity-based health (0-100%) from gather_lending data + tier.
+
+    DeltaPrime has *two* health metrics that agents must not confuse:
+
+      1. health_ratio (on-chain, getHealthRatio): 1.0 = liquidation, >1.0 = solvent.
+         This is the raw weighted-collateral / debt ratio from the SolvencyFacet.
+
+      2. health_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
+         and the account-health-monitor cron. 0% = liquidation, 100% = no debt.
+         Formula:
+           equity    = supplied_usd - debt_usd
+           max_mult  = 10 if PREMIUM tier else 5 if BASIC
+           max_debt  = equity * (max_mult - 1)
+           health_pct = (max_debt - debt_usd) / max_debt * 100
+
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt,
+    tier_label, or error.
+    """
+    supplied_usd = sum(r.get("usd", 0) or 0 for r in data.get("supplied", []))
+    debt_usd = sum(r.get("usd", 0) or 0 for r in data.get("borrowed", []))
+    equity = supplied_usd - debt_usd
+    tier_labels = {0: "BASIC", 1: "PREMIUM", 2: "_NON_EXISTENT"}
+    tier_label = tier_labels.get(tier_code, str(tier_code))
+    max_mult = {0: 5, 1: 10}.get(tier_code, 5)
+
+    if equity <= 0.01:
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+                "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+                "max_debt": 0.0, "tier": tier_label, "error": "equity near zero"}
+
+    max_debt = equity * (max_mult - 1)
+    if max_debt > 0 and debt_usd >= 0:
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
+    else:
+        health_pct = 100.0
+
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
+            "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+            "max_debt": round(max_debt, 2), "tier": tier_label}
+
+
 def cmd_prime_summary():
     w3 = get_w3()
     acct = get_account()
@@ -2022,7 +2081,23 @@ def cmd_prime_summary():
         # gather_lending nulls the ratio when debt is negligible (the raw value is
         # astronomically large there); render that as ">1000" rather than a junk number.
         ratio_str = ">1000.00 (negligible debt)" if ratio is None else f"{ratio:.4f}"
-        print(f"  Health ratio:       {ratio_str}  (>1.0 = solvent)")
+        print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio! See _compute_health_pct docstring.
+        # Get tier from the Prime Account (oracle-free view)
+        try:
+            tier_info = gather_prime_tier(w3, acct, account)
+            tier_code = tier_info.get("tier_code", 0)
+        except Exception:
+            tier_code = 0
+        hp = _compute_health_pct(data, tier_code)
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp['tier']})")
+            print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
+        else:
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if data['solvent'] else 'NO — liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({data.get('solvency_error', 'error')}); "
@@ -4928,9 +5003,12 @@ def gather_defi() -> dict:
         result["total_usd"] = lending["total_value_usd"]
         result["health_ratio"] = lending["health_ratio"]
         result["solvent"] = lending["solvent"]
+        # Compute equity-based health (0-100%) from lending data + tier
+        result["health_pct"] = _compute_health_pct(lending, tier.get("tier_code", 0)).get("health_pct")
         if lending["supplied"] or lending["borrowed"]:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": lending["health_ratio"],
+                "health_pct": result["health_pct"],
                 "supplied": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
                              for r in lending["supplied"]],
                 "borrowed": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}

{primecli-0.5.2 → primecli-0.5.4}/primecli/health_monitor.py

@@ -37,13 +37,21 @@ TIER_MAX = {"basic": 5, "premium": 10}
 # ════════════════════════════════════════════════════════════════════
 
 def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
-    """Compute Bruno's 0-100% health scale from defi --json data.
+    """Compute equity-based health (0-100%) from defi --json data.
+
+    PREFERS the precomputed ``health_pct`` from defi --json (which primecli >= 0.5.4
+    includes), falling back to manual calculation when absent.
 
     Formula:
       equity = total_supplied_usd - total_debt_usd
       max_debt = equity * (tier - 1)    # PREMIUM=10, BASIC=5
       health% = (max_debt - debt) / max_debt * 100
 
+    This is DIFFERENT from getHealthRatio (the on-chain ratio where 1.0 = liquidation).
+    Do NOT convert between the two. The ``health_ratio`` metric is the on-chain value
+    (1.0=liquidation, >1.0=solvent). The ``health_pct`` is the equity-based frontend
+    measurement (0%=liquidation, 50%=half borrowing power used, 100%=no debt).
+
     Returns dict with health metrics or error.
     """
     # Parse groups (DeltaPrime format) or flat format (DegenPrime)
@@ -53,6 +61,31 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
         supplied = g.get("supplied", [])
         borrowed = g.get("borrowed", [])
         health_ratio = g.get("health_ratio", 0) or 0
+        # Use precomputed health_pct from defi --json if available (primecli >= 0.5.4)
+        precomputed = g.get("health_pct") or g.get("bruno_pct")  # bruno_pct for backward compat
+        if precomputed is not None:
+            # Early return: precomputed value exists, enrich with detail fields
+            supplied_usd = sum(s.get("usd", 0) or 0 for s in supplied)
+            debt_usd = sum(b.get("usd", 0) or 0 for b in borrowed)
+            equity = supplied_usd - debt_usd
+            raw_usdc = sum(s.get("usd", 0) for s in supplied if s.get("symbol") == "USDC")
+            symbols = [s.get("symbol", "") for s in supplied]
+            has_gmx = any("GM_" in sym for sym in symbols)
+            has_lb = any(sym in ("LB_AVAX_USDC", "LB_WAVAX_USDC", "JOE") or "TRADERJOE" in sym.upper() for sym in symbols)
+            has_aero = any("AERO" in sym.upper() or "CL_POSITION" in sym.upper() for sym in symbols)
+            return {
+                "health_pct": float(precomputed),
+                "health_ratio": round(health_ratio, 4),
+                "supplied_usd": round(supplied_usd, 2),
+                "debt_usd": round(debt_usd, 2),
+                "equity": round(equity, 2),
+                "max_debt": round(max(0, equity * (max_mult - 1)), 2),
+                "raw_usdc": round(raw_usdc, 2),
+                "has_gmx": has_gmx,
+                "has_lb": has_lb,
+                "has_aero": has_aero,
+                "action": "computed from defi --json health_pct",
+            }
     else:
         supplied = defi_data.get("supplied", [])
         borrowed = defi_data.get("borrowed", [])
@@ -64,7 +97,7 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
 
     if equity <= 0.01:
         return {
-            "bruno_pct": 0.0,
+            "health_pct": 0.0,
             "health_ratio": round(health_ratio, 4),
             "supplied_usd": round(supplied_usd, 2),
             "debt_usd": round(debt_usd, 2),
@@ -88,15 +121,15 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
     has_aero = any("AERO" in sym.upper() or "CL_POSITION" in sym.upper() for sym in symbols)
 
     if max_debt > 0 and debt_usd >= 0:
-        bruno_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
-        bruno_pct = max(0.0, min(100.0, bruno_pct))
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
     else:
-        bruno_pct = 100.0
+        health_pct = 100.0
 
     delta_debt = (max_debt * 0.5) - debt_usd  # center target = 50%
 
     return {
-        "bruno_pct": round(bruno_pct, 1),
+        "health_pct": round(health_pct, 1),
         "health_ratio": round(health_ratio, 4),
         "supplied_usd": round(supplied_usd, 2),
         "debt_usd": round(debt_usd, 2),
@@ -287,7 +320,7 @@ def run_tick(
             "reason": "equity_near_zero",
             "equity": health["equity"],
             "debt": health["debt_usd"],
-            "health_pct": health["bruno_pct"],
+            "health_pct": health["health_pct"],
             "label": label,
         })
         result.update(health)
@@ -303,23 +336,23 @@ def run_tick(
 
     # 5. Health swing detection (always)
     last_pct = load_last_health(state_dir)
-    if last_pct is not None and health["bruno_pct"] is not None:
-        diff = abs(health["bruno_pct"] - last_pct)
+    if last_pct is not None and health["health_pct"] is not None:
+        diff = abs(health["health_pct"] - last_pct)
         if diff > 10:
             write_escalation(state_dir, "health-swing", {
                 "reason": "health_swing",
                 "from_pct": last_pct,
-                "to_pct": health["bruno_pct"],
+                "to_pct": health["health_pct"],
                 "delta": diff,
                 "label": label,
             })
             result["escalation"] = "health_swing"
-    save_last_health(state_dir, health["bruno_pct"] or 0.0)
+    save_last_health(state_dir, health["health_pct"] or 0.0)
 
     # 6. Append to history
     entry = {
         "ts": now_iso, "mode": mode,
-        "pct": health["bruno_pct"],
+        "pct": health["health_pct"],
         "equity": health["equity"],
         "debt": health["debt_usd"],
         "hr": health["health_ratio"],
@@ -336,7 +369,7 @@ def run_tick(
             write_escalation(state_dir, "incomplete-valuation", {
                 "reason": "incomplete_valuation",
                 "detail": val_reason,
-                "health_pct": health["bruno_pct"],
+                "health_pct": health["health_pct"],
                 "equity": health["equity"],
                 "debt": health["debt_usd"],
                 "label": label,
@@ -354,7 +387,7 @@ def run_tick(
         side = strategy.get("side", "short")
         low, high = target_range[0], target_range[1]
 
-        pct = health["bruno_pct"]
+        pct = health["health_pct"]
         equity = health["equity"]
         debt = health["debt_usd"]
         raw_usdc = health["raw_usdc"]

{primecli-0.5.2 → primecli-0.5.4}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.2
+Version: 0.5.4
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -28,7 +28,6 @@ Requires-Dist: eth-account>=0.13
 Requires-Dist: eth-keys>=0.5
 Requires-Dist: eth-abi<7,>=5.0
 Requires-Dist: requests>=2.31
-Dynamic: license-file
 
 # primecli
 

{primecli-0.5.2 → primecli-0.5.4}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=68", "wheel"]
+requires = ["setuptools>=68,<73", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.5.2"
+version = "0.5.4"
 description = "Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required."
 readme = "README.md"
 requires-python = ">=3.10"