primecli 0.10.1__tar.gz → 0.10.2__tar.gz

{primecli-0.10.1 → primecli-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.10.1
+Version: 0.10.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.10.1 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.10.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.10.1 → primecli-0.10.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.10.1 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.10.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.10.1 → primecli-0.10.2}/primecli/_flowledger.py

@@ -90,6 +90,66 @@ def append_flow(chain: str, account: str, record: dict, ledger_dir=None) -> bool
         return False
 
 
+# ERC20 Transfer(address,address,uint256) event topic (keccak of the signature).
+# Hardcoded so this module stays web3-free (it only does JSONL IO otherwise).
+_ERC20_TRANSFER_TOPIC = (
+    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
+)
+
+
+def _to_hex(v) -> str:
+    """Normalise a web3 HexBytes / bytes / str to a 0x-prefixed lowercase hex string."""
+    h = v.hex() if hasattr(v, "hex") else str(v)
+    h = h.lower()
+    return h if h.startswith("0x") else "0x" + h
+
+
+def _norm_addr(v) -> str:
+    """Last-20-bytes address as 0x-prefixed lowercase (handles 32-byte padded topics
+    and 20-byte log addresses alike)."""
+    return "0x" + _to_hex(v)[2:][-40:]
+
+
+def transferred_amount(receipt, token_addr: str, from_addr: str, to_addr: str,
+                       decimals: int):
+    """Real ERC20 amount moved `from_addr` -> `to_addr` in `token_addr` within this
+    receipt, in human units (raw / 10**decimals). Sums all matching Transfer logs.
+
+    Returns None when the receipt carries NO matching Transfer log at all — the caller
+    then falls back to the requested amount (can't determine the truth). A matching
+    Transfer of value 0 returns 0.0 (the fund pulled nothing), NOT None.
+
+    This is the truth source for a fund flow: `fund(asset, amount)` can pull LESS than
+    `amount` when the wallet's balance/allowance is short — e.g. a leverage-open where
+    most of the position is borrowed, so the EOA only holds dust. Logging the requested
+    arg then over-counts contribution and corrupts every downstream PnL/ROI/APR. Parsing
+    the actual on-chain Transfer fixes that at the source.
+    """
+    try:
+        token = _norm_addr(token_addr)
+        frm = _norm_addr(from_addr)
+        to = _norm_addr(to_addr)
+        total_raw = 0
+        found = False
+        for log in receipt["logs"]:
+            if _norm_addr(log["address"]) != token:
+                continue
+            topics = log["topics"]
+            if len(topics) != 3 or _to_hex(topics[0]) != _ERC20_TRANSFER_TOPIC:
+                continue
+            if _norm_addr(topics[1]) != frm or _norm_addr(topics[2]) != to:
+                continue
+            total_raw += int(_to_hex(log["data"]), 16)
+            found = True
+        if not found:
+            return None
+        return total_raw / (10 ** decimals)
+    except Exception as e:  # noqa: BLE001 — never break the caller over a parse error
+        print(f"  WARN flowledger: transfer parse failed ({type(e).__name__}: {e})",
+              file=sys.stderr)
+        return None
+
+
 def make_record(*, ts: int, ftype: str, asset: str, token_amount: float,
                 usd_value, tx: str, block: int, source: str) -> dict:
     """Build a ledger record with exactly the keys pnl_backfill writes (minus the

{primecli-0.10.1 → primecli-0.10.2}/primecli/arbprime.py

@@ -1966,21 +1966,42 @@ def cmd_fund(pool_name: str, amount: float, execute: bool = False):
         receipt = _sign_and_send(w3, acct, fund_tx, f"Fund {amount} {symbol}", fallback_gas=3000000)
         ok = receipt["status"] == 1
         if ok:
-            _log_fund_flow(pa, symbol, amount, receipt)
+            _log_fund_flow(
+                pa, symbol, amount, receipt,
+                token_addr=(None if cfg["native"] else cfg["token"]),
+                from_addr=acct.address, decimals=cfg["decimals"],
+            )
         return ok
 
 
-def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt,
+                   token_addr: str = None, from_addr: str = None,
+                   decimals: int = None) -> None:
     """Append a 'deposit' flow record after a successful fund broadcast. asset is the
     funded bytes32 symbol (the wrapped-native symbol for native funding, e.g. 'ETH').
     usd_value uses the current spot price (≈ flow-time price); None when unpriced.
-    Wrapped so a logging failure can never fail the financial op."""
+    Wrapped so a logging failure can never fail the financial op.
+
+    Logs the ACTUAL ERC20 Transfer(EOA -> account) amount from the receipt, not the
+    requested `amount`: an ERC20 fund() can pull less than asked when the wallet is
+    short (leverage-opens fund mostly from borrow), and logging the request over-counts
+    contribution. Native funding moves the exact msg.value, so `amount` stands there
+    (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and from_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, from_addr, account_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE fund pulled {moved} {symbol} of {amount} requested "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="deposit", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-fund",
         )
@@ -3500,20 +3521,40 @@ def cmd_execute_withdrawal(pool_name: str, index: int = None, execute: bool = Fa
     ok = receipt["status"] == 1
     if ok:
         executed_amount = sum(intents[i][0] for i in ready) / 10 ** cfg["decimals"]
-        _log_withdraw_flow(pa, symbol, executed_amount, receipt)
+        _log_withdraw_flow(
+            pa, symbol, executed_amount, receipt,
+            token_addr=(None if cfg["native"] else cfg["token"]),
+            to_addr=acct.address, decimals=cfg["decimals"],
+        )
 
 
-def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt,
+                       token_addr: str = None, to_addr: str = None,
+                       decimals: int = None) -> None:
     """Append a 'withdraw' flow record after a successful executeWithdrawalIntent
     broadcast (funds left the account to the EOA). amount is the total executed across
     the matured intents. usd_value uses current spot price; None when unpriced. Wrapped
-    so a logging failure can never fail the financial op."""
+    so a logging failure can never fail the financial op.
+
+    Prefers the ACTUAL ERC20 Transfer(account -> EOA) amount from the receipt over the
+    committed `amount`, symmetric with the fund path: the executed amount is normally
+    exact, but parsing the receipt keeps the ledger honest if it ever diverges. Native
+    unwraps emit no ERC20 Transfer, so `amount` stands there (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and to_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, account_addr, to_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE withdraw moved {moved} {symbol} of {amount} executed "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="withdraw", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-withdraw",
         )

{primecli-0.10.1 → primecli-0.10.2}/primecli/degenprime.py

@@ -2002,22 +2002,43 @@ def cmd_fund(pool_name: str, amount: float, execute: bool = False):
         receipt = _sign_and_send(w3, acct, fund_tx, f"Fund {amount} {symbol}", fallback_gas=3000000)
     ok = receipt["status"] == 1
     if ok:
-        _log_fund_flow(pa, symbol, amount, receipt)
+        _log_fund_flow(
+            pa, symbol, amount, receipt,
+            token_addr=(None if cfg["native"] else cfg["token"]),
+            from_addr=acct.address, decimals=cfg["decimals"],
+        )
     return ok
 
 
-def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt,
+                   token_addr: str = None, from_addr: str = None,
+                   decimals: int = None) -> None:
     """Append a 'deposit' flow record after a successful fund broadcast. asset is the
     funded bytes32 symbol (the wrapped-native symbol for native funding — degenprime's
     POOLS already stores the native pool's symbol as the wrapped name, e.g. 'ETH').
     usd_value uses the current spot price (≈ flow-time price); None when unpriced.
-    Wrapped so a logging failure can never fail the financial op."""
+    Wrapped so a logging failure can never fail the financial op.
+
+    The logged amount is the ACTUAL ERC20 Transfer(EOA -> account) from the receipt,
+    not the requested `amount`: an ERC20 fund() can pull less than asked when the
+    wallet is short (leverage-opens fund mostly from borrow), and logging the request
+    over-counts contribution. Native funding moves the exact msg.value (can't be
+    partial), so `amount` stands there (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and from_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, from_addr, account_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE fund pulled {moved} {symbol} of {amount} requested "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="deposit", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-fund",
         )
@@ -3138,7 +3159,17 @@ def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.
     """Swap one in-account asset for another via the Degen Account on ParaSwap v6.
     Sells the account's in-account balance of --from for --to. Carries remainsSolvent,
     so the --execute path appends a RedStone signed-price payload to the calldata."""
-    from_sym, to_sym = from_sym.upper(), to_sym.upper()
+    # Canonicalize to the exact SWAP_ASSETS form (case-insensitive), matching swap-debt.
+    # Without this, a mixed-case pool symbol like cbBTC (passed as 'CBBTC'/'cbbtc') fails
+    # _swap_asset_meta even though it's valid. Unknown assets fall through uppercased so
+    # the "Unknown asset" errors below still fire clearly.
+    def _canon_swap_sym(s):
+        s_up = str(s).upper()
+        for _k in SWAP_ASSETS:
+            if _k.upper() == s_up:
+                return _k
+        return s_up
+    from_sym, to_sym = _canon_swap_sym(from_sym), _canon_swap_sym(to_sym)
     if from_sym == to_sym:
         print("--from and --to must differ.")
         return
@@ -3603,19 +3634,39 @@ def cmd_execute_withdrawal(pool_name: str, index: int = None, execute: bool = Fa
     ok = receipt["status"] == 1
     if ok:
         executed_amount = sum(intents[i][0] for i in ready) / 10 ** cfg["decimals"]
-        _log_withdraw_flow(pa, symbol, executed_amount, receipt)
+        _log_withdraw_flow(
+            pa, symbol, executed_amount, receipt,
+            token_addr=(None if cfg["native"] else cfg["token"]),
+            to_addr=acct.address, decimals=cfg["decimals"],
+        )
 
-def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt,
+                       token_addr: str = None, to_addr: str = None,
+                       decimals: int = None) -> None:
     """Append a 'withdraw' flow record after a successful executeWithdrawalIntent
     broadcast (funds left the account to the EOA). amount is the total executed across
     the matured intents. usd_value uses current spot price; None when unpriced. Wrapped
-    so a logging failure can never fail the financial op."""
+    so a logging failure can never fail the financial op.
+
+    Prefers the ACTUAL ERC20 Transfer(account -> EOA) amount from the receipt over the
+    committed `amount`, symmetric with the fund path: the executed amount is normally
+    exact, but parsing the receipt keeps the ledger honest if it ever diverges. Native
+    unwraps emit no ERC20 Transfer, so `amount` stands there (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and to_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, account_addr, to_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE withdraw moved {moved} {symbol} of {amount} executed "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="withdraw", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-withdraw",
         )
@@ -4247,15 +4298,17 @@ def _aero_use_all_available(
         print(f"  Error reading pool slot0: {e}")
         return False
 
-    # 4. Filter inventory > $5; fallback for pool tokens
+    # 4. Build the deploy set. Non-pool assets need a RedStone price >= $5 to be
+    # worth sweeping in. The pool's OWN two tokens always count if held — they go
+    # straight into the LP, priced by the pool tick, not RedStone. Without this, a
+    # pool token with no RedStone feed (e.g. ZORA, priced via BaseOracle TWAP) reads
+    # usd=0 and was silently dropped whenever the OTHER leg (USDC) was priced, so the
+    # held balance never got deployed. (Paraklaudios fix 2026-06-23.)
     valuable = {sym: bal for sym, (bal, dec, usd) in inventory.items()
                 if usd >= MIN_USD_VALUE}
-    if not valuable:
-        print("  No assets have RedStone prices above $5. Falling back to raw pool-token balances.")
-        for sym in (sym0, sym1):
-            if sym in inventory:
-                bal, dec, _ = inventory[sym]
-                valuable[sym] = bal
+    for sym in (sym0, sym1):
+        if sym in inventory and sym not in valuable:
+            valuable[sym] = inventory[sym][0]
     if not valuable:
         print("  No available assets to deploy.")
         return False
@@ -4395,8 +4448,12 @@ def _aero_use_all_available(
             ok = _swap_with_usdc_fallback(account, sym, dest_sym, amount_human,
                                           slippage_pct, execute=True)
             if not ok:
-                print(f"  Swap {sym} -> {dest_sym} failed (direct + USDC 2-hop). Aborting.")
-                return False
+                print(f"  Swap {sym} -> {dest_sym} failed (direct + USDC 2-hop). "
+                      f"Skipping — minting with current pool-token balances.")
+                # Don't abort just because a small sweep fails. The pool tokens
+                # (ZORA/USDC etc.) are still in the account and the mint can
+                # proceed without converting this non-pool asset. The leftover
+                # will be swept on the next tick.
 
     return (total0_wei, total1_wei, tick_lower, tick_upper, pool_tick)
 
@@ -4594,7 +4651,7 @@ def _cmd_aero_add_liquidity_all_available(pool_key, slippage_pct, execute, width
     )
     if not plan:
         print("  Swap execution finished but post-swap plan is empty. Aborting mint.")
-        return
+        sys.exit(2)
     total0_wei, total1_wei, tick_lower, tick_upper, pool_tick = plan
 
     # ── Precision balance sweep ──────────────────────────────────
@@ -4787,6 +4844,10 @@ def _cmd_aero_add_liquidity_all_available(pool_key, slippage_pct, execute, width
     }
     receipt = _sign_and_send(w3, acct, tx, "Add liquidity", timeout=300, fallback_gas=5000000)
     ok = receipt["status"] == 1
+    if not ok:
+        print("  ABORT: mint transaction reverted.")
+        sys.exit(2)
+    print("  ✓ Mint confirmed.")
 
 
 def cmd_aero_rebuild(token_id: int, width_pct: float = 2.0, slippage_pct: float = 1.0,

{primecli-0.10.1 → primecli-0.10.2}/primecli/deltaprime.py

@@ -1985,21 +1985,42 @@ def cmd_fund(pool_name: str, amount: float, execute: bool = False):
         receipt = _sign_and_send(w3, acct, fund_tx, f"Fund {amount} {symbol}", fallback_gas=3000000)
         ok = receipt["status"] == 1
         if ok:
-            _log_fund_flow(pa, symbol, amount, receipt)
+            _log_fund_flow(
+                pa, symbol, amount, receipt,
+                token_addr=(None if cfg["native"] else cfg["token"]),
+                from_addr=acct.address, decimals=cfg["decimals"],
+            )
         return ok
 
 
-def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_fund_flow(account_addr: str, symbol: str, amount: float, receipt,
+                   token_addr: str = None, from_addr: str = None,
+                   decimals: int = None) -> None:
     """Append a 'deposit' flow record after a successful fund broadcast. asset is the
     funded bytes32 symbol (the wrapped-native symbol for native funding, e.g. 'AVAX').
     usd_value uses the current spot price (≈ flow-time price); None when unpriced.
-    Wrapped so a logging failure can never fail the financial op."""
+    Wrapped so a logging failure can never fail the financial op.
+
+    Logs the ACTUAL ERC20 Transfer(EOA -> account) amount from the receipt, not the
+    requested `amount`: an ERC20 fund() can pull less than asked when the wallet is
+    short (leverage-opens fund mostly from borrow), and logging the request over-counts
+    contribution. Native funding moves the exact msg.value, so `amount` stands there
+    (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and from_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, from_addr, account_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE fund pulled {moved} {symbol} of {amount} requested "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="deposit", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-fund",
         )
@@ -3516,20 +3537,40 @@ def cmd_execute_withdrawal(pool_name: str, index: int = None, execute: bool = Fa
     ok = receipt["status"] == 1
     if ok:
         executed_amount = sum(intents[i][0] for i in ready) / 10 ** cfg["decimals"]
-        _log_withdraw_flow(pa, symbol, executed_amount, receipt)
+        _log_withdraw_flow(
+            pa, symbol, executed_amount, receipt,
+            token_addr=(None if cfg["native"] else cfg["token"]),
+            to_addr=acct.address, decimals=cfg["decimals"],
+        )
 
 
-def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt) -> None:
+def _log_withdraw_flow(account_addr: str, symbol: str, amount: float, receipt,
+                       token_addr: str = None, to_addr: str = None,
+                       decimals: int = None) -> None:
     """Append a 'withdraw' flow record after a successful executeWithdrawalIntent
     broadcast (funds left the account to the EOA). amount is the total executed across
     the matured intents. usd_value uses current spot price; None when unpriced. Wrapped
-    so a logging failure can never fail the financial op."""
+    so a logging failure can never fail the financial op.
+
+    Prefers the ACTUAL ERC20 Transfer(account -> EOA) amount from the receipt over the
+    committed `amount`, symmetric with the fund path: the executed amount is normally
+    exact, but parsing the receipt keeps the ledger honest if it ever diverges. Native
+    unwraps emit no ERC20 Transfer, so `amount` stands there (token_addr is None)."""
     try:
+        actual = amount
+        if token_addr and to_addr and decimals is not None:
+            moved = _flowledger.transferred_amount(
+                receipt, token_addr, account_addr, to_addr, decimals)
+            if moved is not None:
+                if abs(moved - amount) > max(1e-6, abs(amount) * 1e-4):
+                    print(f"  NOTE withdraw moved {moved} {symbol} of {amount} executed "
+                          f"(logging actual)", file=sys.stderr)
+                actual = moved
         px = token_price(symbol)
-        usd = round(amount * px, 8) if px else None
+        usd = round(actual * px, 8) if px else None
         rec = _flowledger.make_record(
             ts=int(time.time()), ftype="withdraw", asset=symbol,
-            token_amount=amount, usd_value=usd,
+            token_amount=actual, usd_value=usd,
             tx=receipt["transactionHash"].hex(), block=receipt["blockNumber"],
             source="live-withdraw",
         )

{primecli-0.10.1 → primecli-0.10.2}/primecli/health_monitor.py

@@ -910,7 +910,7 @@ def run_tick(
                 for s in supply_rows:
                     sym = s.get("symbol", "")
                     usd_val = s.get("usd", 0) or 0
-                    raw_amt = s.get("amount", s.get("balance", 0)) or 0
+                    raw_amt = float(s.get("amount", s.get("balance", 0)) or 0)
                     if sym.upper() == "USDC" or usd_val < 1 or raw_amt <= 0:
                         continue
                     swap_candidates.append((sym, usd_val, raw_amt))
@@ -1053,7 +1053,7 @@ def run_tick(
                         for s in supply_rows2:
                             sym = s.get("symbol", "")
                             usd_val = s.get("usd", 0) or 0
-                            raw_amt = s.get("amount", s.get("balance", 0)) or 0
+                            raw_amt = float(s.get("amount", s.get("balance", 0)) or 0)
                             if sym.upper() == "USDC" or usd_val < 1 or raw_amt <= 0:
                                 continue
                             swap_candidates2.append((sym, usd_val, raw_amt))

{primecli-0.10.1 → primecli-0.10.2}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.10.1
+Version: 0.10.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.10.1 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.10.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.10.1 → primecli-0.10.2}/primecli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ tests/test_aero_range_and_swap_fallback.py
 tests/test_aero_rebalance.py
 tests/test_bridge.py
 tests/test_cross_file_identity.py
+tests/test_flowledger_transferred_amount.py
 tests/test_gas_limit.py
 tests/test_gas_pricing.py
 tests/test_health_meter.py

{primecli-0.10.1 → primecli-0.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.10.1"
+version = "0.10.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.10.2/tests/test_flowledger_transferred_amount.py

@@ -0,0 +1,102 @@
+"""Regression guard for _flowledger.transferred_amount — the receipt-truth parser
+behind the fund/withdraw flow logging fix (2026-06-23).
+
+Background: `fund(asset, amount)` can pull LESS than `amount` when the EOA is short
+(a leverage-open funds mostly from borrow, so the wallet only holds dust). The old
+logger recorded the requested `amount` as contribution, inflating the PnL basis and
+corrupting every downstream since-open PnL / ROI / effective-APR. The fix logs the
+ACTUAL on-chain Transfer(EOA -> account) amount instead. These tests pin that parser.
+"""
+
+from __future__ import annotations
+
+from primecli import _flowledger as fl
+
+# Real lowercase addresses from the incident (Base).
+TOKEN = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"  # USDC (6 decimals)
+EOA = "0x0218f5b006fd43181018f584ed4be13c356b3428"
+ACCT = "0x150619b111e21f0eac2232ff63f5f0027a47d331"
+OTHER = "0x00000000000000000000000000000000deadbeef"
+
+TRANSFER = fl._ERC20_TRANSFER_TOPIC
+
+
+def _topic_addr(addr: str) -> str:
+    """32-byte left-padded topic encoding of an address."""
+    return "0x" + addr.lower().removeprefix("0x").rjust(64, "0")
+
+
+def _transfer_log(token: str, frm: str, to: str, raw: int) -> dict:
+    return {
+        "address": token,
+        "topics": [TRANSFER, _topic_addr(frm), _topic_addr(to)],
+        "data": "0x" + format(raw, "064x"),
+    }
+
+
+def _receipt(logs: list[dict]) -> dict:
+    return {"logs": logs}
+
+
+def test_real_transfer_returns_actual_amount():
+    # 199.9 USDC genuinely funded -> parser returns 199.9, not whatever was requested.
+    rcpt = _receipt([_transfer_log(TOKEN, EOA, ACCT, 199_900_000)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) == 199.9
+
+
+def test_partial_pull_returns_dust_not_requested():
+    # The ZORA phantom: fund(132 USDC) but only 0.08425 actually moved.
+    rcpt = _receipt([_transfer_log(TOKEN, EOA, ACCT, 84_250)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) == 84_250 / 1e6
+
+
+def test_zero_value_transfer_returns_zero_not_none():
+    # A 0-value Transfer is still a Transfer: the fund pulled nothing -> 0.0, not None.
+    rcpt = _receipt([_transfer_log(TOKEN, EOA, ACCT, 0)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) == 0.0
+
+
+def test_no_matching_transfer_returns_none():
+    # No Transfer to the account at all -> None, so the caller falls back to the request.
+    rcpt = _receipt([_transfer_log(TOKEN, EOA, OTHER, 100_000_000)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) is None
+
+
+def test_wrong_token_ignored():
+    other_token = "0x4200000000000000000000000000000000000006"  # WETH
+    rcpt = _receipt([_transfer_log(other_token, EOA, ACCT, 5_000_000)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) is None
+
+
+def test_sums_multiple_matching_transfers():
+    rcpt = _receipt([
+        _transfer_log(TOKEN, EOA, ACCT, 10_000_000),
+        _transfer_log(TOKEN, EOA, ACCT, 25_000_000),
+    ])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) == 35.0
+
+
+def test_direction_matters_for_withdraw():
+    # Withdraw is account -> EOA. A fund-direction parse must not pick it up.
+    rcpt = _receipt([_transfer_log(TOKEN, ACCT, EOA, 50_000_000)])
+    assert fl.transferred_amount(rcpt, TOKEN, EOA, ACCT, 6) is None
+    assert fl.transferred_amount(rcpt, TOKEN, ACCT, EOA, 6) == 50.0
+
+
+def test_checksum_and_hexbytes_inputs_normalise():
+    class _HB(bytes):
+        def hex(self):
+            return super().hex()
+
+    raw_topics = [
+        _HB(bytes.fromhex(TRANSFER.removeprefix("0x"))),
+        _HB(bytes.fromhex(_topic_addr(EOA).removeprefix("0x"))),
+        _HB(bytes.fromhex(_topic_addr(ACCT).removeprefix("0x"))),
+    ]
+    rcpt = {"logs": [{
+        "address": _HB(bytes.fromhex(TOKEN.removeprefix("0x"))),
+        "topics": raw_topics,
+        "data": _HB((75_000_000).to_bytes(32, "big")),
+    }]}
+    # Pass checksum-style mixed-case addresses to confirm normalisation.
+    assert fl.transferred_amount(rcpt, TOKEN.upper(), EOA, ACCT, 6) == 75.0