primecli 0.7.5__tar.gz → 0.8.1__tar.gz

{primecli-0.7.5 → primecli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.7.5
+Version: 0.8.1
 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.7.5 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.8.1 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.7.5 → primecli-0.8.1}/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.7.5 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.8.1 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.7.5 → primecli-0.8.1}/primecli/degenprime.py

@@ -27,7 +27,7 @@ Usage:
   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-remove-liquidity --token-id N [--percentage 100] [--execute]
+  degenprime aero-remove-liquidity --token-id N [--token-id M ...] [--execute]   (full close only)
   degenprime aero-collect-fees --token-id N [--execute]
 
 Configuration (env vars):
@@ -76,14 +76,22 @@ asset (--from), and repays the old debt. --from is the existing debt being
 refinanced; --to is the new debt taken on. RedStone-gated on execute.
 
 aerodrome-positions is read-only: lists each Aerodrome Slipstream (CL) NFT position the
-Degen Account owns/stakes, showing token0/token1/tick range/liquidity via the diamond's
-getOwnedStakedAerodromeTokenIds + getPositionCompositionSimplified views.
+Degen Account owns/stakes, showing token0/token1/tick range/liquidity. Enumerates tokenIds
+via getOwnedStakedAerodromeTokenIds, then reads each from the Aerodrome NPM.positions()
+view (correct for staked NFTs, which the simplified facet view reports as 0 liquidity).
 
 aero-add-liquidity / aero-remove-liquidity / aero-collect-fees provide write paths to
 the Aerodrome Slipstream NonfungiblePositionManager through the Degen Account's
 AerodromeFacet wrapper functions. The facet selectors were determined via on-chain
 probing (Diamond Loupe) of the smart-loan diamond; function names are inferred from
 their parameter layouts and revert signatures.
+
+aero-remove-liquidity fully closes one or more staked positions in a single call via
+batchRemoveStakedLiquidityAerodrome(uint256[]) (selector 0x27bed82e): per tokenId it
+unstakes from the gauge, removes all liquidity, collects fees, and burns the NFT. There
+is no partial/percentage decrease on this path — it always closes 100%. The call is
+solvency-gated, so the calldata carries a RedStone payload (verified byte-exact against
+the manual close 0x0d65...0a50).
 """
 
 import json, os, sys, time, base64
@@ -207,16 +215,15 @@ AERODROME_NPM = "0x827922686190790b37229fd06084350E74485b72"
 #   6f2845cd  getOwnedStakedAerodromeTokenIds()
 #   b6626971  getPositionCompositionSimplified(uint256) -> (address,address,uint256,uint256)
 #   121350b3  (view, takes uint256 — detailed position info, unknown return)
-#   27bed82e  (write, onlyOwner, takes MintParams-like tuple — inferred mint/add)
+#   27bed82e  batchRemoveStakedLiquidityAerodrome(uint256[]) — full close per id
+#             (verified byte-exact vs manual close 0x0d65...0a50, 2026-06-14)
 #   2c710777  (write, onlyOwner, takes IncreaseLiquidityParams-like tuple — inferred increase)
-#   ca15558b  (write, takes DecreaseLiquidityParams tuple 5-field — matches decreaseLiquidity)
 #   92b5a47e  (write, takes uint256 tokenId, checks position exists — burn/collect)
 #   46daca2c  (write, onlyOwnerOrLiquidator — emergency withdrawal)
-AERODROME_SEL_MINT = bytes.fromhex("27bed82e")          # inferred: mint/add
+AERODROME_SEL_MINT = bytes.fromhex("f32f1e56")          # mintAndStakeLiquidityAerodrome
 AERODROME_SEL_INCREASE = bytes.fromhex("2c710777")      # inferred: increaseLiquidity
-AERODROME_SEL_DECREASE = bytes.fromhex("ca15558b")      # inferred: decreaseLiquidity
-AERODROME_SEL_BURN = bytes.fromhex("92b5a47e")          # inferred: burn
-AERODROME_SEL_COLLECT = bytes.fromhex("92b5a47e")       # same as burn (inferred)
+AERODROME_SEL_BURN = bytes.fromhex("27bed82e")           # batchRemoveStakedLiquidityAerodrome
+AERODROME_SEL_COLLECT = bytes.fromhex("887e4b7e")        # collectAerodromeFees
 
 # Whitelisted Aerodrome CL pools exposed as tool keys — the authoritative set of
 # ~31 DegenPrime-supported SlipStream pools. Every entry was verified on-chain
@@ -800,19 +807,6 @@ PRIME_ACCOUNT_ABI = [
     ]}],
      "name": "mintAerodrome", "outputs": [],
      "stateMutability": "nonpayable", "type": "function"},
-    # decreaseAerodromeLiquidity: wraps NPM.decreaseLiquidity(DecreaseLiquidityParams).
-    # DecreaseLiquidityParams = (uint256 tokenId, uint128 liquidity,
-    #   uint256 amount0Min, uint256 amount1Min, uint256 deadline).
-    # Selector: 0xca15558b (probed — accepts 5-field tuple matching decrease layout).
-    {"inputs": [{"name": "params", "type": "tuple", "components": [
-        {"name": "tokenId", "type": "uint256"},
-        {"name": "liquidity", "type": "uint128"},
-        {"name": "amount0Min", "type": "uint256"},
-        {"name": "amount1Min", "type": "uint256"},
-        {"name": "deadline", "type": "uint256"}
-    ]}],
-     "name": "decreaseAerodromeLiquidity", "outputs": [],
-     "stateMutability": "nonpayable", "type": "function"},
     # burnAerodromePosition: wraps NPM.burn(uint256). tokenId must have 0 liquidity
     # and all fees collected.
     # Selector: 0x92b5a47e (probed — takes uint256, checks position exists via NPM.positions).
@@ -824,6 +818,9 @@ PRIME_ACCOUNT_ABI = [
     {"inputs": [{"name": "tokenId", "type": "uint256"}],
      "name": "collectAerodromeFees", "outputs": [],
      "stateMutability": "nonpayable", "type": "function"},
+    # batchRemoveStakedLiquidityAerodrome(uint256[]) — selector 0x27bed82e
+    # (== AERODROME_SEL_BURN, verified). Unstakes + closes the listed positions.
+    {"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"batchRemoveStakedLiquidityAerodrome","outputs":[],"stateMutability":"nonpayable","type":"function"},
 ]
 
 # TokenManager ABI - minimal subset for symbol/decimals lookups + supported tokens
@@ -834,7 +831,8 @@ TOKEN_MANAGER_ABI = [
      "outputs": [{"type": "address"}], "stateMutability": "view", "type": "function"},
     {"inputs": [{"name": "_address", "type": "address"}], "name": "tokenAddressToSymbol",
      "outputs": [{"type": "bytes32"}], "stateMutability": "view", "type": "function"},
-    {"inputs": [{"name": "_symbol", "type": "bytes32"}], "name": "getAssetAddress",
+    {"inputs": [{"name": "_symbol", "type": "bytes32"},
+                {"name": "_allowInactive", "type": "bool"}], "name": "getAssetAddress",
      "outputs": [{"type": "address"}], "stateMutability": "view", "type": "function"},
     {"inputs": [], "name": "getSupportedTokensAddresses",
      "outputs": [{"type": "address[]"}], "stateMutability": "view", "type": "function"},
@@ -947,6 +945,28 @@ def get_prime_account(w3, owner: str) -> str:
 def asset_b32(symbol: str) -> bytes:
     return symbol.encode().ljust(32, b"\x00")
 
+def fmt_token_amount(raw: int, decimals: int) -> str:
+    """Human token amount that never misleadingly rounds a dust balance UP.
+
+    Plain f"{x:,.6f}" turns 9.41e-7 into "0.000001" — visually a larger,
+    round number than the true value, which is exactly what over-requested a
+    dust balance and reverted a mint after burning gas (2026-06-14). For any
+    nonzero value that 6-dp formatting would round to zero or up to its own
+    last place, append the raw base units so the real size is unambiguous.
+    Normal/large balances keep the familiar grouped 6-dp display."""
+    if raw == 0:
+        return "0"
+    amt = Decimal(raw) / (Decimal(10) ** int(decimals))
+    rounded6 = amt.quantize(Decimal("0.000001"))
+    # Switch to sci-notation + raw wei only for genuinely small balances that 6-dp
+    # formatting would misrepresent: rounds to 0 (looks like nothing), or rounds UP
+    # below the 1e-4 dust line (e.g. 9.41e-7 -> 0.000001, the over-request trap).
+    # Larger values keep the familiar grouped 6-dp display even if the last place
+    # rounds — there a round-up isn't misleading and sci-notation would be noise.
+    if rounded6 == 0 or (rounded6 > amt and amt < Decimal("0.0001")):
+        return f"{amt:.3e} ({raw} wei)"
+    return f"{amt:,.6f}"
+
 def pool_to_asset_symbol(pool_name: str) -> str:
     """Pool key -> on-chain bytes32 asset symbol (the contracts use 'ETH', not 'WETH')."""
     return POOLS[pool_name]["symbol"]
@@ -976,7 +996,7 @@ def _asset_meta(w3, symbol: str):
             return _asset_meta_cache[symbol]
     try:
         tm = get_token_manager(w3)
-        addr = tm.functions.getAssetAddress(asset_b32(symbol)).call()
+        addr = tm.functions.getAssetAddress(asset_b32(symbol), True).call()
         if int(addr, 16) == 0:
             _asset_meta_cache[symbol] = (None, 18)
             return _asset_meta_cache[symbol]
@@ -2180,7 +2200,7 @@ def cmd_summary(as_json: bool = False):
             if pool_deposits:
                 print("  Pool Deposits (Diamond Hands):")
                 for r in pool_deposits:
-                    print(f"    {r['symbol']:<8} {r['raw'] / 10**r['decimals']:,.6f}")
+                    print(f"    {r['symbol']:<8} {fmt_token_amount(r['raw'], r['decimals'])}")
         return
 
     account = w3.eth.contract(address=Web3.to_checksum_address(pa), abi=PRIME_ACCOUNT_ABI)
@@ -2228,7 +2248,7 @@ def cmd_summary(as_json: bool = False):
         for r in supplied:
             usd = solvency["prices"].get(r["symbol"])
             usd_str = f"  (~${r['raw'] / 10**r['decimals'] * usd:,.2f})" if usd is not None else ""
-            print(f"    {r['symbol']:<8} {r['raw'] / 10**r['decimals']:,.6f}{usd_str}")
+            print(f"    {r['symbol']:<8} {fmt_token_amount(r['raw'], r['decimals'])}{usd_str}")
     else:
         print("    (none)")
 
@@ -2237,7 +2257,7 @@ def cmd_summary(as_json: bool = False):
         for r in borrowed:
             usd = solvency["prices"].get(r["symbol"])
             usd_str = f"  (~${r['raw'] / 10**r['decimals'] * usd:,.2f})" if usd is not None else ""
-            print(f"    {r['symbol']:<8} {r['raw'] / 10**r['decimals']:,.6f}{usd_str}")
+            print(f"    {r['symbol']:<8} {fmt_token_amount(r['raw'], r['decimals'])}{usd_str}")
     else:
         print("    (none)")
 
@@ -2246,7 +2266,7 @@ def cmd_summary(as_json: bool = False):
         for r in pool_deposits:
             usd = solvency["prices"].get(r["symbol"])
             usd_str = f"  (~${r['raw'] / 10**r['decimals'] * usd:,.2f})" if usd is not None else ""
-            print(f"    {r['symbol']:<8} {r['raw'] / 10**r['decimals']:,.6f}{usd_str}")
+            print(f"    {r['symbol']:<8} {fmt_token_amount(r['raw'], r['decimals'])}{usd_str}")
 
     if solvency["error"] is None:
         # A solvency view can come back None even with no error (e.g. a multicall leg that
@@ -2275,7 +2295,14 @@ def cmd_summary(as_json: bool = False):
             print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
         else:
             print(f"  Health (0-100%): N/A ({hp['error']})")
-        print(f"  Solvent:            {'yes' if solvency['solvent'] else 'NO - liquidatable'}")
+        # An account with no debt cannot be liquidated. isSolvent() can come back
+        # None on a no-debt account (empty multicall leg), which used to render a
+        # misleading "NO - liquidatable" despite ratio >1000 and ~$0 debt. Treat
+        # negligible debt (or a >1000 ratio, surfaced as ratio=None) as solvent.
+        negligible_debt = (solvency["debt"] is None or solvency["debt"] < 0.01
+                           or solvency["ratio"] is None)
+        is_solvent = bool(solvency["solvent"]) or negligible_debt
+        print(f"  Solvent:            {'yes' if is_solvent else 'NO - liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({solvency['error']}); showing balances only")
 
@@ -3065,8 +3092,9 @@ def cmd_cancel_withdrawal(pool_name: str, index: int, execute: bool = False):
 
 def cmd_aerodrome_positions():
     """Read-only: list every Aerodrome Slipstream NFT position the Degen Account
-    owns/stakes, showing token pair, tick range, and liquidity from the diamond's
-    getOwnedStakedAerodromeTokenIds + getPositionCompositionSimplified views."""
+    owns/stakes, showing token pair, tick range, and liquidity. Enumerates tokenIds
+    via getOwnedStakedAerodromeTokenIds, then reads each from NPM.positions() (the
+    simplified facet view reports liquidity=0 + garbage ticks for staked NFTs)."""
     w3 = get_w3()
     acct = get_account()
     print(f"Wallet: {acct.address}")
@@ -3086,42 +3114,51 @@ def cmd_aerodrome_positions():
         return
     print(f"  {len(ids)} Aerodrome NFT position(s):")
 
-    # Batch-read position composition via Multicall3 for efficiency.
-    # getPositionCompositionSimplified returns (token0, token1, tickData, liquidity).
-    # tickData packs tickLower in the upper 128 bits and tickUpper in the lower 128
-    # bits as unsigned; the actual int24 values need sign extension.
-    pos_legs = []
+    # Read each position straight from NPM.positions(). The account's enumerated
+    # tokenIds include STAKED positions whose NFT now belongs to the gauge, and the
+    # facet's getPositionCompositionSimplified reports liquidity=0 + garbage ticks
+    # for those. NPM.positions() returns the real struct for any holder.
     for tid in ids:
-        pos_legs.append((account.address, bytes.fromhex(
-            account.encode_abi("getPositionCompositionSimplified", args=[tid])[2:])))
-    try:
-        results = multicall(w3, pos_legs)
-    except Exception:
-        results = [(False, b"")] * len(ids)
-
-    for tid, (ok, rd) in zip(ids, results):
-        if not ok or not rd:
-            print(f"    [{tid}] composition unavailable")
-            continue
-        try:
-            token0, token1, tick_data, liq = w3.codec.decode(
-                ["address", "address", "uint256", "uint256"], rd)
-        except Exception:
-            print(f"    [{tid}] composition decode failed")
+        pos = _aero_read_position(w3, tid)
+        if pos is None:
+            print(f"    [{tid}] position read failed")
             continue
-        # Decode tickData: upper 128 bits = tickLower (int24), lower 128 bits = tickUpper (int24)
-        tick_lower = _int24_from_hi128(tick_data)
-        tick_upper = _int24_from_lo128(tick_data)
-        # Resolve token symbols
+        token0, token1, tick_lower, tick_upper, liq = pos
         sym0 = _resolve_token_symbol(w3, token0)
         sym1 = _resolve_token_symbol(w3, token1)
-        # Human-readable tick range → price range
-        price_lower = 1.0001 ** tick_lower
-        price_upper = 1.0001 ** tick_upper
-        print(f"    [{tid}] {sym0}/{sym1}  ticks=[{tick_lower}, {tick_upper}]"
-              f"  liq={liq}  price_range=[{price_lower:.4f}, {price_upper:.4f}]")
+        # Human price = token1 per token0 = 1.0001**tick * 10**(dec0 - dec1).
+        dec0 = _resolve_token_decimals(w3, token0)
+        dec1 = _resolve_token_decimals(w3, token1)
+        if dec0 is not None and dec1 is not None:
+            scale = 10 ** (dec0 - dec1)
+            price_lower = 1.0001 ** tick_lower * scale
+            price_upper = 1.0001 ** tick_upper * scale
+            print(f"    [{tid}] {sym0}/{sym1}  ticks=[{tick_lower}, {tick_upper}]"
+                  f"  liq={liq}  price_range=[{price_lower:.6g}, {price_upper:.6g}] ({sym1}/{sym0})")
+        else:
+            print(f"    [{tid}] {sym0}/{sym1}  ticks=[{tick_lower}, {tick_upper}]  liq={liq}")
     print("  Manage on Aerodrome UI: https://aerodrome.finance/positions")
 
+def _aero_read_position(w3, token_id: int):
+    """Authoritative read of an Aerodrome Slipstream position via NPM.positions().
+
+    getPositionCompositionSimplified is wrong for STAKED positions: once an NFT is
+    staked its owner becomes the gauge, and the simplified view returns liquidity=0
+    with a tickData word that is not a tick packing at all (it decodes to garbage,
+    e.g. [0, -3984902] for the live tokenId 71997868). NPM.positions(tokenId) returns
+    the real struct regardless of who holds the NFT — token0/token1, tickLower,
+    tickUpper, and liquidity. Returns (token0, token1, tickLower, tickUpper, liquidity)
+    or None if the read fails."""
+    try:
+        npm = w3.eth.contract(address=Web3.to_checksum_address(AERODROME_NPM),
+                              abi=AERODROME_NPM_ABI)
+        p = npm.functions.positions(token_id).call()
+    except Exception:
+        return None
+    # positions() layout: nonce, operator, token0, token1, tickSpacing,
+    #                      tickLower, tickUpper, liquidity, ...
+    return (p[2], p[3], p[5], p[6], p[7])
+
 def _int24_from_hi128(val: int) -> int:
     """Extract int24 from the upper 128 bits of a uint256, sign-extending."""
     raw = (val >> 128) & 0xFFFFFF
@@ -3160,62 +3197,159 @@ def _resolve_token_symbol(w3, addr: str) -> str:
         pass
     return addr[:10] + "..."
 
+_ERC20_DECIMALS_ABI = json.dumps([{"inputs": [], "name": "decimals",
+    "outputs": [{"type": "uint8"}], "stateMutability": "view", "type": "function"}])
+
+def _resolve_token_decimals(w3, addr: str):
+    """Token decimals from the static pool maps, falling back to an on-chain
+    decimals() read. Returns the int decimals or None if it can't be determined."""
+    addr_lower = addr.lower()
+    for cfg in AERODROME_POOLS.values():
+        if cfg["token0"].lower() == addr_lower:
+            return cfg["decimals0"]
+        if cfg["token1"].lower() == addr_lower:
+            return cfg["decimals1"]
+    try:
+        c = w3.eth.contract(address=Web3.to_checksum_address(addr),
+                            abi=json.loads(_ERC20_DECIMALS_ABI))
+        return c.functions.decimals().call()
+    except Exception:
+        return None
+
 # ─── Aerodrome Write Commands ────────────────────────────────────────────────
 
-# Helper: build the MintParams tuple for Aerodrome Slipstream (12 fields).
-def _aero_mint_params(pool_cfg: dict, amount0: int, amount1: int,
+# Helper: get Aerodrome CL pool address from the factory's getPool (authoritative).
+def _aero_pool_address(pool_cfg: dict) -> str:
+    """Resolve the pool address via the factory's getPool()."""
+    try:
+        w3_local = Web3(Web3.HTTPProvider(BASE_RPC))
+        factory = Web3.to_checksum_address("0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A")
+        import json
+        f_abi = json.loads('[{"inputs":[{"name":"","type":"address"},{"name":"","type":"address"},{"name":"","type":"int24"}],"name":"getPool","outputs":[{"name":"","type":"address"}],"stateMutability":"view","type":"function"}]')
+        factory_c = w3_local.eth.contract(address=factory, abi=f_abi)
+        t0 = Web3.to_checksum_address(pool_cfg["token0"])
+        t1 = Web3.to_checksum_address(pool_cfg["token1"])
+        pool = factory_c.functions.getPool(t0, t1, pool_cfg["tickSpacing"]).call()
+        if pool == "0x0000000000000000000000000000000000000000":
+            raise ValueError("Pool does not exist on Aerodrome")
+        return pool
+    except Exception as e:
+        raise RuntimeError(f"Cannot resolve Aerodrome pool: {e}")
+
+SLOT0_ABI = json.dumps([{"inputs":[],"name":"slot0","outputs":[
+    {"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"},
+    {"internalType":"int24","name":"tick","type":"int24"}],
+    "stateMutability":"view","type":"function"}])
+
+# Helper: build the 14-field arg tuple for the Aerodrome mint+stake facet fn
+# (selector 0xf32f1e56). Layout verified byte-exact against the successful
+# on-chain mint 0x1723377a... (ZORA/USDC, Base, 2026-06-14):
+#   token0, token1, tickLower, tickUpper, tickSpacing,
+#   amount0Desired(wei), amount1Desired(wei), amount0Min(wei), amount1Min(wei),
+#   uint256 const=300, int24 currentTick, 0, 0, 0
+# Both amounts are NATIVE/wei units; there is NO recipient or unix-deadline
+# field, tickSpacing IS part of the args, and the last tick field is the live
+# pool tick (not sqrtPriceX96). The three trailing zero words are
+# sqrtPriceX96=0 / borrow-if-needed bools = false (all zero either way).
+def _aero_in_account_balance(account, symbol: str) -> int:
+    """In-account spendable balance (base units) of `symbol` on the Degen Account.
+
+    The mint+stake facet pulls token0/token1 from the account's own holdings, the
+    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."""
+    try:
+        bal = account.functions.getBalance(asset_b32(symbol)).call()
+    except Exception:
+        return 0
+    try:
+        locked = account.functions.getTotalIntentAmount(asset_b32(symbol)).call()
+    except Exception:
+        locked = 0
+    return bal - locked if bal > locked else 0
+
+def _aero_cap_to_balance(account, pool_cfg: dict, amt0_wei: int, amt1_wei: int) -> tuple:
+    """Cap each requested amount to what the account actually holds, minus a 1-wei
+    margin so display round-up can never push the request past the real balance.
+    Returns (amt0_capped, amt1_capped, notes) where notes lists human cap messages."""
+    notes = []
+    sym0, sym1 = pool_cfg["symbol0"], pool_cfg["symbol1"]
+    dec0, dec1 = pool_cfg["decimals0"], pool_cfg["decimals1"]
+    for amt, sym, dec, idx in ((amt0_wei, sym0, dec0, 0), (amt1_wei, sym1, dec1, 1)):
+        if amt <= 0:
+            continue
+        avail = _aero_in_account_balance(account, sym)
+        safe = avail - 1 if avail > 0 else 0  # 1-wei margin vs rounding overshoot
+        if amt > safe:
+            capped = safe if safe > 0 else 0
+            notes.append((idx, capped,
+                          f"Capped {sym} to {fmt_token_amount(capped, dec)} "
+                          f"(on-chain balance {fmt_token_amount(avail, dec)})"))
+    amt0_out, amt1_out = amt0_wei, amt1_wei
+    for idx, capped, _msg in notes:
+        if idx == 0:
+            amt0_out = capped
+        else:
+            amt1_out = capped
+    return amt0_out, amt1_out, [m for _i, _c, m in notes]
+
+def _aero_simulate_mint(w3, from_addr: str, account_addr: str, calldata: bytes) -> tuple:
+    """eth_call-simulate the mint+stake before broadcasting. Returns (ok, info):
+    ok=True + would-be tokenId on success, ok=False + revert detail on failure.
+    Read-only — never signs or sends."""
+    try:
+        ret = w3.eth.call({"from": from_addr, "to": account_addr,
+                           "data": "0x" + calldata.hex()})
+    except Exception as e:
+        return False, f"{type(e).__name__}: {str(e)[:200]}"
+    token_id = int.from_bytes(bytes(ret)[:32], "big") if len(ret) >= 32 else None
+    return True, token_id
+
+def _aero_mint_params(pool_cfg: dict, amount0_wei: int, amount1_wei: int,
                       tick_lower: int, tick_upper: int,
-                      recipient: str, slippage_pct: float) -> tuple:
-    """Build MintParams=(token0,token1,tickSpacing,tickLower,tickUpper,
-    amount0Desired,amount1Desired,amount0Min,amount1Min,recipient,deadline,
-    sqrtPriceX96). sqrtPriceX96=0 means the NPM uses the pool's current price."""
+                      current_tick: int, slippage_pct: float) -> tuple:
     slippage = Decimal(str(slippage_pct)) / Decimal(100)
-    amount0_min = int(Decimal(str(amount0)) * (Decimal(1) - slippage))
-    amount1_min = int(Decimal(str(amount1)) * (Decimal(1) - slippage))
-    deadline = int(time.time()) + 1800  # 30 minutes
+    amount0_min = int(Decimal(str(amount0_wei)) * (Decimal(1) - slippage))
+    amount1_min = int(Decimal(str(amount1_wei)) * (Decimal(1) - slippage))
     return (
         Web3.to_checksum_address(pool_cfg["token0"]),
         Web3.to_checksum_address(pool_cfg["token1"]),
-        pool_cfg["tickSpacing"],
         tick_lower,
         tick_upper,
-        amount0,
-        amount1,
-        amount0_min,
-        amount1_min,
-        Web3.to_checksum_address(recipient),
-        deadline,
-        0,  # sqrtPriceX96: 0 = use current pool price
+        pool_cfg["tickSpacing"],
+        amount0_wei,          # amount0Desired (wei)
+        amount1_wei,          # amount1Desired (wei)
+        amount0_min,          # amount0Min (wei)
+        amount1_min,          # amount1Min (wei)
+        300,                  # word9 constant (frontend passes 300)
+        int(current_tick),    # word10: live pool tick
+        0, 0, 0,              # word11-13: zero (sqrtPriceX96=0 / bools false)
     )
 
-# Helper: build DecreaseLiquidityParams tuple (5 fields).
-def _aero_decrease_params(token_id: int, liquidity: int,
-                          amount0_min: int, amount1_min: int) -> tuple:
-    deadline = int(time.time()) + 1800
-    return (token_id, liquidity, amount0_min, amount1_min, deadline)
-
 # Helper: compute tick range around a desired centre price.
 def _aero_tick_range(tick_spacing: int, centre_price: float = None,
-                     width_pct: float = 2.0) -> tuple:
-    """Return (tickLower, tickUpper) for a symmetrical range ±width_pct around
-    centre_price. If centre_price is None, uses full-range positions.
-    tickSpacing must be valid (1, 5, 10, 30, 100, 200, etc.).
-    Ticks are snapped to the tickSpacing grid."""
-    if centre_price is None or centre_price <= 0:
-        # Full range: MIN_TICK to MAX_TICK (snapped to spacing)
-        MIN_TICK = -887272
-        MAX_TICK = 887272
+                     width_pct: float = 2.0, pool_tick: int = None) -> tuple:
+    """Return (tickLower, tickUpper) for +/-width_pct around centre.
+    Priority: pool_tick > centre_price > full range."""
+    import math
+    MIN_TICK, MAX_TICK = -887272, 887272
+
+    if pool_tick is not None:
+        tick_delta = int(abs(math.log(1.0 + width_pct / 100.0) / math.log(1.0001))) + 1
+        raw_lower = pool_tick - tick_delta
+        raw_upper = pool_tick + tick_delta
+    elif centre_price is not None and centre_price > 0:
+        lower_price = centre_price * max(1e-12, 1.0 - width_pct / 100.0)
+        upper_price = centre_price * (1.0 + width_pct / 100.0)
+        raw_lower = math.log(lower_price) / math.log(1.0001)
+        raw_upper = math.log(upper_price) / math.log(1.0001)
+    else:
         t_lower = (MIN_TICK // tick_spacing) * tick_spacing
         t_upper = (MAX_TICK // tick_spacing) * tick_spacing
         return (t_lower, t_upper)
-    # Convert price to tick: tick = floor(log(price) / log(1.0001))
-    import math
-    centre_tick = int(math.log(centre_price) / math.log(1.0001))
-    half_width_ticks = int(centre_tick * width_pct / 100.0)
-    tick_lower = ((centre_tick - half_width_ticks) // tick_spacing) * tick_spacing
-    tick_upper = ((centre_tick + half_width_ticks) // tick_spacing) * tick_spacing
-    # Clamp to valid range
-    MIN_TICK, MAX_TICK = -887272, 887272
+
+    tick_lower = math.floor(raw_lower / tick_spacing) * tick_spacing
+    tick_upper = math.ceil(raw_upper / tick_spacing) * tick_spacing
     tick_lower = max(MIN_TICK, min(MAX_TICK, tick_lower))
     tick_upper = max(MIN_TICK, min(MAX_TICK, tick_upper))
     if tick_lower >= tick_upper:
@@ -3259,43 +3393,81 @@ def cmd_aero_add_liquidity(pool_key: str, amount0: float = None,
         print("At least one of --amount-<token0> / --amount-<token1> must be > 0")
         return
 
-    # Get current price from KuCoin for tick range calculation
-    price_sym = pool_cfg["symbol0"] + "-USDT"
+    # Auto-cap each side to the account's real in-account balance. The summary
+    # display can round a dust balance UP, so a request matching the shown value
+    # could exceed the true balance and revert AFTER burning gas (2026-06-14).
+    amt0, amt1, cap_notes = _aero_cap_to_balance(account, pool_cfg, amt0, amt1)
+    for note in cap_notes:
+        print(f"  {note}")
+    if amt0 == 0 and amt1 == 0:
+        print("  Nothing to deposit after capping to on-chain balance.")
+        return
+
+    # Get pool's on-chain tick from slot0 for accurate range computation
+    pool_tick = None
     centre_price = None
     try:
-        r = requests.get(f"https://api.kucoin.com/api/v1/market/orderbook/level1?symbol={price_sym}", timeout=3)
-        if r.status_code == 200 and r.json().get("code") == "200000":
-            centre_price = float(r.json()["data"]["price"])
+        pool_addr = _aero_pool_address(pool_cfg)
+        pool_abi = json.loads(SLOT0_ABI)
+        pool_c = w3.eth.contract(address=pool_addr, abi=pool_abi)
+        slot0 = pool_c.functions.slot0().call()
+        pool_tick = slot0[1]
+        print(f"  Pool tick (on-chain): {pool_tick}")
     except Exception:
-        pass
+        # Fallback to KuCoin price
+        price_sym = pool_cfg["symbol0"] + "-USDT"
+        try:
+            r = requests.get(f"https://api.kucoin.com/api/v1/market/orderbook/level1?symbol={price_sym}", timeout=3)
+            if r.status_code == 200 and r.json().get("code") == "200000":
+                centre_price = float(r.json()["data"]["price"])
+        except Exception:
+            pass
 
-    tick_lower, tick_upper = _aero_tick_range(pool_cfg["tickSpacing"], centre_price, width_pct)
+    tick_lower, tick_upper = _aero_tick_range(pool_cfg["tickSpacing"], centre_price, width_pct, pool_tick)
     params = _aero_mint_params(pool_cfg, amt0, amt1, tick_lower, tick_upper,
-                               pa, slippage_pct)
+                               pool_tick if pool_tick is not None else (tick_lower + tick_upper) // 2,
+                               slippage_pct)
 
     sym0, sym1 = pool_cfg["symbol0"], pool_cfg["symbol1"]
     print(f"Pool: {sym0}/{sym1} (tickSpacing={pool_cfg['tickSpacing']})")
-    if centre_price:
+    if pool_tick is not None:
+        print(f"  Tick range: [{tick_lower}, {tick_upper}] (width: +/-{width_pct}%)")
+    elif centre_price:
         print(f"  Current {sym0} price: ${centre_price:,.2f}")
         print(f"  Tick range: [{tick_lower}, {tick_upper}] → price [{1.0001**tick_lower:.4f}, {1.0001**tick_upper:.4f}]")
         print(f"  Width: ±{width_pct}%")
     else:
         print(f"  Full-range position (no price data available)")
-    print(f"  {sym0}: {amount0 or 0} ({amt0} wei)  {sym1}: {amount1 or 0} ({amt1} wei)")
-
-    if not execute:
-        print("Preview only. Run with --execute to broadcast.")
-        return
+    print(f"  {sym0}: {fmt_token_amount(amt0, pool_cfg['decimals0'])}  "
+          f"{sym1}: {fmt_token_amount(amt1, pool_cfg['decimals1'])}")
 
-    # Build RedStone payload for solvency check
+    # Build RedStone payload + final mint+stake calldata (selector 0xf32f1e56).
+    # 14 flat args; amounts in native wei; tickSpacing + live tick included.
+    # Verified byte-exact vs the successful manual mint 0x1723377a.... Built once
+    # so the same bytes feed both the pre-flight simulation and the broadcast.
     feeds = sorted(REDSTONE_AVAILABLE_FEEDS)
     payload = build_redstone_payload(feeds)
+    from eth_abi import encode as abi_encode
+    flat_types = ['address', 'address', 'int24', 'int24', 'int24',
+                  'uint256', 'uint256', 'uint256', 'uint256',
+                  'uint256', 'int24', 'uint256', 'uint256', 'uint256']
+    encoded_params = abi_encode(flat_types, list(params))
+    mint_calldata = AERODROME_SEL_MINT + encoded_params + payload
+
+    # Pre-flight eth_call simulation — catches reverts (insufficient balance,
+    # slippage/PSC, solvency) BEFORE any gas is spent. Gates every broadcast.
+    sim_ok, sim_info = _aero_simulate_mint(w3, acct.address, account.address, mint_calldata)
+    if not sim_ok:
+        print(f"  Simulation reverted — aborting before broadcast: {sim_info}")
+        return
+    if sim_info is not None:
+        print(f"  Simulation passed — would-be tokenId: {sim_info}")
+    else:
+        print("  Simulation passed.")
 
-    # Encode the mint call: use the probed selector + ABI-encoded params
-    mint_data = account.encode_abi("mintAerodrome", args=[params])
-    # encode_abi returns hex string "0x...", extract params bytes after selector
-    mint_params_bytes = bytes.fromhex(mint_data[2:])[4:]
-    mint_calldata = AERODROME_SEL_MINT + mint_params_bytes + payload
+    if not execute:
+        print("Preview only. Run with --execute to broadcast.")
+        return
 
     tx = {
         "from": acct.address,
@@ -3309,15 +3481,31 @@ def cmd_aero_add_liquidity(pool_key: str, amount0: float = None,
     ok = receipt["status"] == 1
 
 
-def cmd_aero_remove_liquidity(token_id: int, percentage: float = 100.0,
+def cmd_aero_remove_liquidity(token_ids, percentage: float = 100.0,
                                execute: bool = False):
-    """Remove liquidity from an Aerodrome Slipstream position owned by the
-    Degen Account. Decreases liquidity by `percentage` of the current position
-    size (default 100% = full close). The position NFT remains; burn it
-    separately after all liquidity is removed and fees collected.
+    """Fully close one or more staked Aerodrome Slipstream positions owned by the
+    Degen Account, via batchRemoveStakedLiquidityAerodrome(uint256[]) on the
+    AerodromeFacet (selector 0x27bed82e). This single call does the FULL unwind per
+    tokenId: unstake from the gauge + remove all liquidity + collect fees + burn the
+    NFT (the manual reference close 0x0d65... emitted 41 logs doing exactly this).
+
+    There is NO partial/percentage decrease on this path — it always closes 100%.
+    The call is remainsSolvent-gated, so the calldata carries a RedStone signed-price
+    payload (same construction as the mint+stake path)."""
+    if percentage < 100:
+        print(f"  Partial removal ({percentage}%) is not supported on this path — "
+              f"batchRemoveStakedLiquidityAerodrome fully closes each position "
+              f"(unstake + remove + collect + burn). Re-run without --percentage "
+              f"(or with --percentage 100) to fully close.")
+        return
+
+    if isinstance(token_ids, int):
+        token_ids = [token_ids]
+    token_ids = [int(t) for t in token_ids]
+    if not token_ids:
+        print("  No tokenIds supplied.")
+        return
 
-    The facet wraps NPM.decreaseLiquidity. No RedStone payload needed
-    (the decrease path is NOT remainsSolvent — same as TJ lb-remove)."""
     w3 = get_w3()
     acct = get_account()
     print(f"Wallet: {acct.address}")
@@ -3328,54 +3516,55 @@ def cmd_aero_remove_liquidity(token_id: int, percentage: float = 100.0,
     account = w3.eth.contract(address=Web3.to_checksum_address(pa), abi=PRIME_ACCOUNT_ABI)
     print(f"Degen Account: {pa}")
 
-    # Read the position's current liquidity
+    # Show what each position holds before closing (NPM.positions() is correct for
+    # staked NFTs, which the simplified facet view reports as 0 liquidity).
+    for tid in token_ids:
+        pos = _aero_read_position(w3, tid)
+        if pos is None:
+            print(f"  Position {tid}: cannot read (may not exist).")
+            continue
+        token0, token1, tick_lower, tick_upper, current_liq = pos
+        sym0 = _resolve_token_symbol(w3, token0)
+        sym1 = _resolve_token_symbol(w3, token1)
+        print(f"Position {tid}: {sym0}/{sym1}  ticks=[{tick_lower},{tick_upper}]  "
+              f"liquidity={current_liq}")
+
+    # Encode batchRemoveStakedLiquidityAerodrome(uint256[] tokenIds) and append the
+    # RedStone payload raw. Byte-for-byte layout (selector + uint256[] head + payload)
+    # verified against the manual close 0x0d65...0a50.
+    from eth_abi import encode as abi_encode
+    encoded_ids = abi_encode(['uint256[]'], [token_ids])
+    feeds = sorted(REDSTONE_AVAILABLE_FEEDS)
+    payload = build_redstone_payload(feeds)
+    close_calldata = AERODROME_SEL_BURN + encoded_ids + payload
+
+    # Pre-flight eth_call simulation — refuse to broadcast on revert. The close path
+    # IS RedStone-gated, so the simulated calldata already carries the payload.
     try:
-        pos = account.functions.getPositionCompositionSimplified(token_id).call()
+        w3.eth.call({"from": acct.address, "to": account.address,
+                     "data": "0x" + close_calldata.hex()})
     except Exception as e:
-        print(f"  Cannot read position {token_id}: {e}")
-        return
-    token0, token1, tick_data, current_liq = pos
-    if current_liq == 0:
-        print(f"  Position {token_id} has 0 liquidity (may already be closed).")
+        print(f"  Simulation reverted — aborting before broadcast: {type(e).__name__}: {str(e)[:200]}")
         return
-
-    sym0 = _resolve_token_symbol(w3, token0)
-    sym1 = _resolve_token_symbol(w3, token1)
-    tick_lower = _int24_from_hi128(tick_data)
-    tick_upper = _int24_from_lo128(tick_data)
-
-    remove_liq = int(Decimal(str(current_liq)) * Decimal(str(percentage)) / Decimal(100))
-    if remove_liq <= 0:
-        print(f"  Removal percentage {percentage}% yields 0 liquidity.")
-        return
-
-    print(f"Position {token_id}: {sym0}/{sym1}  ticks=[{tick_lower},{tick_upper}]")
-    print(f"  Current liquidity: {current_liq}")
-    print(f"  Removing: {remove_liq} ({percentage}%)")
+    print("  Simulation passed.")
 
     if not execute:
         print("Preview only. Run with --execute to broadcast.")
         return
 
-    params = _aero_decrease_params(token_id, remove_liq, 0, 0)
-    # decreaseLiquidity on the facet (selector ca15558b)
-    dec_data = account.encode_abi("decreaseAerodromeLiquidity", args=[params])
-    dec_params_bytes = bytes.fromhex(dec_data[2:])[4:]
-    dec_calldata = AERODROME_SEL_DECREASE + dec_params_bytes
-
     tx = {
         "from": acct.address,
         "to": account.address,
         "nonce": w3.eth.get_transaction_count(acct.address),
-        "gas": 4000000,
+        "gas": 5000000,
         "chainId": CHAIN_ID,
-        "data": "0x" + dec_calldata.hex(),
+        "data": "0x" + close_calldata.hex(),
     }
-    receipt = _sign_and_send(w3, acct, tx, "Remove liquidity", timeout=300, fallback_gas=4000000)
+    receipt = _sign_and_send(w3, acct, tx, "Close Aerodrome position(s)", timeout=300, fallback_gas=5000000)
     ok = receipt["status"] == 1
-    if ok and percentage >= 100:
-        print(f"  Position fully withdrawn. Collect fees then burn:")
-        print(f"    degenprime aero-collect-fees --token-id {token_id} --execute")
+    if ok:
+        ids_str = ", ".join(str(t) for t in token_ids)
+        print(f"  Fully closed (unstaked + removed + collected + burned): {ids_str}")
 
 
 def cmd_aero_collect_fees(token_id: int, execute: bool = False):
@@ -3395,13 +3584,13 @@ def cmd_aero_collect_fees(token_id: int, execute: bool = False):
     account = w3.eth.contract(address=Web3.to_checksum_address(pa), abi=PRIME_ACCOUNT_ABI)
     print(f"Degen Account: {pa}")
 
-    # Read position composition for display
-    try:
-        pos = account.functions.getPositionCompositionSimplified(token_id).call()
-    except Exception as e:
-        print(f"  Cannot read position {token_id}: {e}")
+    # Read position for display via NPM.positions() — correct for staked NFTs (the
+    # simplified facet view reports liquidity=0 once the gauge owns the NFT).
+    pos = _aero_read_position(w3, token_id)
+    if pos is None:
+        print(f"  Cannot read position {token_id}.")
         return
-    token0, token1, tick_data, liq = pos
+    token0, token1, tick_lower, tick_upper, liq = pos
     sym0 = _resolve_token_symbol(w3, token0)
     sym1 = _resolve_token_symbol(w3, token1)
     print(f"Position {token_id}: {sym0}/{sym1}  liquidity={liq}")
@@ -3662,16 +3851,17 @@ def _dispatch():
             return
         cmd_aero_add_liquidity(pool_key, amt0, amt1, slippage, execute, width)
     elif cmd == "aero-remove-liquidity":
-        token_id = None
+        token_ids = []
         percentage = 100.0
         execute = "--execute" in args
         for i, a in enumerate(args):
-            if a == "--token-id" and i + 1 < len(args): token_id = int(args[i + 1])
+            if a == "--token-id" and i + 1 < len(args): token_ids.append(int(args[i + 1]))
             if a == "--percentage" and i + 1 < len(args): percentage = float(args[i + 1])
-        if token_id is None:
-            print("Usage: degenprime aero-remove-liquidity --token-id N [--percentage 100] [--execute]")
+        if not token_ids:
+            print("Usage: degenprime aero-remove-liquidity --token-id N [--token-id M ...] [--execute]")
+            print("  Fully closes (unstake + remove + collect + burn) each staked position. Full close only.")
             return
-        cmd_aero_remove_liquidity(token_id, percentage, execute)
+        cmd_aero_remove_liquidity(token_ids, percentage, execute)
     elif cmd == "aero-collect-fees":
         token_id = None
         execute = "--execute" in args

{primecli-0.7.5 → primecli-0.8.1}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.7.5
+Version: 0.8.1
 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.7.5 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.8.1 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.7.5 → primecli-0.8.1}/pyproject.toml

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