primecli 0.11.2__tar.gz → 0.11.3__tar.gz

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

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

@@ -3470,12 +3470,24 @@ def cmd_withdrawal_intents():
         return
 
     any_pending = False
+    # Batch the per-asset getAvailableBalance + getTotalIntentAmount + getUserIntents reads
+    # (was 3 sequential eth_calls per owned asset) into one Multicall3 round-trip.
+    pa_cs = account.address
+    legs = []
     for a in owned:
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getAvailableBalance", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getTotalIntentAmount", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getUserIntents", args=[a])[2:])))
+    results = multicall(w3, legs)
+    for i, a in enumerate(owned):
         sym = a.rstrip(b"\x00").decode(errors="replace")
         dec = _asset_decimals(sym)
-        available = account.functions.getAvailableBalance(a).call()
-        total_intent = account.functions.getTotalIntentAmount(a).call()
-        intents = account.functions.getUserIntents(a).call()
+        av_ok, av_rd = results[3 * i]
+        ti_ok, ti_rd = results[3 * i + 1]
+        ui_ok, ui_rd = results[3 * i + 2]
+        available = w3.codec.decode(["uint256"], av_rd)[0] if av_ok and av_rd else 0
+        total_intent = w3.codec.decode(["uint256"], ti_rd)[0] if ti_ok and ti_rd else 0
+        intents = w3.codec.decode(["(uint256,uint256,uint256,bool,bool,bool)[]"], ui_rd)[0] if ui_ok and ui_rd else []
         print(f"  {sym}: available {available / 10**dec:,.6f}, "
               f"pending intents {total_intent / 10**dec:,.6f}")
         for idx, (amt, actionable_at, expires_at, is_pending, is_actionable, is_expired) in enumerate(intents):
@@ -4823,13 +4835,33 @@ def cmd_lb_remove(pair_key: str, slippage_pct: float = 1.0, execute: bool = Fals
         return
 
     pair_c = _lb_pair_contract(w3, pair_cs)
-    active_id = pair_c.functions.getActiveId().call()
+    # Batch getActiveId + per-bin (balanceOf + totalSupply + getBin) into one Multicall3
+    # round-trip (was 1 + 3N sequential eth_calls). This is a WRITE path — the decoded
+    # amounts feed removeLiquidity and the slippage floors — so a failed read aborts rather
+    # than silently defaulting to 0 (matches the prior abort-on-error behaviour).
+    legs = [(pair_cs, bytes.fromhex(pair_c.encode_abi("getActiveId", args=[])[2:]))]
+    for binid in ids:
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("balanceOf", args=[pa_cs, binid])[2:])))
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("totalSupply", args=[binid])[2:])))
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("getBin", args=[binid])[2:])))
+    results = multicall(w3, legs)
+    a_ok, a_rd = results[0]
+    if not (a_ok and a_rd):
+        print("  Could not read the LB pair's active bin — refusing to remove.")
+        return
+    active_id = w3.codec.decode(["uint24"], a_rd)[0]
     amounts = []
     est_x = est_y = 0.0
-    for binid in ids:
-        bal = pair_c.functions.balanceOf(pa_cs, binid).call()
-        ts = pair_c.functions.totalSupply(binid).call()
-        rx, ry = pair_c.functions.getBin(binid).call()
+    for k, binid in enumerate(ids):
+        b_ok, b_rd = results[1 + 3 * k]
+        t_ok, t_rd = results[1 + 3 * k + 1]
+        g_ok, g_rd = results[1 + 3 * k + 2]
+        if not (b_ok and b_rd and t_ok and t_rd and g_ok and g_rd):
+            print(f"  Could not read bin {binid} on [{pair_key}] — refusing to remove (incomplete data).")
+            return
+        bal = w3.codec.decode(["uint256"], b_rd)[0]
+        ts = w3.codec.decode(["uint256"], t_rd)[0]
+        rx, ry = w3.codec.decode(["uint128", "uint128"], g_rd)
         amounts.append(bal)
         share = (bal / ts) if ts else 0
         est_x += rx * share / 10**x_cfg["decimals"]

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

@@ -1492,12 +1492,21 @@ def build_redstone_payload(symbols: list) -> bytes:
     payload += REDSTONE_MARKER
     return payload
 
-def degen_account_price_feeds(account) -> list:
+def degen_account_price_feeds(account, w3=None) -> list:
     """RedStone feed symbols a solvency check on this account needs: ETH (Base's native
     base-asset reference, the BaseOracle anchor), every owned asset that has a RedStone
     feed, and every debt-registry asset that has one. Symbols without a RedStone feed
     are skipped - the SolvencyFacet sources them on-chain from BaseOracle TWAP and the
-    payload doesn't need to cover them. Deduped, ETH first."""
+    payload doesn't need to cover them. Deduped, ETH first.
+
+    Staked Aerodrome LP legs need the same treatment: getAllOwnedAssets() and
+    getDebts() never see tokens locked inside a staked LP NFT (per
+    _aero_position_legs's own docstring), so an account whose ONLY exposure to a
+    RedStone-priced asset is via a staked LP (no raw balance, no debt in it) would
+    otherwise never request that feed - and every solvency-gated call
+    (getTotalValue/getHealthRatio/isSolvent/repay/shouldRebalance) reverts for lack
+    of a price instead of pricing the position correctly. Pass w3 to also enumerate
+    those legs; omit it to keep the old (narrower) behavior."""
     feeds = ["ETH"]
     for a in account.functions.getAllOwnedAssets().call():
         sym = a.rstrip(b"\x00").decode(errors="replace")
@@ -1507,6 +1516,18 @@ def degen_account_price_feeds(account) -> list:
         sym = name.rstrip(b"\x00").decode(errors="replace")
         if sym and sym in REDSTONE_AVAILABLE_FEEDS:
             feeds.append(sym)
+    if w3 is not None:
+        for lg in _aero_position_legs(w3, account):
+            for raw_sym in (lg.get("sym0"), lg.get("sym1")):
+                if not raw_sym:
+                    continue
+                # LP legs are read straight off the ERC20 (_resolve_token_symbol),
+                # which returns the real on-chain symbol (e.g. "EURC"). DegenPrime's
+                # TokenManager - and RedStone's feed - use the aliased name ("EUROC"),
+                # same alias _account_asset_symbol already applies for raw holdings.
+                sym = _account_asset_symbol(raw_sym)
+                if sym in REDSTONE_AVAILABLE_FEEDS:
+                    feeds.append(sym)
     return list(dict.fromkeys(feeds))
 
 def redstone_view_call(w3, account, fn_name: str, payload: bytes, args: list = None):
@@ -2221,7 +2242,7 @@ def _gather_account_state(w3, account, pool_deposits: list):
     # but correct: the SolvencyFacet parses the payload from the calldata tail per leg.
     solvency = {"total": None, "debt": None, "ratio": None, "solvent": None, "error": None, "prices": {}}
     try:
-        feeds = degen_account_price_feeds(account)
+        feeds = degen_account_price_feeds(account, w3=w3)
         # Pool-deposit assets need their feeds in the payload too, else getPrices reverts
         # on any deposit symbol whose feed the Degen Account doesn't already carry.
         for _dr in pool_deposits:
@@ -2229,8 +2250,12 @@ def _gather_account_state(w3, account, pool_deposits: list):
                 feeds.append(_dr["symbol"])
         payload = build_redstone_payload(feeds)
         payload_hex = payload.hex()
-        price_syms = [s for s in dict.fromkeys(r["symbol"] for r in supplied + borrowed + pool_deposits)
-                      if s and s in REDSTONE_AVAILABLE_FEEDS]
+        # Reuse `feeds` (already ETH + owned + debts + pool_deposits + staked LP legs,
+        # alias-corrected, filtered to REDSTONE_AVAILABLE_FEEDS) instead of re-deriving
+        # from supplied/borrowed/pool_deposits alone - that narrower set is exactly what
+        # left LP-locked-only assets (e.g. EURC/EUROC) unpriced for the display/health
+        # computation below even after the solvency payload itself carried the feed.
+        price_syms = list(dict.fromkeys(feeds))
         solv_legs = [
             ("getTotalValue", ["uint256"], account.encode_abi("getTotalValue", args=[])),
             ("getDebt", ["uint256"], account.encode_abi("getDebt", args=[])),
@@ -2275,6 +2300,56 @@ def _gather_account_state(w3, account, pool_deposits: list):
     return pa_eth, supplied, borrowed, solvency
 
 
+def _aero_resolve_positions_batched(w3, token_ids, pa):
+    """Resolve {tokenId: (npm_contract, deployment, positions_struct)} for a list of staked
+    Aerodrome tokenIds, batching the positions() probes on the V2 and V3 NPMs into ONE
+    Multicall3 round-trip (previously 2 sequential eth_calls per id inside
+    _aero_npm_for_token). aggregate3 allowFailure=True mirrors that resolver's try/except:
+    a positions() revert means the id is not live on that deployment. For an id live on BOTH
+    deployments (overlapping id ranges) the security-sensitive "which deployment does pa
+    actually own" disambiguation is delegated unchanged to per-id _aero_npm_for_token. Dead
+    ids are omitted. Each (contract, deployment, struct) returned is identical to what
+    _aero_npm_for_token(w3, id, pa) would return."""
+    if not token_ids:
+        return {}
+    npms = {
+        "v2": w3.eth.contract(address=Web3.to_checksum_address(AERODROME_NPM_V2), abi=AERODROME_NPM_ABI),
+        "v3": w3.eth.contract(address=Web3.to_checksum_address(AERODROME_NPM_V3), abi=AERODROME_NPM_ABI),
+    }
+    pos_out_types = [o["type"] for o in next(
+        f for f in AERODROME_NPM_ABI if f.get("name") == "positions")["outputs"]]
+    order = ("v2", "v3")
+    legs = []
+    for tid in token_ids:
+        for ver in order:
+            legs.append((npms[ver].address,
+                         bytes.fromhex(npms[ver].encode_abi("positions", args=[tid])[2:])))
+    try:
+        results = multicall(w3, legs)
+    except Exception:
+        results = [(False, b"")] * len(legs)
+    resolved = {}
+    for i, tid in enumerate(token_ids):
+        live = []
+        for j, ver in enumerate(order):
+            ok, rd = results[2 * i + j]
+            if ok and rd:
+                try:
+                    live.append((ver, w3.codec.decode(pos_out_types, rd)))
+                except Exception:
+                    continue
+        if not live:
+            continue
+        if len(live) > 1 and pa is not None:
+            npm, ver, pos = _aero_npm_for_token(w3, tid, pa)
+            if npm is not None:
+                resolved[tid] = (npm, ver, pos)
+        else:
+            ver, pos = live[0]
+            resolved[tid] = (npms[ver], ver, pos)
+    return resolved
+
+
 def _aero_gauge_earned(w3, degen_account: 'Web3.eth.Contract', token_id: int) -> float:
     """Query unclaimed AERO rewards from the Aerodrome gauge for a staked LP.
 
@@ -2331,11 +2406,16 @@ def _aero_position_legs(w3, account):
         return []
     slot0_abi = json.loads(SLOT0_ABI)
     q96 = Decimal(2) ** 96
+    # Resolve V2/V3 per tokenId in ONE batched positions() round-trip (was 2 sequential
+    # eth_calls per id). _aero_resolve_positions_batched returns exactly what per-id
+    # _aero_npm_for_token would, ownership disambiguation for both-live ids included.
+    resolved = _aero_resolve_positions_batched(w3, ids, account.address)
     legs = []
     for tid in ids:
-        # Resolve V2/V3 per tokenId — the two NPMs are independent ERC-721s. Pass the
-        # prime account so an id live on both deployments resolves to the one it owns.
-        _npm, ver, p = _aero_npm_for_token(w3, tid, account.address)
+        entry = resolved.get(tid)
+        if entry is None:
+            continue
+        _npm, ver, p = entry
         if p is None:
             continue
         # positions(): nonce, operator, token0, token1, tickSpacing, tickLower,
@@ -2348,8 +2428,12 @@ def _aero_position_legs(w3, account):
         dec1 = _resolve_token_decimals(w3, token1)
         if dec0 is None or dec1 is None:
             continue
-        sym0 = _resolve_token_symbol(w3, token0)
-        sym1 = _resolve_token_symbol(w3, token1)
+        # Aliased (_account_asset_symbol) so a leg's symbol matches how DegenPrime's
+        # TokenManager / RedStone feeds name it (e.g. "EURC" on-chain -> "EUROC"),
+        # not the raw ERC20 symbol - callers price these legs against REDSTONE_
+        # AVAILABLE_FEEDS / solvency["prices"], both keyed by the aliased name.
+        sym0 = _account_asset_symbol(_resolve_token_symbol(w3, token0))
+        sym1 = _account_asset_symbol(_resolve_token_symbol(w3, token1))
         # Current sqrtPriceX96 from the pool's slot0 (exact); fall back to the
         # geometric mean of the range bounds if the pool read fails.
         sqrt_p = None
@@ -2817,9 +2901,38 @@ def _aero_unclaimed_usd(w3, account, solvency_prices: dict) -> float:
         token_ids = []
     if not token_ids:
         return 0.0
+    # Batch the gauge-reward reads: resolve each staked NFT's NPM (one batched positions()
+    # round-trip), then batch ownerOf() to find each gauge, then batch earned() across all
+    # gauges — was ~4 sequential eth_calls per id via _aero_gauge_earned. Fail-closed per
+    # position exactly like _aero_gauge_earned: any failed leg contributes 0 AERO.
     total_aero = 0.0
-    for tid in token_ids:
-        total_aero += _aero_gauge_earned(w3, account, tid)
+    resolved = _aero_resolve_positions_batched(w3, token_ids, account.address)
+    staked = [(tid, resolved[tid][0]) for tid in token_ids if tid in resolved]
+    if staked:
+        owner_legs = [(npm.address, bytes.fromhex(npm.encode_abi("ownerOf", args=[tid])[2:]))
+                      for tid, npm in staked]
+        try:
+            owner_res = multicall(w3, owner_legs)
+        except Exception:
+            owner_res = [(False, b"")] * len(owner_legs)
+        _gauge_abi = json.loads('[{"inputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"earned","outputs":[{"name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]')
+        earned_legs = []
+        for (tid, _npm), (ok, rd) in zip(staked, owner_res):
+            if not (ok and rd):
+                continue
+            gauge_addr = w3.codec.decode(["address"], rd)[0]
+            if not gauge_addr or int(gauge_addr, 16) == 0:
+                continue
+            gc = w3.eth.contract(address=Web3.to_checksum_address(gauge_addr), abi=_gauge_abi)
+            earned_legs.append((Web3.to_checksum_address(gauge_addr),
+                                bytes.fromhex(gc.encode_abi("earned", args=[account.address, tid])[2:])))
+        try:
+            earned_res = multicall(w3, earned_legs)
+        except Exception:
+            earned_res = [(False, b"")] * len(earned_legs)
+        for ok, rd in earned_res:
+            if ok and rd:
+                total_aero += w3.codec.decode(["uint256"], rd)[0] / 10 ** 18
     if total_aero <= 0:
         return 0.0
     aero_price = (solvency_prices or {}).get("AERO")
@@ -3060,7 +3173,7 @@ def cmd_repay(pool_name: str, amount: float, execute: bool = False):
         print(f"  Capped requested {amount} {symbol} to {amount_wei / 10**cfg['decimals']:.6f} "
               f"({'; '.join(cap_notes)}).")
     # repay's internal _isSolvent uses proxyDelegateCalldata -> needs RedStone payload
-    feeds = degen_account_price_feeds(account)
+    feeds = degen_account_price_feeds(account, w3=w3)
     if symbol not in feeds and symbol in REDSTONE_AVAILABLE_FEEDS:
         feeds.append(symbol)
     payload = build_redstone_payload(feeds)
@@ -3636,12 +3749,24 @@ def cmd_withdrawal_intents():
         return
 
     any_pending = False
+    # Batch the per-asset getAvailableBalance + getTotalIntentAmount + getUserIntents reads
+    # (was 3 sequential eth_calls per owned asset) into one Multicall3 round-trip.
+    pa_cs = account.address
+    legs = []
     for a in owned:
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getAvailableBalance", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getTotalIntentAmount", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getUserIntents", args=[a])[2:])))
+    results = multicall(w3, legs)
+    for i, a in enumerate(owned):
         sym = a.rstrip(b"\x00").decode(errors="replace")
         dec = _asset_decimals(w3, sym)
-        available = account.functions.getAvailableBalance(a).call()
-        total_intent = account.functions.getTotalIntentAmount(a).call()
-        intents = account.functions.getUserIntents(a).call()
+        av_ok, av_rd = results[3 * i]
+        ti_ok, ti_rd = results[3 * i + 1]
+        ui_ok, ui_rd = results[3 * i + 2]
+        available = w3.codec.decode(["uint256"], av_rd)[0] if av_ok and av_rd else 0
+        total_intent = w3.codec.decode(["uint256"], ti_rd)[0] if ti_ok and ti_rd else 0
+        intents = w3.codec.decode(["(uint256,uint256,uint256,bool,bool,bool)[]"], ui_rd)[0] if ui_ok and ui_rd else []
         print(f"  {sym}: available {available / 10**dec:,.6f}, "
               f"pending intents {total_intent / 10**dec:,.6f}")
         for idx, (amt, actionable_at, expires_at, is_pending, is_actionable, is_expired) in enumerate(intents):
@@ -4369,6 +4494,48 @@ def _aero_separate_pool_and_sweeps(valuable: dict, sym0: str, sym1: str):
     return pool0_bal_wei, pool1_bal_wei, sweeps
 
 
+def _aero_inventory_available(w3, account, pool_cfg):
+    """Inventory every REDSTONE-fed asset + both pool tokens held in the Degen Account, net
+    of locked (withdrawal-intent) amounts. Batches the per-symbol getBalance +
+    getTotalIntentAmount reads into ONE Multicall3 round-trip (was 2 sequential eth_calls per
+    symbol — the documented cause of Base-converge RPC 429s). aggregate3 allowFailure=True
+    preserves the old per-call tolerance: a reverting/failed leg reads 0, exactly as the
+    previous per-call try/except did. Returns {sym: [avail_wei, decimals, 0.0]} for symbols
+    with a positive available balance and resolvable decimals (empty dict if none)."""
+    sym0, sym1 = pool_cfg["symbol0"], pool_cfg["symbol1"]
+    candidates = sorted(set(REDSTONE_AVAILABLE_FEEDS) | {sym0, sym1})
+    legs = []
+    for sym in candidates:
+        ab = asset_b32(_account_asset_symbol(sym))
+        legs.append((account.address, bytes.fromhex(account.encode_abi("getBalance", args=[ab])[2:])))
+        legs.append((account.address, bytes.fromhex(account.encode_abi("getTotalIntentAmount", args=[ab])[2:])))
+    try:
+        results = multicall(w3, legs)
+    except Exception:
+        results = [(False, b"")] * len(legs)
+    inventory = {}
+    for i, sym in enumerate(candidates):
+        b_ok, b_rd = results[2 * i]
+        l_ok, l_rd = results[2 * i + 1]
+        bal = w3.codec.decode(["uint256"], b_rd)[0] if b_ok and b_rd else 0
+        if bal <= 0:
+            continue
+        locked = w3.codec.decode(["uint256"], l_rd)[0] if l_ok and l_rd else 0
+        avail = bal - locked if bal > locked else 0
+        if avail <= 0:
+            continue
+        dec = pool_cfg["decimals0"] if sym == sym0 else (
+              pool_cfg["decimals1"] if sym == sym1 else None)
+        if dec is None:
+            meta = _swap_asset_meta(w3, sym)
+            if meta:
+                dec = meta.get("decimals")
+        if dec is None:
+            continue
+        inventory[sym] = [avail, dec, 0.0]
+    return inventory
+
+
 def _aero_use_all_available(
     w3, acct, account, pa_cs, pool_cfg,
     width_pct=2.0, slippage_pct=1.0, execute=False,
@@ -4390,34 +4557,9 @@ def _aero_use_all_available(
     dec0, dec1 = pool_cfg["decimals0"], pool_cfg["decimals1"]
     MIN_USD_VALUE = 5.0
 
-    # 1. Inventory: check RedStone-fed assets + both pool tokens for balance
-    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(account_sym)).call()
-        except Exception:
-            bal = 0
-        if bal <= 0:
-            continue
-        try:
-            locked = account.functions.getTotalIntentAmount(asset_b32(account_sym)).call()
-        except Exception:
-            locked = 0
-        avail = bal - locked if bal > locked else 0
-        if avail <= 0:
-            continue
-        dec = pool_cfg["decimals0"] if sym == sym0 else (
-              pool_cfg["decimals1"] if sym == sym1 else None)
-        if dec is None:
-            meta = _swap_asset_meta(w3, sym)
-            if meta:
-                dec = meta.get("decimals")
-        if dec is None:
-            continue
-        inventory[sym] = [avail, dec, 0.0]
-
+    # 1. Inventory: check RedStone-fed assets + both pool tokens for balance, batched into
+    # one Multicall3 round-trip (see _aero_inventory_available).
+    inventory = _aero_inventory_available(w3, account, pool_cfg)
     if not inventory:
         print("  No in-account assets found with non-zero balance.")
         return False
@@ -5761,7 +5903,7 @@ def cmd_aero_rebalance_status(token_id: int = None, check: bool = False,
             d["position"] = None
         if check:
             try:
-                payload = build_redstone_payload(degen_account_price_feeds(account))
+                payload = build_redstone_payload(degen_account_price_feeds(account, w3=w3))
                 d["shouldRebalance"] = bool(redstone_view_call(
                     w3, account, "shouldRebalance", payload, args=[tid])[0])
             except Exception as e:
@@ -5926,34 +6068,9 @@ def _aero_rebuild_sweep(w3, acct, account, pa_cs, pool_key, pool_cfg=None, execu
     sym0, sym1 = pool_cfg["symbol0"], pool_cfg["symbol1"]
     MIN_USD_VALUE = 5.0
 
-    # Inventory RedStone-priced assets
-    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(account_sym)).call()
-        except Exception:
-            bal = 0
-        if bal <= 0:
-            continue
-        try:
-            locked = account.functions.getTotalIntentAmount(asset_b32(account_sym)).call()
-        except Exception:
-            locked = 0
-        avail = bal - locked if bal > locked else 0
-        if avail <= 0:
-            continue
-        dec = pool_cfg["decimals0"] if sym == sym0 else (
-              pool_cfg["decimals1"] if sym == sym1 else None)
-        if dec is None:
-            meta = _swap_asset_meta(w3, sym)
-            if meta:
-                dec = meta.get("decimals")
-        if dec is None:
-            continue
-        inventory[sym] = [avail, dec, 0.0]
-
+    # Inventory RedStone-priced assets + both pool tokens, batched into one Multicall3
+    # round-trip (see _aero_inventory_available).
+    inventory = _aero_inventory_available(w3, account, pool_cfg)
     if not inventory:
         return
 

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

@@ -1726,11 +1726,24 @@ def cmd_withdrawal_requests():
     acct = get_account()
     print(f"Wallet: {acct.address}")
     any_pending = False
-    for pool_name, cfg in POOLS.items():
-        contract = w3.eth.contract(address=Web3.to_checksum_address(cfg["proxy"]), abi=POOL_ABI)
-        balance = contract.functions.balanceOf(acct.address).call()
-        total_intent = contract.functions.getTotalIntentAmount(acct.address).call()
-        intents = contract.functions.getUserIntents(acct.address).call()
+    # Batch the per-pool balanceOf + getTotalIntentAmount + getUserIntents reads (was 3
+    # sequential eth_calls per pool) into one Multicall3 round-trip.
+    pool_meta = list(POOLS.items())
+    legs = []
+    for _pool_name, cfg in pool_meta:
+        proxy_cs = Web3.to_checksum_address(cfg["proxy"])
+        contract = w3.eth.contract(address=proxy_cs, abi=POOL_ABI)
+        legs.append((proxy_cs, bytes.fromhex(contract.encode_abi("balanceOf", args=[acct.address])[2:])))
+        legs.append((proxy_cs, bytes.fromhex(contract.encode_abi("getTotalIntentAmount", args=[acct.address])[2:])))
+        legs.append((proxy_cs, bytes.fromhex(contract.encode_abi("getUserIntents", args=[acct.address])[2:])))
+    results = multicall(w3, legs)
+    for i, (pool_name, cfg) in enumerate(pool_meta):
+        b_ok, b_rd = results[3 * i]
+        t_ok, t_rd = results[3 * i + 1]
+        u_ok, u_rd = results[3 * i + 2]
+        balance = w3.codec.decode(["uint256"], b_rd)[0] if b_ok and b_rd else 0
+        total_intent = w3.codec.decode(["uint256"], t_rd)[0] if t_ok and t_rd else 0
+        intents = w3.codec.decode(["(uint256,uint256,uint256,bool,bool,bool)[]"], u_rd)[0] if u_ok and u_rd else []
         if balance == 0 and not intents:
             continue
         dec = cfg["decimals"]
@@ -3492,12 +3505,24 @@ def cmd_withdrawal_intents():
         return
 
     any_pending = False
+    # Batch the per-asset getAvailableBalance + getTotalIntentAmount + getUserIntents reads
+    # (was 3 sequential eth_calls per owned asset) into one Multicall3 round-trip.
+    pa_cs = account.address
+    legs = []
     for a in owned:
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getAvailableBalance", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getTotalIntentAmount", args=[a])[2:])))
+        legs.append((pa_cs, bytes.fromhex(account.encode_abi("getUserIntents", args=[a])[2:])))
+    results = multicall(w3, legs)
+    for i, a in enumerate(owned):
         sym = a.rstrip(b"\x00").decode(errors="replace")
         dec = _asset_decimals(sym)
-        available = account.functions.getAvailableBalance(a).call()
-        total_intent = account.functions.getTotalIntentAmount(a).call()
-        intents = account.functions.getUserIntents(a).call()
+        av_ok, av_rd = results[3 * i]
+        ti_ok, ti_rd = results[3 * i + 1]
+        ui_ok, ui_rd = results[3 * i + 2]
+        available = w3.codec.decode(["uint256"], av_rd)[0] if av_ok and av_rd else 0
+        total_intent = w3.codec.decode(["uint256"], ti_rd)[0] if ti_ok and ti_rd else 0
+        intents = w3.codec.decode(["(uint256,uint256,uint256,bool,bool,bool)[]"], ui_rd)[0] if ui_ok and ui_rd else []
         print(f"  {sym}: available {available / 10**dec:,.6f}, "
               f"pending intents {total_intent / 10**dec:,.6f}")
         for idx, (amt, actionable_at, expires_at, is_pending, is_actionable, is_expired) in enumerate(intents):
@@ -4473,13 +4498,33 @@ def cmd_lb_remove(pair_key: str, slippage_pct: float = 1.0, execute: bool = Fals
         return
 
     pair_c = _lb_pair_contract(w3, pair_cs)
-    active_id = pair_c.functions.getActiveId().call()
+    # Batch getActiveId + per-bin (balanceOf + totalSupply + getBin) into one Multicall3
+    # round-trip (was 1 + 3N sequential eth_calls). This is a WRITE path — the decoded
+    # amounts feed removeLiquidity and the slippage floors — so a failed read aborts rather
+    # than silently defaulting to 0 (matches the prior abort-on-error behaviour).
+    legs = [(pair_cs, bytes.fromhex(pair_c.encode_abi("getActiveId", args=[])[2:]))]
+    for binid in ids:
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("balanceOf", args=[pa_cs, binid])[2:])))
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("totalSupply", args=[binid])[2:])))
+        legs.append((pair_cs, bytes.fromhex(pair_c.encode_abi("getBin", args=[binid])[2:])))
+    results = multicall(w3, legs)
+    a_ok, a_rd = results[0]
+    if not (a_ok and a_rd):
+        print("  Could not read the LB pair's active bin — refusing to remove.")
+        return
+    active_id = w3.codec.decode(["uint24"], a_rd)[0]
     amounts = []
     est_x = est_y = 0.0
-    for binid in ids:
-        bal = pair_c.functions.balanceOf(pa_cs, binid).call()
-        ts = pair_c.functions.totalSupply(binid).call()
-        rx, ry = pair_c.functions.getBin(binid).call()
+    for k, binid in enumerate(ids):
+        b_ok, b_rd = results[1 + 3 * k]
+        t_ok, t_rd = results[1 + 3 * k + 1]
+        g_ok, g_rd = results[1 + 3 * k + 2]
+        if not (b_ok and b_rd and t_ok and t_rd and g_ok and g_rd):
+            print(f"  Could not read bin {binid} on [{pair_key}] — refusing to remove (incomplete data).")
+            return
+        bal = w3.codec.decode(["uint256"], b_rd)[0]
+        ts = w3.codec.decode(["uint256"], t_rd)[0]
+        rx, ry = w3.codec.decode(["uint128", "uint128"], g_rd)
         amounts.append(bal)
         share = (bal / ts) if ts else 0
         est_x += rx * share / 10**x_cfg["decimals"]

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

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

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