primecli 0.11.0__tar.gz → 0.11.2__tar.gz

{primecli-0.11.0 → primecli-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.11.0
+Version: 0.11.2
 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.11.0 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.11.2 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.11.0 → primecli-0.11.2}/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.11.0 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.11.2 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.11.0 → primecli-0.11.2}/primecli/arbprime.py

@@ -201,7 +201,7 @@ Only depositPrime (inside prime-activate --amount) is solvency-gated -> RedStone
 prime-* write is onlyOwner and needs no payload. All prime-* views are oracle-free. Preview by default; --execute broadcasts.
 """
 
-import json, os, sys, time, re, base64, struct
+import json, os, sys, time, re, random, base64, struct
 from decimal import Decimal, ROUND_HALF_UP
 from pathlib import Path
 import requests
@@ -238,6 +238,10 @@ except ImportError:
 
 # Arbitrum One RPC. Override with ARBPRIME_RPC for a paid Alchemy/Infura endpoint.
 ARBITRUM_RPC = os.environ.get("ARBPRIME_RPC", "https://arb1.arbitrum.io/rpc")
+# Secondary RPCs tried when the primary returns 429/5xx. Expanded list for resilience.
+_ARBITRUM_RPC_FALLBACKS = [
+    "https://arbitrum.publicnode.com",
+]
 EXPLORER = "https://arbiscan.io"  # display/links only — never used for ABI fetch
 CHAIN_ID = 42161
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
@@ -701,12 +705,33 @@ def multicall(w3, calls):
 _W3 = None
 
 def get_w3():
-    """Process-local Arbitrum RPC client. Arbitrum is a standard rollup (like Base) — no
-    POA middleware needed (and injecting it would error on Arbitrum block headers)."""
+    """Process-local Arbitrum RPC client with built-in fallback + exponential backoff.
+    Arbitrum is a standard rollup (like Base) — no POA middleware needed."""
     global _W3
-    if _W3 is None:
-        _W3 = Web3(Web3.HTTPProvider(ARBITRUM_RPC))
-    return _W3
+    if _W3 is not None:
+        return _W3
+    candidates = [ARBITRUM_RPC] + [u for u in _ARBITRUM_RPC_FALLBACKS if u != ARBITRUM_RPC]
+    last_exc = None
+    for attempt, url in enumerate(candidates * 2):  # At most 2 rounds through the list
+        try:
+            w3 = Web3(Web3.HTTPProvider(url, request_kwargs={"timeout": 10}))
+            # eth_chainId is cheaper than block_number for health checks
+            w3.eth.chain_id
+            _W3 = w3
+            return _W3
+        except Exception as e:
+            last_exc = e
+            msg = str(e)
+            if any(code in msg for code in ("429", "500", "502", "503", "Connection", "Timeout")):
+                # Exponential backoff with jitter: 0.5s, 1s, 2s, 4s, 8s, capped at 16s
+                delay = min(2 ** (attempt // len(candidates)) * 0.5, 16.0)
+                delay += random.uniform(0, delay * 0.3)
+                time.sleep(delay)
+                continue
+            raise
+    if last_exc:
+        raise last_exc
+    raise RuntimeError(f"All {len(candidates)} Arbitrum RPCs failed, last: {last_exc}")
 
 def _tx_gas_price(w3) -> int:
     """Estimated per-gas cost for balance checks (gas buffer pre-flights). Returns 2x the
@@ -1174,6 +1199,15 @@ def get_prime_account(w3, owner: str) -> str:
 def asset_b32(symbol: str) -> bytes:
     return symbol.encode().ljust(32, b"\x00")
 
+def _account_asset_symbol(symbol: str) -> str:
+    """Map a display/pool symbol to the bytes32 symbol the account stores on-chain.
+    Identity on Arbitrum today — every pool/token config already uses the canonical
+    account symbol and Arbitrum lists no aliased assets (no EURC/EUROC here). Kept so
+    _resolve_debt_coverages stays byte-identical with the degenprime copy, where Base
+    pool configs use "EURC" and must be normalized to the account's "EUROC" before
+    getAssetAddress can resolve it."""
+    return symbol
+
 def pool_to_asset_symbol(pool_name: str) -> str:
     """Pool key -> on-chain bytes32 asset symbol (the contracts use 'ETH', not 'WETH';
     'BTC', not 'WBTC')."""
@@ -2247,7 +2281,10 @@ def _resolve_debt_coverages(w3, symbols: list, tier_code: int = 0) -> dict:
         '{"inputs":[{"name":"t","type":"uint8"},{"name":"a","type":"address"}],"name":"tieredDebtCoverage",'
         '"outputs":[{"type":"uint256"}],"stateMutability":"view","type":"function"}]')
     tm = w3.eth.contract(address=Web3.to_checksum_address(TOKEN_MANAGER), abi=tm_abi)
-    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(tm.encode_abi("getAssetAddress", args=[asset_b32(s), True])[2:]))
+    # Resolve through the account's bytes32 alias (identity on this chain; see
+    # _account_asset_symbol) so this batched resolver stays byte-identical with the
+    # degenprime copy, where Base configs use "EURC" for the account symbol "EUROC".
+    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(tm.encode_abi("getAssetAddress", args=[asset_b32(_account_asset_symbol(s)), True])[2:]))
                  for s in missing]
     addr_res = multicall(w3, addr_legs)
     addrs = {}

{primecli-0.11.0 → primecli-0.11.2}/primecli/degenprime.py

@@ -27,8 +27,9 @@ Usage:
   degenprime execute-withdrawal --pool usdc [--index N] [--execute]
   degenprime cancel-withdrawal --pool usdc --index N [--execute]
   degenprime aerodrome-positions
-  degenprime aero-add-liquidity --pool weth-usdc-100 --amount-weth 0.05 --amount-usdc 100 [--slippage 1] [--execute]
-  degenprime aero-add-liquidity --pool weth-usdc-100 --use-all-available [--width 2] [--slippage 1] [--execute]
+  degenprime aero-add-liquidity --pool weth-usdc-100 --amount-token0 0.05 --amount-token1 100 [--slippage 1] [--execute]
+  degenprime aero-add-liquidity --pool virtual-weth-50-v3 --amount-token0 100 --amount-token1 0.05 [--slippage 1] [--execute]
+  degenprime aero-add-liquidity --pool weth-euroc-100-v3 --use-all-available [--width 2] [--slippage 1] [--execute]
   degenprime aero-increase-liquidity --pool weth-usdc-100 --token-id N --amount-token0 X --amount-token1 Y [--slippage 1] [--execute]
   degenprime aero-remove-liquidity --token-id N [--token-id M ...] [--execute]   (full close only)
   degenprime aero-collect-fees --token-id N [--execute]
@@ -125,7 +126,7 @@ position (a NEW tokenId) when price drifts past the trigger. Subcommands:
             primitive; not solvency-gated (no RedStone).
 """
 
-import json, os, sys, time, base64
+import json, os, sys, time, random, base64
 from decimal import Decimal, ROUND_HALF_UP, localcontext
 from pathlib import Path
 import requests
@@ -162,7 +163,14 @@ except ImportError:
 # and has been the most reliable free option for this tool's traffic pattern (lots of
 # small reads in quick succession for `pool-info all` / `my-positions` / `summary`).
 # Override with the DEGENPRIME_RPC env var for paid Alchemy/QuickNode/Infura endpoints.
-BASE_RPC = os.environ.get("DEGENPRIME_RPC", "https://base.publicnode.com")
+BASE_RPC = os.environ.get("DEGENPRIME_RPC", "https://base-rpc.publicnode.com")
+# Secondary RPCs tried when the primary returns 429/5xx. Expanded list so the
+# burst of overlapping cron processes spread across more endpoints instead of
+# pounding the same 2 into 429. No in-flight retry within a single call.
+_BASE_RPC_FALLBACKS = [
+    "https://base.drpc.org",
+    "https://base.meowrpc.com",
+]
 EXPLORER = "https://basescan.org"
 CHAIN_ID = 8453
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
@@ -490,12 +498,39 @@ _asset_meta_cache = {}
 _W3 = None
 
 def get_w3():
-    """Process-local Base RPC client. Base has no POA middleware - it's a standard EVM
-    chain; middleware injection is not needed (and would error on Base block headers)."""
+    """Process-local Base RPC client with built-in fallback + exponential backoff.
+    Base has no POA middleware - it's a standard EVM chain; middleware injection is
+    not needed (and would error on Base block headers).
+
+    Tries the primary RPC first (BASE_RPC / DEGENPRIME_RPC env). On 429/5xx, rotates
+    through _BASE_RPC_FALLBACKS with exponential backoff + jitter so multiple
+    concurrent processes don't thundering-herd the same fallback endpoint.
+    The first working RPC is cached for the process lifetime."""
     global _W3
-    if _W3 is None:
-        _W3 = Web3(Web3.HTTPProvider(BASE_RPC))
-    return _W3
+    if _W3 is not None:
+        return _W3
+    candidates = [BASE_RPC] + [u for u in _BASE_RPC_FALLBACKS if u != BASE_RPC]
+    last_exc = None
+    for attempt, url in enumerate(candidates * 2):  # At most 2 rounds through the list
+        try:
+            w3 = Web3(Web3.HTTPProvider(url, request_kwargs={"timeout": 10}))
+            # Quick health check — eth_chainId is cheaper for providers than block_number
+            w3.eth.chain_id
+            _W3 = w3
+            return _W3
+        except Exception as e:
+            last_exc = e
+            msg = str(e)
+            if any(code in msg for code in ("429", "500", "502", "503", "Connection", "Timeout")):
+                # Exponential backoff with jitter: 0.5s, 1s, 2s, 4s, 8s, capped at 16s
+                delay = min(2 ** (attempt // len(candidates)) * 0.5, 16.0)
+                delay += random.uniform(0, delay * 0.3)  # 30% jitter
+                time.sleep(delay)
+                continue
+            raise
+    if last_exc:
+        raise last_exc
+    raise RuntimeError(f"All {len(candidates)} Base RPCs failed, last: {last_exc}")
 
 def _tx_gas_price(w3) -> int:
     """Estimated per-gas cost for balance checks (gas buffer pre-flights). Returns 2x the
@@ -1068,6 +1103,12 @@ def get_prime_account(w3, owner: str) -> str:
 def asset_b32(symbol: str) -> bytes:
     return symbol.encode().ljust(32, b"\x00")
 
+def _account_asset_symbol(symbol: str) -> str:
+    """Map display symbols to the bytes32 symbols DegenPrime stores on accounts."""
+    if str(symbol).upper() == "EURC":
+        return "EUROC"
+    return symbol
+
 def fmt_token_amount(raw: int, decimals: int) -> str:
     """Human token amount that never misleadingly rounds a dust balance UP.
 
@@ -1110,6 +1151,7 @@ def _asset_meta(w3, symbol: str):
     Used for in-account assets that aren't lending pool symbols (memecoin collateral
     like AIXBT, TOSHI, etc.). Cached - reads are pure but the TokenManager call is one
     eth_call + an ERC20.decimals() per asset."""
+    symbol = _account_asset_symbol(symbol)
     if symbol in _asset_meta_cache:
         return _asset_meta_cache[symbol]
     # Pool symbols hit the static map - no on-chain read needed.
@@ -1245,7 +1287,15 @@ def _resolve_debt_coverages(w3, symbols: list, tier_code: int = 0) -> dict:
         '{"inputs":[{"name":"t","type":"uint8"},{"name":"a","type":"address"}],"name":"tieredDebtCoverage",'
         '"outputs":[{"type":"uint256"}],"stateMutability":"view","type":"function"}]')
     tm = w3.eth.contract(address=Web3.to_checksum_address(TOKEN_MANAGER), abi=tm_abi)
-    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(tm.encode_abi("getAssetAddress", args=[asset_b32(s), True])[2:]))
+    # Resolve the address through the account's bytes32 alias, not the raw display
+    # symbol: DegenPrime's TokenManager stores EURC as "EUROC", so getAssetAddress
+    # for "EURC" returns the zero address → dc=0 → a leveraged ETH/EURC LP read as
+    # 0% health even while solvent (health_ratio 1.29). The single-symbol resolver
+    # (_asset_meta) already normalizes via _account_asset_symbol; this batched path
+    # did not. Keep the output keyed by the original symbol so callers' lookups
+    # (which use the display symbol) still hit. (Bruno, 2026-06-27.)
+    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(
+        tm.encode_abi("getAssetAddress", args=[asset_b32(_account_asset_symbol(s)), True])[2:]))
                  for s in missing]
     addr_res = multicall(w3, addr_legs)
     addrs = {}
@@ -3087,6 +3137,7 @@ def _swap_asset_meta(w3, symbol: str):
     """Resolve a swap-side symbol to {token, decimals}. Falls back to TokenManager for
     non-pool collateral (memecoins). Returns None if the asset is unknown.
     Lookup is case-insensitive (keys like cbBTC match CBBTC)."""
+    symbol = _account_asset_symbol(symbol)
     if symbol in SWAP_ASSETS:
         return SWAP_ASSETS[symbol]
     # Case-insensitive fallback for mixed-case symbols like cbBTC.
@@ -3101,17 +3152,19 @@ def _swap_asset_meta(w3, symbol: str):
 def _paraswap_price_route(src_token, src_dec, dest_token, dest_dec, amount_in_wei, user_addr):
     """ParaSwap /prices on Base (network=8453, v6.2). Returns the priceRoute dict for a
     SELL of amount_in_wei src->dest. The priceRoute is passed verbatim to /transactions.
-    excludeContractMethods is hard-coded to keep ParaSwap from picking a router method
-    the facet can't decode (multiSwap/megaSwap/protected* etc.). excludeDEXS drops the
-    RFQ/maker sources (AugustusRFQ, Hashflow, etc.) up front: those won't fill for a
-    contract caller and are the prime SwapFailed() culprits - cutting them at the quote
-    keeps the re-quote loop from churning through routes that can never simulate clean."""
+    includeContractMethods pins the API to exactly the two router methods the facet can
+    decode (PARASWAP_SUPPORTED_SELECTORS) - an allowlist, not a blocklist, so a future
+    ParaSwap route type the facet still can't decode is excluded by construction instead
+    of needing a matching blocklist entry. excludeDEXS drops the RFQ/maker sources
+    (AugustusRFQ, Hashflow, etc.) up front: those won't fill for a contract caller and
+    are the prime SwapFailed() culprits - cutting them at the quote keeps the re-quote
+    loop from churning through routes that can never simulate clean."""
     params = {
         "srcToken": src_token, "srcDecimals": src_dec,
         "destToken": dest_token, "destDecimals": dest_dec,
         "amount": str(amount_in_wei), "side": "SELL",
         "network": CHAIN_ID, "version": "6.2", "userAddress": user_addr,
-        "excludeContractMethods": "multiSwap,megaSwap,protectedMultiSwap,protectedMegaSwap,protectedSimpleSwap,simpleSwap,swapExactAmountInOnCurveV1",
+        "includeContractMethods": "swapExactAmountIn,swapExactAmountInOnUniswapV3",
         "excludeDEXS": "AugustusRFQ,ParaSwapLimitOrders,Hashflow,Bebop,Swaap,SwaapV2,DexalotRFQ,NativeV1,Clipper,Metric,MetricRFQ",
     }
     r = requests.get(f"{PARASWAP_API}/prices", params=params,
@@ -3406,7 +3459,12 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
     if borrowed == 0:
         print(f"Degen Account has no {from_sym} debt to refinance.")
         return
-    repay_amount = min(to_wei_units(amount, from_cfg["decimals"]), borrowed)
+    requested_wei = to_wei_units(amount, from_cfg["decimals"])
+    repay_amount = min(requested_wei, borrowed)
+    if requested_wei > borrowed:
+        print(f"  Warning: requested {amount} {from_sym} exceeds the "
+              f"{borrowed / 10**from_cfg['decimals']:.6f} {from_sym} debt "
+              f"(--amount is in {from_sym} units, not USD) — capping to the full debt.")
 
     feeds = sorted(REDSTONE_AVAILABLE_FEEDS)
     payload = build_redstone_payload(feeds)
@@ -4003,7 +4061,7 @@ def _aero_pool_address(pool_cfg: dict) -> str:
     if baked:
         return Web3.to_checksum_address(baked)
     try:
-        w3_local = Web3(Web3.HTTPProvider(BASE_RPC))
+        w3_local = get_w3()
         factory_addr = (AERODROME_CL_FACTORY_V3
                         if pool_cfg.get("slipstreamVersion", 0) == 1
                         else AERODROME_CL_FACTORY_V2)
@@ -4042,12 +4100,13 @@ def _aero_in_account_balance(account, symbol: str) -> int:
     same balance getBalance(bytes32) reports (verified equal to ERC20.balanceOf on
     the account 2026-06-14). Subtract any pending withdrawal-intent lock so we never
     treat reserved funds as available. Returns 0 if the view reverts."""
+    account_symbol = _account_asset_symbol(symbol)
     try:
-        bal = account.functions.getBalance(asset_b32(symbol)).call()
+        bal = account.functions.getBalance(asset_b32(account_symbol)).call()
     except Exception:
         return 0
     try:
-        locked = account.functions.getTotalIntentAmount(asset_b32(symbol)).call()
+        locked = account.functions.getTotalIntentAmount(asset_b32(account_symbol)).call()
     except Exception:
         locked = 0
     return bal - locked if bal > locked else 0
@@ -4284,6 +4343,32 @@ def _swap_with_usdc_fallback(account, from_sym, to_sym, amount_human,
     return True
 
 
+def _aero_separate_pool_and_sweeps(valuable: dict, sym0: str, sym1: str):
+    """Split a {symbol: balance_wei} inventory into the two pool-token balances
+    and the non-pool "sweep" assets, returning (pool0_bal_wei, pool1_bal_wei,
+    sweeps).
+
+    Comparison is on NORMALIZED account symbols (_account_asset_symbol), so an
+    account alias of a pool token — EURC held/queried as EUROC — is attributed to
+    its pool leg instead of the sweep bucket. A raw string compare ("EUROC" ==
+    "EURC") dropped the real pool-token balance into `sweeps`, which --execute
+    would then swap away before the mint even though it was also counted as the
+    pool leg. Same alias dedup _aero_rebuild_sweep already applies (ba9ae34)."""
+    norm0, norm1 = _account_asset_symbol(sym0), _account_asset_symbol(sym1)
+    pool0_bal_wei = 0
+    pool1_bal_wei = 0
+    sweeps = {}
+    for sym, bal_wei in valuable.items():
+        norm = _account_asset_symbol(sym)
+        if norm == norm0:
+            pool0_bal_wei = bal_wei
+        elif norm == norm1:
+            pool1_bal_wei = bal_wei
+        else:
+            sweeps[sym] = bal_wei
+    return pool0_bal_wei, pool1_bal_wei, sweeps
+
+
 def _aero_use_all_available(
     w3, acct, account, pa_cs, pool_cfg,
     width_pct=2.0, slippage_pct=1.0, execute=False,
@@ -4309,14 +4394,15 @@ def _aero_use_all_available(
     all_candidates = set(REDSTONE_AVAILABLE_FEEDS) | {sym0, sym1}
     inventory = {}
     for sym in sorted(all_candidates):
+        account_sym = _account_asset_symbol(sym)
         try:
-            bal = account.functions.getBalance(asset_b32(sym)).call()
+            bal = account.functions.getBalance(asset_b32(account_sym)).call()
         except Exception:
             bal = 0
         if bal <= 0:
             continue
         try:
-            locked = account.functions.getTotalIntentAmount(asset_b32(sym)).call()
+            locked = account.functions.getTotalIntentAmount(asset_b32(account_sym)).call()
         except Exception:
             locked = 0
         avail = bal - locked if bal > locked else 0
@@ -4382,17 +4468,11 @@ def _aero_use_all_available(
         print("  No available assets to deploy.")
         return False
 
-    # 5. Identify non-pool assets (to sweep) and pool-token balances
-    sweeps = {}
-    pool0_bal_wei = valuable.get(sym0, 0)
-    pool1_bal_wei = valuable.get(sym1, 0)
-    for sym, bal_wei in valuable.items():
-        if sym == sym0:
-            pool0_bal_wei = bal_wei
-        elif sym == sym1:
-            pool1_bal_wei = bal_wei
-        else:
-            sweeps[sym] = bal_wei
+    # 5. Identify non-pool assets (to sweep) and pool-token balances. Alias-aware
+    # (EURC/EUROC) so the same underlying is never both a pool leg and a sweep
+    # target — see _aero_separate_pool_and_sweeps.
+    pool0_bal_wei, pool1_bal_wei, sweeps = _aero_separate_pool_and_sweeps(
+        valuable, sym0, sym1)
 
     # 6. Compute optimal allocation for pool tokens
     tick_lower, tick_upper = _aero_tick_range(
@@ -4534,9 +4614,11 @@ def cmd_aero_add_liquidity(pool_key: str, amount0: float = None,
     """Add concentrated liquidity to an Aerodrome Slipstream pool through the
     Degen Account's AerodromeFacet. Uses in-account token0/token1 balances.
 
-    --pool selects a whitelisted CL pool (e.g. weth-usdc-100).
-    --amount-weth / --amount-usdc (or --amount-token0 / --amount-token1) specify
-    the desired liquidity amounts in token units. At least one side must be >0.
+    --pool selects a whitelisted CL pool (e.g. weth-usdc-100,
+    virtual-weth-50-v3, weth-euroc-100-v3).
+    --amount-token0 / --amount-token1 specify the desired liquidity amounts in
+    the pool's token0/token1 units. Legacy --amount-weth / --amount-usdc aliases
+    are accepted only for WETH/USDC-shaped pools. At least one side must be >0.
     --slippage sets the min-amount floor (default 1%).
     --width sets the range +/-width% around the current price (default 2%).
 
@@ -4957,6 +5039,16 @@ def cmd_aero_rebuild(token_id: int, width_pct: float = 2.0, slippage_pct: float
         sys.exit(2)
     pool_cfg = AERODROME_POOLS[pool_key]
 
+    # ⚠️  Aerodrome V3 gauge anti-sniping (10-second cooldown). The
+    # batchRemoveStakedLiquidityAerodrome (Step 1) unstaked from the gauge at
+    # block.timestamp. V3 gauges reject a new stake within 10 seconds of a
+    # withdraw by the same address. Sleep 14s to ensure the cooldown has elapsed
+    # before the mint+stake in Step 3, even when the sweep step has no swaps.
+    if pool_cfg.get("slipstreamVersion", 0) >= 1 and execute:
+        print(f"  V3 gauge anti-sniping: waiting 14s before re-staking...")
+        import time
+        time.sleep(14)
+
     print(f"\nStep 2: Sweeping idle assets >$5 to pool {pool_key}...")
     _aero_rebuild_sweep(w3, acct, account, pa_cs, pool_key, pool_cfg, execute=execute)
 
@@ -5552,7 +5644,7 @@ def _aero_rebalance_events(account: str, from_block=None, to_block="latest"):
     CHUNK_FLOOR = 2_000
     t0_to_name = {t.lower().removeprefix("0x"): n for n, t in REBALANCE_TOPIC0.items()}
     all_topic0 = list(REBALANCE_TOPIC0.values())
-    scan_w3 = Web3(Web3.HTTPProvider(BASE_RPC, request_kwargs={"timeout": 20}))
+    scan_w3 = get_w3()
     out = []
     start = from_block
     chunk = CHUNK
@@ -5838,14 +5930,15 @@ def _aero_rebuild_sweep(w3, acct, account, pa_cs, pool_key, pool_cfg=None, execu
     candidates = set(REDSTONE_AVAILABLE_FEEDS) | {sym0, sym1}
     inventory = {}
     for sym in sorted(candidates):
+        account_sym = _account_asset_symbol(sym)
         try:
-            bal = account.functions.getBalance(asset_b32(sym)).call()
+            bal = account.functions.getBalance(asset_b32(account_sym)).call()
         except Exception:
             bal = 0
         if bal <= 0:
             continue
         try:
-            locked = account.functions.getTotalIntentAmount(asset_b32(sym)).call()
+            locked = account.functions.getTotalIntentAmount(asset_b32(account_sym)).call()
         except Exception:
             locked = 0
         avail = bal - locked if bal > locked else 0
@@ -5885,9 +5978,12 @@ def _aero_rebuild_sweep(w3, acct, account, pa_cs, pool_key, pool_cfg=None, execu
         return
 
     # Determine which non-pool assets to sweep
+    # Normalize via _account_asset_symbol so symbol aliases (EURC/EUROC) don't
+    # register the same underlying token as both pool-token and sweep-target.
+    _pool_norm = {_account_asset_symbol(sym0), _account_asset_symbol(sym1)}
     sweeps = {}
     for sym, bal_wei in valuable.items():
-        if sym not in (sym0, sym1):
+        if _account_asset_symbol(sym) not in _pool_norm:
             sweeps[sym] = bal_wei
 
     if not sweeps:
@@ -5972,6 +6068,10 @@ def cmd_aero_rebalance_create(token_id: int, width_pct: float, mode: str = "outs
             if pool_key:
                 print(f"  Auto-sweeping idle assets to pool: {pool_key}...")
                 _aero_rebuild_sweep(w3, acct, account, pa_cs, pool_key, execute=execute)
+                if pool_key.endswith("-v3"):
+                    print(f"  (Note: {pool_key} is a Gauges-V3 pool with a 10-second")
+                    print(f"  anti-sniping cooldown. The protocol's executor should handle")
+                    print(f"  this; off-chain rebuilds via `aero-rebuild` also respect it.")
 
     try:
         params, preview = _build_rebalance_order_params(
@@ -6261,11 +6361,12 @@ def _dispatch():
             if a == "--width" and i + 1 < len(args): width = float(args[i + 1])
         use_all = "--use-all-available" in args
         if not pool_key:
-            print("Usage: degenprime aero-add-liquidity --pool weth-usdc-100 --amount-weth 0.05 --amount-usdc 100 [--slippage 1] [--width 2] [--execute]")
+            print("Usage: degenprime aero-add-liquidity --pool <pool-key> --amount-token0 X --amount-token1 Y [--slippage 1] [--width 2] [--execute]")
+            print("Example V3: degenprime aero-add-liquidity --pool virtual-weth-50-v3 --amount-token0 100 --amount-token1 0.05")
             return
         if not use_all and (amt0 is None and amt1 is None):
-            print("Specify --amount-* values or add --use-all-available to auto-detect.")
-            print("Usage: degenprime aero-add-liquidity --pool weth-usdc-100 [--use-all-available] [--slippage 1] [--width 2] [--execute]")
+            print("Specify --amount-token0 / --amount-token1 values or add --use-all-available to auto-detect.")
+            print("Usage: degenprime aero-add-liquidity --pool <pool-key> [--use-all-available] [--slippage 1] [--width 2] [--execute]")
             return
         if use_all:
             cmd_aero_add_liquidity(pool_key, slippage_pct=slippage, execute=execute, width_pct=width, use_all_available=True)

{primecli-0.11.0 → primecli-0.11.2}/primecli/deltaprime.py

@@ -209,7 +209,7 @@ Only depositPrime (inside prime-activate --amount) is solvency-gated -> RedStone
 prime-* write is onlyOwner and needs no payload. All prime-* views are oracle-free. Preview by default; --execute broadcasts.
 """
 
-import json, os, sys, time, re, base64, struct
+import json, os, sys, time, re, random, base64, struct
 from decimal import Decimal, ROUND_HALF_UP
 from pathlib import Path
 import requests
@@ -246,6 +246,12 @@ except ImportError:
     def check_version(*a, **kw): pass
 
 AVALANCHE_RPC = os.environ.get("DELTAPRIME_RPC", "https://api.avax.network/ext/bc/C/rpc")
+# Secondary RPCs tried when the primary returns 429/5xx. Expanded list spreads
+# concurrent cron process load across more free endpoints.
+_AVALANCHE_RPC_FALLBACKS = [
+    "https://avalanche.publicnode.com",
+    "https://avalanche.drpc.org",
+]
 EXPLORER = "https://snowtrace.io"
 CHAIN_ID = 43114
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
@@ -699,15 +705,40 @@ _impl_cache = {}
 # HTTPProvider — wasteful on multi-pool reads (cmd_pool_info("all"), gather_defi).
 _W3 = None
 
+def _make_avax_w3(rpc_url: str):
+    w3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": 10}))
+    w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+    return w3
+
+
 def get_w3():
-    """Process-local Web3 client. Avalanche C-chain needs the POA middleware injected
-    once; subsequent callers share the same provider + middleware stack."""
+    """Process-local Web3 client with built-in fallback + exponential backoff on 429/5xx.
+    Avalanche C-chain needs the POA middleware injected once."""
     global _W3
-    if _W3 is None:
-        w3 = Web3(Web3.HTTPProvider(AVALANCHE_RPC))
-        w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-        _W3 = w3
-    return _W3
+    if _W3 is not None:
+        return _W3
+    candidates = [AVALANCHE_RPC] + [u for u in _AVALANCHE_RPC_FALLBACKS if u != AVALANCHE_RPC]
+    last_exc = None
+    for attempt, url in enumerate(candidates * 2):  # At most 2 rounds through the list
+        try:
+            w3 = _make_avax_w3(url)
+            # eth_chainId is cheaper than block_number for health checks
+            w3.eth.chain_id
+            _W3 = w3
+            return _W3
+        except Exception as e:
+            last_exc = e
+            msg = str(e)
+            if any(code in msg for code in ("429", "500", "502", "503", "Connection", "Timeout")):
+                # Exponential backoff with jitter: 0.5s, 1s, 2s, 4s, 8s, capped at 16s
+                delay = min(2 ** (attempt // len(candidates)) * 0.5, 16.0)
+                delay += random.uniform(0, delay * 0.3)
+                time.sleep(delay)
+                continue
+            raise
+    if last_exc:
+        raise last_exc
+    raise RuntimeError(f"All {len(candidates)} Avalanche RPCs failed, last: {last_exc}")
 
 def _tx_gas_price(w3) -> int:
     """Estimated per-gas cost for balance checks (gas buffer pre-flights). Returns 2x the
@@ -1205,6 +1236,15 @@ def get_prime_account(w3, owner: str) -> str:
 def asset_b32(symbol: str) -> bytes:
     return symbol.encode().ljust(32, b"\x00")
 
+def _account_asset_symbol(symbol: str) -> str:
+    """Map a display/pool symbol to the bytes32 symbol the account stores on-chain.
+    Identity on Avalanche today — every pool/token config already uses the canonical
+    account symbol (the euro coin is configured as "EUROC", not "EURC"; WAVAX as "AVAX";
+    WETH as "ETH"). Kept so _resolve_debt_coverages stays byte-identical with the
+    degenprime copy, where Base pool configs use "EURC" and must be normalized to the
+    account's "EUROC" before getAssetAddress can resolve it."""
+    return symbol
+
 def pool_to_asset_symbol(pool_name: str) -> str:
     """Pool key -> on-chain bytes32 asset symbol (the contracts use 'AVAX', not 'WAVAX')."""
     return POOLS[pool_name]["symbol"]
@@ -2266,7 +2306,10 @@ def _resolve_debt_coverages(w3, symbols: list, tier_code: int = 0) -> dict:
         '{"inputs":[{"name":"t","type":"uint8"},{"name":"a","type":"address"}],"name":"tieredDebtCoverage",'
         '"outputs":[{"type":"uint256"}],"stateMutability":"view","type":"function"}]')
     tm = w3.eth.contract(address=Web3.to_checksum_address(TOKEN_MANAGER), abi=tm_abi)
-    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(tm.encode_abi("getAssetAddress", args=[asset_b32(s), True])[2:]))
+    # Resolve through the account's bytes32 alias (identity on this chain; see
+    # _account_asset_symbol) so this batched resolver stays byte-identical with the
+    # degenprime copy, where Base configs use "EURC" for the account symbol "EUROC".
+    addr_legs = [(TOKEN_MANAGER, bytes.fromhex(tm.encode_abi("getAssetAddress", args=[asset_b32(_account_asset_symbol(s)), True])[2:]))
                  for s in missing]
     addr_res = multicall(w3, addr_legs)
     addrs = {}

{primecli-0.11.0 → primecli-0.11.2}/primecli/health_monitor.py

@@ -622,6 +622,7 @@ def _delever_lp_positions(
     strategy: dict,
     state_dir: str,
     label: str,
+    health_pct: float | None = None,
     dry_run: bool = False,
 ) -> dict:
     """Close LP positions to free assets for USDC debt repayment.
@@ -698,7 +699,7 @@ def _delever_lp_positions(
                         }))
                         detail = f"GMX {market_label}: withdraw {gm_to_withdraw:.4f} GM submitted (keeper pending)"
                         result = {"ok": True, "async": True, "freed": 0.0, "detail": detail}
-                        _notify(f"\U0001f504 De-lever: {label} {detail}")
+                        _notify(f"🔄 ⚠️ De-lever on {label}: health low — withdrawing GMX position to free collateral. {detail}")
                     else:
                         err = r.stderr[:300]
                         result = {"ok": False, "error": f"gmx-withdraw failed: {err}"}
@@ -734,7 +735,7 @@ def _delever_lp_positions(
                     if r.returncode == 0:
                         detail = f"closed Aerodrome tokenId {token_id}"
                         result = {"ok": True, "freed": item_usd, "detail": detail}
-                        _notify(f"\U0001f504 De-lever: {label} closed Aerodrome tokenId {token_id}")
+                        _notify(f"🔄 ⚠️ De-lever on {label}: health was {health_pct}% — closing Aerodrome LP position #{token_id} (${item_usd:.2f} worth of collateral)")
                     else:
                         err = r.stderr[:300]
                         result = {"ok": False, "error": f"aero-remove-liquidity failed: {err}"}
@@ -787,7 +788,7 @@ def _delever_lp_positions(
                     if r.returncode == 0:
                         detail = f"closed LB {pair}"
                         result = {"ok": True, "freed": 0.0, "detail": detail}
-                        _notify(f"\U0001f504 De-lever: {label} closed LB {pair}")
+                        _notify(f"🔄 ⚠️ De-lever on {label}: health was {health_pct}% — closing TraderJoe LB position ({pair})")
                     else:
                         err = r.stderr[:300]
                         result = {"ok": False, "error": f"lb-remove failed: {err}"}
@@ -862,7 +863,7 @@ def _check_pending_gmx_delever(state_dir: str, defi_data: dict, label: str) -> d
         lvl = "partial" if gm_now > 0 else "full"
         detail = f"{market}: GM {gm_before:.2f} -> {gm_now:.2f} ({lvl} close)"
         marker_path.unlink(missing_ok=True)
-        _notify(f"\u2705 GMX de-lever {label}: {detail}")
+        _notify(f"✅ GMX de-lever on {label}: withdraw complete — {detail}")
         return {"settled": True, "detail": detail}
 
     if age > _GMX_PENDING_MAX_AGE:
@@ -1254,7 +1255,7 @@ def run_tick(
                     lp_result = _delever_lp_positions(
                         defi_data, tool_path, lp_shortfall,
                         strategy, state_dir, label,
-                        dry_run=dry_run,
+                        health_pct=pct, dry_run=dry_run,
                     )
                     # DRY-RUN: _delever_lp_positions broadcast NOTHING. Report what it
                     # WOULD have closed/repaid and stop — never touch the chain.
@@ -1348,9 +1349,9 @@ def run_tick(
                                 "health_pct": pct, "label": label,
                             })
                             _notify(
-                                f"🚨 {label}: de-lever LP closed but debt remains "
-                                f"(${repay_amt:.2f} to repay, nothing freed/repayable). "
-                                f"Health {pct}%. Manual unwind needed."
+                                f"🚨 {label}: LP position closed but CANNOT repay debt — "
+                                f"no freed tokens matched any existing debt leg. "
+                                f"Still owe ${repay_amt:.2f}, health at {pct}%. Manual intervention needed."
                             )
                             result["action"] = "escalate (debt remains after LP close)"
                             return result
@@ -1363,8 +1364,9 @@ def run_tick(
                         if remaining_after < 1.0 or usdc_shortfall < 0.50:
                             result["action"] = f"repaid ${repaid_usd:.2f} (LP de-lever, token-matched)"
                             _notify(
-                                f"🔄 Rebalance: {label} closed LP + repaid ${repaid_usd:.2f} "
-                                f"(token-matched, health was {pct}%)"
+                                f"🔄 ✅ Rebalance {label}: closed LP and repaid ${repaid_usd:.2f} "
+                                f"from freed tokens directly (no swap needed — "
+                                f"freed USDC matched debt USDC). Health was {pct}%."
                             )
                             return result
 
@@ -1446,8 +1448,9 @@ def run_tick(
                                 total_repaid = repaid_usd + second_repay
                                 result["action"] = f"repaid ${total_repaid:.2f} (LP de-lever)"
                                 _notify(
-                                    f"🔄 Rebalance: {label} closed LP + repaid ${total_repaid:.2f} "
-                                    f"(health was {pct}%)"
+                                    f"🔄 ✅ Rebalance {label}: closed LP, swapped freed tokens to "
+                                    f"USDC, and repaid ${total_repaid:.2f} total. "
+                                    f"Health was {pct}%."
                                 )
                             else:
                                 result["warning"] = f"shortfall repay failed: {r2.stderr[:200]}"
@@ -1478,7 +1481,7 @@ def run_tick(
                 if r.returncode == 0:
                     cooldown_file.write_text(str(int(time.time())))
                     result["action"] = f"repaid ${repay_amt:.2f}"
-                    _notify(f"🔄 Rebalance: {label} repaid ${repay_amt:.2f} USDC (health was {pct}%)")
+                    _notify(f"🔄 ✅ {label}: repaid ${repay_amt:.2f} USDC directly from raw balance (health was {pct}% — no swap needed)")
                 else:
                     result["error"] = f"repay failed: {r.stderr[:200]}"
             except Exception as e:
@@ -1565,14 +1568,14 @@ def run_tick(
                     )
                     if sr.returncode == 0:
                         result["action"] = f"borrowed ${borrow_amt:.2f}, swapped to {swap_target}"
-                        _notify(f"🔄 Rebalance: {label} borrowed ${borrow_amt:.2f} USDC → swapped to {swap_target} (health was {pct}%)")
+                        _notify(f"🔄 ⬆️ {label}: leveraging up — borrowed ${borrow_amt:.2f} USDC and swapped to {swap_target} (health was {pct}%, adding leverage for yield)")
                     else:
                         result["warning"] = f"swap to {swap_target} failed after borrow: {sr.stderr[:200]}"
                 except Exception as e:
                     result["error"] = f"borrow+swap error: {e}"
             else:
                 result["action"] = f"borrowed ${borrow_amt:.2f} USDC (defisims autofarm deploys)"
-                _notify(f"🔄 Rebalance: {label} borrowed ${borrow_amt:.2f} USDC (health was {pct}%) → defisims deploys")
+                _notify(f"🔄 ⬆️ {label}: leveraging up — borrowed ${borrow_amt:.2f} USDC (health was {pct}%, defisims autofarm will deploy into LP)")
 
             cooldown_file.write_text(str(int(time.time())))
     return result

{primecli-0.11.0 → primecli-0.11.2}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.11.0
+Version: 0.11.2
 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.11.0 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.11.2 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.11.0 → primecli-0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.11.0"
+version = "0.11.2"
 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.11.0 → primecli-0.11.2}/tests/test_aero_v3_collision_fixes.py

@@ -262,3 +262,65 @@ def test_match_pool_cfg_pair_only_unchanged_for_unique_pair():
     # Legacy 2-arg call still works for callers/tests that don't pass tickSpacing/version.
     cfg = dp.AERODROME_POOLS["aero-cbbtc-200"]
     assert dp._aero_match_pool_cfg(cfg["token0"], cfg["token1"]) is cfg
+
+
+# ─────────────────────────── FIX 3: EURC display vs EUROC account symbol ─────
+
+def test_eurc_display_symbol_reads_euroc_account_balance():
+    calls = []
+
+    class _AccountFns:
+        def getBalance(self, sym_b32):
+            calls.append(("balance", sym_b32.rstrip(b"\x00").decode()))
+            return _Call(lambda: 123, ())
+
+        def getTotalIntentAmount(self, sym_b32):
+            calls.append(("intent", sym_b32.rstrip(b"\x00").decode()))
+            return _Call(lambda: 0, ())
+
+    class _Account:
+        functions = _AccountFns()
+
+    assert dp._account_asset_symbol("EURC") == "EUROC"
+    assert dp._aero_in_account_balance(_Account(), "EURC") == 123
+    assert calls == [("balance", "EUROC"), ("intent", "EUROC")]
+
+
+# ─────────────── FIX 4: EURC/EUROC sweep-separation dedup (_use_all_available) ─
+# _aero_use_all_available split its inventory into the two pool-token balances vs
+# the non-pool "sweep" assets with a raw string compare (sym == symbol1). For an
+# ETH/EURC pool the account holds the EURC leg under its EUROC alias, so
+# "EUROC" != "EURC" dropped that real pool-token balance into the sweep bucket —
+# which --execute would then swap away before minting, while it was ALSO counted as
+# the pool leg. The fix normalizes both sides via _account_asset_symbol.
+
+def test_separate_pool_and_sweeps_dedups_eurc_alias():
+    # symbol1 == "EURC", but the same balance is also keyed under the account alias
+    # "EUROC". Neither may land in sweeps, and the pool leg is counted exactly once.
+    bal = 820_000_000  # ~820 EURC (6 decimals)
+    valuable = {"ETH": 5 * 10**17, "EURC": bal, "EUROC": bal, "USDC": 50_000_000}
+    pool0, pool1, sweeps = dp._aero_separate_pool_and_sweeps(valuable, "ETH", "EURC")
+    assert "EURC" not in sweeps
+    assert "EUROC" not in sweeps
+    assert pool0 == 5 * 10**17
+    assert pool1 == bal                        # counted once, not doubled
+    assert sweeps == {"USDC": 50_000_000}      # only the genuine foreign asset sweeps
+
+
+def test_separate_pool_and_sweeps_pool_token_only_under_alias():
+    # Even when the EURC leg is present ONLY under its EUROC account alias, it is
+    # attributed to the pool leg, never swept.
+    bal = 100_000_000
+    pool0, pool1, sweeps = dp._aero_separate_pool_and_sweeps(
+        {"ETH": 10**18, "EUROC": bal}, "ETH", "EURC")
+    assert pool1 == bal
+    assert sweeps == {}
+
+
+def test_separate_pool_and_sweeps_no_alias_normal_split():
+    # No alias involved: genuine non-pool assets sweep, pool tokens don't.
+    valuable = {"WETH": 10**18, "USDC": 2_000_000, "AERO": 999, "cbBTC": 7}
+    pool0, pool1, sweeps = dp._aero_separate_pool_and_sweeps(valuable, "WETH", "USDC")
+    assert pool0 == 10**18
+    assert pool1 == 2_000_000
+    assert sweeps == {"AERO": 999, "cbBTC": 7}

{primecli-0.11.0 → primecli-0.11.2}/tests/test_paraswap_requote.py

@@ -141,3 +141,27 @@ def test_price_route_excludes_rfq_dexs(monkeypatch):
     excluded = captured["params"]["excludeDEXS"]
     assert "AugustusRFQ" in excluded
     assert "ParaSwapLimitOrders" in excluded
+
+
+def test_price_route_pins_include_contract_methods(monkeypatch):
+    """`_paraswap_price_route` must allowlist via includeContractMethods (not
+    blocklist via excludeContractMethods) so a future ParaSwap route type the facet
+    still can't decode is excluded by construction, matching PARASWAP_SUPPORTED_SELECTORS
+    (swapExactAmountIn / swapExactAmountInOnUniswapV3)."""
+    captured = {}
+
+    class _Resp:
+        @staticmethod
+        def json():
+            return {"priceRoute": {"destAmount": "1"}}
+
+    def fake_get(url, params=None, headers=None, timeout=None):
+        captured["params"] = params
+        return _Resp()
+
+    monkeypatch.setattr(dp.requests, "get", fake_get)
+    dp._paraswap_price_route(SRC, 18, DEST, 6, AMOUNT, PA)
+    params = captured["params"]
+    assert "excludeContractMethods" not in params
+    included = set(params["includeContractMethods"].split(","))
+    assert included == {"swapExactAmountIn", "swapExactAmountInOnUniswapV3"}