primecli 0.5.5__tar.gz → 0.5.7__tar.gz

{primecli-0.5.5 → primecli-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.5
+Version: 0.5.7
 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
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.5.2 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.5.6 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 

{primecli-0.5.5 → primecli-0.5.7}/README.md

@@ -16,7 +16,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.5.2 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.5.6 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 

{primecli-0.5.5 → primecli-0.5.7}/primecli/arbprime.py

@@ -294,16 +294,16 @@ PARASWAP_AUGUSTUS = "0x6A000F20005980200259B80c5102003040001068"
 PARASWAP_SUPPORTED_SELECTORS = {"0xe3ead59e", "0x876a02f6"}
 # Executors the facet whitelists (ParaSwapHelper._checkExecutorAddress). Lowercased.
 PARASWAP_EXECUTORS = {
-    # Must match the ParaSwap executor whitelist on DeltaPrime's ParaSwapFacet and
-    # SwapDebtFacet. The ParaSwap API can return new executors that aren't whitelisted
-    # yet — those cause on-chain InvalidExecutor() reverts. Only add executors verified
-    # to be whitelisted on-chain.
+    # Historical static whitelist. Since the protocol-level facet fix (confirmed
+    # 2026-06-04), API-returned executors outside this set can be VALID — Velora
+    # rotates executors per quote (seen: 0x8faa…e820, 0x6f05…0900). The swap paths
+    # now decide by eth_call simulation of the exact tx, not by this set; it's kept
+    # only to label "known" vs "new" executors in output.
     "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
     "0x6a000f20005980200259b80c5102003040001068",
     "0x000010036c0190e009a000d0fc3541100a07380a",
     "0x00c600b30fb0400701010f4b080409018b9006e0",
     "0xa0f408a000017007015e0f00320e470d00090a5b",
-    # 0x8faa... (Velora) returned by API but NOT whitelisted on-chain — confirmed 2026-05-28 & 2026-05-29
 }
 
 # RedStone on-demand oracle config for DeltaPrime on Arbitrum — IDENTICAL to Avalanche
@@ -671,33 +671,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):
@@ -2326,14 +2335,40 @@ def _swap_via_paraswap(w3, acct, pa_cs, account, from_sym, to_sym, from_cfg, to_
     selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
     _exec, _src, _dest, from_amt, min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, from_cfg["token"], to_cfg["token"], amount_in, pa_cs)
-    # Same executor-patching as swap-debt (see cmd_swap_debt for full rationale).
+    # Same simulate-first executor handling as swap-debt (see cmd_swap_debt for full
+    # rationale): keep the API executor when the exact tx simulates clean; only fall
+    # back to the legacy executor if the unpatched calldata reverts.
     _PARASWAP_FALLBACK_EXECUTOR = "0x000010036C0190E009a000d0fc3541100A07380A"
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"], to_cfg["token"],
-                                   amount_in, pa_cs)
+    feeds = prime_account_price_feeds(account)
+    for s in (from_sym, to_sym):
+        if s not in feeds:
+            feeds.append(s)
+    payload = build_redstone_payload(feeds)
+    def _sim_paraswap(db):
+        base = account.encode_abi("paraSwapV6", args=[full[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_paraswap(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_paraswap(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"],
+                                       to_cfg["token"], amount_in, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     print(f"Swap {amount} {from_sym} -> {to_sym} on Prime Account {pa_cs}  (via ParaSwap/Velora)")
     print(f"  Router method: {price_route['contractMethod']} ({selector_hex})")
@@ -2348,10 +2383,12 @@ def _swap_via_paraswap(w3, acct, pa_cs, account, from_sym, to_sym, from_cfg, to_
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
-    feeds = prime_account_price_feeds(account)
-    for s in (from_sym, to_sym):
-        if s not in feeds:
-            feeds.append(s)
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
+    # Rebuild the payload fresh for broadcast (the sim payload may be near the
+    # RedStone staleness window by now).
     payload = build_redstone_payload(feeds)
     base_calldata = account.encode_abi("paraSwapV6", args=[full[:4], data_bytes])
     data = base_calldata + payload.hex()
@@ -2544,7 +2581,8 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
 
     Default (one-tx): SwapDebtFacet.swapDebtParaSwap — borrows _borrowAmount of _toAsset,
     ParaSwaps it into _fromAsset, and repays _repayAmount of _fromAsset debt in a single tx.
-    Broken on-chain due to a protocol-level bug on the Velora/ParaSwap facet (as of 2026-05-30).
+    (Was broken on-chain 2026-05-30 by a protocol-level Velora/ParaSwap facet bug; the
+    DeltaPrime team fixed it — re-verified working via eth_call + live tx 2026-06-04.)
 
     --fallback (manual 3-tx via YieldYak):
       1. borrow to_sym  — borrow the new debt asset into the account
@@ -2766,16 +2804,40 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
     _exec, _src, _dest, swap_from_amt, swap_min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, to_cfg["token"], from_cfg["token"], borrow_amount, pa_cs)
 
-    # If the ParaSwap API returned a new executor not on the DeltaPrime whitelist, patch
-    # it to EXECUTOR_3 (0x00001003…A07380A) — the only legacy executor whose calldata
-    # format is compatible with the current API's output (tested on-chain 2026-05-28).
+    # Velora/ParaSwap executors rotate per quote and the facet's on-chain executor
+    # check was fixed at the protocol level (DeltaPrime team, confirmed by eth_call
+    # 2026-06-04) — API-built calldata now passes with its own executor, while the old
+    # hard-patch to the legacy executor REVERTS (executor-specific calldata mismatch).
+    # So: simulate the exact tx first and keep the API executor when it passes; only
+    # fall back to the legacy executor if the unpatched calldata reverts.
     _PARASWAP_FALLBACK_EXECUTOR = "0x000010036C0190E009a000d0fc3541100A07380A"
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"], from_cfg["token"],
-                                   borrow_amount, pa_cs)
+    def _sim_swap_debt(db):
+        base = account.encode_abi("swapDebtParaSwap", args=[
+            asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
+            full_data[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_swap_debt(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_swap_debt(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"],
+                                       from_cfg["token"], borrow_amount, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     from_pool, _, _ = get_pool_contract(_SYMBOL_TO_POOL[from_sym])
     borrowed = from_pool.functions.getBorrowed(pa_cs).call()
@@ -2806,6 +2868,10 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
     base_calldata = account.encode_abi("swapDebtParaSwap", args=[
         asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
         full_data[:4], data_bytes,

{primecli-0.5.5 → primecli-0.5.7}/primecli/degenprime.py

@@ -137,6 +137,42 @@ ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # read lazily so read-only commands that don't sign never need a key at all.
 _CLI_KEY = None  # set by the --key CLI flag in main()
 
+# Named-wallet table shared with deltaprime/arbprime. Allows running via
+# DEGENPRIME_AGENT=parakletos (or the fallback DELTAPRIME_AGENT) which is
+# cleaner than passing raw keys through environment variables.
+# Agent resolution also supports --as <agent> CLI flag.
+AGENTS = {
+    "parakletos":   ("/root/.openclaw/.env",                "PARAKLETOS_EVM_PRIVATE_KEY"),
+    "paraklaudios": ("/root/paraklaudios/.credentials.env", "PARAKLAUDIOS_EVM_PRIVATE_KEY"),
+}
+_SELECTED_AGENT = None        # set by the --as CLI flag in main()
+
+
+def _read_env_var(path, var):
+    """Return the value of `var` from a KEY=VALUE env file, or None if absent."""
+    try:
+        for line in Path(path).read_text().splitlines():
+            s = line.strip()
+            if s.startswith(var + "="):
+                return s.split("=", 1)[1].strip().strip('"').strip("'")
+    except FileNotFoundError:
+        return None
+    return None
+
+
+def _agent_key(agent):
+    if agent not in AGENTS:
+        raise RuntimeError(
+            f"Unknown agent '{agent}'. Known agents: {', '.join(AGENTS)}. "
+            f"Or set DEGENPRIME_PRIVATE_KEY, or DEGENPRIME_KEY_FILE."
+        )
+    path, var = AGENTS[agent]
+    key = _read_env_var(path, var)
+    if not key:
+        raise RuntimeError(f"{var} not found in {path} (agent '{agent}').")
+    return key
+
+
 # Core protocol addresses (verified on Base 2026-05-29).
 FACTORY_PROXY = "0x5A6a0e2702cF4603a098C3Df01f3F0DF56115456"  # SmartLoansFactory TUP
 # Diamond beacon. Every Degen Account is a per-user proxy that delegates here, so the
@@ -242,27 +278,36 @@ 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 resolve_private_key():
     """Resolve the signing key per the documented precedence:
        1. --key <0xhex> CLI flag
-       2. DEGENPRIME_PRIVATE_KEY env var
-       3. DEGENPRIME_KEY_FILE env var (path to a file containing the 0x key)
-       4. DELTAPRIME_PRIVATE_KEY / DELTAPRIME_KEY_FILE (same key, both chains)
-    Raises with a clear message if none of the four are set."""
+       2. --as <agent> CLI flag
+       3. DEGENPRIME_PRIVATE_KEY env var
+       4. DEGENPRIME_KEY_FILE env var (path to a file containing the 0x key)
+       5. DELTAPRIME_PRIVATE_KEY / DELTAPRIME_KEY_FILE (same key, both chains)
+       6. DEGENPRIME_AGENT env var
+       7. DELTAPRIME_AGENT env var (fallback)
+    Raises with a clear message if none resolve."""
     if _CLI_KEY:
         return _CLI_KEY.strip()
     for env_var in ("DEGENPRIME_PRIVATE_KEY", "DELTAPRIME_PRIVATE_KEY"):
@@ -276,6 +321,11 @@ def resolve_private_key():
                 return Path(key_file).read_text().strip()
             except FileNotFoundError:
                 raise RuntimeError(f"{path_var} points at {key_file} but the file does not exist.")
+    # Named agent via env var
+    for ag in ("DEGENPRIME_AGENT", "DELTAPRIME_AGENT"):
+        agent = os.environ.get(ag)
+        if agent:
+            return _agent_key(agent)
     raise RuntimeError(
         "No signing key found. Set DEGENPRIME_PRIVATE_KEY (raw 0x... key) or "
         "DEGENPRIME_KEY_FILE (path to a file with the key), or pass --key <0xhex>. "
@@ -1983,12 +2033,39 @@ def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.
     selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
     _exec, _src, _dest, _from_amt, min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, from_cfg["token"], to_cfg["token"], amount_in, pa_cs)
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"], to_cfg["token"],
-                                   amount_in, pa_cs)
+    # Simulate-first executor handling (see cmd_swap_debt rationale): keep the API
+    # executor when the exact tx simulates clean; only fall back to the legacy
+    # executor if the unpatched calldata reverts.
+    feeds = degen_account_price_feeds(account)
+    for s in (from_sym, to_sym):
+        if s in REDSTONE_AVAILABLE_FEEDS and s not in feeds:
+            feeds.append(s)
+    payload = build_redstone_payload(feeds)
+    def _sim_paraswap(db):
+        base = account.encode_abi("paraSwapV6", args=[full[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_paraswap(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_paraswap(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"],
+                                       to_cfg["token"], amount_in, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     print(f"Swap {amount} {from_sym} -> {to_sym} on Degen Account {pa_cs}  (via ParaSwap/Velora)")
     print(f"  Router method: {price_route['contractMethod']} ({selector_hex})")
@@ -2003,10 +2080,12 @@ def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
-    feeds = degen_account_price_feeds(account)
-    for s in (from_sym, to_sym):
-        if s in REDSTONE_AVAILABLE_FEEDS and s not in feeds:
-            feeds.append(s)
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
+    # Rebuild the payload fresh for broadcast (the sim payload may be near the
+    # RedStone staleness window by now).
     payload = build_redstone_payload(feeds)
     base_calldata = account.encode_abi("paraSwapV6", args=[full[:4], data_bytes])
     data = base_calldata + payload.hex()
@@ -2112,12 +2191,36 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
     selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
     _exec, _src, _dest, _swap_from_amt, swap_min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, to_cfg["token"], from_cfg["token"], borrow_amount, pa_cs)
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"], from_cfg["token"],
-                                   borrow_amount, pa_cs)
+    # Simulate-first executor handling (protocol-level facet fix confirmed 2026-06-04;
+    # Velora rotates executors per quote): keep the API executor when the exact tx
+    # simulates clean; only fall back to the legacy executor if it reverts.
+    def _sim_swap_debt(db):
+        base = account.encode_abi("swapDebtParaSwap", args=[
+            asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
+            full[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_swap_debt(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_swap_debt(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"],
+                                       from_cfg["token"], borrow_amount, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     print(f"Swap debt on Degen Account {pa}")
     print(f"  Refinance: {from_sym} debt -> {to_sym} debt")
@@ -2145,6 +2248,10 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
     base_calldata = account.encode_abi("swapDebtParaSwap", args=[
         asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
         full[:4], data_bytes,

{primecli-0.5.5 → primecli-0.5.7}/primecli/deltaprime.py

@@ -299,16 +299,16 @@ PARASWAP_AUGUSTUS = "0x6A000F20005980200259B80c5102003040001068"
 PARASWAP_SUPPORTED_SELECTORS = {"0xe3ead59e", "0x876a02f6"}
 # Executors the facet whitelists (ParaSwapHelper._checkExecutorAddress). Lowercased.
 PARASWAP_EXECUTORS = {
-    # Must match the ParaSwap executor whitelist on DeltaPrime's ParaSwapFacet and
-    # SwapDebtFacet. The ParaSwap API can return new executors that aren't whitelisted
-    # yet — those cause on-chain InvalidExecutor() reverts. Only add executors verified
-    # to be whitelisted on-chain.
+    # Historical static whitelist. Since the protocol-level facet fix (confirmed
+    # 2026-06-04), API-returned executors outside this set can be VALID — Velora
+    # rotates executors per quote (seen: 0x8faa…e820, 0x6f05…0900). The swap paths
+    # now decide by eth_call simulation of the exact tx, not by this set; it's kept
+    # only to label "known" vs "new" executors in output.
     "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
     "0x6a000f20005980200259b80c5102003040001068",
     "0x000010036c0190e009a000d0fc3541100a07380a",
     "0x00c600b30fb0400701010f4b080409018b9006e0",
     "0xa0f408a000017007015e0f00320e470d00090a5b",
-    # 0x8faa... (Velora) returned by API but NOT whitelisted on-chain — confirmed 2026-05-28 & 2026-05-29
 }
 
 # RedStone on-demand oracle config for DeltaPrime on Avalanche. The Prime Account's
@@ -2352,14 +2352,40 @@ def _swap_via_paraswap(w3, acct, pa_cs, account, from_sym, to_sym, from_cfg, to_
     selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
     _exec, _src, _dest, from_amt, min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, from_cfg["token"], to_cfg["token"], amount_in, pa_cs)
-    # Same executor-patching as swap-debt (see cmd_swap_debt for full rationale).
+    # Same simulate-first executor handling as swap-debt (see cmd_swap_debt for full
+    # rationale): keep the API executor when the exact tx simulates clean; only fall
+    # back to the legacy executor if the unpatched calldata reverts.
     _PARASWAP_FALLBACK_EXECUTOR = "0x000010036C0190E009a000d0fc3541100A07380A"
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"], to_cfg["token"],
-                                   amount_in, pa_cs)
+    feeds = prime_account_price_feeds(account)
+    for s in (from_sym, to_sym):
+        if s not in feeds:
+            feeds.append(s)
+    payload = build_redstone_payload(feeds)
+    def _sim_paraswap(db):
+        base = account.encode_abi("paraSwapV6", args=[full[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_paraswap(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_paraswap(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"],
+                                       to_cfg["token"], amount_in, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     print(f"Swap {amount} {from_sym} -> {to_sym} on Prime Account {pa_cs}  (via ParaSwap/Velora)")
     print(f"  Router method: {price_route['contractMethod']} ({selector_hex})")
@@ -2374,10 +2400,12 @@ def _swap_via_paraswap(w3, acct, pa_cs, account, from_sym, to_sym, from_cfg, to_
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
-    feeds = prime_account_price_feeds(account)
-    for s in (from_sym, to_sym):
-        if s not in feeds:
-            feeds.append(s)
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
+    # Rebuild the payload fresh for broadcast (the sim payload may be near the
+    # RedStone staleness window by now).
     payload = build_redstone_payload(feeds)
     base_calldata = account.encode_abi("paraSwapV6", args=[full[:4], data_bytes])
     data = base_calldata + payload.hex()
@@ -2570,7 +2598,8 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
 
     Default (one-tx): SwapDebtFacet.swapDebtParaSwap — borrows _borrowAmount of _toAsset,
     ParaSwaps it into _fromAsset, and repays _repayAmount of _fromAsset debt in a single tx.
-    Broken on-chain due to a protocol-level bug on the Velora/ParaSwap facet (as of 2026-05-30).
+    (Was broken on-chain 2026-05-30 by a protocol-level Velora/ParaSwap facet bug; the
+    DeltaPrime team fixed it — re-verified working via eth_call + live tx 2026-06-04.)
 
     --fallback (manual 3-tx via YieldYak):
       1. borrow to_sym  — borrow the new debt asset into the account
@@ -2792,16 +2821,40 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
     _exec, _src, _dest, swap_from_amt, swap_min_out = _paraswap_decode_and_check(
         selector_hex, data_bytes, to_cfg["token"], from_cfg["token"], borrow_amount, pa_cs)
 
-    # If the ParaSwap API returned a new executor not on the DeltaPrime whitelist, patch
-    # it to EXECUTOR_3 (0x00001003…A07380A) — the only legacy executor whose calldata
-    # format is compatible with the current API's output (tested on-chain 2026-05-28).
+    # Velora/ParaSwap executors rotate per quote and the facet's on-chain executor
+    # check was fixed at the protocol level (DeltaPrime team, confirmed by eth_call
+    # 2026-06-04) — API-built calldata now passes with its own executor, while the old
+    # hard-patch to the legacy executor REVERTS (executor-specific calldata mismatch).
+    # So: simulate the exact tx first and keep the API executor when it passes; only
+    # fall back to the legacy executor if the unpatched calldata reverts.
     _PARASWAP_FALLBACK_EXECUTOR = "0x000010036C0190E009a000d0fc3541100A07380A"
-    if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-        fallback_bytes = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:])
-        data_bytes = fallback_bytes + data_bytes[32:]
-        print(f"  ⚠ Executor {_exec} not whitelisted; patching to {_PARASWAP_FALLBACK_EXECUTOR}")
-        _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"], from_cfg["token"],
-                                   borrow_amount, pa_cs)
+    def _sim_swap_debt(db):
+        base = account.encode_abi("swapDebtParaSwap", args=[
+            asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
+            full_data[:4], db])
+        try:
+            w3.eth.call({"from": acct.address, "to": pa_cs,
+                         "data": base + payload.hex(), "gas": 8000000})
+            return True, None
+        except Exception as e:
+            return False, str(e)
+    sim_ok, sim_err = _sim_swap_debt(data_bytes)
+    if sim_ok:
+        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
+            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
+                  f"simulates clean — using the API calldata as-is.")
+    else:
+        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
+        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
+        sim_ok, err2 = _sim_swap_debt(patched)
+        if sim_ok:
+            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
+                  f"(simulates clean).")
+            data_bytes = patched
+            _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"],
+                                       from_cfg["token"], borrow_amount, pa_cs)
+        else:
+            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
 
     from_pool, _, _ = get_pool_contract(_SYMBOL_TO_POOL[from_sym])
     borrowed = from_pool.functions.getBorrowed(pa_cs).call()
@@ -2832,6 +2885,10 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
         print("Run with --execute to broadcast (appends a fresh RedStone price payload).")
         return
 
+    if not sim_ok:
+        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        return
+
     base_calldata = account.encode_abi("swapDebtParaSwap", args=[
         asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
         full_data[:4], data_bytes,

{primecli-0.5.5 → primecli-0.5.7}/primecli/health_monitor.py

@@ -37,22 +37,21 @@ TIER_MAX = {"basic": 5, "premium": 10}
 # ════════════════════════════════════════════════════════════════════
 
 def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
-    """Compute equity-based health (0-100%) from defi --json data.
+    """Compute health (0-100%) using the frontend formula from DeltaPrime docs.
 
-    PREFERS the precomputed ``health_pct`` from defi --json (which primecli >= 0.5.4
-    includes), falling back to manual calculation when absent.
+    Uses the cross-margin health formula (all assets assumed same borrowing power):
+      equity    = total_supplied_usd - total_debt_usd
+      health_pct = 100 * (1 - debt / (max_mult * equity))
+      (0% = liquidation, 100% = no debt)
 
-    Formula:
-      equity = total_supplied_usd - total_debt_usd
-      max_debt = equity * (tier - 1)    # PREMIUM=10, BASIC=5
-      health% = (max_debt - debt) / max_debt * 100
+    Background:
+      The frontend uses Pr = tier / (tier + 1) and computes:
+        health_pct = (Pr * supplied - debt) / (Pr * equity) * 100
+      which simplifies to: 100 * (1 - debt / (max_mult * equity)).
 
-    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.
+    DIFFERENT from the equity-based "health_pct" in defi --json / prime-summary
+    (which uses max_debt = equity * (tier - 1)).
+    The on-chain health_ratio (1.0=liquidation) is NOT used here.
     """
     # Parse groups (DeltaPrime format) or flat format (DegenPrime)
     groups = defi_data.get("groups", [])
@@ -62,24 +61,27 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
         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
+        precomputed = g.get("health_pct")
         if precomputed is not None:
-            # Early return: precomputed value exists, enrich with detail fields
+            # Override health_pct with frontend formula (ignores precomputed value)
             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
+            equity = max(supplied_usd - debt_usd, 0.01)
             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_gmx = sum(s.get("usd", 0) for s in supplied if "GM_" in s.get("symbol", "")) > 1.0
             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)
+            # Frontend formula: health_pct = 100 * (1 - debt / (max_mult * equity))
+            fe_health = max(0.0, 100.0 * (1.0 - round(debt_usd, 2) / (max_mult * equity)))
+            fe_max_debt = round(max_mult * equity, 2)
             return {
-                "health_pct": float(precomputed),
+                "health_pct": round(fe_health, 1),
                 "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),
+                "max_debt": round(max(0, max_mult * equity), 2),
                 "raw_usdc": round(raw_usdc, 2),
                 "has_gmx": has_gmx,
                 "has_lb": has_lb,
@@ -105,14 +107,14 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
             "error": "equity near zero",
         }
 
-    max_debt = equity * (max_mult - 1)
+    max_debt = round(max_mult * equity, 2)  # frontend formula: max debt before liquidation
 
     # Raw USDC in account
     raw_usdc = sum(s.get("usd", 0) for s in supplied if s.get("symbol") == "USDC")
 
     # Position type detection
     symbols = [s.get("symbol", "") for s in supplied]
-    has_gmx = any("GM_" in sym for sym in symbols)
+    has_gmx = sum(s.get("usd", 0) for s in supplied if "GM_" in s.get("symbol", "")) > 1.0
     has_lb = any(
         sym in ("LB_AVAX_USDC", "LB_WAVAX_USDC", "JOE")
         or "TRADERJOE" in sym.upper()
@@ -120,13 +122,13 @@ 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:
-        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
-        health_pct = max(0.0, min(100.0, health_pct))
+    if max_debt > 0.01 and debt_usd >= 0:
+        health_pct = max(0.0, 100.0 * (1.0 - round(debt_usd, 2) / max_debt))
     else:
         health_pct = 100.0
 
-    delta_debt = (max_debt * 0.5) - debt_usd  # center target = 50%
+    # Center target (50% health): target_debt = max_debt * 0.5
+    delta_debt = (max_debt * 0.5) - debt_usd
 
     return {
         "health_pct": round(health_pct, 1),
@@ -306,28 +308,32 @@ def run_tick(
             max_mult = TIER_MAX.get("basic", 5)
             tier = "basic"
         else:
-            max_mult = TIER_MAX.get("premium", 10)
-            tier = "premium"
+            max_mult = TIER_MAX.get("basic", 5)
+            tier = "basic"
     except Exception:
-        max_mult = 10
-        tier = "premium"
+        max_mult = 5
+        tier = "basic"
 
     # 3. Compute health
     health = compute_health(defi_data, max_mult)
     health["tier"] = tier
     if health.get("error") == "equity near zero":
-        write_escalation(state_dir, "equity-near-zero", {
-            "reason": "equity_near_zero",
-            "equity": health["equity"],
-            "debt": health["debt_usd"],
-            "health_pct": health["health_pct"],
-            "label": label,
-        })
+        # Only escalate if there's actual debt — an empty unfunded wallet is not an emergency
+        if health.get("debt_usd", 0) and health["debt_usd"] > 0.5:
+            write_escalation(state_dir, "equity-near-zero", {
+                "reason": "equity_near_zero",
+                "equity": health["equity"],
+                "debt": health["debt_usd"],
+                "health_pct": health["health_pct"],
+                "label": label,
+            })
+            result["mode"] = "escalated"
+        else:
+            result["action"] = "none (unfunded account)"
         result.update(health)
-        result["mode"] = "escalated"
         return result
 
-    # 4. Load strategy
+    # 4. Load strategy (position/market/side are optional hints now — auto-detected from defi_data)
     strategy = load_strategy(strategy_path)
     mode = strategy.get("mode", "observer")
     health["mode"] = mode
@@ -390,7 +396,7 @@ def run_tick(
         pct = health["health_pct"]
         equity = health["equity"]
         debt = health["debt_usd"]
-        raw_usdc = health["raw_usdc"]
+        raw_usdc = health.get("raw_usdc", 0)
 
         # ── Stop-loss: equity drawdown ──────────────────────────────
         if stop_loss_drawdown > 0:
@@ -513,32 +519,86 @@ def run_tick(
                 result["error"] = f"borrow error: {e}"
                 return result
 
-            # Deploy into GMX (default position type)
-            if position_type == "gmx":
-                try:
-                    r = subprocess.run(
-                        [sys.executable, tool_path, "gmx-deposit",
-                         "--market", market, "--amount", f"{borrow_amt:.2f}",
-                         "--side", side, "--fee-buffer", "1.5", "--execute"],
-                        capture_output=True, text=True, timeout=120,
-                    )
-                    if r.returncode == 0:
-                        cooldown_file.write_text(str(int(time.time())))
-                        result["action"] = f"borrowed ${borrow_amt:.2f} + GMX deposit"
-                    else:
-                        # Partial state: borrowed but deposit failed
-                        result["warning"] = f"borrow ok but deposit failed: {r.stderr[:200]}"
-                        result["action"] = "partial (borrowed, deposit failed)"
-                except Exception as e:
-                    result["error"] = f"gmx deposit error: {e}"
+            # Deploy into whatever positions are open (detected dynamically from defi_data)
+            has_gmx = health.get("has_gmx", False)
+            has_lb = health.get("has_lb", False)
+            has_aero = health.get("has_aero", False)
+            open_positions = []
+            if has_gmx: open_positions.append("gmx")
+            if has_lb:  open_positions.append("lb")
+            if has_aero: open_positions.append("aero")
+
+            if not open_positions:
+                # No open positions — just borrow and leave as USDC (or deploy to default)
+                result["action"] = f"borrowed ${borrow_amt:.2f} (no positions to deploy into)"
+                cooldown_file.write_text(str(int(time.time())))
             else:
-                result["action"] = f"escalate (unsupported position: {position_type})"
-                write_escalation(state_dir, "unsupported-position", {
-                    "reason": "lever_unsupported_position",
-                    "position": position_type,
-                    "borrow_amt": borrow_amt,
-                    "label": label,
-                })
+                # Split borrow amount proportionally across open positions
+                split_amt = borrow_amt / len(open_positions)
+                deployed_ok = 0
+                deployed_fail = 0
+
+                for pos_type in open_positions:
+                    if pos_type == "gmx":
+                        # Use market/side from strategy as hint, fall back to sensible defaults
+                        mkt = strategy.get("market", "avax-usdc") if tool_path else "avax-usdc"
+                        sd = strategy.get("side", "long") if tool_path else "long"
+                        try:
+                            r = subprocess.run(
+                                [sys.executable, tool_path, "gmx-deposit",
+                                 "--market", mkt, "--amount", f"{split_amt:.2f}",
+                                 "--side", sd, "--fee-buffer", "1.5", "--execute"],
+                                capture_output=True, text=True, timeout=120,
+                            )
+                            if r.returncode == 0:
+                                deployed_ok += 1
+                            else:
+                                result["warning"] = f"gmx deposit failed: {r.stderr[:200]}"
+                                deployed_fail += 1
+                        except Exception as e:
+                            result["error"] = f"gmx deposit error: {e}"
+                            deployed_fail += 1
+
+                    elif pos_type == "lb":
+                        # LB deposits: use the pool from strategy hint, default to AVAX/USDC
+                        lb_pool = strategy.get("lb_pool", "AVAX/USDC")
+                        try:
+                            r = subprocess.run(
+                                [sys.executable, tool_path, "lb-deposit",
+                                 "--pool", lb_pool, "--amount", f"{split_amt:.2f}",
+                                 "--execute"],
+                                capture_output=True, text=True, timeout=120,
+                            )
+                            if r.returncode == 0:
+                                deployed_ok += 1
+                            else:
+                                result["warning"] = f"lb deposit failed: {r.stderr[:200]}"
+                                deployed_fail += 1
+                        except Exception as e:
+                            result["error"] = f"lb deposit error: {e}"
+                            deployed_fail += 1
+
+                    elif pos_type == "aero":
+                        try:
+                            r = subprocess.run(
+                                [sys.executable, tool_path, "aerodrome-deposit",
+                                 "--amount", f"{split_amt:.2f}", "--execute"],
+                                capture_output=True, text=True, timeout=120,
+                            )
+                            if r.returncode == 0:
+                                deployed_ok += 1
+                            else:
+                                result["warning"] = f"aerodrome deposit failed: {r.stderr[:200]}"
+                                deployed_fail += 1
+                        except Exception as e:
+                            result["error"] = f"aerodrome deposit error: {e}"
+                            deployed_fail += 1
+
+                if deployed_ok > 0:
+                    cooldown_file.write_text(str(int(time.time())))
+                    result["action"] = f"borrowed ${borrow_amt:.2f}, deployed ${split_amt:.2f} to {deployed_ok} position(s)"
+                else:
+                    result["warning"] = f"borrow ok but all deposits failed" 
 
     return result
 
@@ -573,7 +633,7 @@ def cli():
             [sys.executable, tool_path, "defi", "--json"],
             capture_output=True, text=True, timeout=90,
         )
-        tier = "premium"  # default
+        tier = "basic"  # default
         try:
             t = subprocess.run(
                 [sys.executable, tool_path, "prime-tier"],

{primecli-0.5.5 → primecli-0.5.7}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.5
+Version: 0.5.7
 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
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.5.2 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.5.6 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 

{primecli-0.5.5 → primecli-0.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.5.5"
+version = "0.5.7"
 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"

{primecli-0.5.5 → primecli-0.5.7}/tests/test_gas_pricing.py

@@ -1,10 +1,13 @@
 """Offline tests for `_set_gas_price_for(chain_id, w3, tx)` in deltaprime and arbprime.
 
-This helper sets gas fields for an explicit chain id (used by cross-chain flows
-like prime-bridge), so it must pick the right fee model per chain:
-  * Arbitrum (42161) / Base (8453): EIP-1559 — maxFeePerGas + maxPriorityFeePerGas,
+This helper sets gas fields for cross-chain flows (like prime-bridge). All three
+supported chains (Arbitrum 42161, Base 8453, Avalanche 43114 post-Etna) speak
+EIP-1559, so the helper now tries EIP-1559 first regardless of chain id:
+  * `eth.max_priority_fee` works → maxFeePerGas + maxPriorityFeePerGas,
     and NO legacy gasPrice.
-  * Avalanche (43114): legacy gasPrice with a 1 gwei floor (post-Etna), and NO EIP-1559 fields.
+  * `eth.max_priority_fee` raises (legacy-only chain/RPC) → legacy gasPrice with
+    a 1 gwei floor, and NO EIP-1559 fields.
+  * EIP-1559 fields already present on the tx → left untouched (stale gasPrice dropped).
 
 No RPC is made: we feed a stub w3 whose `eth.gas_price` / `eth.max_priority_fee`
 return canned values. The helper is duplicated in both modules, so both are tested.
@@ -24,7 +27,13 @@ MODULES = ["primecli.deltaprime", "primecli.arbprime"]
 class _StubEth:
     def __init__(self, gas_price, max_priority_fee):
         self.gas_price = gas_price
-        self.max_priority_fee = max_priority_fee
+        self._max_priority_fee = max_priority_fee
+
+    @property
+    def max_priority_fee(self):
+        if isinstance(self._max_priority_fee, Exception):
+            raise self._max_priority_fee
+        return self._max_priority_fee
 
 
 class _StubW3:
@@ -82,24 +91,46 @@ def test_base_sets_eip1559_no_gasprice(mod):
 
 
 # ──────────────────────────────────────────────────────────────────────────────
-# Avalanche (43114) — legacy gasPrice with 1 gwei floor (post-Etna ACP-125)
+# Avalanche (43114) — EIP-1559 post-Etna (ACP-125); legacy gasPrice only as fallback
 
 
-def test_avalanche_sets_legacy_gasprice_no_eip1559(mod):
-    # gas_price*2 (60 gwei) > 1 gwei floor → uses doubled value
+def test_avalanche_uses_eip1559_when_priority_fee_available(mod):
     w3 = _StubW3(gas_price=30 * GWEI, max_priority_fee=1 * GWEI)
-    tx = {}
+    tx = {"gasPrice": 1}  # stale value dropped, not added-to
     mod._set_gas_price_for(43114, w3, tx)
-    assert tx["gasPrice"] == 60 * GWEI
-    assert "maxFeePerGas" not in tx
-    assert "maxPriorityFeePerGas" not in tx
+    assert "gasPrice" not in tx
+    # max(base*2, base + prio + 1gwei) = max(60, 32) = 60 gwei
+    assert tx["maxFeePerGas"] == 60 * GWEI
+    assert tx["maxPriorityFeePerGas"] == 1 * GWEI
 
 
-def test_avalanche_applies_1_gwei_floor(mod):
-    # gas_price*2 (0.02 gwei, realistic post-Etna base) < 1 gwei floor → floor wins
-    w3 = _StubW3(gas_price=GWEI // 100, max_priority_fee=1 * GWEI)
+def test_legacy_fallback_applies_1_gwei_floor(mod):
+    # max_priority_fee unsupported (raises) → legacy gasPrice path with the 1 gwei
+    # floor: gas_price*2 (0.02 gwei, realistic post-Etna base) < 1 gwei → floor wins
+    w3 = _StubW3(gas_price=GWEI // 100, max_priority_fee=ValueError("no eip-1559"))
     tx = {"gasPrice": 1}  # stale value replaced, not added-to
     mod._set_gas_price_for(43114, w3, tx)
     assert tx["gasPrice"] == 1 * GWEI
     assert "maxFeePerGas" not in tx
     assert "maxPriorityFeePerGas" not in tx
+
+
+def test_legacy_fallback_doubles_above_floor(mod):
+    # max_priority_fee unsupported → legacy path: gas_price*2 (60 gwei) > 1 gwei floor
+    w3 = _StubW3(gas_price=30 * GWEI, max_priority_fee=ValueError("no eip-1559"))
+    tx = {}
+    mod._set_gas_price_for(43114, w3, tx)
+    assert tx["gasPrice"] == 60 * GWEI
+    assert "maxFeePerGas" not in tx
+    assert "maxPriorityFeePerGas" not in tx
+
+
+def test_preset_eip1559_fields_left_untouched(mod):
+    # build_transaction already set the fee fields → helper must not override them,
+    # but must still drop a stale legacy gasPrice
+    w3 = _StubW3(gas_price=30 * GWEI, max_priority_fee=1 * GWEI)
+    tx = {"maxFeePerGas": 5 * GWEI, "maxPriorityFeePerGas": 2 * GWEI, "gasPrice": 1}
+    mod._set_gas_price_for(43114, w3, tx)
+    assert tx["maxFeePerGas"] == 5 * GWEI
+    assert tx["maxPriorityFeePerGas"] == 2 * GWEI
+    assert "gasPrice" not in tx

{primecli-0.5.5 → primecli-0.5.7}/tests/test_health_monitor.py

@@ -57,8 +57,8 @@ def test_compute_health_lever_branch_high_pct():
         max_mult=10,
     )
     assert h["equity"] == 2000
-    assert h["bruno_pct"] == 85.0
-    assert h["bruno_pct"] > 70  # lever territory
+    assert h["health_pct"] == 85.0
+    assert h["health_pct"] > 70  # lever territory
 
 
 def test_compute_health_in_range_branch():
@@ -71,8 +71,8 @@ def test_compute_health_in_range_branch():
         max_mult=10,
     )
     assert h["equity"] == 2000
-    assert h["bruno_pct"] == 50.0
-    assert 30 <= h["bruno_pct"] <= 70
+    assert h["health_pct"] == 50.0
+    assert 30 <= h["health_pct"] <= 70
 
 
 def test_compute_health_delever_branch_low_pct():
@@ -85,8 +85,8 @@ def test_compute_health_delever_branch_low_pct():
         max_mult=10,
     )
     assert h["equity"] == 2000
-    assert h["bruno_pct"] == 10.0
-    assert h["bruno_pct"] < 30  # de-lever territory
+    assert h["health_pct"] == 10.0
+    assert h["health_pct"] < 30  # de-lever territory
 
 
 def test_compute_health_equity_near_zero_errors():
@@ -99,7 +99,7 @@ def test_compute_health_equity_near_zero_errors():
         max_mult=10,
     )
     assert h["error"] == "equity near zero"
-    assert h["bruno_pct"] == 0.0
+    assert h["health_pct"] == 0.0
 
 
 def test_compute_health_basic_tier_lower_ceiling():
@@ -112,7 +112,7 @@ def test_compute_health_basic_tier_lower_ceiling():
     assert basic["equity"] == premium["equity"] == 2000
     assert basic["max_debt"] == 2000 * 4
     assert premium["max_debt"] == 2000 * 9
-    assert basic["bruno_pct"] < premium["bruno_pct"]
+    assert basic["health_pct"] < premium["health_pct"]
 
 
 def test_compute_health_flat_format_and_position_detection():