primecli 0.10.2__tar.gz → 0.10.4__tar.gz

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

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

@@ -1904,6 +1904,14 @@ def cmd_create_prime_account(execute: bool = False, fund_pool: str = None, fund_
             time.sleep(2)
         if pa:
             print(f"  Prime Account: {pa}")
+            if funding:
+                # Seed deposit: createAndFundLoan does transferFrom(EOA, factory, amount)
+                # — the FULL amount or it reverts (can't be partial), so the requested
+                # amount is exact. Log it live so the PnL basis is captured without a
+                # later rescan. token_addr left None (the ERC20 Transfer routes
+                # EOA->factory->account, not directly EOA->account), so the exact
+                # requested amount is logged; the backfill dedupes on (tx, asset, type).
+                _log_fund_flow(pa, symbol, fund_amount, receipt)
         else:
             print("  Prime Account: created — getLoanForOwner not propagated yet, run 'my-positions' shortly.")
 

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

@@ -397,17 +397,15 @@ AERODROME_POOLS = {
 PARASWAP_API = "https://apiv5.paraswap.io"
 PARASWAP_AUGUSTUS = "0x6A000F20005980200259B80c5102003040001068"
 PARASWAP_SUPPORTED_SELECTORS = {"0xe3ead59e", "0x876a02f6"}
-# Executors the facet whitelists. Lowercased. Starting set mirrors DeltaPrime's - the
-# v6 router is shared, so the same executors are plausible candidates. Real txs will
-# reveal missing ones with InvalidExecutor reverts; add as they show up.
+# Executors the facet actually accepts on Base, lowercased. Pruned 2026-06-24 after
+# on-chain verification: only the v6.2 API executor below works through the DegenPrime
+# ParaSwapFacet. The others Velora rotates into quotes hard-revert: 0x6a000f20 (Augustus)
+# and 0x6f053800 (Velora v1) -> SwapFailed(); 0x000010036c, 0x00c600b3, 0xa0f408a0,
+# 0xdef171fe -> InvalidExecutor(). So a route built around any of them is dead - the fix
+# is to re-quote (Velora returns a different route each call) rather than patch the
+# executor word. See _paraswap_requote_until_clean.
 PARASWAP_EXECUTORS = {
-    "0xdef171fe48cf0115b1d80b88dc8eab59176fee57",
-    "0x6a000f20005980200259b80c5102003040001068",
-    "0x000010036c0190e009a000d0fc3541100a07380a",
-    "0x00c600b30fb0400701010f4b080409018b9006e0",
-    "0xa0f408a000017007015e0f00320e470d00090a5b",
-    "0x8faa0000c10015610005ca010ee000d006e0e820",
-    "0x6f0538001f90d0a5f0000060d01d34c002030900",  # Velora v1
+    "0x8faa0000c10015610005ca010ee000d006e0e820",  # v6.2 swapExactAmountIn / UniV3 executor
 }
 
 # RedStone on-demand oracle config for DegenPrime on Base. Verified identical to
@@ -1941,6 +1939,14 @@ def cmd_create_account(execute: bool = False, fund_pool: str = None, fund_amount
             time.sleep(2)
         if pa:
             print(f"  Degen Account: {pa}")
+            if funding:
+                # Seed deposit: createAndFundLoan does transferFrom(EOA, factory, amount)
+                # — the FULL amount or it reverts (can't be partial), so the requested
+                # amount is exact. Log it live so the PnL basis is captured without a
+                # later rescan. token_addr left None (the ERC20 Transfer routes
+                # EOA->factory->account, not directly EOA->account), so the exact
+                # requested amount is logged; the backfill dedupes on (tx, asset, type).
+                _log_fund_flow(pa, symbol, fund_amount, receipt)
         else:
             print("  Degen Account: created - getLoansForOwner not propagated yet, run 'my-positions' shortly.")
 
@@ -3070,13 +3076,17 @@ def _paraswap_price_route(src_token, src_dec, dest_token, dest_dec, amount_in_we
     """ParaSwap /prices on Base (network=8453, v6.2). Returns the priceRoute dict for a
     SELL of amount_in_wei src->dest. The priceRoute is passed verbatim to /transactions.
     excludeContractMethods is hard-coded to keep ParaSwap from picking a router method
-    the facet can't decode (multiSwap/megaSwap/protected* etc.)."""
+    the facet can't decode (multiSwap/megaSwap/protected* etc.). excludeDEXS drops the
+    RFQ/maker sources (AugustusRFQ, Hashflow, etc.) up front: those won't fill for a
+    contract caller and are the prime SwapFailed() culprits - cutting them at the quote
+    keeps the re-quote loop from churning through routes that can never simulate clean."""
     params = {
         "srcToken": src_token, "srcDecimals": src_dec,
         "destToken": dest_token, "destDecimals": dest_dec,
         "amount": str(amount_in_wei), "side": "SELL",
         "network": CHAIN_ID, "version": "6.2", "userAddress": user_addr,
         "excludeContractMethods": "multiSwap,megaSwap,protectedMultiSwap,protectedMegaSwap,protectedSimpleSwap,simpleSwap,swapExactAmountInOnCurveV1",
+        "excludeDEXS": "AugustusRFQ,ParaSwapLimitOrders,Hashflow,Bebop,Swaap,SwaapV2,DexalotRFQ,NativeV1,Clipper,Metric,MetricRFQ",
     }
     r = requests.get(f"{PARASWAP_API}/prices", params=params,
                      headers={"Accept": "application/json"}, timeout=20)
@@ -3149,10 +3159,52 @@ def _paraswap_decode_and_check(selector_hex, data_bytes, src_token, dest_token,
     # UniV3 variant: selector + length sanity only.
     return None, src_token, dest_token, expected_from, None
 
-# Executor fallback - mirrors DeltaPrime's swap-debt path. If the ParaSwap API returns a
-# new executor not on the whitelist, patch in this one (the canonical legacy executor
-# whose calldata format is compatible with the current API output).
-_PARASWAP_FALLBACK_EXECUTOR = "0x000010036C0190E009a000d0fc3541100A07380A"
+# How many times to re-quote ParaSwap when the built route's facet simulation reverts.
+# Velora's /prices is non-deterministic per call: a SwapFailed() route (dead-but-
+# whitelisted executor, or an RFQ/maker leg that excludeDEXS missed) usually clears on a
+# fresh quote. We keep re-quoting and take the FIRST route that simulates clean for a
+# known-good executor. Patching the executor word in place no longer works (every
+# alternate executor reverts - see PARASWAP_EXECUTORS), so re-quoting is the only fix.
+_PARASWAP_REQUOTE_ATTEMPTS = 5
+
+def _paraswap_requote_until_clean(src_token, src_dec, dest_token, dest_dec, amount_in_wei,
+                                  slippage_pct, pa_cs, sim_fn):
+    """Quote -> build -> decode -> simulate, re-quoting up to _PARASWAP_REQUOTE_ATTEMPTS
+    times until the facet simulation passes, and return the first clean route.
+
+    `sim_fn(selector4, data_bytes) -> (ok: bool, err: str|None)` wraps the ParaSwap
+    calldata in the caller's facet method (paraSwapV6 / swapDebtParaSwap) and eth_call's
+    it. Returns a dict with the chosen route's artifacts (price_route, full, selector_hex,
+    data_bytes, quoted_out, min_out, executor), plus sim_ok/last_err describing the final
+    attempt. On all-fail it returns the LAST attempt's artifacts with sim_ok=False so the
+    caller can still print a preview and refuse to broadcast."""
+    last = None
+    for attempt in range(1, _PARASWAP_REQUOTE_ATTEMPTS + 1):
+        price_route = _paraswap_price_route(src_token, src_dec, dest_token, dest_dec,
+                                            amount_in_wei, pa_cs)
+        quoted_out = int(price_route["destAmount"])
+        tx_built = _paraswap_build_tx(price_route, src_token, src_dec, dest_token, dest_dec,
+                                      amount_in_wei, slippage_pct, pa_cs)
+        full = bytes.fromhex(tx_built["data"][2:])
+        selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
+        executor, _src, _dest, _from_amt, min_out = _paraswap_decode_and_check(
+            selector_hex, data_bytes, src_token, dest_token, amount_in_wei, pa_cs)
+        sim_ok, sim_err = sim_fn(full[:4], data_bytes)
+        last = {
+            "price_route": price_route, "tx_built": tx_built, "full": full,
+            "selector_hex": selector_hex, "data_bytes": data_bytes,
+            "quoted_out": quoted_out, "min_out": min_out, "executor": executor,
+            "sim_ok": sim_ok, "last_err": sim_err,
+        }
+        if sim_ok:
+            if attempt > 1:
+                print(f"  ✓ Route simulates clean on re-quote attempt {attempt}/"
+                      f"{_PARASWAP_REQUOTE_ATTEMPTS} (executor {executor}).")
+            return last
+        print(f"  ✗ Route from quote attempt {attempt}/{_PARASWAP_REQUOTE_ATTEMPTS} "
+              f"(executor {executor}) reverted in simulation: {sim_err}")
+    print(f"  ✗ All {_PARASWAP_REQUOTE_ATTEMPTS} ParaSwap quotes reverted in simulation.")
+    return last
 
 def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.0,
              execute: bool = False):
@@ -3207,46 +3259,25 @@ def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.
         print("Fund or borrow more of the asset into the account first.")
         return
 
-    price_route = _paraswap_price_route(from_cfg["token"], from_cfg["decimals"],
-                                        to_cfg["token"], to_cfg["decimals"], amount_in, pa_cs)
-    quoted_out = int(price_route["destAmount"])
-    tx_built = _paraswap_build_tx(price_route, from_cfg["token"], from_cfg["decimals"],
-                                  to_cfg["token"], to_cfg["decimals"], amount_in,
-                                  slippage_pct, pa_cs)
-    full = bytes.fromhex(tx_built["data"][2:])
-    selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
-    _exec, _src, _dest, _from_amt, min_out = _paraswap_decode_and_check(
-        selector_hex, data_bytes, from_cfg["token"], to_cfg["token"], amount_in, pa_cs)
-    # Simulate-first executor handling (see cmd_swap_debt rationale): keep the API
-    # executor when the exact tx simulates clean; only fall back to the legacy
-    # executor if the unpatched calldata reverts.
+    # Simulate-first with a re-quote loop: Velora rotates executors/routes per quote, so
+    # a SwapFailed() route usually clears on a fresh quote. Keep re-quoting and take the
+    # first route that simulates clean (see _paraswap_requote_until_clean).
     feeds = sorted(REDSTONE_AVAILABLE_FEEDS)
     payload = build_redstone_payload(feeds)
-    def _sim_paraswap(db):
-        base = account.encode_abi("paraSwapV6", args=[full[:4], db])
+    def _sim_paraswap(selector4, db):
+        base = account.encode_abi("paraSwapV6", args=[selector4, db])
         try:
             w3.eth.call({"from": acct.address, "to": pa_cs,
                          "data": base + payload.hex(), "gas": 8000000})
             return True, None
         except Exception as e:
             return False, str(e)
-    sim_ok, sim_err = _sim_paraswap(data_bytes)
-    if sim_ok:
-        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
-                  f"simulates clean — using the API calldata as-is.")
-    else:
-        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
-        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
-        sim_ok, err2 = _sim_paraswap(patched)
-        if sim_ok:
-            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
-                  f"(simulates clean).")
-            data_bytes = patched
-            _paraswap_decode_and_check(selector_hex, data_bytes, from_cfg["token"],
-                                       to_cfg["token"], amount_in, pa_cs)
-        else:
-            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
+    route = _paraswap_requote_until_clean(
+        from_cfg["token"], from_cfg["decimals"], to_cfg["token"], to_cfg["decimals"],
+        amount_in, slippage_pct, pa_cs, _sim_paraswap)
+    price_route, tx_built, full = route["price_route"], route["tx_built"], route["full"]
+    selector_hex, data_bytes = route["selector_hex"], route["data_bytes"]
+    quoted_out, min_out, sim_ok = route["quoted_out"], route["min_out"], route["sim_ok"]
 
     print(f"Swap {amount} {from_asset_sym} -> {to_asset_sym} on Degen Account {pa_cs}  (via ParaSwap/Velora)")
     print(f"  Router method: {price_route['contractMethod']} ({selector_hex})")
@@ -3262,7 +3293,8 @@ def cmd_swap(from_sym: str, to_sym: str, amount: float, slippage_pct: float = 1.
         return
 
     if not sim_ok:
-        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        print(f"✗ Refusing to broadcast: every ParaSwap quote reverted in simulation "
+              f"({_PARASWAP_REQUOTE_ATTEMPTS} attempts). Try again shortly.")
         return
 
     # Rebuild the payload fresh for broadcast (the sim payload may be near the
@@ -3365,46 +3397,25 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
     borrow_usd = price_to * borrow_amount / 10**to_cfg["decimals"] / 1e18
     diff_bps = (abs(repay_usd - borrow_usd) / max(repay_usd, borrow_usd)) * 10000 if max(repay_usd, borrow_usd) else 0
 
-    price_route = _paraswap_price_route(to_cfg["token"], to_cfg["decimals"],
-                                        from_cfg["token"], from_cfg["decimals"], borrow_amount, pa_cs)
-    quoted_out = int(price_route["destAmount"])
-    tx_built = _paraswap_build_tx(price_route, to_cfg["token"], to_cfg["decimals"],
-                                  from_cfg["token"], from_cfg["decimals"], borrow_amount,
-                                  slippage_pct, pa_cs)
-    full = bytes.fromhex(tx_built["data"][2:])
-    selector_hex, data_bytes = "0x" + full[:4].hex(), full[4:]
-    _exec, _src, _dest, _swap_from_amt, swap_min_out = _paraswap_decode_and_check(
-        selector_hex, data_bytes, to_cfg["token"], from_cfg["token"], borrow_amount, pa_cs)
-    # Simulate-first executor handling (protocol-level facet fix confirmed 2026-06-04;
-    # Velora rotates executors per quote): keep the API executor when the exact tx
-    # simulates clean; only fall back to the legacy executor if it reverts.
-    def _sim_swap_debt(db):
+    # Simulate-first with a re-quote loop (Velora rotates executors/routes per quote, and
+    # an RFQ/maker leg won't fill for a contract caller): re-quote until the swapDebt tx
+    # simulates clean, taking the first good route (see _paraswap_requote_until_clean).
+    def _sim_swap_debt(selector4, db):
         base = account.encode_abi("swapDebtParaSwap", args=[
             asset_b32(from_sym), asset_b32(to_sym), repay_amount, borrow_amount,
-            full[:4], db])
+            selector4, db])
         try:
             w3.eth.call({"from": acct.address, "to": pa_cs,
                          "data": base + payload.hex(), "gas": 8000000})
             return True, None
         except Exception as e:
             return False, str(e)
-    sim_ok, sim_err = _sim_swap_debt(data_bytes)
-    if sim_ok:
-        if _exec is not None and _exec.lower() not in PARASWAP_EXECUTORS:
-            print(f"  ✓ Executor {_exec} not in the static whitelist, but the full tx "
-                  f"simulates clean — using the API calldata as-is.")
-    else:
-        print(f"  ✗ Simulation with API executor {_exec} reverted: {sim_err}")
-        patched = bytes(12) + bytes.fromhex(_PARASWAP_FALLBACK_EXECUTOR[2:]) + data_bytes[32:]
-        sim_ok, err2 = _sim_swap_debt(patched)
-        if sim_ok:
-            print(f"  ⚠ Falling back to legacy executor {_PARASWAP_FALLBACK_EXECUTOR} "
-                  f"(simulates clean).")
-            data_bytes = patched
-            _paraswap_decode_and_check(selector_hex, data_bytes, to_cfg["token"],
-                                       from_cfg["token"], borrow_amount, pa_cs)
-        else:
-            print(f"  ✗ Legacy-executor fallback also reverted: {err2}")
+    route = _paraswap_requote_until_clean(
+        to_cfg["token"], to_cfg["decimals"], from_cfg["token"], from_cfg["decimals"],
+        borrow_amount, slippage_pct, pa_cs, _sim_swap_debt)
+    price_route, tx_built, full = route["price_route"], route["tx_built"], route["full"]
+    selector_hex, data_bytes = route["selector_hex"], route["data_bytes"]
+    quoted_out, swap_min_out, sim_ok = route["quoted_out"], route["min_out"], route["sim_ok"]
 
     print(f"Swap debt on Degen Account {pa}")
     print(f"  Refinance: {from_sym} debt -> {to_sym} debt")
@@ -3433,7 +3444,8 @@ def cmd_swap_debt(from_sym: str, to_sym: str, amount: float, slippage_pct: float
         return
 
     if not sim_ok:
-        print("✗ Refusing to broadcast: simulation reverted for both executor variants.")
+        print(f"✗ Refusing to broadcast: every ParaSwap quote reverted in simulation "
+              f"({_PARASWAP_REQUOTE_ATTEMPTS} attempts). Try again shortly.")
         return
 
     base_calldata = account.encode_abi("swapDebtParaSwap", args=[

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

@@ -1923,6 +1923,14 @@ def cmd_create_prime_account(execute: bool = False, fund_pool: str = None, fund_
             time.sleep(2)
         if pa:
             print(f"  Prime Account: {pa}")
+            if funding:
+                # Seed deposit: createAndFundLoan does transferFrom(EOA, factory, amount)
+                # — the FULL amount or it reverts (can't be partial), so the requested
+                # amount is exact. Log it live so the PnL basis is captured without a
+                # later rescan. token_addr left None (the ERC20 Transfer routes
+                # EOA->factory->account, not directly EOA->account), so the exact
+                # requested amount is logged; the backfill dedupes on (tx, asset, type).
+                _log_fund_flow(pa, symbol, fund_amount, receipt)
         else:
             print("  Prime Account: created — getLoanForOwner not propagated yet, run 'my-positions' shortly.")
 

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

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

@@ -24,6 +24,7 @@ tests/test_gas_limit.py
 tests/test_gas_pricing.py
 tests/test_health_meter.py
 tests/test_health_monitor.py
+tests/test_paraswap_requote.py
 tests/test_paraswap_validator.py
 tests/test_redstone_encoding.py
 tests/test_to_wei_units.py

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

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

@@ -0,0 +1,143 @@
+"""Offline tests for the ParaSwap re-quote loop in degenprime.
+
+`_paraswap_requote_until_clean` is the resilience fix for transient SwapFailed()
+reverts: Velora's /prices is non-deterministic per call, so a route whose executor
+is dead-but-whitelisted (or an RFQ/maker leg) usually clears on a fresh quote. The
+loop re-quotes up to `_PARASWAP_REQUOTE_ATTEMPTS` times and returns the FIRST route
+that simulates clean for the caller's facet method.
+
+Pure/offline: the three ParaSwap HTTP helpers (`_paraswap_price_route`,
+`_paraswap_build_tx`, `_paraswap_decode_and_check`) and the simulate callback are
+all stubbed. No network, no signing, no RPC.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+import pytest
+
+dp = importlib.import_module("primecli.degenprime")
+
+SRC = "0x" + "11" * 20
+DEST = "0x" + "22" * 20
+PA = "0x" + "33" * 20
+AMOUNT = 1000
+
+
+def _patch_quote_chain(monkeypatch, *, n_routes):
+    """Stub the price-route / build-tx / decode chain so each loop iteration produces a
+    distinct, identifiable route. Route k carries destAmount=1000+k and selector word
+    bytes that encode k, so we can assert WHICH route the loop returned."""
+    calls = {"price": 0, "build": 0, "decode": 0}
+
+    def fake_price(src_token, src_dec, dest_token, dest_dec, amount_in_wei, user_addr):
+        calls["price"] += 1
+        k = calls["price"]
+        return {"destAmount": str(1000 + k), "contractMethod": "swapExactAmountIn",
+                "_k": k}
+
+    def fake_build(price_route, *a, **kw):
+        calls["build"] += 1
+        k = price_route["_k"]
+        # 4-byte selector + a body byte that records k, so data_bytes differs per route.
+        data_hex = "0xe3ead59e" + f"{k:064x}"
+        return {"data": data_hex, "to": "0xaugustus"}
+
+    def fake_decode(selector_hex, data_bytes, src_token, dest_token, expected_from, pa_cs):
+        calls["decode"] += 1
+        k = int.from_bytes(data_bytes, "big")  # body == k
+        # (executor, src, dest, from_amt, to_amt)
+        return ("0xexec", src_token, dest_token, expected_from, 990 + k)
+
+    monkeypatch.setattr(dp, "_paraswap_price_route", fake_price)
+    monkeypatch.setattr(dp, "_paraswap_build_tx", fake_build)
+    monkeypatch.setattr(dp, "_paraswap_decode_and_check", fake_decode)
+    return calls
+
+
+def _run(sim_fn):
+    return dp._paraswap_requote_until_clean(
+        SRC, 18, DEST, 6, AMOUNT, 1.0, PA, sim_fn)
+
+
+def test_first_route_clean_no_requote(monkeypatch):
+    """Happy path: the first quote simulates clean -> exactly one quote, returned as-is."""
+    calls = _patch_quote_chain(monkeypatch, n_routes=5)
+    sim_calls = []
+
+    def sim_ok(selector4, db):
+        sim_calls.append(db)
+        return True, None
+
+    route = _run(sim_ok)
+    assert route["sim_ok"] is True
+    assert calls["price"] == 1  # no re-quote
+    assert len(sim_calls) == 1
+    assert route["quoted_out"] == 1001  # route k=1
+    assert route["min_out"] == 991
+
+
+def test_bad_then_good_requotes_and_picks_good(monkeypatch):
+    """The first two routes revert in simulation; the third clears. The loop must
+    re-quote and return the THIRD route (its artifacts), not the first."""
+    calls = _patch_quote_chain(monkeypatch, n_routes=5)
+    attempts = {"n": 0}
+
+    def sim_bad_then_good(selector4, db):
+        attempts["n"] += 1
+        if attempts["n"] < 3:
+            return False, "SwapFailed()"
+        return True, None
+
+    route = _run(sim_bad_then_good)
+    assert route["sim_ok"] is True
+    assert calls["price"] == 3  # re-quoted twice before the clean route
+    assert route["quoted_out"] == 1003  # route k=3 won
+    assert route["min_out"] == 993
+    # data_bytes belongs to the winning (3rd) route.
+    assert int.from_bytes(route["data_bytes"], "big") == 3
+
+
+def test_all_bad_returns_last_with_sim_ok_false(monkeypatch):
+    """If every quote reverts, the loop exhausts its attempts and returns the LAST
+    route's artifacts with sim_ok=False so the caller can preview and refuse."""
+    calls = _patch_quote_chain(monkeypatch, n_routes=10)
+
+    def sim_always_bad(selector4, db):
+        return False, "SwapFailed()"
+
+    route = _run(sim_always_bad)
+    assert route["sim_ok"] is False
+    assert route["last_err"] == "SwapFailed()"
+    assert calls["price"] == dp._PARASWAP_REQUOTE_ATTEMPTS  # tried the full budget
+    # Returned artifacts are from the final attempt.
+    assert int.from_bytes(route["data_bytes"], "big") == dp._PARASWAP_REQUOTE_ATTEMPTS
+
+
+def test_executors_pruned_to_verified_good():
+    """The static whitelist is pruned to the single verified-good v6.2 executor; the
+    dead legacy executors (and the useless fallback constant) are gone."""
+    assert dp.PARASWAP_EXECUTORS == {"0x8faa0000c10015610005ca010ee000d006e0e820"}
+    assert not hasattr(dp, "_PARASWAP_FALLBACK_EXECUTOR")
+
+
+def test_price_route_excludes_rfq_dexs(monkeypatch):
+    """`_paraswap_price_route` must send excludeDEXS dropping the RFQ/maker sources so
+    they never reach the build/simulate stage."""
+    captured = {}
+
+    class _Resp:
+        @staticmethod
+        def json():
+            return {"priceRoute": {"destAmount": "1"}}
+
+    def fake_get(url, params=None, headers=None, timeout=None):
+        captured["params"] = params
+        return _Resp()
+
+    monkeypatch.setattr(dp.requests, "get", fake_get)
+    dp._paraswap_price_route(SRC, 18, DEST, 6, AMOUNT, PA)
+    excluded = captured["params"]["excludeDEXS"]
+    assert "AugustusRFQ" in excluded
+    assert "ParaSwapLimitOrders" in excluded