wayfinder-paths 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -8,9 +8,11 @@ so the position remains safe under a stETH/ETH depeg.
 
 import asyncio
 import time
-from typing import Any
+from dataclasses import dataclass
+from typing import Any, Optional
 
 import httpx
+from eth_utils import to_checksum_address
 from loguru import logger
 
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
@@ -18,6 +20,7 @@ from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.moonwell_adapter.adapter import MoonwellAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.services.base import Web3Service
 from wayfinder_paths.core.services.local_token_txn import LocalTokenTxnService
 from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
@@ -87,17 +90,35 @@ class MoonwellWstethLoopStrategy(Strategy):
     # When wrapping ETH to WETH for swaps/repayment, avoid draining gas below this floor.
     # We can dip below MIN_GAS temporarily, but should not wipe the wallet.
     WRAP_GAS_RESERVE = 0.0014
-    MIN_USDC_DEPOSIT = 20.0  # Minimum USDC deposit required as initial collateral
+    MIN_USDC_DEPOSIT = 10.0  # Minimum USDC deposit required as initial collateral
+    MIN_REWARD_CLAIM_USD = 0.30  # Only claim WELL rewards if >= this value
     MAX_DEPEG = 0.01  # Maximum allowed stETH depeg threshold (1%)
     MAX_HEALTH_FACTOR = 1.5
     MIN_HEALTH_FACTOR = 1.2
-    # Continue levering up if HF is more than this amount above MIN_HEALTH_FACTOR
-    HF_LEVER_UP_BUFFER = 0.05  # Lever up if HF > MIN + 0.05 (i.e., > 1.25)
+    # Operational target HF (keep some buffer above MIN_HEALTH_FACTOR).
+    TARGET_HEALTH_FACTOR = 1.25
+    # Lever up if HF is more than this amount above TARGET_HEALTH_FACTOR
+    HF_LEVER_UP_BUFFER = 0.05  # Lever up if HF > TARGET + buffer
+    # Deleverage if HF drops below (TARGET - buffer).
+    HF_DELEVERAGE_BUFFER = 0.05
+    # Deleverage if leverage multiplier exceeds target by this much.
+    LEVERAGE_DELEVERAGE_BUFFER = 0.05
+    # During leverage-delever, allow HF to dip temporarily during the withdraw tx
+    # (swap+repay follows immediately). Keep well above liquidation.
+    LEVERAGE_DELEVER_HF_FLOOR = 1.05
+    # How close we need to be to "delta neutral" before we stop trying.
+    DELTA_TOL_USD = 5.0
+    # Prevent the post-run guard from spinning forever.
+    POST_RUN_MAX_PASSES = 2
+    # Full-exit (withdraw) dust behavior: do fewer, larger actions so we can repay_full in one go.
+    FULL_EXIT_BUFFER_MULT = 1.05
+    FULL_EXIT_MIN_BATCH_USD = 10.0
     _MAX_LOOP_LIMIT = 30  # Prevents infinite loops
 
     # Parameters
     leverage_limit = 10  # Limit on leverage multiplier
     min_withdraw_usd = 2
+    sweep_min_usd = 0.20
     max_swap_retries = 3  # Maximum number of swap retry attempts
     swap_slippage_tolerance = 0.005  # Base slippage of 50 bps
     MAX_SLIPPAGE_TOLERANCE = 0.03  # 3% absolute maximum slippage to prevent MEV attacks
@@ -111,7 +132,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         description="Leveraged wstETH carry: loops USDC → borrow WETH → swap wstETH → lend. "
         "Depeg-aware sizing with safety factor. ETH-neutral: WETH debt vs wstETH collateral.",
         summary="Leveraged wstETH carry on Base with depeg-aware sizing.",
-        risk_description=f"Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include weth/wsteth depegging (this strategy tracks the peg and is robust up to {int(MAX_DEPEG * 100)}% depeg). The rate spread between weth borrow and wsteth lend may also turn negative. This will likely only be temporary and is very rare. If this persists manual withdraw may be needed.",
+        risk_description="Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include wstETH/ETH depeg events which could trigger liquidations, health factor deterioration requiring emergency deleveraging, smart contract risk on Moonwell, and swap slippage during position adjustments. Strategy monitors peg ratio and adjusts leverage ceiling accordingly.",
         gas_token_symbol="ETH",
         gas_token_id=ETH_TOKEN_ID,
         deposit_token_id=USDC_TOKEN_ID,
@@ -171,9 +192,8 @@ class MoonwellWstethLoopStrategy(Strategy):
         strategy_wallet: dict | None = None,
         simulation: bool = False,
         web3_service: Web3Service | None = None,
-        api_key: str | None = None,
     ):
-        super().__init__(api_key=api_key)
+        super().__init__()
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -293,6 +313,1330 @@ class MoonwellWstethLoopStrategy(Strategy):
         wallet = self.config.get("main_wallet", {})
         return wallet.get("address", "")
 
+    def _gas_keep_wei(self) -> int:
+        """
+        Hard ETH reserve in the strategy wallet.
+        Never spend below this when wrapping/swapping ETH.
+        """
+        # Extra buffer for a couple txs (wrap + swap/repay).
+        tx_buffer = int(0.0003 * 10**18)
+        return max(
+            int(self.MIN_GAS * 10**18),
+            int(self.WRAP_GAS_RESERVE * 10**18) + tx_buffer,
+        )
+
+    @dataclass
+    class AccountingSnapshot:
+        # raw balances
+        wallet_eth: int
+        wallet_weth: int
+        wallet_wsteth: int
+        wallet_usdc: int
+
+        usdc_supplied: int  # underlying raw
+        wsteth_supplied: int  # underlying raw
+        weth_debt: int  # borrow raw
+
+        # prices/decimals
+        eth_price: float
+        weth_price: float
+        wsteth_price: float
+        usdc_price: float
+
+        eth_dec: int
+        weth_dec: int
+        wsteth_dec: int
+        usdc_dec: int
+
+        # derived USD values
+        wallet_usd: float
+        supplies_usd: float
+        debt_usd: float
+        net_equity_usd: float
+
+        # borrow capacity + risk
+        capacity_usd: float
+        ltv: float
+        hf: float
+
+        # gas
+        gas_keep_wei: int
+        eth_usable_wei: int
+
+        # convenient totals dict for HF simulations (same key shape as existing helpers)
+        totals_usd: dict[str, float]
+
+    async def _accounting_snapshot(
+        self, collateral_factors: tuple[float, float] | None = None
+    ) -> tuple["MoonwellWstethLoopStrategy.AccountingSnapshot", tuple[float, float]]:
+        """
+        One snapshot for decisions.
+        Keep it deterministic and re-usable across rebalance/unwind paths.
+        """
+        if collateral_factors is None:
+            collateral_factors = await self._get_collateral_factors()
+        cf_u, cf_w = collateral_factors
+
+        # Prices + decimals
+        (
+            (eth_price, eth_dec),
+            (weth_price, weth_dec),
+            (wsteth_price, wsteth_dec),
+            (usdc_price, usdc_dec),
+        ) = await asyncio.gather(
+            self._get_token_data(ETH_TOKEN_ID),
+            self._get_token_data(WETH_TOKEN_ID),
+            self._get_token_data(WSTETH_TOKEN_ID),
+            self._get_token_data(USDC_TOKEN_ID),
+        )
+
+        addr = self._get_strategy_wallet_address()
+
+        # Wallet balances
+        wallet_eth, wallet_weth, wallet_wsteth, wallet_usdc = await asyncio.gather(
+            self._get_balance_raw(token_id=ETH_TOKEN_ID, wallet_address=addr),
+            self._get_balance_raw(token_id=WETH_TOKEN_ID, wallet_address=addr),
+            self._get_balance_raw(token_id=WSTETH_TOKEN_ID, wallet_address=addr),
+            self._get_balance_raw(token_id=USDC_TOKEN_ID, wallet_address=addr),
+        )
+
+        # Protocol positions (sequential to avoid RPC burst)
+        usdc_pos_ok, usdc_pos = await self.moonwell_adapter.get_pos(mtoken=M_USDC)
+        wsteth_pos_ok, wsteth_pos = await self.moonwell_adapter.get_pos(mtoken=M_WSTETH)
+        weth_pos_ok, weth_pos = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
+
+        usdc_supplied = (
+            int((usdc_pos or {}).get("underlying_balance", 0) or 0)
+            if usdc_pos_ok
+            else 0
+        )
+        wsteth_supplied = (
+            int((wsteth_pos or {}).get("underlying_balance", 0) or 0)
+            if wsteth_pos_ok
+            else 0
+        )
+        weth_debt = (
+            int((weth_pos or {}).get("borrow_balance", 0) or 0) if weth_pos_ok else 0
+        )
+
+        # Gas reserve
+        gas_keep_wei = int(self._gas_keep_wei())
+        eth_usable_wei = max(0, int(wallet_eth) - int(gas_keep_wei))
+
+        # USD conversions
+        def _usd(raw: int, price: float, dec: int) -> float:
+            if raw <= 0 or not price or price <= 0:
+                return 0.0
+            return (raw / (10**dec)) * float(price)
+
+        wallet_usd = (
+            _usd(wallet_eth, eth_price, eth_dec)
+            + _usd(wallet_weth, weth_price, weth_dec)
+            + _usd(wallet_wsteth, wsteth_price, wsteth_dec)
+            + _usd(wallet_usdc, usdc_price, usdc_dec)
+        )
+        supplies_usd = _usd(usdc_supplied, usdc_price, usdc_dec) + _usd(
+            wsteth_supplied, wsteth_price, wsteth_dec
+        )
+        debt_usd = _usd(weth_debt, weth_price, weth_dec)
+
+        net_equity_usd = wallet_usd + supplies_usd - debt_usd
+
+        capacity_usd = cf_u * _usd(usdc_supplied, usdc_price, usdc_dec) + cf_w * _usd(
+            wsteth_supplied, wsteth_price, wsteth_dec
+        )
+        ltv = (
+            (debt_usd / capacity_usd)
+            if (capacity_usd > 0 and debt_usd > 0)
+            else (0.0 if debt_usd <= 0 else float("nan"))
+        )
+        hf = (capacity_usd / debt_usd) if debt_usd > 0 else float("inf")
+
+        totals_usd = {
+            f"Base_{M_USDC}": _usd(usdc_supplied, usdc_price, usdc_dec),
+            f"Base_{M_WSTETH}": _usd(wsteth_supplied, wsteth_price, wsteth_dec),
+            f"Base_{WETH}": -debt_usd,
+        }
+
+        snap = self.AccountingSnapshot(
+            wallet_eth=int(wallet_eth),
+            wallet_weth=int(wallet_weth),
+            wallet_wsteth=int(wallet_wsteth),
+            wallet_usdc=int(wallet_usdc),
+            usdc_supplied=usdc_supplied,
+            wsteth_supplied=wsteth_supplied,
+            weth_debt=weth_debt,
+            eth_price=float(eth_price or 0.0),
+            weth_price=float(weth_price or 0.0),
+            wsteth_price=float(wsteth_price or 0.0),
+            usdc_price=float(usdc_price or 0.0),
+            eth_dec=int(eth_dec or 18),
+            weth_dec=int(weth_dec or 18),
+            wsteth_dec=int(wsteth_dec or 18),
+            usdc_dec=int(usdc_dec or 6),
+            wallet_usd=float(wallet_usd),
+            supplies_usd=float(supplies_usd),
+            debt_usd=float(debt_usd),
+            net_equity_usd=float(net_equity_usd),
+            capacity_usd=float(capacity_usd),
+            ltv=float(ltv),
+            hf=float(hf),
+            gas_keep_wei=gas_keep_wei,
+            eth_usable_wei=eth_usable_wei,
+            totals_usd=totals_usd,
+        )
+        return snap, collateral_factors
+
+    async def _ensure_markets_for_state(
+        self, snap: "MoonwellWstethLoopStrategy.AccountingSnapshot"
+    ) -> tuple[bool, str]:
+        """Idempotently ensure Moonwell markets are entered based on current positions."""
+        errors: list[str] = []
+
+        if snap.usdc_supplied > 0:
+            ok, msg = await self.moonwell_adapter.set_collateral(mtoken=M_USDC)
+            if not ok:
+                errors.append(f"USDC: {msg}")
+
+        if snap.wsteth_supplied > 0:
+            ok, msg = await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+            if not ok:
+                errors.append(f"wstETH: {msg}")
+
+        if snap.weth_debt > 0:
+            ok, msg = await self.moonwell_adapter.set_collateral(mtoken=M_WETH)
+            if not ok:
+                errors.append(f"WETH: {msg}")
+
+        if errors:
+            return (False, "; ".join(errors))
+        return (True, "markets ensured")
+
+    def _debt_gap_report(
+        self, snap: "MoonwellWstethLoopStrategy.AccountingSnapshot"
+    ) -> dict[str, float]:
+        """
+        Mode-agnostic accounting: how much USDC needs to be raised to repay debt.
+        """
+        eth_usable_usd = (
+            (snap.eth_usable_wei / (10**snap.eth_dec)) * snap.eth_price
+            if snap.eth_price
+            else 0.0
+        )
+        repayable_wallet_usd = (
+            (snap.wallet_weth / (10**snap.weth_dec)) * snap.weth_price
+            + (snap.wallet_wsteth / (10**snap.wsteth_dec)) * snap.wsteth_price
+            + (snap.wallet_usdc / (10**snap.usdc_dec)) * snap.usdc_price
+            + eth_usable_usd
+        )
+
+        missing_to_repay_usd = max(0.0, snap.debt_usd - repayable_wallet_usd)
+
+        gas_keep_usd = (
+            (snap.gas_keep_wei / (10**snap.eth_dec)) * snap.eth_price
+            if snap.eth_price
+            else 0.0
+        )
+        expected_final_usdc_usd = max(0.0, snap.net_equity_usd - gas_keep_usd)
+
+        return {
+            "debt_usd": float(snap.debt_usd),
+            "repayable_wallet_usd": float(repayable_wallet_usd),
+            "missing_to_repay_usd": float(missing_to_repay_usd),
+            "net_equity_usd": float(snap.net_equity_usd),
+            "expected_final_usdc_usd_if_fully_unwound": float(expected_final_usdc_usd),
+        }
+
+    def _delta_mismatch_usd(
+        self, snap: "MoonwellWstethLoopStrategy.AccountingSnapshot"
+    ) -> float:
+        """
+        Positive => net SHORT (debt > wstETH collateral) in USD terms.
+        Negative => net LONG (wstETH collateral > debt).
+        """
+        wsteth_coll_usd = float(snap.totals_usd.get(f"Base_{M_WSTETH}", 0.0))
+        return float(snap.debt_usd) - wsteth_coll_usd
+
+    def _max_safe_withdraw_usd(
+        self,
+        *,
+        totals_usd: dict[str, float],
+        withdraw_key: str,
+        collateral_factors: tuple[float, float],
+        hf_floor: float,
+        precision_usd: float = 0.50,
+    ) -> float:
+        """
+        Maximum USD amount of a given collateral you can remove while keeping HF >= hf_floor,
+        considering only the withdrawal step (before the subsequent swap+repay improves HF).
+        """
+        current_val = float(totals_usd.get(withdraw_key, 0.0))
+        if current_val <= 0:
+            return 0.0
+
+        debt_usd = abs(float(totals_usd.get(f"Base_{WETH}", 0.0)))
+        if debt_usd <= 0:
+            return current_val  # if no debt, you can withdraw all
+
+        cf_u, cf_w = collateral_factors
+        usdc_key = f"Base_{M_USDC}"
+        wsteth_key = f"Base_{M_WSTETH}"
+        usdc_coll = float(totals_usd.get(usdc_key, 0.0))
+        wsteth_coll = float(totals_usd.get(wsteth_key, 0.0))
+
+        def hf_after(withdraw_usd: float) -> float:
+            u = usdc_coll - withdraw_usd if withdraw_key == usdc_key else usdc_coll
+            w = (
+                wsteth_coll - withdraw_usd
+                if withdraw_key == wsteth_key
+                else wsteth_coll
+            )
+            u = max(0.0, u)
+            w = max(0.0, w)
+            cap = cf_u * u + cf_w * w
+            return cap / debt_usd if debt_usd > 0 else float("inf")
+
+        lo, hi = 0.0, current_val
+        for _ in range(30):
+            mid = 0.5 * (lo + hi)
+            if hf_after(mid) >= hf_floor:
+                lo = mid
+            else:
+                hi = mid
+            if (hi - lo) <= precision_usd:
+                break
+
+        return max(0.0, lo)
+
+    async def _post_run_guard(
+        self,
+        *,
+        mode: str = "operate",
+        prior_error: Exception | None = None,
+    ) -> tuple[bool, str]:
+        """
+        Always-run finalizer. Attempts to restore:
+          - HF >= MIN_HEALTH_FACTOR
+          - Not net-short ETH (wstETH collateral >= WETH debt, within tolerance)
+
+        mode:
+          - "operate": keep strategy running normally after guard
+          - "exit": conservative (don't buy/lend; only reconcile wallet collateral + delever)
+        """
+        logger.info("-" * 40)
+        logger.info(f"POST-RUN GUARD: mode={mode}")
+        if prior_error:
+            logger.warning(f"  Prior error: {prior_error}")
+        logger.info("-" * 40)
+
+        try:
+            gas = await self._get_gas_balance()
+            if gas < int(self.MAINTENANCE_GAS * 10**18):
+                return (
+                    False,
+                    f"post-run guard: insufficient gas ({gas / 1e18:.6f} ETH)",
+                )
+
+            collateral_factors = await self._get_collateral_factors()
+
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+            ok, msg = await self._ensure_markets_for_state(snap)
+            if not ok:
+                return (False, f"post-run guard: failed ensuring markets: {msg}")
+
+            # 0) Post collateral already in the wallet: lend loose wstETH and ensure collateral.
+            if snap.wallet_wsteth > 0:
+                ok, msg = await self.moonwell_adapter.lend(
+                    mtoken=M_WSTETH,
+                    underlying_token=WSTETH,
+                    amount=int(snap.wallet_wsteth),
+                )
+                if not ok:
+                    return (
+                        False,
+                        f"post-run guard: failed lending wallet wstETH: {msg}",
+                    )
+                ok, msg = await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+                if not ok:
+                    return (
+                        False,
+                        f"post-run guard: failed ensuring wstETH collateral: {msg}",
+                    )
+                snap, _ = await self._accounting_snapshot(
+                    collateral_factors=collateral_factors
+                )
+
+            # 1) HF safety check: deleverage until HF >= MIN_HEALTH_FACTOR.
+            if snap.hf < float(self.MIN_HEALTH_FACTOR):
+                if snap.capacity_usd <= 0:
+                    return (
+                        False,
+                        "post-run guard: HF low but capacity_usd<=0; cannot compute deleverage target",
+                    )
+                try:
+                    ok, msg = await self._settle_weth_debt_to_target_usd(
+                        target_debt_usd=0.0,
+                        target_hf=float(self.MIN_HEALTH_FACTOR),
+                        collateral_factors=collateral_factors,
+                        mode="exit",
+                        max_batch_usd=2500.0,
+                        max_steps=20,
+                    )
+                except SwapOutcomeUnknownError as exc:
+                    return (
+                        False,
+                        f"post-run guard: swap outcome unknown during deleverage: {exc}",
+                    )
+                if not ok:
+                    return (False, f"post-run guard: deleverage failed: {msg}")
+
+                snap, _ = await self._accounting_snapshot(
+                    collateral_factors=collateral_factors
+                )
+
+            # 2) Delta guard: keep ETH delta roughly neutral.
+            # We treat delta mismatch as (debt_usd - wstETH_collateral_usd).
+            tol = max(float(self.DELTA_TOL_USD), float(self.min_withdraw_usd))
+
+            for _ in range(int(self.POST_RUN_MAX_PASSES)):
+                mismatch = self._delta_mismatch_usd(snap)  # + => net short
+                short_usd = max(0.0, float(mismatch))
+                long_usd = max(0.0, float(-mismatch))
+
+                if snap.weth_debt <= 1:
+                    return (True, f"post-run guard: no debt (hf={snap.hf:.3f})")
+
+                if abs(float(mismatch)) <= float(tol):
+                    return (
+                        True,
+                        "post-run guard: delta ok "
+                        f"(short=${short_usd:.2f}, long=${long_usd:.2f}, hf={snap.hf:.3f})",
+                    )
+
+                # Net long: unwind excess wstETH into USDC collateral (operate mode only).
+                if mismatch < -tol:
+                    if mode == "exit":
+                        return (
+                            True,
+                            "post-run guard: delta ok for exit "
+                            f"(short=${short_usd:.2f}, long=${long_usd:.2f}, hf={snap.hf:.3f})",
+                        )
+
+                    unwind_usd = max(0.0, float(long_usd) - float(tol))
+                    try:
+                        ok, msg = await self._reduce_wsteth_long_to_usdc_collateral(
+                            collateral_factors=collateral_factors,
+                            unwind_usd=float(unwind_usd),
+                            hf_floor=float(self.MIN_HEALTH_FACTOR),
+                            max_batch_usd=8000.0,
+                        )
+                        if not ok:
+                            logger.warning(f"post-run guard: long unwind failed: {msg}")
+                        else:
+                            logger.info(f"post-run guard: long unwind: {msg}")
+                    except SwapOutcomeUnknownError as exc:
+                        return (
+                            False,
+                            f"post-run guard: swap outcome unknown during long unwind: {exc}",
+                        )
+
+                    snap, _ = await self._accounting_snapshot(
+                        collateral_factors=collateral_factors
+                    )
+                    continue
+
+                # 2a) Try to fix delta without touching collateral: complete borrow→swap→lend if stuck.
+                if mode != "exit":
+                    try:
+                        ok, msg = await self._reconcile_wallet_into_position(
+                            collateral_factors=collateral_factors,
+                            max_batch_usd=8000.0,
+                        )
+                        if not ok:
+                            logger.warning(f"post-run guard: reconcile failed: {msg}")
+                    except SwapOutcomeUnknownError as exc:
+                        logger.warning(
+                            f"post-run guard: swap outcome unknown during reconcile: {exc}"
+                        )
+
+                    snap, _ = await self._accounting_snapshot(
+                        collateral_factors=collateral_factors
+                    )
+                    mismatch = self._delta_mismatch_usd(snap)
+                    short_usd = max(0.0, float(mismatch))
+                    long_usd = max(0.0, float(-mismatch))
+
+                    if abs(float(mismatch)) <= float(tol):
+                        return (
+                            True,
+                            "post-run guard: delta restored by reconcile "
+                            f"(short=${short_usd:.2f}, long=${long_usd:.2f}, hf={snap.hf:.3f})",
+                        )
+
+                # 2b) Still net short: reduce debt down to what wstETH collateral can cover.
+                wsteth_coll_usd = float(snap.totals_usd.get(f"Base_{M_WSTETH}", 0.0))
+                target_debt_usd = max(0.0, wsteth_coll_usd - 1.0)
+                try:
+                    ok, msg = await self._settle_weth_debt_to_target_usd(
+                        target_debt_usd=float(target_debt_usd),
+                        collateral_factors=collateral_factors,
+                        mode="exit",
+                        max_batch_usd=2500.0,
+                        max_steps=20,
+                    )
+                except SwapOutcomeUnknownError as exc:
+                    return (
+                        False,
+                        f"post-run guard: swap outcome unknown during delta delever: {exc}",
+                    )
+                if not ok:
+                    return (False, f"post-run guard: could not delever to delta: {msg}")
+
+                snap, _ = await self._accounting_snapshot(
+                    collateral_factors=collateral_factors
+                )
+
+            mismatch = self._delta_mismatch_usd(snap)
+            short_usd = max(0.0, float(mismatch))
+            long_usd = max(0.0, float(-mismatch))
+            if mismatch > tol:
+                return (
+                    False,
+                    "post-run guard: exceeded passes; "
+                    f"remaining short=${short_usd:.2f}, long=${long_usd:.2f}, hf={snap.hf:.3f}",
+                )
+            return (
+                True,
+                "post-run guard: exceeded passes; "
+                f"remaining short=${short_usd:.2f}, long=${long_usd:.2f}, hf={snap.hf:.3f}",
+            )
+
+        except Exception as exc:
+            if prior_error is not None:
+                logger.warning(
+                    f"post-run guard crashed after prior error {type(prior_error).__name__}: {prior_error}"
+                )
+            return (False, f"post-run guard crashed: {type(exc).__name__}: {exc}")
+
+    def _target_leverage(
+        self,
+        *,
+        collateral_factors: tuple[float, float],
+        target_hf: float | None = None,
+    ) -> float:
+        """Compute the target leverage multiplier implied by HF + collateral factors.
+
+        In this strategy, leverage is defined as (wstETH_supply_usd / usdc_supply_usd) + 1.
+        """
+        cf_u, cf_w = collateral_factors
+        hf = (
+            float(target_hf)
+            if target_hf is not None
+            else float(self.TARGET_HEALTH_FACTOR)
+        )
+
+        if cf_u <= 0 or hf <= 0:
+            return 0.0
+
+        denominator = float(hf) + 0.001 - float(cf_w)
+        if denominator <= 0:
+            return 0.0
+
+        return float(cf_u) / float(denominator) + 1.0
+
+    async def _delever_wsteth_to_target_leverage(
+        self,
+        *,
+        target_leverage: float,
+        collateral_factors: tuple[float, float],
+        max_over_leverage: float | None = None,
+        max_batch_usd: float = 4000.0,
+        max_steps: int = 10,
+    ) -> tuple[bool, str]:
+        """Reduce leverage by withdrawing wstETH collateral and repaying WETH debt."""
+        band = (
+            float(max_over_leverage)
+            if max_over_leverage is not None
+            else float(self.LEVERAGE_DELEVERAGE_BUFFER)
+        )
+        band = max(0.0, float(band))
+
+        if not target_leverage or float(target_leverage) <= 0:
+            return (True, "Target leverage unavailable; skipping leverage delever")
+
+        addr = self._get_strategy_wallet_address()
+
+        for _step in range(int(max_steps)):
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+
+            usdc_key = f"Base_{M_USDC}"
+            wsteth_key = f"Base_{M_WSTETH}"
+            usdc_lend_value = float(snap.totals_usd.get(usdc_key, 0.0))
+            wsteth_lend_value = float(snap.totals_usd.get(wsteth_key, 0.0))
+
+            if usdc_lend_value <= 0 or wsteth_lend_value <= 0:
+                return (True, "No leveraged wstETH position to delever")
+
+            current_leverage = wsteth_lend_value / usdc_lend_value + 1.0
+            if current_leverage <= float(target_leverage) + float(band):
+                return (
+                    True,
+                    f"Leverage within band. leverage={current_leverage:.2f}x "
+                    f"<= target+buffer={(float(target_leverage) + float(band)):.2f}x",
+                )
+
+            if snap.weth_debt <= 0:
+                return (True, "No WETH debt; nothing to delever")
+
+            if not snap.wsteth_price or snap.wsteth_price <= 0:
+                return (False, "wstETH price unavailable; cannot delever safely")
+
+            target_wsteth_usd = max(
+                0.0, (float(target_leverage) - 1.0) * float(usdc_lend_value)
+            )
+            remaining_usd = max(
+                0.0, float(wsteth_lend_value) - float(target_wsteth_usd)
+            )
+            batch_usd = min(float(max_batch_usd), float(remaining_usd))
+
+            safe_withdraw_usd = self._max_safe_withdraw_usd(
+                totals_usd=snap.totals_usd,
+                withdraw_key=wsteth_key,
+                collateral_factors=collateral_factors,
+                hf_floor=float(self.LEVERAGE_DELEVER_HF_FLOOR),
+            )
+            withdraw_usd = min(float(batch_usd), float(safe_withdraw_usd))
+
+            if withdraw_usd <= max(1.0, float(self.min_withdraw_usd)):
+                return (
+                    False,
+                    "Unable to safely withdraw wstETH collateral to delever "
+                    f"(safe_withdraw_usd=${safe_withdraw_usd:.2f}, remaining_usd=${remaining_usd:.2f}, hf={snap.hf:.3f})",
+                )
+
+            underlying_raw = (
+                int(withdraw_usd / snap.wsteth_price * 10**snap.wsteth_dec) + 1
+            )
+            if underlying_raw <= 0:
+                return (False, "Calculated delever withdrawal amount was 0")
+
+            mw_res = await self.moonwell_adapter.max_withdrawable_mtoken(
+                mtoken=M_WSTETH
+            )
+            if not mw_res[0]:
+                return (
+                    False,
+                    f"Failed to compute max withdrawable wstETH: {mw_res[1]}",
+                )
+            withdraw_info = mw_res[1]
+            if not isinstance(withdraw_info, dict):
+                return (False, f"Bad withdraw info for wstETH: {withdraw_info}")
+
+            mtoken_amt = self._mtoken_amount_for_underlying(
+                withdraw_info, underlying_raw
+            )
+            if mtoken_amt <= 0:
+                return (
+                    False,
+                    "Could not compute a withdrawable mToken amount for delever",
+                )
+
+            ok, unlend_res = await self.moonwell_adapter.unlend(
+                mtoken=M_WSTETH, amount=mtoken_amt
+            )
+            if not ok:
+                return (False, f"Failed to unlend wstETH for delever: {unlend_res}")
+
+            pinned_block = self._pinned_block(unlend_res)
+
+            wallet_wsteth = await self._get_balance_raw(
+                token_id=WSTETH_TOKEN_ID,
+                wallet_address=addr,
+                block_identifier=pinned_block,
+            )
+            amount_to_swap = min(int(wallet_wsteth), int(underlying_raw))
+            if amount_to_swap <= 0:
+                return (
+                    False,
+                    "Delever unlend succeeded but no wstETH observed in wallet "
+                    f"(wallet_wsteth={wallet_wsteth}, pinned_block={pinned_block})",
+                )
+
+            repaid = await self._swap_to_weth_and_repay(
+                WSTETH_TOKEN_ID, amount_to_swap, snap.weth_debt
+            )
+            if repaid <= 0:
+                logger.warning(
+                    "Leverage delever swap->repay failed; re-lending wstETH to restore position"
+                )
+                relend_bal = await self._get_balance_raw(
+                    token_id=WSTETH_TOKEN_ID, wallet_address=addr
+                )
+                if relend_bal > 0:
+                    await self.moonwell_adapter.lend(
+                        mtoken=M_WSTETH, underlying_token=WSTETH, amount=relend_bal
+                    )
+                    await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+
+                return (
+                    False,
+                    "Failed swapping wstETH->WETH and repaying during leverage delever",
+                )
+
+        return (False, f"Exceeded max_steps={max_steps} while deleveraging leverage")
+
+    async def _reconcile_wallet_into_position(
+        self,
+        *,
+        collateral_factors: tuple[float, float],
+        max_batch_usd: float = 5000.0,
+    ) -> tuple[bool, str]:
+        """
+        Operate-mode reconciliation:
+          - Always lend loose wallet wstETH (no swaps).
+          - If there is WETH debt and wstETH collateral is short, use wallet WETH then wallet ETH
+            (above gas reserve) to buy wstETH and lend it.
+        """
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+        addr = self._get_strategy_wallet_address()
+
+        # 1) Lend loose wallet wstETH first
+        if snap.wallet_wsteth > 0:
+            usd_val = (
+                (snap.wallet_wsteth / 10**snap.wsteth_dec) * snap.wsteth_price
+                if snap.wsteth_price
+                else 0.0
+            )
+            if usd_val >= float(self.min_withdraw_usd):
+                ok, msg = await self.moonwell_adapter.lend(
+                    mtoken=M_WSTETH,
+                    underlying_token=WSTETH,
+                    amount=int(snap.wallet_wsteth),
+                )
+                if not ok:
+                    return (False, f"Failed to lend wallet wstETH: {msg}")
+                # Ensure it's collateral (idempotent).
+                await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+
+        # Refresh (cheap) for next decisions
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+
+        if snap.weth_debt <= 0 or not snap.weth_price or snap.weth_price <= 0:
+            logger.info(
+                "  Result: No WETH debt (or missing price); wallet reconciliation done"
+            )
+            return (True, "No WETH debt (or missing price); wallet reconciliation done")
+
+        # 2) How much wstETH collateral are we missing vs debt (delta-neutral intent)
+        wsteth_coll_usd = snap.totals_usd.get(f"Base_{M_WSTETH}", 0.0)
+        deficit_usd = max(0.0, float(snap.debt_usd) - float(wsteth_coll_usd))
+
+        if deficit_usd <= max(1.0, float(self.min_withdraw_usd)):
+            logger.info(
+                "  Result: wstETH collateral roughly matches WETH debt; wallet reconciliation done"
+            )
+            return (
+                True,
+                "wstETH collateral roughly matches WETH debt; wallet reconciliation done",
+            )
+
+        deficit_usd = min(deficit_usd, float(max_batch_usd))
+        needed_weth_raw = (
+            int(deficit_usd / snap.weth_price * 10**snap.weth_dec / (1 - 0.005)) + 1
+        )
+
+        # 3) Use wallet WETH -> wstETH
+        used_any = False
+        if snap.wallet_weth > 0 and needed_weth_raw > 0:
+            amt = min(int(snap.wallet_weth), int(needed_weth_raw))
+            if amt > 0:
+                wsteth_before = await self._get_balance_raw(
+                    token_id=WSTETH_TOKEN_ID, wallet_address=addr
+                )
+                swap_res = await self._swap_with_retries(
+                    from_token_id=WETH_TOKEN_ID,
+                    to_token_id=WSTETH_TOKEN_ID,
+                    amount=amt,
+                    preferred_providers=["aerodrome", "enso"],
+                )
+                if swap_res is None:
+                    return (
+                        False,
+                        "Failed swapping wallet WETH->wstETH during reconciliation",
+                    )
+                pinned_block = self._pinned_block(swap_res)
+                wsteth_after = await self._get_balance_raw(
+                    token_id=WSTETH_TOKEN_ID,
+                    wallet_address=addr,
+                    block_identifier=pinned_block,
+                )
+                got = max(0, int(wsteth_after) - int(wsteth_before))
+                if got > 0:
+                    ok, msg = await self.moonwell_adapter.lend(
+                        mtoken=M_WSTETH, underlying_token=WSTETH, amount=got
+                    )
+                    if not ok:
+                        return (False, f"Failed lending swapped wstETH: {msg}")
+                    await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+                    used_any = True
+
+                needed_weth_raw = max(0, int(needed_weth_raw) - int(amt))
+
+        # 4) Use wallet ETH (above reserve) -> wstETH
+        if needed_weth_raw > 0 and snap.eth_usable_wei > 0:
+            eth_amt = min(int(snap.eth_usable_wei), int(needed_weth_raw))
+            if eth_amt > 0:
+                wsteth_before = await self._get_balance_raw(
+                    token_id=WSTETH_TOKEN_ID, wallet_address=addr
+                )
+                swap_res = await self._swap_with_retries(
+                    from_token_id=ETH_TOKEN_ID,
+                    to_token_id=WSTETH_TOKEN_ID,
+                    amount=eth_amt,
+                    preferred_providers=["aerodrome", "enso"],
+                )
+                if swap_res is None:
+                    return (
+                        False,
+                        "Failed swapping usable wallet ETH->wstETH during reconciliation",
+                    )
+                pinned_block = self._pinned_block(swap_res)
+                wsteth_after = await self._get_balance_raw(
+                    token_id=WSTETH_TOKEN_ID,
+                    wallet_address=addr,
+                    block_identifier=pinned_block,
+                )
+                got = max(0, int(wsteth_after) - int(wsteth_before))
+                if got > 0:
+                    ok, msg = await self.moonwell_adapter.lend(
+                        mtoken=M_WSTETH, underlying_token=WSTETH, amount=got
+                    )
+                    if not ok:
+                        return (False, f"Failed lending swapped wstETH: {msg}")
+                    await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+                    used_any = True
+
+        return (
+            True,
+            "Wallet reconciliation completed"
+            if used_any
+            else "No usable wallet assets to reconcile further",
+        )
+
+    async def _reduce_wsteth_long_to_usdc_collateral(
+        self,
+        *,
+        collateral_factors: tuple[float, float],
+        unwind_usd: float,
+        hf_floor: float,
+        max_batch_usd: float = 8000.0,
+    ) -> tuple[bool, str]:
+        """Reduce net long wstETH exposure by converting mwstETH collateral into mUSDC."""
+        if unwind_usd <= 0:
+            return (True, "No wstETH long to unwind")
+
+        addr = self._get_strategy_wallet_address()
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+
+        if not snap.wsteth_price or snap.wsteth_price <= 0:
+            return (False, "wstETH price unavailable; cannot unwind long safely")
+
+        safe_unlend_usd = self._max_safe_withdraw_usd(
+            totals_usd=snap.totals_usd,
+            withdraw_key=f"Base_{M_WSTETH}",
+            collateral_factors=collateral_factors,
+            hf_floor=float(hf_floor),
+        )
+        desired_usd = min(
+            float(unwind_usd), float(max_batch_usd), float(safe_unlend_usd)
+        )
+
+        min_usd = max(1.0, float(self.min_withdraw_usd))
+        if desired_usd < min_usd:
+            return (
+                True,
+                f"wstETH long unwind not needed/too small (desired=${desired_usd:.2f})",
+            )
+
+        desired_underlying_raw = (
+            int(desired_usd / snap.wsteth_price * 10**snap.wsteth_dec) + 1
+        )
+        if desired_underlying_raw <= 0:
+            return (False, "Computed 0 wstETH to unlend")
+
+        mw_ok, mw_info = await self.moonwell_adapter.max_withdrawable_mtoken(
+            mtoken=M_WSTETH
+        )
+        if not mw_ok or not isinstance(mw_info, dict):
+            return (False, f"Failed to compute withdrawable mwstETH: {mw_info}")
+
+        mtoken_amt = self._mtoken_amount_for_underlying(mw_info, desired_underlying_raw)
+        if mtoken_amt <= 0:
+            return (False, "mwstETH withdrawable amount is 0 (cash/shortfall bound)")
+
+        ok, msg = await self.moonwell_adapter.unlend(mtoken=M_WSTETH, amount=mtoken_amt)
+        if not ok:
+            return (False, f"Failed to redeem mwstETH to unwind long: {msg}")
+
+        pinned_block = self._pinned_block(msg)
+        wsteth_wallet_raw = await self._balance_after_tx(
+            token_id=WSTETH_TOKEN_ID,
+            wallet=addr,
+            pinned_block=pinned_block,
+            min_expected=1,
+            attempts=5,
+        )
+        if wsteth_wallet_raw <= 0 and pinned_block is not None:
+            wsteth_wallet_raw = await self._balance_after_tx(
+                token_id=WSTETH_TOKEN_ID,
+                wallet=addr,
+                pinned_block=None,
+                min_expected=1,
+                attempts=5,
+            )
+
+        amount_to_swap = min(int(wsteth_wallet_raw), int(desired_underlying_raw))
+        if amount_to_swap <= 0:
+            return (False, "No wstETH available in wallet after unlend")
+
+        swap_res = await self._swap_with_retries(
+            from_token_id=WSTETH_TOKEN_ID,
+            to_token_id=USDC_TOKEN_ID,
+            amount=amount_to_swap,
+            preferred_providers=["aerodrome", "enso"],
+        )
+        if swap_res is None:
+            # Restore collateral: re-lend wstETH if the swap fails.
+            restore_amt = await self._get_balance_raw(
+                token_id=WSTETH_TOKEN_ID,
+                wallet_address=addr,
+                block_identifier=pinned_block,
+            )
+            if restore_amt > 0:
+                await self.moonwell_adapter.lend(
+                    mtoken=M_WSTETH,
+                    underlying_token=WSTETH,
+                    amount=restore_amt,
+                )
+                await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+            return (False, "Failed swapping wstETH->USDC while unwinding long")
+
+        # Lend resulting USDC back as collateral (idempotent).
+        usdc_wallet_raw = await self._get_balance_raw(
+            token_id=USDC_TOKEN_ID, wallet_address=addr
+        )
+        if usdc_wallet_raw > 0:
+            lend_ok, lend_msg = await self.moonwell_adapter.lend(
+                mtoken=M_USDC, underlying_token=USDC, amount=int(usdc_wallet_raw)
+            )
+            if not lend_ok:
+                return (
+                    False,
+                    f"wstETH->USDC swap succeeded but lending USDC failed: {lend_msg}",
+                )
+            await self.moonwell_adapter.set_collateral(mtoken=M_USDC)
+
+        return (
+            True,
+            f"Reduced long wstETH by ≈${desired_usd:.2f} via mwstETH->wstETH->USDC->mUSDC",
+        )
+
+    async def _settle_weth_debt_to_target_usd(
+        self,
+        *,
+        target_debt_usd: float,
+        target_hf: float | None = None,
+        collateral_factors: tuple[float, float],
+        mode: str,  # "operate" or "exit"
+        max_batch_usd: float = 4000.0,
+        max_steps: int = 20,
+    ) -> tuple[bool, str]:
+        """
+        Reduce debt until the specified target is met.
+        Uses wallet assets first; if insufficient, redeems collateral in HF-safe batches.
+
+        mode="operate": be conservative about collateral withdrawals (HF floor ~ MIN_HEALTH_FACTOR)
+        mode="exit": allow lower HF floor during the withdraw step (still > 1.05), since repay comes right after.
+        """
+        logger.info(
+            f"SETTLE DEBT: target_debt=${target_debt_usd:.2f}, target_hf={target_hf}, mode={mode}"
+        )
+        addr = self._get_strategy_wallet_address()
+        effective_target_hf = float(target_hf) if target_hf is not None else None
+        if effective_target_hf is not None and effective_target_hf <= 0:
+            effective_target_hf = None
+
+        is_full_exit = (
+            mode == "exit"
+            and float(target_debt_usd) <= 0.0
+            and effective_target_hf is None
+        )
+
+        def _debt_target_usd(
+            snap: "MoonwellWstethLoopStrategy.AccountingSnapshot",
+        ) -> float:
+            if is_full_exit:
+                return 0.0
+            if effective_target_hf is not None:
+                if snap.capacity_usd <= 0:
+                    return 0.0
+                return float(snap.capacity_usd) / float(effective_target_hf)
+            return float(target_debt_usd)
+
+        for step in range(max_steps):
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+
+            if is_full_exit:
+                # Treat 1 wei dust as cleared (repay_full allows <=1 wei remaining).
+                if snap.weth_debt <= 1:
+                    return (
+                        True,
+                        f"Debt settled. debt=${snap.debt_usd:.6f} (weth_debt={snap.weth_debt})",
+                    )
+            elif effective_target_hf is not None:
+                if snap.hf >= effective_target_hf:
+                    return (
+                        True,
+                        f"HF target reached. hf={snap.hf:.3f} >= target={effective_target_hf:.3f}",
+                    )
+            elif snap.debt_usd <= target_debt_usd + 1.0:
+                return (
+                    True,
+                    f"Debt settled to target. debt=${snap.debt_usd:.2f} <= target=${target_debt_usd:.2f}",
+                )
+
+            if not snap.weth_price or snap.weth_price <= 0:
+                return (False, "WETH price unavailable; cannot settle debt safely")
+
+            debt_target_usd = _debt_target_usd(snap)
+            remaining_usd = max(0.0, float(snap.debt_usd) - float(debt_target_usd))
+            if is_full_exit:
+                # For full exit, aim to source a small WETH buffer so repayBorrow(MAX_UINT256)
+                # can fully clear the debt even with minor interest/rounding drift.
+                remaining_usd = snap.debt_usd
+                batch_usd = min(
+                    float(max_batch_usd),
+                    max(
+                        float(remaining_usd) * float(self.FULL_EXIT_BUFFER_MULT),
+                        float(self.FULL_EXIT_MIN_BATCH_USD),
+                    ),
+                )
+            else:
+                batch_usd = min(float(max_batch_usd), float(remaining_usd))
+            batch_weth_raw = int(batch_usd / snap.weth_price * 10**snap.weth_dec) + 1
+
+            progressed = False
+
+            # 1) Wallet WETH -> repay
+            if snap.wallet_weth > 0:
+                repay_amt = min(int(snap.wallet_weth), int(batch_weth_raw))
+                if repay_amt > 0:
+                    repaid = await self._repay_weth(repay_amt, snap.weth_debt)
+                    if repaid > 0:
+                        progressed = True
+                        continue
+
+            # 2) Wallet ETH (above reserve) -> wrap -> repay
+            if snap.eth_usable_wei > 0:
+                wrap_amt = min(int(snap.eth_usable_wei), int(batch_weth_raw))
+                if wrap_amt > 0:
+                    wrap_ok, wrap_msg = await self.moonwell_adapter.wrap_eth(
+                        amount=wrap_amt
+                    )
+                    if wrap_ok:
+                        pinned_block = self._pinned_block(wrap_msg)
+                        weth_now = await self._get_balance_raw(
+                            token_id=WETH_TOKEN_ID,
+                            wallet_address=addr,
+                            block_identifier=pinned_block,
+                        )
+                        if weth_now > 0:
+                            repaid = await self._repay_weth(weth_now, snap.weth_debt)
+                            if repaid > 0:
+                                progressed = True
+                                continue
+                    else:
+                        logger.warning(
+                            f"wrap_eth failed during debt settle: {wrap_msg}"
+                        )
+
+            # 3) Wallet wstETH -> swap -> repay (skip dust)
+            wallet_wsteth_usd = (
+                (snap.wallet_wsteth / (10**snap.wsteth_dec)) * float(snap.wsteth_price)
+                if snap.wsteth_price
+                else 0.0
+            )
+            if (
+                snap.wallet_wsteth > 0
+                and snap.wsteth_price
+                and snap.wsteth_price > 0
+                and wallet_wsteth_usd >= 1.0
+            ):
+                needed_wsteth_usd = batch_usd * 1.02
+                needed_wsteth_raw = (
+                    int(needed_wsteth_usd / snap.wsteth_price * 10**snap.wsteth_dec) + 1
+                )
+                swap_amt = min(int(snap.wallet_wsteth), int(needed_wsteth_raw))
+                if swap_amt > 0:
+                    repaid = await self._swap_to_weth_and_repay(
+                        WSTETH_TOKEN_ID, swap_amt, snap.weth_debt
+                    )
+                    if repaid > 0:
+                        progressed = True
+                        continue
+
+            # 4) Wallet USDC -> swap -> repay (skip dust)
+            wallet_usdc_usd = (
+                (snap.wallet_usdc / (10**snap.usdc_dec)) * float(snap.usdc_price)
+                if snap.usdc_price
+                else 0.0
+            )
+            if (
+                snap.wallet_usdc > 0
+                and snap.usdc_price
+                and snap.usdc_price > 0
+                and wallet_usdc_usd >= 1.0
+            ):
+                needed_usdc_usd = batch_usd * 1.02
+                needed_usdc_raw = (
+                    int(needed_usdc_usd / snap.usdc_price * 10**snap.usdc_dec) + 1
+                )
+                swap_amt = min(int(snap.wallet_usdc), int(needed_usdc_raw))
+                if swap_amt > 0:
+                    repaid = await self._swap_to_weth_and_repay(
+                        USDC_TOKEN_ID, swap_amt, snap.weth_debt
+                    )
+                    if repaid > 0:
+                        progressed = True
+                        continue
+
+            # 5) Need more: redeem collateral in HF-safe batches, then swap -> repay.
+            if mode == "operate":
+                hf_floor = float(self.MIN_HEALTH_FACTOR)
+            elif is_full_exit:
+                # Full unwind can allow HF to dip temporarily during the unlend tx
+                # (swap+repay follows immediately). This reduces the number of small
+                # redeem+swap+repay cycles when HF is just above MIN_HEALTH_FACTOR.
+                hf_floor = float(self.LEVERAGE_DELEVER_HF_FLOOR)
+            else:
+                hf_floor = max(
+                    self.LEVERAGE_DELEVER_HF_FLOOR,
+                    min(
+                        float(self.MIN_HEALTH_FACTOR),
+                        float(snap.hf) - 0.02
+                        if snap.hf != float("inf")
+                        else float(self.MIN_HEALTH_FACTOR),
+                    ),
+                )
+
+            # Choose the collateral source that can actually be withdrawn (HF-safe + cash bound)
+            # in the largest size. This avoids getting stuck redeeming ever-smaller amounts when
+            # a market (often wstETH) is cash-limited.
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+
+            if is_full_exit:
+                if snap.weth_debt <= 1:
+                    logger.info("  Result: Debt fully settled")
+                    return (True, "Debt settled")
+            elif effective_target_hf is not None:
+                if snap.hf >= effective_target_hf:
+                    logger.info(f"  Result: HF target reached (HF={snap.hf:.3f})")
+                    return (True, "HF target reached")
+            elif snap.debt_usd <= target_debt_usd + 1.0:
+                logger.info(
+                    f"  Result: Debt settled to target (debt=${snap.debt_usd:.2f})"
+                )
+                return (True, "Debt settled to target")
+
+            debt_target_usd = _debt_target_usd(snap)
+            remaining_usd = max(0.0, float(snap.debt_usd) - float(debt_target_usd))
+            if is_full_exit:
+                remaining_usd = snap.debt_usd
+                batch_usd = min(
+                    float(max_batch_usd),
+                    max(
+                        float(remaining_usd) * float(self.FULL_EXIT_BUFFER_MULT),
+                        float(self.FULL_EXIT_MIN_BATCH_USD),
+                    ),
+                )
+            else:
+                batch_usd = min(float(max_batch_usd), float(remaining_usd))
+
+            # Withdraw a small extra buffer so the subsequent swap->repay can tolerate slippage,
+            # while still respecting the HF-safe withdrawal bound.
+            slip = float(self.swap_slippage_tolerance)
+            slip = max(0.0, min(slip, float(self.MAX_SLIPPAGE_TOLERANCE)))
+            buffer_factor = 1.0 / (1.0 - slip) if slip < 0.999 else 1.0
+
+            # For full exit, allow smaller redemptions than operate-mode, but skip sub-$1 dust
+            # to avoid spinning on tiny swaps.
+            min_redeem_usd = (
+                1.0 if is_full_exit else max(1.0, float(self.min_withdraw_usd))
+            )
+
+            candidates: list[dict[str, Any]] = []
+            for withdraw_mtoken, withdraw_token_id, withdraw_key in [
+                (M_WSTETH, WSTETH_TOKEN_ID, f"Base_{M_WSTETH}"),
+                (M_USDC, USDC_TOKEN_ID, f"Base_{M_USDC}"),
+            ]:
+                safe_withdraw_usd = self._max_safe_withdraw_usd(
+                    totals_usd=snap.totals_usd,
+                    withdraw_key=withdraw_key,
+                    collateral_factors=collateral_factors,
+                    hf_floor=hf_floor,
+                )
+
+                desired_withdraw_usd = min(
+                    float(batch_usd) * buffer_factor, float(safe_withdraw_usd)
+                )
+                if desired_withdraw_usd <= float(min_redeem_usd):
+                    continue
+
+                if withdraw_token_id == WSTETH_TOKEN_ID:
+                    price = float(snap.wsteth_price)
+                    dec = int(snap.wsteth_dec)
+                else:
+                    price = float(snap.usdc_price)
+                    dec = int(snap.usdc_dec)
+
+                if not price or price <= 0:
+                    continue
+
+                desired_underlying_raw = int(desired_withdraw_usd / price * 10**dec) + 1
+                if desired_underlying_raw <= 0:
+                    continue
+
+                mw_ok, mw_info = await self.moonwell_adapter.max_withdrawable_mtoken(
+                    mtoken=withdraw_mtoken
+                )
+                if not mw_ok or not isinstance(mw_info, dict):
+                    continue
+
+                max_underlying_raw = int(mw_info.get("underlying_raw", 0) or 0)
+                if max_underlying_raw <= 0:
+                    continue
+
+                expected_underlying_raw = min(
+                    int(desired_underlying_raw), max_underlying_raw
+                )
+                expected_usd = (expected_underlying_raw / (10**dec)) * price
+                if expected_usd <= float(min_redeem_usd):
+                    continue
+
+                mtoken_amt = self._mtoken_amount_for_underlying(
+                    mw_info, int(desired_underlying_raw)
+                )
+                if mtoken_amt <= 0:
+                    continue
+
+                candidates.append(
+                    {
+                        "expected_usd": float(expected_usd),
+                        "safe_withdraw_usd": float(safe_withdraw_usd),
+                        "cash_bound_usd": float(
+                            (max_underlying_raw / (10**dec)) * price
+                        ),
+                        "withdraw_mtoken": withdraw_mtoken,
+                        "withdraw_token_id": withdraw_token_id,
+                        "underlying_raw": int(desired_underlying_raw),
+                        "mtoken_amt": int(mtoken_amt),
+                    }
+                )
+
+            if not candidates:
+                logger.warning(
+                    "Debt settle: no HF-safe withdrawable collateral found "
+                    f"(batch=${float(batch_usd):.2f}, hf_floor={float(hf_floor):.2f})"
+                )
+
+            candidates.sort(key=lambda c: float(c["expected_usd"]), reverse=True)
+
+            for chosen in candidates:
+                withdraw_mtoken = str(chosen["withdraw_mtoken"])
+                withdraw_token_id = str(chosen["withdraw_token_id"])
+                underlying_raw = int(chosen["underlying_raw"])
+                mtoken_amt = int(chosen["mtoken_amt"])
+
+                logger.info(
+                    f"Debt settle: redeem {withdraw_token_id} "
+                    f"(expected≈${float(chosen['expected_usd']):.2f}, "
+                    f"safe=${float(chosen['safe_withdraw_usd']):.2f}, "
+                    f"cash≤${float(chosen['cash_bound_usd']):.2f}, "
+                    f"batch=${float(batch_usd):.2f}, hf_floor={float(hf_floor):.2f})"
+                )
+
+                ok, msg = await self.moonwell_adapter.unlend(
+                    mtoken=withdraw_mtoken, amount=mtoken_amt
+                )
+                if not ok:
+                    logger.warning(f"unlend failed for {withdraw_mtoken}: {msg}")
+                    continue
+
+                pinned_block = self._pinned_block(msg)
+                wallet_underlying = await self._balance_after_tx(
+                    token_id=withdraw_token_id,
+                    wallet=addr,
+                    pinned_block=pinned_block,
+                    min_expected=1,
+                    attempts=5,
+                )
+                if wallet_underlying <= 0 and pinned_block is not None:
+                    wallet_underlying = await self._balance_after_tx(
+                        token_id=withdraw_token_id,
+                        wallet=addr,
+                        pinned_block=None,
+                        min_expected=1,
+                        attempts=5,
+                    )
+
+                amount_to_swap = min(int(wallet_underlying), int(underlying_raw))
+                if amount_to_swap <= 0:
+                    continue
+
+                repaid = await self._swap_to_weth_and_repay(
+                    withdraw_token_id, amount_to_swap, snap.weth_debt
+                )
+                if repaid > 0:
+                    progressed = True
+                    break
+
+                # Swap failed: restore collateral to avoid leaving risk worsened.
+                logger.warning(
+                    f"swap->repay failed after unlend ({withdraw_token_id}); re-lending to restore"
+                )
+                relend_bal = await self._get_balance_raw(
+                    token_id=withdraw_token_id,
+                    wallet_address=addr,
+                )
+                if relend_bal > 0:
+                    underlying_addr = WSTETH if withdraw_mtoken == M_WSTETH else USDC
+                    await self.moonwell_adapter.lend(
+                        mtoken=withdraw_mtoken,
+                        underlying_token=underlying_addr,
+                        amount=relend_bal,
+                    )
+                    if withdraw_mtoken == M_WSTETH:
+                        await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
+
+            if progressed:
+                continue
+
+            gap = self._debt_gap_report(snap)
+            return (
+                False,
+                f"Could not progress debt settlement (step={step + 1}/{max_steps}). Gap report: {gap}",
+            )
+
+        return (False, f"Exceeded max_steps={max_steps} while settling debt")
+
     async def setup(self):
         """Initialize token info and validate configuration."""
         if self.token_adapter is None:
@@ -369,6 +1713,24 @@ class MoonwellWstethLoopStrategy(Strategy):
         if base_slippage is None:
             base_slippage = self.swap_slippage_tolerance
 
+        # Get token info for logging
+        from_decimals = (
+            18 if from_token_id in (ETH_TOKEN_ID, WETH_TOKEN_ID, WSTETH_TOKEN_ID) else 6
+        )
+        from_symbol = (
+            from_token_id.split("-")[0].upper()
+            if "-" in from_token_id
+            else from_token_id[-6:].upper()
+        )
+        to_symbol = (
+            to_token_id.split("-")[0].upper()
+            if "-" in to_token_id
+            else to_token_id[-6:].upper()
+        )
+        logger.info(
+            f"SWAP: {amount / 10**from_decimals:.6f} {from_symbol} → {to_symbol}"
+        )
+
         last_error: Exception | None = None
         strategy_address = self._get_strategy_wallet_address()
 
@@ -378,16 +1740,26 @@ class MoonwellWstethLoopStrategy(Strategy):
                 token_id=from_token_id,
                 wallet_address=strategy_address,
             )
+            logger.debug(
+                f"  Balance check: {from_symbol} wallet={wallet_balance / 10**from_decimals:.6f}"
+            )
             if from_token_id == ETH_TOKEN_ID:
-                reserve = int(self.WRAP_GAS_RESERVE * 10**18)
+                reserve = int(self._gas_keep_wei())
                 wallet_balance = max(0, wallet_balance - reserve)
+                logger.debug(
+                    f"  After gas reserve: {wallet_balance / 10**from_decimals:.6f}"
+                )
+            if int(amount) > wallet_balance:
+                logger.info(
+                    f"  Adjusting amount from {amount / 10**from_decimals:.6f} to {wallet_balance / 10**from_decimals:.6f} (wallet limit)"
+                )
             amount = min(int(amount), wallet_balance)
         except Exception as exc:
             logger.warning(f"Failed to check swap balance for {from_token_id}: {exc}")
 
         if amount <= 0:
             logger.warning(
-                f"Swap skipped: no available balance for {from_token_id} (post-reserve)"
+                f"Swap skipped: no available balance for {from_symbol} (post-reserve)"
             )
             return None
 
@@ -412,6 +1784,22 @@ class MoonwellWstethLoopStrategy(Strategy):
         for i in range(max_retries):
             # Cap slippage at MAX_SLIPPAGE_TOLERANCE to prevent MEV attacks
             slippage = min(base_slippage * (i + 1), self.MAX_SLIPPAGE_TOLERANCE)
+
+            # On the final retry, try a different provider ordering to avoid getting stuck
+            # on a single provider/route that may be intermittently broken.
+            attempt_providers = preferred_providers
+            if i == max_retries - 1:
+                if preferred_providers:
+                    # Rotate preference order (e.g., [a, b] -> [b, a]) to encourage a different route.
+                    attempt_providers = (
+                        preferred_providers[1:] + preferred_providers[:1]
+                        if len(preferred_providers) > 1
+                        else None
+                    )
+                else:
+                    # If the caller didn't specify providers, try a last-resort preference order.
+                    attempt_providers = ["enso", "aerodrome", "lifi"]
+
             try:
                 success, result = await self.brap_adapter.swap_from_token_ids(
                     from_token_id=from_token_id,
@@ -419,7 +1807,7 @@ class MoonwellWstethLoopStrategy(Strategy):
                     from_address=strategy_address,
                     amount=str(amount),
                     slippage=slippage,
-                    preferred_providers=preferred_providers,
+                    preferred_providers=attempt_providers,
                 )
                 if success and result:
                     logger.info(
@@ -437,7 +1825,8 @@ class MoonwellWstethLoopStrategy(Strategy):
 
                 last_error = Exception(str(result))
                 logger.warning(
-                    f"Swap attempt {i + 1}/{max_retries} returned unsuccessful: {result}"
+                    f"Swap attempt {i + 1}/{max_retries} (providers={attempt_providers}) "
+                    f"returned unsuccessful: {result}"
                 )
             except SwapOutcomeUnknownError:
                 raise
@@ -446,8 +1835,8 @@ class MoonwellWstethLoopStrategy(Strategy):
                     raise SwapOutcomeUnknownError(str(e)) from e
                 last_error = e
                 logger.warning(
-                    f"Swap attempt {i + 1}/{max_retries} failed with slippage "
-                    f"{slippage * 100:.1f}%: {e}"
+                    f"Swap attempt {i + 1}/{max_retries} (providers={attempt_providers}) "
+                    f"failed with slippage {slippage * 100:.1f}%: {e}"
                 )
             if i < max_retries - 1:
                 # Exponential backoff: 1s, 2s, 4s
@@ -533,15 +1922,59 @@ class MoonwellWstethLoopStrategy(Strategy):
             )
             return 0
 
-        try:
-            ok, bal = await self.balance_adapter.get_balance(
-                token_id=token_id,
-                wallet_address=wallet_address,
-            )
-            return int(bal) if ok else 0
-        except Exception as exc:
-            logger.warning(f"On-chain balance read failed for {token_id}: {exc}")
-            return 0
+        block_id = block_identifier if block_identifier is not None else "latest"
+        max_retries = 3
+        last_error: Exception | None = None
+
+        for attempt in range(max_retries):
+            w3 = None
+            try:
+                w3 = self.web3_service.get_web3(BASE_CHAIN_ID)
+
+                if token_id == ETH_TOKEN_ID:
+                    bal = await w3.eth.get_balance(
+                        to_checksum_address(wallet_address),
+                        block_identifier=block_id,
+                    )
+                    return int(bal)
+
+                contract = w3.eth.contract(
+                    address=to_checksum_address(str(token_address)),
+                    abi=ERC20_ABI,
+                )
+                bal = await contract.functions.balanceOf(
+                    to_checksum_address(wallet_address)
+                ).call(block_identifier=block_id)
+                return int(bal)
+            except Exception as exc:
+                last_error = exc if isinstance(exc, Exception) else Exception(str(exc))
+                err = str(exc)
+                if ("429" in err or "Too Many Requests" in err) and attempt < (
+                    max_retries - 1
+                ):
+                    # Backoff: 1s, 2s
+                    await asyncio.sleep(2**attempt)
+                    continue
+                logger.warning(
+                    f"On-chain balance read failed for {token_id} at block {block_id}: {exc}"
+                )
+                return 0
+            finally:
+                if w3 is not None:
+                    try:
+                        close_web3 = getattr(
+                            self.web3_service.evm_transactions, "_close_web3", None
+                        )
+                        if close_web3 is not None:
+                            await close_web3(w3)
+                    except Exception:
+                        pass
+
+        logger.warning(
+            f"On-chain balance read failed after {max_retries} attempts for {token_id} "
+            f"at block {block_id}: {last_error}"
+        )
+        return 0
 
     def _normalize_usd_value(self, raw: Any) -> float:
         """Normalize a USD value that may be 18-decimal scaled (Compound/Moonwell style).
@@ -586,593 +2019,149 @@ class MoonwellWstethLoopStrategy(Strategy):
             ) // exchange_rate_raw
         else:
             try:
-                cf = float(conversion_factor)
-            except (TypeError, ValueError):
-                cf = 0.0
-            ctokens_needed = (
-                int(cf * int(underlying_raw)) + 1 if cf > 0 else max_ctokens
-            )
-
-        return min(int(ctokens_needed), max_ctokens)
-
-    async def _get_gas_balance(self) -> int:
-        """Get ETH balance in strategy wallet (raw wei)."""
-        return await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
-        )
-
-    async def _get_usdc_balance(self) -> int:
-        """Get USDC balance in strategy wallet (raw wei)."""
-        return await self._get_balance_raw(
-            token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
-        )
-
-    async def _validate_gas_balance(self) -> tuple[bool, str]:
-        """Validate gas balance meets minimum requirements."""
-        gas_balance = await self._get_gas_balance()
-        main_gas = await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=self._get_main_wallet_address()
-        )
-        total_gas = gas_balance + main_gas
-
-        if total_gas < int(self.MIN_GAS * 10**18):
-            return (
-                False,
-                f"Need at least {self.MIN_GAS} Base ETH for gas. You have: {total_gas / 10**18:.6f}",
-            )
-        return (True, "Gas balance validated")
-
-    async def _validate_usdc_deposit(
-        self, usdc_amount: float
-    ) -> tuple[bool, str, float]:
-        """Validate USDC deposit amount."""
-        actual_balance = await self._get_balance_raw(
-            token_id=USDC_TOKEN_ID, wallet_address=self._get_main_wallet_address()
-        )
-
-        token_info = await self._get_token_info(USDC_TOKEN_ID)
-        decimals = token_info.get("decimals", 6)
-        available_usdc = actual_balance / (10**decimals)
-
-        usdc_amount = min(usdc_amount, available_usdc)
-
-        if usdc_amount < self.MIN_USDC_DEPOSIT:
-            return (
-                False,
-                f"Minimum deposit is {self.MIN_USDC_DEPOSIT} USDC. Available: {available_usdc:.2f}",
-                usdc_amount,
-            )
-        return (True, "USDC deposit amount validated", usdc_amount)
-
-    async def _check_quote_profitability(self) -> tuple[bool, str]:
-        """Check if the quote APY is profitable."""
-        quote = await self.quote()
-        if quote.get("apy", 0) < 0:
-            return (
-                False,
-                "APYs and ratios are not profitable at the moment, aborting deposit",
-            )
-        return (True, "Quote is profitable")
-
-    async def _transfer_usdc_to_vault(self, usdc_amount: float) -> tuple[bool, str]:
-        """Transfer USDC from main wallet to vault wallet."""
-        (
-            success,
-            msg,
-        ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-            USDC_TOKEN_ID, usdc_amount
-        )
-        if not success:
-            return (False, f"Depositing USDC into vault wallet failed: {msg}")
-        return (True, "USDC transferred to vault")
-
-    async def _transfer_gas_to_vault(self) -> tuple[bool, str]:
-        """Transfer gas from main wallet to vault if needed."""
-        vault_gas = await self._get_gas_balance()
-        if vault_gas < int(self.MIN_GAS * 10**18):
-            needed_gas = self.MIN_GAS - vault_gas / 10**18
-            (
-                success,
-                msg,
-            ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                ETH_TOKEN_ID, needed_gas
-            )
-            if not success:
-                return (False, f"Depositing gas into strategy wallet failed: {msg}")
-        return (True, "Gas transferred to strategy")
-
-    async def _balance_weth_debt(self) -> tuple[bool, str]:
-        """Balance WETH debt if it exceeds wstETH collateral for delta-neutrality."""
-        # Get wstETH position (can be zero; missing collateral is a common recovery case)
-        wsteth_underlying = 0
-        wsteth_pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WSTETH)
-        if wsteth_pos_result[0] and isinstance(wsteth_pos_result[1], dict):
-            wsteth_pos = wsteth_pos_result[1]
-            wsteth_underlying = int(wsteth_pos.get("underlying_balance", 0) or 0)
-        else:
-            # Treat as 0 collateral and proceed conservatively (we still may have WETH debt).
-            logger.warning(
-                f"Failed to fetch wstETH position; treating as 0 for debt balancing: {wsteth_pos_result[1]}"
-            )
-
-        # Get WETH debt value
-        weth_pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
-        if not weth_pos_result[0]:
-            return (True, "No WETH debt to balance")
-
-        weth_pos = weth_pos_result[1]
-        weth_debt = weth_pos.get("borrow_balance", 0)
-
-        if weth_debt == 0:
-            return (True, "No WETH debt to balance")
-
-        # Get prices and decimals
-        weth_price, weth_decimals = await self._get_token_data(WETH_TOKEN_ID)
-        if not weth_price or weth_price <= 0:
-            return (False, "WETH price unavailable; cannot balance debt safely")
-
-        wsteth_price, wsteth_decimals = await self._get_token_data(WSTETH_TOKEN_ID)
-        if wsteth_underlying > 0 and (not wsteth_price or wsteth_price <= 0):
-            return (False, "wstETH price unavailable; cannot balance debt safely")
-        # If wstETH collateral is zero, we don't need wstETH price to proceed.
-        wsteth_price = float(wsteth_price or 0.0)
-
-        wsteth_value = (wsteth_underlying / 10**wsteth_decimals) * wsteth_price
-        weth_debt_value = (weth_debt / 10**weth_decimals) * weth_price
-
-        # Check if we're imbalanced (debt > collateral)
-        excess_debt_value = weth_debt_value - wsteth_value
-        if excess_debt_value <= 0:
-            return (True, "WETH debt is balanced with wstETH collateral")
-
-        logger.warning(
-            f"WETH debt exceeds wstETH collateral by ${excess_debt_value:.2f}. Rebalancing..."
-        )
-
-        excess_debt_wei = int(excess_debt_value / weth_price * 10**weth_decimals)
-        repaid = 0
-
-        # Step 1: Try using wallet WETH
-        wallet_weth = await self._get_balance_raw(
-            token_id=WETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
-        )
-        if wallet_weth > 0:
-            repay_amt = min(wallet_weth, excess_debt_wei - repaid)
-            success, _ = await self.moonwell_adapter.repay(
-                mtoken=M_WETH,
-                underlying_token=WETH,
-                amount=repay_amt,
-            )
-            if success:
-                repaid += repay_amt
-                logger.info(f"Repaid {repay_amt / 10**18:.6f} WETH from wallet")
-
-        if repaid >= excess_debt_wei:
-            return (
-                True,
-                f"Balanced debt by repaying {repaid / 10**18:.6f} WETH from wallet",
-            )
-
-        # Step 2: Try wrapping wallet ETH → WETH and repaying (within gas reserve)
-        wallet_eth = await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
-        )
-        gas_reserve = int(self.WRAP_GAS_RESERVE * 10**18)
-        usable_eth = max(0, wallet_eth - gas_reserve)
-        if usable_eth > 0:
-            wrap_amt = min(usable_eth, excess_debt_wei - repaid)
-            try:
-                wrap_success, wrap_msg = await self.moonwell_adapter.wrap_eth(
-                    amount=wrap_amt
-                )
-                if not wrap_success:
-                    logger.warning(f"Failed to wrap ETH for repayment: {wrap_msg}")
-                else:
-                    weth_after = await self._get_balance_raw(
-                        token_id=WETH_TOKEN_ID,
-                        wallet_address=self._get_strategy_wallet_address(),
-                    )
-                    repay_amt = min(weth_after, excess_debt_wei - repaid)
-                    if repay_amt > 0:
-                        repay_success, _ = await self.moonwell_adapter.repay(
-                            mtoken=M_WETH,
-                            underlying_token=WETH,
-                            amount=repay_amt,
-                        )
-                        if repay_success:
-                            repaid += repay_amt
-                            logger.info(
-                                f"Wrapped and repaid {repay_amt / 10**18:.6f} ETH (as WETH)"
-                            )
-
-                # Try topping up gas back to MIN_GAS if we dipped below it (non-critical).
-                topup_success, topup_msg = await self._transfer_gas_to_vault()
-                if not topup_success:
-                    logger.warning(f"Gas top-up failed (non-critical): {topup_msg}")
-            except Exception as e:
-                logger.warning(f"Failed to wrap ETH and repay: {e}")
-
-        if repaid >= excess_debt_wei:
-            return (True, f"Balanced debt by repaying {repaid / 10**18:.6f} WETH")
-
-        # Step 3: Try swapping wallet USDC to WETH and repaying
-        remaining_to_repay = excess_debt_wei - repaid
-        remaining_value = (remaining_to_repay / 10**weth_decimals) * weth_price
-
-        wallet_usdc = await self._get_balance_raw(
-            token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
-        )
-        if wallet_usdc > 0 and remaining_to_repay > 0:
-            usdc_price, usdc_decimals = await self._get_token_data(USDC_TOKEN_ID)
-            wallet_usdc_value = (wallet_usdc / 10**usdc_decimals) * usdc_price
-
-            if wallet_usdc_value >= self.min_withdraw_usd:
-                # Swap enough USDC to cover remaining debt (with 2% buffer)
-                needed_usdc_value = min(remaining_value * 1.02, wallet_usdc_value)
-                needed_usdc = int(needed_usdc_value / usdc_price * 10**usdc_decimals)
-                amount_to_swap = min(needed_usdc, wallet_usdc)
-                try:
-                    swap_result = await self._swap_with_retries(
-                        from_token_id=USDC_TOKEN_ID,
-                        to_token_id=WETH_TOKEN_ID,
-                        amount=amount_to_swap,
-                    )
-                    if swap_result:
-                        # Use actual post-swap WETH balance to avoid relying on quoted to_amount.
-                        weth_after = await self._get_balance_raw(
-                            token_id=WETH_TOKEN_ID,
-                            wallet_address=self._get_strategy_wallet_address(),
-                        )
-                        repay_amt = min(weth_after, excess_debt_wei - repaid)
-                        if repay_amt > 0:
-                            success, _ = await self.moonwell_adapter.repay(
-                                mtoken=M_WETH,
-                                underlying_token=WETH,
-                                amount=repay_amt,
-                            )
-                            if success:
-                                repaid += repay_amt
-                                logger.info(
-                                    f"Swapped wallet USDC and repaid {repay_amt / 10**18:.6f} WETH"
-                                )
-                except SwapOutcomeUnknownError as exc:
-                    return (
-                        False,
-                        f"Swap outcome unknown while swapping wallet USDC for repayment: {exc}",
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to swap wallet USDC for repayment: {e}")
-
-        if repaid >= excess_debt_wei:
-            return (True, f"Balanced debt by repaying {repaid / 10**18:.6f} WETH")
-
-        # Step 4: Unlend USDC collateral, swap to WETH, and repay
-        remaining_to_repay = excess_debt_wei - repaid
-        remaining_value = (remaining_to_repay / 10**weth_decimals) * weth_price
-
-        usdc_withdraw_result = await self.moonwell_adapter.max_withdrawable_mtoken(
-            mtoken=M_USDC
-        )
-        if usdc_withdraw_result[0]:
-            withdraw_info = usdc_withdraw_result[1]
-            underlying_raw = withdraw_info.get("underlying_raw", 0)
-
-            usdc_price, usdc_decimals = await self._get_token_data(USDC_TOKEN_ID)
-            usdc_value = (underlying_raw / 10**usdc_decimals) * usdc_price
-
-            if usdc_value > self.min_withdraw_usd:
-                # Calculate how much USDC to unlock
-                needed_usdc_value = min(remaining_value * 1.02, usdc_value)  # 2% buffer
-                needed_usdc = int(needed_usdc_value / usdc_price * 10**usdc_decimals)
-                mtoken_amt = self._mtoken_amount_for_underlying(
-                    withdraw_info, needed_usdc
-                )
-
-                try:
-                    success, _ = await self.moonwell_adapter.unlend(
-                        mtoken=M_USDC, amount=mtoken_amt
-                    )
-                    if success:
-                        # Swap only what we actually have in-wallet (avoid balance-based reverts).
-                        wallet_usdc_after = await self._get_balance_raw(
-                            token_id=USDC_TOKEN_ID,
-                            wallet_address=self._get_strategy_wallet_address(),
-                        )
-                        amount_to_swap = min(wallet_usdc_after, needed_usdc)
-                        if amount_to_swap <= 0:
-                            raise Exception("No USDC available to swap after unlending")
-                        # Swap USDC to WETH
-                        swap_result = await self._swap_with_retries(
-                            from_token_id=USDC_TOKEN_ID,
-                            to_token_id=WETH_TOKEN_ID,
-                            amount=amount_to_swap,
-                        )
-                        if swap_result:
-                            weth_after = await self._get_balance_raw(
-                                token_id=WETH_TOKEN_ID,
-                                wallet_address=self._get_strategy_wallet_address(),
-                            )
-                            repay_amt = min(weth_after, excess_debt_wei - repaid)
-                            if repay_amt > 0:
-                                repay_success, _ = await self.moonwell_adapter.repay(
-                                    mtoken=M_WETH,
-                                    underlying_token=WETH,
-                                    amount=repay_amt,
-                                )
-                                if repay_success:
-                                    repaid += repay_amt
-                                    logger.info(
-                                        f"Unlent USDC, swapped and repaid {repay_amt / 10**18:.6f} WETH"
-                                    )
-                except SwapOutcomeUnknownError as exc:
-                    return (
-                        False,
-                        f"Swap outcome unknown while unlocking USDC for repayment: {exc}",
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to unlock USDC and swap for repayment: {e}")
-
-        if repaid >= excess_debt_wei * 0.95:  # Allow 5% tolerance
-            return (True, f"Balanced debt by repaying {repaid / 10**18:.6f} WETH")
-
-        return (
-            False,
-            f"Could only repay {repaid / 10**18:.6f} of {excess_debt_wei / 10**18:.6f} excess WETH debt",
-        )
-
-    async def _complete_unpaired_weth_borrow(self) -> tuple[bool, str]:
-        """If we have WETH debt but insufficient wstETH collateral, try to complete the loop.
-
-        This is the common "failed swap" recovery state:
-        - Debt exists on Moonwell (borrowed WETH),
-        - wstETH collateral is missing/low,
-        - The borrowed value is still sitting in the wallet as WETH and/or native ETH.
-
-        We prefer swapping wallet WETH → wstETH and lending it (to restore the intended position)
-        before considering debt repayment.
-        """
-        # Read positions
-        wsteth_pos_result, weth_pos_result = await asyncio.gather(
-            self.moonwell_adapter.get_pos(mtoken=M_WSTETH),
-            self.moonwell_adapter.get_pos(mtoken=M_WETH),
-        )
-        if not weth_pos_result[0]:
-            return (True, "No WETH debt to complete")
-
-        weth_debt = int((weth_pos_result[1] or {}).get("borrow_balance", 0) or 0)
-        if weth_debt <= 0:
-            return (True, "No WETH debt to complete")
-
-        wsteth_underlying = 0
-        if wsteth_pos_result[0]:
-            wsteth_underlying = int(
-                (wsteth_pos_result[1] or {}).get("underlying_balance", 0) or 0
-            )
-
-        # Determine whether we're meaningfully unpaired.
-        # Prefer price-based comparison, but allow a strict fallback for the common case:
-        # wstETH collateral is literally 0 after a failed swap.
-        wsteth_price, wsteth_decimals = await self._get_token_data(WSTETH_TOKEN_ID)
-        weth_price, weth_decimals = await self._get_token_data(WETH_TOKEN_ID)
-
-        deficit_usd: float | None = None
-        if wsteth_price and wsteth_price > 0 and weth_price and weth_price > 0:
-            wsteth_value = (wsteth_underlying / 10**wsteth_decimals) * wsteth_price
-            weth_debt_value = (weth_debt / 10**weth_decimals) * weth_price
-            deficit_usd = weth_debt_value - wsteth_value
-
-            # Small deficits are just rounding; ignore.
-            if deficit_usd <= max(1.0, float(self.min_withdraw_usd)):
-                return (True, "wstETH collateral already roughly matches WETH debt")
-        elif wsteth_underlying > 0:
-            # If we already have some wstETH collateral but cannot price it, don't guess.
-            return (True, "Price unavailable; skipping unpaired borrow completion")
-
-        strategy_address = self._get_strategy_wallet_address()
-
-        # Check for loose wstETH first - lend it before swapping anything
-        wallet_wsteth = await self._get_balance_raw(
-            token_id=WSTETH_TOKEN_ID, wallet_address=strategy_address
-        )
-        if wallet_wsteth > 0:
-            logger.info(
-                f"Found {wallet_wsteth / 10**18:.6f} loose wstETH in wallet, lending first"
-            )
-            lend_success, lend_msg = await self.moonwell_adapter.lend(
-                mtoken=M_WSTETH,
-                underlying_token=WSTETH,
-                amount=int(wallet_wsteth),
-            )
-            if lend_success:
-                # Recalculate deficit after lending
-                wsteth_pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WSTETH)
-                if wsteth_pos_result[0]:
-                    wsteth_underlying = int(
-                        (wsteth_pos_result[1] or {}).get("underlying_balance", 0) or 0
-                    )
-                    if (
-                        wsteth_price
-                        and wsteth_price > 0
-                        and weth_price
-                        and weth_price > 0
-                    ):
-                        wsteth_value = (
-                            wsteth_underlying / 10**wsteth_decimals
-                        ) * wsteth_price
-                        weth_debt_value = (weth_debt / 10**weth_decimals) * weth_price
-                        deficit_usd = weth_debt_value - wsteth_value
-                        if deficit_usd <= max(1.0, float(self.min_withdraw_usd)):
-                            return (
-                                True,
-                                "Loose wstETH lent; collateral now matches debt",
-                            )
-            else:
-                logger.warning(f"Failed to lend loose wstETH: {lend_msg}")
-
-        wallet_weth = await self._get_balance_raw(
-            token_id=WETH_TOKEN_ID, wallet_address=strategy_address
-        )
-        wallet_eth = await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=strategy_address
-        )
-
-        gas_reserve = int(self.WRAP_GAS_RESERVE * 10**18)
-        usable_eth = max(0, wallet_eth - gas_reserve)
-
-        # Target WETH input needed.
-        # If we couldn't price, fall back to swapping up to the debt amount when collateral is 0.
-        if deficit_usd is None:
-            target_weth_in = int(weth_debt)
-        else:
-            # Add 0.5% buffer for slippage/fees, but never exceed debt.
-            target_weth_in = (
-                int(deficit_usd / weth_price * 10**weth_decimals / (1 - 0.005)) + 1
+                cf = float(conversion_factor)
+            except (TypeError, ValueError):
+                cf = 0.0
+            ctokens_needed = (
+                int(cf * int(underlying_raw)) + 1 if cf > 0 else max_ctokens
             )
-            target_weth_in = min(int(target_weth_in), int(weth_debt))
 
-        available_weth_like = int(wallet_weth) + int(usable_eth)
-        if available_weth_like <= 0:
-            return (False, "No wallet WETH/ETH available to complete the loop")
+        return min(int(ctokens_needed), max_ctokens)
 
-        amount_to_source = min(int(target_weth_in), int(available_weth_like))
-        if amount_to_source <= 0:
-            return (True, "No meaningful WETH amount available to swap to wstETH")
+    def _pinned_block(self, tx_result: Any) -> int | None:
+        """Extract a deterministic pinned block number from an adapter tx result (best-effort)."""
+        if not isinstance(tx_result, dict):
+            return None
 
-        wsteth_before = await self._get_balance_raw(
-            token_id=WSTETH_TOKEN_ID, wallet_address=strategy_address
+        receipt = tx_result.get("receipt") or {}
+        receipt_block = (
+            receipt.get("blockNumber") if isinstance(receipt, dict) else None
         )
 
-        remaining = int(amount_to_source)
-
-        # Swap wallet WETH first (ERC20 path).
-        # Prefer enso/aerodrome for WETH→wstETH - LiFi gets bad fills
-        weth_to_swap = min(int(wallet_weth), int(remaining))
-        if weth_to_swap > 0:
-            swap_res = await self._swap_with_retries(
-                from_token_id=WETH_TOKEN_ID,
-                to_token_id=WSTETH_TOKEN_ID,
-                amount=weth_to_swap,
-                preferred_providers=["aerodrome", "enso"],
-            )
-            if swap_res is None:
-                logger.warning(
-                    "WETH→wstETH swap failed during unpaired borrow completion"
-                )
-            remaining -= int(weth_to_swap)
-
-        # Then swap native ETH (borrowed WETH often arrives as ETH on Base in practice).
-        # Prefer enso/aerodrome for ETH→wstETH - LiFi gets bad fills
-        eth_to_swap = min(int(usable_eth), int(remaining))
-        if eth_to_swap > 0:
-            swap_res = await self._swap_with_retries(
-                from_token_id=ETH_TOKEN_ID,
-                to_token_id=WSTETH_TOKEN_ID,
-                amount=eth_to_swap,
-                preferred_providers=["aerodrome", "enso"],
-            )
-            if swap_res is None:
-                logger.warning(
-                    "ETH→wstETH swap failed during unpaired borrow completion"
-                )
-
-        wsteth_after = await self._get_balance_raw(
-            token_id=WSTETH_TOKEN_ID, wallet_address=strategy_address
+        return (
+            tx_result.get("confirmed_block_number")
+            or tx_result.get("block_number")
+            or receipt_block
         )
-        received = max(0, int(wsteth_after) - int(wsteth_before))
-        if received <= 0:
-            return (
-                False,
-                "Swap to wstETH produced no wstETH; will fall back to debt balancing",
-            )
 
-        success, msg = await self.moonwell_adapter.lend(
-            mtoken=M_WSTETH,
-            underlying_token=WSTETH,
-            amount=received,
-        )
-        if not success:
-            return (False, f"Lending wstETH failed: {msg}")
+    async def _balance_after_tx(
+        self,
+        *,
+        token_id: str,
+        wallet: str,
+        pinned_block: int | None,
+        min_expected: int = 1,
+        attempts: int = 5,
+    ) -> int:
+        """Read a balance at a pinned block, retrying briefly to avoid RPC indexing lag."""
+        bal = 0
+        for i in range(int(attempts)):
+            bal = await self._get_balance_raw(
+                token_id=token_id,
+                wallet_address=wallet,
+                block_identifier=pinned_block,
+            )
+            if bal >= int(min_expected):
+                return int(bal)
+            await asyncio.sleep(1 + i)
+        return int(bal)
 
-        await self.moonwell_adapter.set_collateral(mtoken=M_WSTETH)
-        return (
-            True,
-            f"Completed unpaired borrow by lending {received / 10**18:.6f} wstETH",
+    async def _get_gas_balance(self) -> int:
+        """Get ETH balance in strategy wallet (raw wei)."""
+        return await self._get_balance_raw(
+            token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
 
-    async def _convert_excess_eth_to_usdc(self) -> tuple[bool, str]:
-        """Convert excess native ETH (above MIN_GAS) into USDC to be redeployed."""
-        strategy_address = self._get_strategy_wallet_address()
-        eth_bal = await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=strategy_address
+    async def _get_usdc_balance(self) -> int:
+        """Get USDC balance in strategy wallet (raw wei)."""
+        return await self._get_balance_raw(
+            token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
 
-        keep_wei = int(self.MIN_GAS * 10**18)
-        excess = int(eth_bal) - int(keep_wei)
-        # Avoid dust conversions; 0.001 ETH is already plenty of gas on Base.
-        min_excess = int(0.001 * 10**18)
-        if excess <= min_excess:
-            return (True, "No excess ETH to convert")
-
-        # Wrap excess ETH to WETH (so swaps are ERC20-based and allowance-friendly).
-        weth_before = await self._get_balance_raw(
-            token_id=WETH_TOKEN_ID, wallet_address=strategy_address
+    async def _validate_gas_balance(self) -> tuple[bool, str]:
+        """Validate gas balance meets minimum requirements."""
+        gas_balance = await self._get_gas_balance()
+        main_gas = await self._get_balance_raw(
+            token_id=ETH_TOKEN_ID, wallet_address=self._get_main_wallet_address()
         )
-        wrap_success, wrap_msg = await self.moonwell_adapter.wrap_eth(amount=excess)
-        if not wrap_success:
-            return (False, f"Wrap ETH→WETH failed: {wrap_msg}")
+        total_gas = gas_balance + main_gas
 
-        weth_after = await self._get_balance_raw(
-            token_id=WETH_TOKEN_ID, wallet_address=strategy_address
-        )
-        wrapped = max(0, int(weth_after) - int(weth_before))
-        if wrapped <= 0:
-            return (False, "ETH→WETH wrap produced no WETH")
+        min_gas_wei = int(self._gas_keep_wei())
+        if total_gas < min_gas_wei:
+            return (
+                False,
+                f"Need at least {min_gas_wei / 10**18:.4f} Base ETH for gas. "
+                f"You have: {total_gas / 10**18:.6f}",
+            )
+        return (True, "Gas balance validated")
 
-        swap_result = await self._swap_with_retries(
-            from_token_id=WETH_TOKEN_ID,
-            to_token_id=USDC_TOKEN_ID,
-            amount=wrapped,
+    async def _validate_usdc_deposit(
+        self, usdc_amount: float
+    ) -> tuple[bool, str, float]:
+        """Validate USDC deposit amount."""
+        actual_balance = await self._get_balance_raw(
+            token_id=USDC_TOKEN_ID, wallet_address=self._get_main_wallet_address()
         )
-        if swap_result is None:
-            return (False, "WETH→USDC swap failed when converting excess ETH")
 
-        return (True, "Converted excess ETH to USDC")
+        token_info = await self._get_token_info(USDC_TOKEN_ID)
+        decimals = token_info.get("decimals", 6)
+        available_usdc = actual_balance / (10**decimals)
 
-    async def _convert_spot_wsteth_to_usdc(self) -> tuple[bool, str]:
-        """Convert wallet (spot) wstETH into USDC so it can be redeployed.
+        usdc_amount = min(usdc_amount, available_usdc)
 
-        This never touches native ETH, so it cannot drain gas.
-        """
-        strategy_address = self._get_strategy_wallet_address()
-        wsteth_raw = await self._get_balance_raw(
-            token_id=WSTETH_TOKEN_ID, wallet_address=strategy_address
-        )
-        if wsteth_raw <= 0:
-            return (True, "No wallet wstETH to convert")
+        if usdc_amount < self.MIN_USDC_DEPOSIT:
+            return (
+                False,
+                f"Minimum deposit is {self.MIN_USDC_DEPOSIT} USDC. Available: {available_usdc:.2f}",
+                usdc_amount,
+            )
+        return (True, "USDC deposit amount validated", usdc_amount)
 
-        # Avoid dust conversions.
-        wsteth_price, wsteth_decimals = await self._get_token_data(WSTETH_TOKEN_ID)
-        if not wsteth_price or wsteth_price <= 0:
-            return (True, "wstETH price unavailable; skipping wallet wstETH conversion")
-        usd_value = (wsteth_raw / 10**wsteth_decimals) * wsteth_price
-        if usd_value < float(self.min_withdraw_usd):
-            return (True, "Wallet wstETH below threshold; skipping conversion")
+    async def _check_quote_profitability(self) -> tuple[bool, str]:
+        """Check if the quote APY is profitable."""
+        quote = await self.quote()
+        if quote.get("apy", 0) < 0:
+            return (
+                False,
+                "APYs and ratios are not profitable at the moment, aborting deposit",
+            )
+        return (True, "Quote is profitable")
 
-        swap_result = await self._swap_with_retries(
-            from_token_id=WSTETH_TOKEN_ID,
-            to_token_id=USDC_TOKEN_ID,
-            amount=int(wsteth_raw),
+    async def _transfer_usdc_to_vault(self, usdc_amount: float) -> tuple[bool, str]:
+        """Transfer USDC from main wallet to vault wallet."""
+        (
+            success,
+            msg,
+        ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
+            USDC_TOKEN_ID, usdc_amount
         )
-        if swap_result is None:
-            return (False, "wstETH→USDC swap failed")
+        if not success:
+            return (False, f"Depositing USDC into vault wallet failed: {msg}")
+        return (True, "USDC transferred to vault")
 
-        return (True, f"Converted wallet wstETH (~${usd_value:.2f}) to USDC")
+    async def _transfer_gas_to_vault(self) -> tuple[bool, str]:
+        """Transfer gas from main wallet to vault if needed."""
+        vault_gas = await self._get_gas_balance()
+        min_gas_wei = int(self._gas_keep_wei())
+        if vault_gas < min_gas_wei:
+            needed_gas = (min_gas_wei - vault_gas) / 10**18
+            (
+                success,
+                msg,
+            ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
+                ETH_TOKEN_ID, needed_gas
+            )
+            if not success:
+                return (False, f"Depositing gas into strategy wallet failed: {msg}")
+        return (True, "Gas transferred to strategy")
 
     async def _sweep_token_balances(
         self,
         target_token_id: str,
         exclude: set[str] | None = None,
         min_usd_value: float = 1.0,
+        *,
+        strict: bool = False,
     ) -> tuple[bool, str]:
         """Sweep miscellaneous tokens above min_usd_value to target token."""
         if exclude is None:
@@ -1215,7 +2204,16 @@ class MoonwellWstethLoopStrategy(Strategy):
                         f"Swept {balance / 10**decimals:.6f} {token_id} "
                         f"(${usd_value:.2f}) to {target_token_id}"
                     )
+                else:
+                    msg = f"Failed to sweep {token_id} to {target_token_id}"
+                    logger.warning(msg)
+                    if strict:
+                        return (False, msg)
+            except SwapOutcomeUnknownError:
+                raise
             except Exception as e:
+                if strict:
+                    return (False, f"Failed to sweep {token_id}: {e}")
                 logger.warning(f"Failed to sweep {token_id}: {e}")
 
         if swept_count == 0:
@@ -1223,6 +2221,83 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         return (True, f"Swept {swept_count} tokens totaling ${total_swept_usd:.2f}")
 
+    async def _claim_and_reinvest_rewards(self) -> tuple[bool, str]:
+        """Claim WELL rewards, swap to USDC, and lend directly to mUSDC (no leverage).
+
+        This deposits rewards as unleveraged USDC collateral rather than running
+        them through the leverage loop, preserving the strategy's debt ratio.
+        """
+        # Claim rewards if above threshold
+        claimed_ok, claimed = await self.moonwell_adapter.claim_rewards(
+            min_rewards_usd=self.MIN_REWARD_CLAIM_USD
+        )
+        if not claimed_ok:
+            logger.warning(f"Failed to claim rewards: {claimed}")
+            return (True, "Reward claim failed, skipping reinvestment")
+
+        # Check if we actually got rewards (claimed is dict of token -> amount)
+        if not claimed or not isinstance(claimed, dict):
+            return (True, "No rewards to reinvest")
+
+        # Check WELL balance in wallet
+        well_balance = await self._get_balance_raw(
+            token_id=WELL_TOKEN_ID,
+            wallet_address=self._get_strategy_wallet_address(),
+        )
+        if well_balance <= 0:
+            return (True, "No WELL balance to reinvest")
+
+        # Get WELL price and check value
+        well_price, well_decimals = await self._get_token_data(WELL_TOKEN_ID)
+        well_value_usd = (well_balance / 10**well_decimals) * well_price
+
+        if well_value_usd < self.MIN_REWARD_CLAIM_USD:
+            logger.debug(
+                f"WELL balance ${well_value_usd:.2f} below threshold, skipping swap"
+            )
+            return (True, f"WELL value ${well_value_usd:.2f} below threshold")
+
+        # Swap WELL → USDC
+        logger.info(
+            f"Swapping {well_balance / 10**well_decimals:.4f} WELL "
+            f"(${well_value_usd:.2f}) to USDC"
+        )
+        try:
+            swap_result = await self._swap_with_retries(
+                from_token_id=WELL_TOKEN_ID,
+                to_token_id=USDC_TOKEN_ID,
+                amount=well_balance,
+            )
+            if not swap_result:
+                logger.warning("Failed to swap WELL to USDC")
+                return (True, "WELL swap failed, rewards left in wallet")
+        except Exception as e:
+            logger.warning(f"WELL swap error: {e}")
+            return (True, f"WELL swap error: {e}")
+
+        # Get resulting USDC balance to lend
+        usdc_balance = await self._get_balance_raw(
+            token_id=USDC_TOKEN_ID,
+            wallet_address=self._get_strategy_wallet_address(),
+        )
+        if usdc_balance <= 0:
+            return (True, "No USDC from reward swap")
+
+        usdc_decimals = 6
+        usdc_amount = usdc_balance / 10**usdc_decimals
+
+        # Lend USDC directly to mUSDC (no leverage loop)
+        logger.info(f"Lending {usdc_amount:.2f} USDC from rewards to mUSDC")
+        lend_ok, lend_msg = await self.moonwell_adapter.lend(
+            mtoken=M_USDC,
+            amount=usdc_balance,
+        )
+        if not lend_ok:
+            logger.warning(f"Failed to lend reward USDC: {lend_msg}")
+            return (True, f"Reward USDC lend failed: {lend_msg}")
+
+        return (True, f"Reinvested ${usdc_amount:.2f} USDC from WELL rewards")
+
     async def deposit(
         self, main_token_amount: float = 0.0, gas_token_amount: float = 0.0
     ) -> StatusTuple:
@@ -1261,8 +2336,10 @@ class MoonwellWstethLoopStrategy(Strategy):
         if not success:
             return (False, message)
 
-        # Execute the leverage loop via update
-        return await self.update()
+        return (
+            True,
+            f"Deposited {usdc_amount:.2f} USDC to strategy wallet. Call update() to deploy funds to Moonwell.",
+        )
 
     async def _get_collateral_factors(self) -> tuple[float, float]:
         """Fetch both collateral factors (USDC and wstETH), using adapter cache.
@@ -1279,170 +2356,30 @@ class MoonwellWstethLoopStrategy(Strategy):
 
     async def _get_current_leverage(
         self,
-        positions: tuple[dict, dict] | None = None,
+        snap: Optional["MoonwellWstethLoopStrategy.AccountingSnapshot"] = None,
+        collateral_factors: tuple[float, float] | None = None,
     ) -> tuple[float, float, float]:
         """Returns (usdc_lend_value, wsteth_lend_value, current_leverage).
 
         Args:
-            positions: Optional (total_bals, total_usd_bals) from _aggregate_positions().
-                       If provided, skips position fetches.
-        """
-        # Use provided positions or fetch them
-        if positions is not None:
-            _total_bals, totals_usd = positions
-            usdc_key = f"Base_{M_USDC}"
-            wsteth_key = f"Base_{M_WSTETH}"
-            usdc_lend_value = float(totals_usd.get(usdc_key, 0.0))
-            wsteth_lend_value = float(totals_usd.get(wsteth_key, 0.0))
-        else:
-            wsteth_result = await self.moonwell_adapter.get_pos(mtoken=M_WSTETH)
-            usdc_result = await self.moonwell_adapter.get_pos(mtoken=M_USDC)
-
-            # Get prices/decimals
-            wsteth_price, wsteth_decimals = await self._get_token_data(WSTETH_TOKEN_ID)
-            usdc_price, usdc_decimals = await self._get_token_data(USDC_TOKEN_ID)
-
-            # Calculate wstETH lend value (may not exist yet)
-            wsteth_lend_value = 0.0
-            if wsteth_result[0]:
-                wsteth_pos = wsteth_result[1]
-                wsteth_underlying = wsteth_pos.get("underlying_balance", 0)
-                wsteth_lend_value = (
-                    wsteth_underlying / 10**wsteth_decimals
-                ) * wsteth_price
-
-            # Calculate USDC lend value
-            usdc_lend_value = 0.0
-            if usdc_result[0]:
-                usdc_pos = usdc_result[1]
-                usdc_underlying = usdc_pos.get("underlying_balance", 0)
-                usdc_lend_value = (usdc_underlying / 10**usdc_decimals) * usdc_price
-
-        initial_leverage = (
-            wsteth_lend_value / usdc_lend_value + 1 if usdc_lend_value else 0
-        )
-
-        return (usdc_lend_value, wsteth_lend_value, initial_leverage)
-
-    async def _aggregate_positions(self) -> tuple[dict, dict]:
-        """Aggregate positions from all Moonwell markets. Returns (total_bals, total_usd_bals).
-
-        Note: Position fetches are done sequentially to avoid overwhelming public RPCs
-        with too many parallel requests (each get_pos makes 5 RPC calls).
-        """
-        mtoken_list = [M_USDC, M_WETH, M_WSTETH]
-        underlying_list = [USDC, WETH, WSTETH]
-
-        # Sequential fetch for positions with delays to avoid rate limiting on public RPCs
-        # Each get_pos makes 5 sequential RPC calls; adding delays between positions
-        # helps the rate limiter recover (Base public RPC has aggressive limits)
-        positions = []
-        for mtoken in mtoken_list:
-            pos = await self.moonwell_adapter.get_pos(mtoken=mtoken)
-            positions.append(pos)
-            # 2s delay between positions for public RPC
-            await asyncio.sleep(2.0)
-
-        # Token data can be fetched in parallel (uses cache, minimal RPC)
-        token_data = await asyncio.gather(
-            self._get_token_data(USDC_TOKEN_ID),
-            self._get_token_data(WETH_TOKEN_ID),
-            self._get_token_data(WSTETH_TOKEN_ID),
-        )
-
-        total_bals: dict[str, float] = {}
-        total_usd_bals: dict[str, float] = {}
-
-        for i, mtoken in enumerate(mtoken_list):
-            success, pos = positions[i]
-            if not success:
-                logger.warning(f"get_pos failed for {mtoken}: {pos}")
-                continue
-
-            price, decimals = token_data[i]
-            underlying_addr = underlying_list[i]
-
-            underlying_bal = pos.get("underlying_balance", 0)
-            borrow_bal = pos.get("borrow_balance", 0)
-
-            key_mtoken = f"Base_{mtoken}"
-            key_underlying = f"Base_{underlying_addr}"
-
-            # Store underlying as positive if lent
-            if underlying_bal > 0:
-                total_bals[key_mtoken] = underlying_bal
-                total_usd_bals[key_mtoken] = (underlying_bal / 10**decimals) * price
-
-            # Store borrow as negative
-            if borrow_bal > 0:
-                total_bals[key_underlying] = -borrow_bal
-                total_usd_bals[key_underlying] = -(borrow_bal / 10**decimals) * price
-
-        return total_bals, total_usd_bals
-
-    async def compute_ltv(
-        self,
-        total_usd_bals: dict,
-        collateral_factors: tuple[float, float] | None = None,
-    ) -> float:
-        """Compute loan-to-value ratio.
-
-        LTV = Debt / (cf_u * C_u + cf_s * C_s)
-
-        Args:
-            total_usd_bals: USD balances from _aggregate_positions().
-            collateral_factors: Optional (cf_usdc, cf_wsteth) tuple.
-                                If provided, skips collateral factor fetches.
+            snap: Optional accounting snapshot. If provided, skips snapshot fetches.
+            collateral_factors: Optional (cf_usdc, cf_wsteth) tuple; only used if `snap` is None.
         """
-        # Get debt (WETH borrow)
-        weth_key = f"Base_{WETH}"
-        debt_usd = abs(float(total_usd_bals.get(weth_key, 0.0)))
+        if snap is None:
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
 
-        # Get collateral values
         usdc_key = f"Base_{M_USDC}"
         wsteth_key = f"Base_{M_WSTETH}"
-        usdc_collateral = float(total_usd_bals.get(usdc_key, 0.0))
-        wsteth_collateral = float(total_usd_bals.get(wsteth_key, 0.0))
-
-        # Use provided collateral factors or fetch them
-        if collateral_factors is not None:
-            cf_u, cf_s = collateral_factors
-        else:
-            cf_u, cf_s = await self._get_collateral_factors()
-
-        capacity = cf_u * usdc_collateral + cf_s * wsteth_collateral
+        usdc_lend_value = float(snap.totals_usd.get(usdc_key, 0.0))
+        wsteth_lend_value = float(snap.totals_usd.get(wsteth_key, 0.0))
 
-        if capacity <= 0:
-            return float("nan")
-
-        return debt_usd / capacity
+        initial_leverage = (
+            wsteth_lend_value / usdc_lend_value + 1 if usdc_lend_value else 0.0
+        )
 
-    async def _can_withdraw_token(
-        self,
-        total_usd_bals: dict[str, float],
-        withdraw_token_id: str,
-        withdraw_token_usd_val: float,
-        *,
-        collateral_factors: tuple[float, float] | None = None,
-    ) -> bool:
-        """Simulate withdrawing collateral and check resulting HF stays >= MIN_HEALTH_FACTOR."""
-        current_val = float(total_usd_bals.get(withdraw_token_id, 0.0))
-        if withdraw_token_usd_val <= 0:
-            return True
-        if withdraw_token_usd_val > current_val:
-            return False
-
-        simulated_bals = dict(total_usd_bals)
-        simulated_bals[withdraw_token_id] = current_val - withdraw_token_usd_val
-
-        new_ltv = await self.compute_ltv(simulated_bals, collateral_factors)
-        if new_ltv == 0:
-            return True
-        if not new_ltv or new_ltv != new_ltv:
-            return False
-
-        new_hf = 1.0 / new_ltv
-        return new_hf >= self.MIN_HEALTH_FACTOR
+        return (usdc_lend_value, wsteth_lend_value, initial_leverage)
 
     async def _get_steth_apy(self) -> float | None:
         """Fetch wstETH APY from Lido API."""
@@ -1495,7 +2432,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             return {"apy": 0, "information": "Invalid collateral factor", "data": {}}
 
         # Calculate target borrow and leverage
-        denominator = self.MIN_HEALTH_FACTOR - cf_w
+        denominator = self.TARGET_HEALTH_FACTOR - cf_w
         if denominator <= 0:
             return {"apy": 0, "information": "Invalid health factor params", "data": {}}
         target_borrow = cf_u / denominator
@@ -1539,54 +2476,41 @@ class MoonwellWstethLoopStrategy(Strategy):
         if not success:
             raise Exception(f"Borrow failed: {borrow_result}")
 
-        # Extract block number from transaction result for block-pinned reads
-        tx_block: int | None = None
-        if isinstance(borrow_result, dict):
-            tx_block = borrow_result.get("block_number") or (
-                borrow_result.get("receipt", {}).get("blockNumber")
-            )
+        # Extract a deterministic pinned block number from the transaction result.
+        # On Base we wait +2 blocks by default; `confirmed_block_number` is safe to pin reads to.
+        pinned_block = self._pinned_block(borrow_result)
 
         logger.info(
             f"Borrowed {safe_borrow_amt / 10**18:.6f} WETH (may arrive as ETH) "
-            f"in block {tx_block}"
+            f"(pinned block {pinned_block})"
         )
 
         # Use block-pinned reads to check balances at the transaction's block
         # This avoids stale reads from RPC indexing lag on L2s like Base
+        eth_after = int(eth_before)
+        weth_after = int(weth_before)
         eth_delta = 0
         weth_delta = 0
-        eth_after = 0
-        weth_after = 0
         for attempt in range(5):
-            if attempt > 0:
-                # Exponential backoff: 1, 2, 4, 8 seconds
-                await asyncio.sleep(2 ** (attempt - 1))
-
-            # Read at the specific block where the borrow occurred
             eth_after, weth_after = await asyncio.gather(
                 self._get_balance_raw(
                     token_id=ETH_TOKEN_ID,
                     wallet_address=strategy_address,
-                    block_identifier=tx_block,
+                    block_identifier=pinned_block,
                 ),
                 self._get_balance_raw(
                     token_id=WETH_TOKEN_ID,
                     wallet_address=strategy_address,
-                    block_identifier=tx_block,
+                    block_identifier=pinned_block,
                 ),
             )
-
             eth_delta = max(0, int(eth_after) - int(eth_before))
             weth_delta = max(0, int(weth_after) - int(weth_before))
-
             if eth_delta > 0 or weth_delta > 0:
                 break
-            logger.debug(
-                f"Balance check attempt {attempt + 1} at block {tx_block}: "
-                f"no delta detected yet, retrying..."
-            )
+            await asyncio.sleep(1 + attempt)
 
-        gas_reserve = int(self.WRAP_GAS_RESERVE * 10**18)
+        gas_reserve = int(self._gas_keep_wei())
         # Usable ETH is the minimum of what we received (eth_delta) and what's available after gas reserve
         usable_eth = min(eth_delta, max(0, int(eth_after) - gas_reserve))
 
@@ -1667,7 +2591,7 @@ class MoonwellWstethLoopStrategy(Strategy):
                     eth_bal = await self._get_balance_raw(
                         token_id=ETH_TOKEN_ID, wallet_address=strategy_address
                     )
-                    gas_reserve = int(self.WRAP_GAS_RESERVE * 10**18)
+                    gas_reserve = int(self._gas_keep_wei())
                     available_for_wrap = max(0, eth_bal - gas_reserve)
                     shortfall = safe_borrow_amt - weth_bal
                     wrap_amt = min(shortfall, available_for_wrap)
@@ -1861,8 +2785,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
         """Create USDC liquidity in the strategy wallet by safely redeeming collateral."""
-        self._clear_price_cache()
-
         if usd_value <= 0:
             raise ValueError(f"usd_value must be positive, got {usd_value}")
 
@@ -1882,108 +2804,93 @@ class MoonwellWstethLoopStrategy(Strategy):
                 f"Partial liquidation not needed. Available: {available:.2f} USDC",
             )
 
-        missing = usd_value - current_usdc
+        missing_usd = float(usd_value - current_usdc)
 
-        # (2) Fetch Moonwell positions and collateral factors
-        (_totals_token, total_usd_bals), collateral_factors = await asyncio.gather(
-            self._aggregate_positions(),
-            self._get_collateral_factors(),
-        )
+        collateral_factors = await self._get_collateral_factors()
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
 
         key_wsteth = f"Base_{M_WSTETH}"
-        key_weth = f"Base_{WETH}"
         key_usdc = f"Base_{M_USDC}"
 
-        wsteth_usd = float(total_usd_bals.get(key_wsteth, 0.0))
-        weth_debt_usd = abs(float(total_usd_bals.get(key_weth, 0.0)))
+        wsteth_usd = float(snap.totals_usd.get(key_wsteth, 0.0))
+        weth_debt_usd = float(snap.debt_usd)
 
-        # (2a) If wstETH collateral exceeds WETH debt, redeem some wstETH and swap to USDC
-        if missing > 0 and wsteth_usd > weth_debt_usd:
-            unlend_usd = min(missing, wsteth_usd - weth_debt_usd)
-            if await self._can_withdraw_token(
-                total_usd_bals,
-                key_wsteth,
-                unlend_usd,
+        # (2a) Prefer withdrawing wstETH first if we're meaningfully long (collateral > debt).
+        if missing_usd > 0 and wsteth_usd > weth_debt_usd:
+            max_delta_unwind = max(0.0, wsteth_usd - weth_debt_usd)
+            desired_unlend_usd = min(float(missing_usd), float(max_delta_unwind))
+
+            safe_unlend_usd = self._max_safe_withdraw_usd(
+                totals_usd=snap.totals_usd,
+                withdraw_key=key_wsteth,
                 collateral_factors=collateral_factors,
-            ):
-                wsteth_price = await self._get_token_price(WSTETH_TOKEN_ID)
-                if not wsteth_price or wsteth_price <= 0:
+                hf_floor=float(self.MIN_HEALTH_FACTOR),
+            )
+            unlend_usd = min(float(desired_unlend_usd), float(safe_unlend_usd))
+
+            if unlend_usd >= float(self.min_withdraw_usd):
+                if not snap.wsteth_price or snap.wsteth_price <= 0:
                     return (False, "Invalid wstETH price")
 
-                wsteth_info = await self._get_token_info(WSTETH_TOKEN_ID)
-                wsteth_decimals = wsteth_info.get("decimals", 18)
+                unlend_underlying_raw = (
+                    int(unlend_usd / snap.wsteth_price * 10**snap.wsteth_dec) + 1
+                )
 
-                token_qty = unlend_usd / wsteth_price
-                unlend_underlying_raw = int(token_qty * (10**wsteth_decimals))
+                mwsteth_res = await self.moonwell_adapter.max_withdrawable_mtoken(
+                    mtoken=M_WSTETH
+                )
+                if not mwsteth_res[0]:
+                    return (
+                        False,
+                        f"Failed to compute withdrawable mwstETH: {mwsteth_res[1]}",
+                    )
+                withdraw_info = mwsteth_res[1]
+                if not isinstance(withdraw_info, dict):
+                    return (False, f"Bad withdraw info for mwstETH: {withdraw_info}")
 
-                if unlend_underlying_raw > 0:
-                    mwsteth_res = await self.moonwell_adapter.max_withdrawable_mtoken(
-                        mtoken=M_WSTETH
+                mtoken_amt = self._mtoken_amount_for_underlying(
+                    withdraw_info, unlend_underlying_raw
+                )
+                if mtoken_amt > 0:
+                    success, msg = await self.moonwell_adapter.unlend(
+                        mtoken=M_WSTETH, amount=mtoken_amt
                     )
-                    if mwsteth_res[0]:
-                        withdraw_info = mwsteth_res[1]
-                        max_ctokens = int(withdraw_info.get("cTokens_raw", 0))
-                        exchange_rate_raw = int(
-                            withdraw_info.get("exchangeRate_raw", 0)
-                        )
-                        conversion_factor = float(
-                            withdraw_info.get("conversion_factor", 0) or 0
+                    if not success:
+                        return (
+                            False,
+                            f"Failed to redeem mwstETH for partial liquidation: {msg}",
                         )
 
-                        if max_ctokens > 0:
-                            if exchange_rate_raw > 0:
-                                # underlying = cTokens * exchangeRate / 1e18
-                                ctokens_needed = (
-                                    unlend_underlying_raw * 10**18
-                                    + exchange_rate_raw
-                                    - 1
-                                ) // exchange_rate_raw
-                            elif conversion_factor > 0:
-                                ctokens_needed = (
-                                    int(conversion_factor * unlend_underlying_raw) + 1
-                                )
-                            else:
-                                ctokens_needed = max_ctokens
-
-                            ctokens_to_redeem = min(int(ctokens_needed), max_ctokens)
-                            if ctokens_to_redeem > 0:
-                                success, msg = await self.moonwell_adapter.unlend(
-                                    mtoken=M_WSTETH, amount=ctokens_to_redeem
-                                )
-                                if not success:
-                                    return (
-                                        False,
-                                        f"Failed to redeem mwstETH for partial liquidation: {msg}",
-                                    )
-
-                                # Swap withdrawn wstETH → USDC
-                                wsteth_wallet_raw = await self._get_balance_raw(
-                                    token_id=WSTETH_TOKEN_ID,
-                                    wallet_address=strategy_address,
+                    pinned_block = self._pinned_block(msg)
+                    wsteth_wallet_raw = await self._balance_after_tx(
+                        token_id=WSTETH_TOKEN_ID,
+                        wallet=strategy_address,
+                        pinned_block=pinned_block,
+                        min_expected=1,
+                        attempts=5,
+                    )
+                    amount_to_swap = min(
+                        int(wsteth_wallet_raw), int(unlend_underlying_raw)
+                    )
+                    if amount_to_swap > 0:
+                        swap_res = await self._swap_with_retries(
+                            from_token_id=WSTETH_TOKEN_ID,
+                            to_token_id=USDC_TOKEN_ID,
+                            amount=amount_to_swap,
+                        )
+                        if swap_res is None:
+                            restore_amt = min(
+                                int(wsteth_wallet_raw), int(amount_to_swap)
+                            )
+                            if restore_amt > 0:
+                                await self.moonwell_adapter.lend(
+                                    mtoken=M_WSTETH,
+                                    underlying_token=WSTETH,
+                                    amount=restore_amt,
                                 )
-                                amount_to_swap = min(
-                                    wsteth_wallet_raw, unlend_underlying_raw
+                                await self.moonwell_adapter.set_collateral(
+                                    mtoken=M_WSTETH
                                 )
-                                if amount_to_swap > 0:
-                                    swap_res = await self._swap_with_retries(
-                                        from_token_id=WSTETH_TOKEN_ID,
-                                        to_token_id=USDC_TOKEN_ID,
-                                        amount=amount_to_swap,
-                                    )
-                                    if swap_res is None:
-                                        # Restore collateral if swap fails
-                                        restore_amt = min(
-                                            amount_to_swap, wsteth_wallet_raw
-                                        )
-                                        if restore_amt > 0:
-                                            await self.moonwell_adapter.lend(
-                                                mtoken=M_WSTETH,
-                                                underlying_token=WSTETH,
-                                                amount=restore_amt,
-                                            )
-                                            await self.moonwell_adapter.set_collateral(
-                                                mtoken=M_WSTETH
-                                            )
 
         # (3) Re-check wallet USDC balance
         usdc_raw = await self._get_balance_raw(
@@ -1993,63 +2900,62 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         # (4) If still short, redeem USDC collateral directly
         if current_usdc < usd_value:
-            # Refresh Moonwell balances after any prior redemptions/swaps.
-            (_totals_token, total_usd_bals) = await self._aggregate_positions()
-
-            missing_usdc = usd_value - current_usdc
-            available_usdc = float(total_usd_bals.get(key_usdc, 0.0))
-
-            if missing_usdc > 0 and available_usdc > 0:
-                unlend_usdc = min(missing_usdc, available_usdc)
-                if await self._can_withdraw_token(
-                    total_usd_bals,
-                    key_usdc,
-                    unlend_usdc,
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+
+            missing_usdc = float(usd_value - current_usdc)
+            available_usdc_usd = float(snap.totals_usd.get(key_usdc, 0.0))
+
+            if missing_usdc > 0 and available_usdc_usd > 0:
+                safe_unlend_usd = self._max_safe_withdraw_usd(
+                    totals_usd=snap.totals_usd,
+                    withdraw_key=key_usdc,
                     collateral_factors=collateral_factors,
-                ):
-                    unlend_underlying_raw = int(unlend_usdc * (10**usdc_decimals))
-                    if unlend_underlying_raw > 0:
-                        musdc_res = await self.moonwell_adapter.max_withdrawable_mtoken(
-                            mtoken=M_USDC
-                        )
-                        if not musdc_res[0]:
-                            return (
-                                False,
-                                f"Failed to compute withdrawable mUSDC: {musdc_res[1]}",
+                    hf_floor=float(self.MIN_HEALTH_FACTOR),
+                )
+                desired_unlend_usd = min(
+                    float(missing_usdc),
+                    float(available_usdc_usd),
+                    float(safe_unlend_usd),
+                )
+                if desired_unlend_usd >= float(self.min_withdraw_usd):
+                    if snap.usdc_price and snap.usdc_price > 0:
+                        unlend_underlying_raw = (
+                            int(
+                                desired_unlend_usd / snap.usdc_price * 10**snap.usdc_dec
                             )
-                        withdraw_info = musdc_res[1]
-                        max_ctokens = int(withdraw_info.get("cTokens_raw", 0))
-                        exchange_rate_raw = int(
-                            withdraw_info.get("exchangeRate_raw", 0)
+                            + 1
                         )
-                        conversion_factor = float(
-                            withdraw_info.get("conversion_factor", 0) or 0
+                    else:
+                        unlend_underlying_raw = int(
+                            desired_unlend_usd * (10**usdc_decimals)
                         )
 
-                        if max_ctokens > 0:
-                            if exchange_rate_raw > 0:
-                                ctokens_needed = (
-                                    unlend_underlying_raw * 10**18
-                                    + exchange_rate_raw
-                                    - 1
-                                ) // exchange_rate_raw
-                            elif conversion_factor > 0:
-                                ctokens_needed = (
-                                    int(conversion_factor * unlend_underlying_raw) + 1
-                                )
-                            else:
-                                ctokens_needed = max_ctokens
+                    musdc_res = await self.moonwell_adapter.max_withdrawable_mtoken(
+                        mtoken=M_USDC
+                    )
+                    if not musdc_res[0]:
+                        return (
+                            False,
+                            f"Failed to compute withdrawable mUSDC: {musdc_res[1]}",
+                        )
+                    withdraw_info = musdc_res[1]
+                    if not isinstance(withdraw_info, dict):
+                        return (False, f"Bad withdraw info for mUSDC: {withdraw_info}")
 
-                            ctokens_to_redeem = min(int(ctokens_needed), max_ctokens)
-                            if ctokens_to_redeem > 0:
-                                success, msg = await self.moonwell_adapter.unlend(
-                                    mtoken=M_USDC, amount=ctokens_to_redeem
-                                )
-                                if not success:
-                                    return (
-                                        False,
-                                        f"Failed to redeem mUSDC for partial liquidation: {msg}",
-                                    )
+                    mtoken_amt = self._mtoken_amount_for_underlying(
+                        withdraw_info, unlend_underlying_raw
+                    )
+                    if mtoken_amt > 0:
+                        success, msg = await self.moonwell_adapter.unlend(
+                            mtoken=M_USDC, amount=mtoken_amt
+                        )
+                        if not success:
+                            return (
+                                False,
+                                f"Failed to redeem mUSDC for partial liquidation: {msg}",
+                            )
 
         # (5) Final available USDC (capped to target)
         usdc_raw = await self._get_balance_raw(
@@ -2185,10 +3091,10 @@ class MoonwellWstethLoopStrategy(Strategy):
         max_safe_f = self._max_safe_F(cf_w)
 
         # Guard against division by zero/negative denominator
-        denominator = self.MIN_HEALTH_FACTOR + 0.001 - cf_w
+        denominator = self.TARGET_HEALTH_FACTOR + 0.001 - cf_w
         if denominator <= 0:
             logger.warning(
-                f"Cannot calculate target borrow: cf_w ({cf_w:.3f}) >= MIN_HF ({self.MIN_HEALTH_FACTOR})"
+                f"Cannot calculate target borrow: cf_w ({cf_w:.3f}) >= TARGET_HF ({self.TARGET_HEALTH_FACTOR})"
             )
             return (False, initial_leverage, -1)
 
@@ -2286,9 +3192,44 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         return (True, leverage_tracker[-1], len(leverage_tracker) - 1)
 
-    async def update(self) -> StatusTuple:
-        """Rebalance positions. Runs deposit loop only if HF > MAX_HEALTH_FACTOR."""
-        self._clear_price_cache()
+    async def update(self) -> StatusTuple:
+        """Rebalance positions, then run a post-run safety guard."""
+        logger.info("")
+        logger.info("*" * 60)
+        logger.info("* MOONWELL STRATEGY UPDATE CALLED")
+        logger.info("*" * 60)
+        self._clear_price_cache()
+
+        status: StatusTuple = (False, "Unknown")
+        err: Exception | None = None
+
+        try:
+            status = await self._update_impl()
+        except Exception as exc:
+            err = exc
+            if isinstance(exc, SwapOutcomeUnknownError):
+                status = (False, f"Swap outcome unknown: {exc}")
+            else:
+                status = (False, f"Update failed: {exc}")
+
+        guard_ok, guard_msg = await self._post_run_guard(
+            mode="operate", prior_error=err
+        )
+        if not guard_ok:
+            return (
+                False,
+                f"{status[1]} | finalizer FAILED: {guard_msg}",
+            )
+        return (
+            status[0],
+            f"{status[1]} | finalizer: {guard_msg}",
+        )
+
+    async def _update_impl(self) -> StatusTuple:
+        """Update implementation (called by update() wrapper)."""
+        logger.info("=" * 60)
+        logger.info("UPDATE START")
+        logger.info("=" * 60)
 
         # Best-effort top-up if we dipped below MIN_GAS (non-critical).
         topup_success, topup_msg = await self._transfer_gas_to_vault()
@@ -2296,105 +3237,198 @@ class MoonwellWstethLoopStrategy(Strategy):
             logger.warning(f"Gas top-up failed (non-critical): {topup_msg}")
 
         gas_amt = await self._get_gas_balance()
+        logger.info(
+            f"Gas balance: {gas_amt / 10**18:.6f} ETH (min: {self.MAINTENANCE_GAS} ETH)"
+        )
         if gas_amt < int(self.MAINTENANCE_GAS * 10**18):
+            logger.error(
+                f"Insufficient gas: {gas_amt / 10**18:.6f} < {self.MAINTENANCE_GAS}"
+            )
             return (
                 False,
                 f"Less than {self.MAINTENANCE_GAS} ETH in strategy wallet. Please transfer more gas.",
             )
 
-        # Recovery: if a previous loop borrowed WETH but failed to swap/lend, complete it first.
-        try:
-            completed, msg = await self._complete_unpaired_weth_borrow()
-            if not completed:
-                logger.warning(
-                    f"Unpaired borrow completion failed (will continue): {msg}"
-                )
-        except Exception as exc:
-            return (False, f"Failed while completing unpaired borrow: {exc}")
+        # Pre-fetch collateral factors once (saves RPC + makes decisions consistent)
+        collateral_factors = await self._get_collateral_factors()
 
-        # Balance WETH debt first (critical for delta-neutrality)
-        balance_success, balance_msg = await self._balance_weth_debt()
-        if not balance_success:
-            return (
-                False,
-                f"Failed to balance WETH debt: {balance_msg}. Consider calling withdraw to unwind safely.",
-            )
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+
+        # Log current state
+        logger.info("-" * 40)
+        logger.info("CURRENT STATE:")
+        logger.info(f"  Health Factor: {snap.hf:.3f}")
+        logger.info(
+            f"  Wallet: ETH={snap.wallet_eth / 10**18:.4f}, WETH={snap.wallet_weth / 10**18:.4f}, USDC={snap.wallet_usdc / 10**6:.2f}"
+        )
+        logger.info(
+            f"  Supplied: USDC=${snap.usdc_supplied / 10**6 * snap.usdc_price:.2f}, wstETH=${snap.wsteth_supplied / 10**18 * snap.wsteth_price:.2f}"
+        )
+        logger.info(f"  Debt: WETH=${snap.weth_debt / 10**18 * snap.weth_price:.2f}")
+        logger.info(f"  Net equity: ${snap.net_equity_usd:.2f}")
+        logger.info(f"  Borrow capacity: ${snap.capacity_usd:.2f}")
+        logger.info("-" * 40)
 
-        # If we are holding excess native ETH, convert it into USDC so it can be redeployed.
+        ok, msg = await self._ensure_markets_for_state(snap)
+        if not ok:
+            return (False, f"Failed ensuring markets: {msg}")
+
+        # 1) Reconcile wallet leftovers into the intended position
+        logger.info("STEP 1: Reconciling wallet leftovers into position...")
         try:
-            converted, msg = await self._convert_excess_eth_to_usdc()
-            if not converted:
-                logger.warning(f"Excess ETH conversion failed (non-critical): {msg}")
+            ok, msg = await self._reconcile_wallet_into_position(
+                collateral_factors=collateral_factors,
+                max_batch_usd=8000.0,
+            )
+            if not ok:
+                return (False, msg)
         except SwapOutcomeUnknownError as exc:
-            return (False, f"Swap outcome unknown while converting excess ETH: {exc}")
+            return (False, f"Swap outcome unknown during wallet reconciliation: {exc}")
         except Exception as exc:
-            logger.warning(f"Excess ETH conversion raised (non-critical): {exc}")
+            return (False, f"Failed during wallet reconciliation: {exc}")
 
-        # Fetch positions and collateral factors in parallel (single fetch for update)
-        positions_task = self._aggregate_positions()
-        cf_task = self._get_collateral_factors()
-        (totals_token, totals_usd), collateral_factors = await asyncio.gather(
-            positions_task, cf_task
-        )
+        # 2) Refresh snapshot and keep HF near TARGET_HEALTH_FACTOR (deleverage if too low)
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+        logger.info(f"STEP 2: Check HF thresholds (current HF={snap.hf:.3f})")
 
-        # Compute health factor using pre-fetched data
-        ltv = await self.compute_ltv(totals_usd, collateral_factors=collateral_factors)
-        hf = (1 / ltv) if ltv and ltv > 0 and not (ltv != ltv) else float("inf")
+        emergency_hf_floor = float(self.LEVERAGE_DELEVER_HF_FLOOR)
+        if snap.hf < emergency_hf_floor:
+            logger.warning(
+                f"EMERGENCY: HF {snap.hf:.3f} < floor {emergency_hf_floor:.2f} - depositing USDC to raise HF"
+            )
+            # Emergency: raise collateral without touching debt/collateral withdrawals.
+            # Sweep whatever wallet assets we can into USDC, then lend it as collateral.
+            try:
+                ok, sweep_msg = await self._sweep_token_balances(
+                    target_token_id=USDC_TOKEN_ID,
+                    exclude={ETH_TOKEN_ID},
+                    min_usd_value=float(self.sweep_min_usd),
+                )
+            except SwapOutcomeUnknownError as exc:
+                return (False, f"Swap outcome unknown during emergency sweep: {exc}")
 
-        # Check if we need to deleverage
-        if hf < self.MIN_HEALTH_FACTOR:
-            cf_u, cf_w = collateral_factors
+            if not ok:
+                return (False, f"Emergency sweep failed: {sweep_msg}")
 
-            usdc_key = f"Base_{M_USDC}"
-            weth_key = f"Base_{WETH}"
+            addr = self._get_strategy_wallet_address()
+            usdc_bal = await self._get_balance_raw(
+                token_id=USDC_TOKEN_ID, wallet_address=addr
+            )
+            if usdc_bal <= 0:
+                return (
+                    False,
+                    f"HF={snap.hf:.3f} below emergency floor ({emergency_hf_floor:.2f}); "
+                    "no USDC available to deposit after sweep",
+                )
 
-            c_u = totals_usd.get(usdc_key, 0)
-            debt = abs(totals_usd.get(weth_key, 0))
+            lend_ok, lend_res = await self.moonwell_adapter.lend(
+                mtoken=M_USDC, underlying_token=USDC, amount=int(usdc_bal)
+            )
+            if not lend_ok:
+                return (False, f"Emergency USDC deposit failed: {lend_res}")
 
-            repay_usd = debt - (cf_u * c_u) / (self.MIN_HEALTH_FACTOR + 1e-4 - cf_w)
-            weth_price = await self._get_token_price(WETH_TOKEN_ID)
+            # Ensure USDC market is entered as collateral (idempotent).
+            await self.moonwell_adapter.set_collateral(mtoken=M_USDC)
 
-            repay_amt = int(repay_usd / weth_price * 10**18) + 1
-            success, msg = await self._repay_debt_loop(target_repaid=repay_amt)
+            return (
+                True,
+                f"HF={snap.hf:.3f} below emergency floor ({emergency_hf_floor:.2f}); "
+                f"swept+deposited {usdc_bal / 10**snap.usdc_dec:.2f} USDC to improve HF "
+                f"({sweep_msg})",
+            )
 
-            if not success:
+        target_hf = float(self.TARGET_HEALTH_FACTOR)
+        deleverage_threshold = max(
+            float(self.MIN_HEALTH_FACTOR),
+            float(target_hf) - float(self.HF_DELEVERAGE_BUFFER),
+        )
+        logger.info(
+            f"  Target HF={target_hf:.2f}, Deleverage threshold={deleverage_threshold:.2f}"
+        )
+        if snap.hf < deleverage_threshold:
+            logger.info(
+                f"DELEVERAGE: HF {snap.hf:.3f} < threshold {deleverage_threshold:.2f} - reducing debt"
+            )
+            if snap.capacity_usd <= 0:
                 return (
                     False,
-                    f"Health factor is {hf:.2f} which is dangerous. Deleveraging failed: {msg}",
+                    "No borrow capacity found; cannot compute deleverage target",
+                )
+            try:
+                ok, msg = await self._settle_weth_debt_to_target_usd(
+                    target_debt_usd=0.0,
+                    target_hf=float(target_hf),
+                    collateral_factors=collateral_factors,
+                    mode="operate",
+                    max_batch_usd=3000.0,
                 )
-            return (success, msg)
+            except SwapOutcomeUnknownError as exc:
+                return (False, f"Swap outcome unknown during deleverage: {exc}")
+            if not ok:
+                return (False, f"Deleverage failed: {msg}")
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
 
-        # Claim rewards if above threshold
-        await self.moonwell_adapter.claim_rewards(min_rewards_usd=self.MIN_USDC_DEPOSIT)
+        # If leverage drifted above target (by > LEVERAGE_DELEVERAGE_BUFFER), reduce it by
+        # withdrawing wstETH collateral and applying it to the WETH borrow.
+        target_leverage = self._target_leverage(
+            collateral_factors=collateral_factors,
+            target_hf=float(target_hf),
+        )
+        usdc_key = f"Base_{M_USDC}"
+        wsteth_key = f"Base_{M_WSTETH}"
+        usdc_lend_value = float(snap.totals_usd.get(usdc_key, 0.0))
+        wsteth_lend_value = float(snap.totals_usd.get(wsteth_key, 0.0))
+        current_leverage = (
+            wsteth_lend_value / usdc_lend_value + 1.0 if usdc_lend_value > 0 else 0.0
+        )
+        logger.info(
+            f"STEP 3: Check leverage (current={current_leverage:.2f}x, target={target_leverage:.2f}x)"
+        )
+        if target_leverage > 0 and current_leverage > target_leverage + float(
+            self.LEVERAGE_DELEVERAGE_BUFFER
+        ):
+            logger.info(
+                f"DELEVER: Leverage {current_leverage:.2f}x > target+buffer {target_leverage + self.LEVERAGE_DELEVERAGE_BUFFER:.2f}x"
+            )
+            try:
+                ok, msg = await self._delever_wsteth_to_target_leverage(
+                    target_leverage=float(target_leverage),
+                    collateral_factors=collateral_factors,
+                    max_over_leverage=float(self.LEVERAGE_DELEVERAGE_BUFFER),
+                    max_batch_usd=3000.0,
+                    max_steps=10,
+                )
+            except SwapOutcomeUnknownError as exc:
+                return (False, f"Swap outcome unknown during leverage delever: {exc}")
+            if not ok:
+                return (False, msg)
+
+            snap, _ = await self._accounting_snapshot(
+                collateral_factors=collateral_factors
+            )
+
+        totals_usd = snap.totals_usd
+        hf = snap.hf
+
+        # Claim WELL rewards, swap to USDC, and lend directly (no leverage)
+        logger.info("STEP 4: Claim and reinvest WELL rewards...")
+        reward_ok, reward_msg = await self._claim_and_reinvest_rewards()
+        logger.info(f"  Rewards: {reward_msg}")
 
         # Check profitability
         success, msg = await self._check_quote_profitability()
         if not success:
             return (False, msg)
 
-        # If we have idle wallet wstETH (spot long), convert it to USDC so it can be redeployed
-        # via the leverage loop. This does not affect native ETH gas.
-        try:
-            converted, conv_msg = await self._convert_spot_wsteth_to_usdc()
-            if not converted:
-                logger.warning(
-                    f"Wallet wstETH conversion failed (non-critical): {conv_msg}"
-                )
-        except SwapOutcomeUnknownError as exc:
-            return (
-                False,
-                f"Swap outcome unknown while converting wallet wstETH: {exc}",
-            )
-        except Exception as exc:
-            logger.warning(f"Wallet wstETH conversion raised (non-critical): {exc}")
-
         # Get USDC balance in wallet
         usdc_balance_wei = await self._get_usdc_balance()
         token_info = await self._get_token_info(USDC_TOKEN_ID)
         decimals = token_info.get("decimals", 6)
         usdc_balance = usdc_balance_wei / 10**decimals
 
-        # Get lend values from already-fetched aggregate positions
+        # Get lend values from the snapshot
         usdc_key = f"Base_{M_USDC}"
         wsteth_key = f"Base_{M_WSTETH}"
         usdc_lend_value = totals_usd.get(usdc_key, 0)
@@ -2403,8 +3437,17 @@ class MoonwellWstethLoopStrategy(Strategy):
             wsteth_lend_value / usdc_lend_value + 1 if usdc_lend_value else 0
         )
 
+        logger.info("STEP 5: Check for USDC to deploy...")
+        logger.info(
+            f"  Wallet USDC: {usdc_balance:.2f}, Min deposit: {self.MIN_USDC_DEPOSIT}"
+        )
+        logger.info(f"  Current leverage: {initial_leverage:.2f}x, HF: {hf:.3f}")
+
         # If we have meaningful USDC in-wallet, redeploy it regardless of current HF.
         if usdc_balance >= self.MIN_USDC_DEPOSIT:
+            logger.info(
+                f"REDEPLOY: Deploying {usdc_balance:.2f} USDC into leverage loop"
+            )
             success, final_leverage, n_loops = await self._execute_deposit_loop(
                 usdc_balance
             )
@@ -2418,13 +3461,19 @@ class MoonwellWstethLoopStrategy(Strategy):
                 f"Redeployed {usdc_balance:.2f} USDC to {final_leverage:.2f}x with {n_loops} loops",
             )
 
-        # Lever-up when HF is significantly above target (MIN_HEALTH_FACTOR).
-        # Only skip if HF is close enough to target (within HF_LEVER_UP_BUFFER).
-        lever_up_threshold = self.MIN_HEALTH_FACTOR + self.HF_LEVER_UP_BUFFER
+        # Lever-up when HF is significantly above target (TARGET_HEALTH_FACTOR).
+        lever_up_threshold = float(target_hf) + float(self.HF_LEVER_UP_BUFFER)
+        logger.info(
+            f"STEP 6: Check lever-up (HF={hf:.3f}, threshold={lever_up_threshold:.2f})"
+        )
         if hf <= lever_up_threshold:
+            logger.info(
+                f"NO ACTION: HF {hf:.3f} <= lever-up threshold {lever_up_threshold:.2f}"
+            )
+            logger.info("=" * 60)
             return (
                 True,
-                f"HF={hf:.3f} <= target+buffer({lever_up_threshold:.2f}); no action needed.",
+                f"HF={hf:.3f} <= lever-up threshold({lever_up_threshold:.2f}); no action needed.",
             )
 
         # Use 95% threshold to handle rounding/slippage from deposit
@@ -2481,107 +3530,38 @@ class MoonwellWstethLoopStrategy(Strategy):
             f"Executed redeposit loop to {final_leverage:.2f}x with {n_loops} loops",
         )
 
-    async def _repay_debt_loop(
-        self, target_repaid: int | None = None
-    ) -> tuple[bool, str]:
-        """Iteratively repay debt."""
-        total_repaid = 0
-
-        if target_repaid is not None and target_repaid < 0:
-            return (False, "Target repay was negative")
-
-        for _ in range(self._MAX_LOOP_LIMIT * 2):
-            # Get current debt
-            pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
-            if not pos_result[0]:
-                break
-
-            current_debt = pos_result[1].get("borrow_balance", 0)
-            if current_debt < 1:
-                break
-
-            # Attempt repayment
-            try:
-                repaid = await self._safe_repay(current_debt)
-            except SwapOutcomeUnknownError as exc:
-                return (False, f"Swap outcome unknown during debt repayment: {exc}")
-            if repaid == 0:
-                break
-
-            total_repaid += repaid
-
-            if target_repaid is not None and total_repaid >= target_repaid:
-                return (True, f"Repaid {total_repaid} > {target_repaid} target")
+    async def _repay_weth(self, amount: int, remaining_debt: int) -> int:
+        """Repay WETH debt. Returns amount actually repaid."""
+        if amount <= 0 or remaining_debt <= 0:
+            return 0
 
-        # Check remaining debt
-        pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
-        if not pos_result[0]:
-            return (False, "Failed to check remaining debt after repayment")
+        amount = int(amount)
+        remaining_debt = int(remaining_debt)
 
-        remaining_debt = pos_result[1].get("borrow_balance", 0)
+        # Only use repay_full when we have a small buffer above the observed debt.
+        # This avoids cases where debt accrues between snapshot and execution and leaves dust.
+        full_repay_buffer_wei = max(
+            10_000, remaining_debt // 10_000
+        )  # 0.01% or 10k wei
+        can_repay_full = amount >= (remaining_debt + full_repay_buffer_wei)
 
-        if remaining_debt > 0:
-            return (
-                False,
-                f"Could not repay all debt. Remaining: {remaining_debt / 10**18:.6f} WETH",
+        if can_repay_full:
+            # Approve the full amount we have available so repayBorrow(MAX_UINT256)
+            # can clear debt even if it drifted slightly.
+            success, _ = await self.moonwell_adapter.repay(
+                mtoken=M_WETH,
+                underlying_token=WETH,
+                amount=amount,
+                repay_full=True,
             )
+            return remaining_debt if success else 0
 
-        return (True, "Debt repayment completed")
-
-    async def _emergency_eth_repayment(self, debt: int) -> tuple[bool, str]:
-        """Emergency fallback to repay debt using available ETH."""
-        gas_balance = await self._get_gas_balance()
-        # Reserve for gas: base reserve + buffer for wrap + repay tx gas
-        tx_gas_buffer = int(0.001 * 10**18)  # ~0.001 ETH for wrap + repay txs
-        gas_buffer = int(self.WRAP_GAS_RESERVE * 10**18) + tx_gas_buffer
-
-        logger.debug(
-            f"Emergency repay check: gas_balance={gas_balance / 10**18:.6f}, "
-            f"gas_buffer={gas_buffer / 10**18:.6f}, debt={debt / 10**18:.6f}"
-        )
-
-        if gas_balance > gas_buffer:
-            available_eth = gas_balance - gas_buffer
-            repay_amt = min(available_eth, debt)
-
-            try:
-                wrap_success, wrap_msg = await self.moonwell_adapter.wrap_eth(
-                    amount=repay_amt
-                )
-                if not wrap_success:
-                    logger.warning(f"Emergency wrap failed: {wrap_msg}")
-                    return (False, f"Wrap failed: {wrap_msg}")
-
-                # Only use repay_full=True when we have enough to cover full debt
-                can_repay_full = repay_amt >= debt
-                success, _ = await self.moonwell_adapter.repay(
-                    mtoken=M_WETH,
-                    underlying_token=WETH,
-                    amount=repay_amt,
-                    repay_full=can_repay_full,
-                )
-                if success:
-                    logger.info(f"Emergency repayment: {repay_amt / 10**18:.6f} WETH")
-                    return (True, f"Emergency repaid {repay_amt}")
-                else:
-                    logger.warning("Emergency repayment transaction failed")
-                    return (False, "Repay transaction failed")
-            except Exception as e:
-                logger.warning(f"Emergency ETH repayment failed: {e}")
-                return (False, str(e))
-
-        return (False, "Insufficient ETH for emergency repayment")
-
-    async def _repay_weth(self, amount: int, remaining_debt: int) -> int:
-        """Repay WETH debt. Returns amount actually repaid."""
-        if amount <= 0:
-            return 0
         repay_amt = min(amount, remaining_debt)
         success, _ = await self.moonwell_adapter.repay(
             mtoken=M_WETH,
             underlying_token=WETH,
             amount=repay_amt,
-            repay_full=(repay_amt >= remaining_debt),
+            repay_full=False,
         )
         return repay_amt if success else 0
 
@@ -2590,26 +3570,31 @@ class MoonwellWstethLoopStrategy(Strategy):
     ) -> int:
         """Swap token to WETH and repay. Returns amount repaid."""
         swap_result = await self._swap_with_retries(
-            from_token_id=token_id, to_token_id=WETH_TOKEN_ID, amount=amount
+            from_token_id=token_id,
+            to_token_id=WETH_TOKEN_ID,
+            amount=amount,
+            preferred_providers=["aerodrome", "enso"],
         )
         if not swap_result:
             return 0
 
+        pinned_block = self._pinned_block(swap_result)
+
         # Use swap quote amount as minimum expected, retry balance read until we see it
-        expected_weth = int(swap_result.get("to_amount") or 0)
+        expected_weth = (
+            int(swap_result.get("to_amount") or 0)
+            if isinstance(swap_result, dict)
+            else 0
+        )
         addr = self._get_strategy_wallet_address()
-        weth_bal = 0
-
-        for attempt in range(5):
-            weth_bal = await self._get_balance_raw(
-                token_id=WETH_TOKEN_ID, wallet_address=addr
-            )
-            if weth_bal >= expected_weth * 0.95 or weth_bal > 0:
-                break
-            logger.debug(
-                f"WETH balance read {weth_bal}, expected ~{expected_weth}, retrying..."
-            )
-            await asyncio.sleep(1 + attempt)
+        min_expected = max(1, int(expected_weth * 0.95)) if expected_weth > 0 else 1
+        weth_bal = await self._balance_after_tx(
+            token_id=WETH_TOKEN_ID,
+            wallet=addr,
+            pinned_block=pinned_block,
+            min_expected=min_expected,
+            attempts=5,
+        )
 
         if weth_bal <= 0:
             logger.warning(
@@ -2619,211 +3604,181 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         return await self._repay_weth(weth_bal, remaining_debt)
 
-    async def _safe_repay(self, debt_to_repay: int) -> int:
-        """Attempt repayment using all available assets. Returns total amount repaid."""
-        if debt_to_repay < 1:
-            return 0
-
-        repaid = 0
-        addr = self._get_strategy_wallet_address()
+    async def withdraw(self, amount: float | None = None) -> StatusTuple:
+        """Withdraw funds; on failure, run a post-run safety guard."""
+        logger.info("")
+        logger.info("*" * 60)
+        logger.info("* MOONWELL STRATEGY WITHDRAW CALLED")
+        logger.info(
+            f"* Amount requested: {amount if amount else 'ALL (full withdrawal)'}"
+        )
+        logger.info("*" * 60)
+        self._clear_price_cache()
 
-        # 1. Use wallet WETH directly
-        weth_bal = await self._get_balance_raw(
-            token_id=WETH_TOKEN_ID, wallet_address=addr
-        )
-        if weth_bal > 0:
-            repaid += await self._repay_weth(weth_bal, debt_to_repay - repaid)
-            if repaid >= debt_to_repay:
-                return repaid
-
-        # 2. Wrap ETH (above gas reserve) and repay
-        eth_bal = await self._get_balance_raw(
-            token_id=ETH_TOKEN_ID, wallet_address=addr
-        )
-        gas_reserve = int((self.WRAP_GAS_RESERVE + 0.0005) * 10**18)
-        usable_eth = max(0, eth_bal - gas_reserve)
-        if usable_eth > 0:
-            wrap_amt = min(usable_eth, debt_to_repay - repaid)
-            wrap_ok, _ = await self.moonwell_adapter.wrap_eth(amount=wrap_amt)
-            if wrap_ok:
-                weth_bal = await self._get_balance_raw(
-                    token_id=WETH_TOKEN_ID, wallet_address=addr
-                )
-                repaid += await self._repay_weth(weth_bal, debt_to_repay - repaid)
-                if repaid >= debt_to_repay:
-                    return repaid
+        status: StatusTuple = (False, "Unknown")
+        err: Exception | None = None
 
-        # 3. Swap wallet assets (wstETH, USDC) to WETH and repay
-        weth_price, weth_dec = await self._get_token_data(WETH_TOKEN_ID)
-        if not weth_price or weth_price <= 0:
-            return repaid
+        try:
+            status = await self._withdraw_impl(amount)
+        except Exception as exc:
+            err = exc
+            if isinstance(exc, SwapOutcomeUnknownError):
+                status = (False, f"Swap outcome unknown: {exc}")
+            else:
+                status = (False, f"Withdraw failed: {exc}")
 
-        for token_id in [WSTETH_TOKEN_ID, USDC_TOKEN_ID]:
-            remaining = debt_to_repay - repaid
-            if remaining <= 0:
-                return repaid
+        # Only run the guard if withdraw failed; a successful withdraw should not touch positions.
+        if status[0]:
+            return status
 
-            bal = await self._get_balance_raw(token_id=token_id, wallet_address=addr)
-            if bal <= 0:
-                continue
+        guard_ok, guard_msg = await self._post_run_guard(mode="exit", prior_error=err)
+        suffix = (
+            f"finalizer: {guard_msg}" if guard_ok else f"finalizer FAILED: {guard_msg}"
+        )
+        return (False, f"{status[1]} | {suffix}")
 
-            price, dec = await self._get_token_data(token_id)
-            if not price or price <= 0:
-                continue
+    async def _withdraw_impl(self, amount: float | None = None) -> StatusTuple:
+        """Withdraw implementation (called by withdraw() wrapper).
 
-            bal_usd = (bal / 10**dec) * price
-            if bal_usd < self.min_withdraw_usd:
-                continue
+        Logic:
+        1. Liquidate any Moonwell positions to USDC (if any exist)
+        2. Transfer any USDC > 0 to main wallet
+        """
+        # NOTE: amount is currently unused; withdraw() is all-or-nothing in this strategy.
+        logger.info("=" * 60)
+        logger.info("WITHDRAW START - Full position unwind")
+        logger.info("=" * 60)
 
-            # Swap only what's needed (with 2% slippage buffer)
-            needed_usd = (remaining / 10**weth_dec) * weth_price * 1.02
-            needed_raw = int(needed_usd / price * 10**dec) + 1
-            swap_amt = min(bal, needed_raw)
+        collateral_factors = await self._get_collateral_factors()
 
-            logger.info(
-                f"Swapping {swap_amt / 10**dec:.6f} {token_id} to WETH for repayment"
-            )
-            repaid += await self._swap_to_weth_and_repay(
-                token_id, swap_amt, debt_to_repay - repaid
-            )
+        # Get initial state for logging
+        snap, _ = await self._accounting_snapshot(collateral_factors=collateral_factors)
+        logger.info("INITIAL STATE:")
+        logger.info(f"  USDC supplied: ${snap.usdc_supplied / 10**6:.2f}")
+        logger.info(
+            f"  wstETH supplied: {snap.wsteth_supplied / 10**18:.6f} (${snap.wsteth_supplied / 10**18 * snap.wsteth_price:.2f})"
+        )
+        logger.info(
+            f"  WETH debt: {snap.weth_debt / 10**18:.6f} (${snap.weth_debt / 10**18 * snap.weth_price:.2f})"
+        )
+        logger.info(f"  Wallet USDC: {snap.wallet_usdc / 10**6:.2f}")
+        logger.info(f"  Health Factor: {snap.hf:.3f}")
+        logger.info("-" * 40)
 
-        # 4. Unlend collateral, swap to WETH, and repay
-        for mtoken, token_id in [(M_WSTETH, WSTETH_TOKEN_ID), (M_USDC, USDC_TOKEN_ID)]:
-            remaining = debt_to_repay - repaid
-            if remaining <= 0:
-                return repaid
+        # Best-effort: convert reward/odd-lot tokens to WETH to improve repayment.
+        logger.info("STEP 1: Sweeping wallet tokens to WETH for debt repayment...")
+        await self._sweep_token_balances(target_token_id=WETH_TOKEN_ID)
 
-            withdraw_result = await self.moonwell_adapter.max_withdrawable_mtoken(
-                mtoken=mtoken
+        # 1) Settle debt to zero (batchy + safe)
+        logger.info("STEP 2: Settling WETH debt to zero...")
+        logger.info("  Source: Withdraw wstETH collateral → swap to WETH → repay")
+        try:
+            ok, msg = await self._settle_weth_debt_to_target_usd(
+                target_debt_usd=0.0,
+                collateral_factors=collateral_factors,
+                mode="exit",
+                max_batch_usd=4000.0,
+                max_steps=30,
             )
-            if not withdraw_result[0]:
-                continue
-
-            withdraw_info = withdraw_result[1]
-            underlying_raw = withdraw_info.get("underlying_raw", 0)
-            if underlying_raw < 1:
-                continue
-
-            price, dec = await self._get_token_data(token_id)
-            if not price or price <= 0:
-                continue
-
-            avail_raw = int(underlying_raw * COLLATERAL_SAFETY_FACTOR)
-            avail_usd = (avail_raw / 10**dec) * price
-            if avail_usd <= self.min_withdraw_usd:
-                continue
-
-            # Calculate needed amount with buffer
-            remaining_usd = (remaining / 10**weth_dec) * weth_price
-            target_usd = max(remaining_usd * 1.02, float(self.min_withdraw_usd))
-            needed_raw = int(target_usd / price * 10**dec) + 1
-            unlend_raw = min(avail_raw, needed_raw)
+        except SwapOutcomeUnknownError as exc:
+            return (False, f"Swap outcome unknown while unwinding debt: {exc}")
 
-            mtoken_amt = self._mtoken_amount_for_underlying(withdraw_info, unlend_raw)
-            if mtoken_amt <= 0:
-                continue
+        if not ok:
+            logger.error(f"Failed to settle debt: {msg}")
+            return (False, f"Failed to unwind debt: {msg}")
+        logger.info("  Debt settled successfully")
 
-            success, _ = await self.moonwell_adapter.unlend(
-                mtoken=mtoken, amount=mtoken_amt
-            )
-            if not success:
-                continue
+        # 2) Unlend everything and convert to USDC
+        logger.info("STEP 3: Unlending remaining positions and converting to USDC...")
+        logger.info("  Source: Redeem mUSDC → USDC, Redeem mwstETH → swap to USDC")
+        try:
+            (
+                ok,
+                msg,
+            ) = (
+                await self._unlend_remaining_positions()
+            )  # swaps wstETH->USDC internally
+        except SwapOutcomeUnknownError as exc:
+            return (False, f"Swap outcome unknown while unlending positions: {exc}")
+        except Exception as exc:  # noqa: BLE001
+            return (False, f"Failed while unlending positions: {exc}")
 
-            # Swap what we unlended
-            bal = await self._get_balance_raw(token_id=token_id, wallet_address=addr)
-            swap_amt = min(bal, unlend_raw)
-            if swap_amt <= 0:
-                continue
+        if not ok:
+            logger.error(f"Failed to unlend positions: {msg}")
+            return (False, msg)
+        logger.info("  Positions unlent successfully")
 
-            logger.info(f"Swapping {swap_amt / 10**dec:.6f} unlent {token_id} to WETH")
-            amt_repaid = await self._swap_to_weth_and_repay(
-                token_id, swap_amt, remaining
+        # 3) Sweep any wallet leftovers to USDC (keeping ETH)
+        logger.info("STEP 4: Sweeping remaining wallet tokens to USDC...")
+        try:
+            ok, msg = await self._sweep_token_balances(
+                target_token_id=USDC_TOKEN_ID,
+                exclude={ETH_TOKEN_ID, WELL_TOKEN_ID},
+                min_usd_value=float(self.sweep_min_usd),
+                strict=True,
             )
-            if amt_repaid > 0:
-                repaid += amt_repaid
-            else:
-                # Swap failed - re-lend to restore position
-                logger.warning(f"Swap failed for {token_id}, re-lending")
-                underlying = WSTETH if mtoken == M_WSTETH else USDC
-                relend_bal = await self._get_balance_raw(
-                    token_id=token_id, wallet_address=addr
-                )
-                if relend_bal > 0:
-                    await self.moonwell_adapter.lend(
-                        mtoken=mtoken, underlying_token=underlying, amount=relend_bal
-                    )
-
-        # Emergency fallback: use available ETH when nothing else worked
-        if repaid == 0 and debt_to_repay > 0:
-            success, _ = await self._emergency_eth_repayment(debt_to_repay)
-            if success:
-                pos_result = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
-                if pos_result[0]:
-                    new_debt = pos_result[1].get("borrow_balance", 0)
-                    repaid = debt_to_repay - new_debt
-                    logger.info(
-                        f"Emergency repayment succeeded: {repaid / 10**18:.6f} WETH"
-                    )
-
-        return repaid
+        except SwapOutcomeUnknownError as exc:
+            return (False, f"Swap outcome unknown while sweeping wallet: {exc}")
 
-    async def withdraw(self, amount: float | None = None) -> StatusTuple:
-        """Withdraw funds. If amount is None, withdraws all.
+        if not ok:
+            logger.error(f"Failed to sweep wallet: {msg}")
+            return (False, msg)
+        logger.info("  Wallet swept successfully")
 
-        Logic:
-        1. Liquidate any Moonwell positions to USDC (if any exist)
-        2. Transfer any USDC > 0 to main wallet (regardless of step 1)
-        """
-        self._clear_price_cache()
+        # Step 5: Report final balances in strategy wallet
+        logger.info("STEP 5: Checking final balances in strategy wallet...")
+        usdc_balance = await self._get_balance_raw(
+            token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
+        )
+        gas_balance = await self._get_balance_raw(
+            token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
+        )
 
-        # Step 1: Liquidate Moonwell positions if any exist
-        totals_token, totals_usd = await self._aggregate_positions()
-        has_positions = len(totals_token) > 0
+        token_info = await self._get_token_info(USDC_TOKEN_ID)
+        decimals = token_info.get("decimals", 6)
+        usdc_amount = usdc_balance / 10**decimals if usdc_balance > 0 else 0.0
+        gas_amount = gas_balance / 10**18 if gas_balance > 0 else 0.0
 
-        if has_positions:
-            # Sweep misc tokens to WETH first (helps with repayment)
-            await self._sweep_token_balances(
-                target_token_id=WETH_TOKEN_ID,
-                exclude={USDC_TOKEN_ID, WSTETH_TOKEN_ID},
-            )
+        logger.info(f"  Strategy wallet USDC: {usdc_amount:.2f}")
+        logger.info(f"  Strategy wallet ETH: {gas_amount:.6f}")
 
-            # Execute debt repayment loop
-            success, message = await self._repay_debt_loop()
-            if not success:
-                return (False, message)
+        return (
+            True,
+            f"Positions liquidated. Strategy wallet contains {usdc_amount:.2f} USDC and {gas_amount:.6f} ETH. Call exit() to transfer to main wallet.",
+        )
 
-            # Unlend and convert remaining positions to USDC
-            await self._unlend_remaining_positions()
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        logger.info("")
+        logger.info("*" * 60)
+        logger.info("* MOONWELL STRATEGY EXIT CALLED")
+        logger.info("*" * 60)
 
-        # Always sweep any remaining tokens to USDC (catches WETH, wstETH, WELL even without positions)
-        await self._sweep_token_balances(
-            target_token_id=USDC_TOKEN_ID,
-            exclude={ETH_TOKEN_ID},  # Keep gas token
-        )
+        transferred_items = []
 
-        # Step 2: Transfer any USDC to main wallet
+        # Transfer USDC to main wallet
         usdc_balance = await self._get_balance_raw(
             token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
+        if usdc_balance > 0:
+            token_info = await self._get_token_info(USDC_TOKEN_ID)
+            decimals = token_info.get("decimals", 6)
+            usdc_amount = usdc_balance / 10**decimals
+            logger.info(f"Transferring {usdc_amount:.2f} USDC to main wallet")
 
-        if usdc_balance <= 0:
-            return (False, "No USDC to withdraw.")
-
-        token_info = await self._get_token_info(USDC_TOKEN_ID)
-        decimals = token_info.get("decimals", 6)
-        usdc_amount = usdc_balance / 10**decimals
-
-        (
-            success,
-            msg,
-        ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-            USDC_TOKEN_ID, usdc_amount
-        )
-        if not success:
-            return (False, f"USDC transfer failed: {msg}")
+            (
+                success,
+                msg,
+            ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                USDC_TOKEN_ID, usdc_amount
+            )
+            if not success:
+                logger.error(f"USDC transfer failed: {msg}")
+                return (False, f"USDC transfer failed: {msg}")
+            transferred_items.append(f"{usdc_amount:.2f} USDC")
+            logger.info(f"USDC transfer successful: {usdc_amount:.2f} USDC")
 
-        # Step 3: Transfer remaining gas to main wallet (keep reserve for tx fee)
-        gas_transferred = 0.0
+        # Transfer ETH (minus small reserve for tx fees) to main wallet
         gas_balance = await self._get_balance_raw(
             token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
@@ -2831,6 +3786,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         transferable_gas = gas_balance - tx_fee_reserve
         if transferable_gas > 0:
             gas_amount = transferable_gas / 10**18
+            logger.info(f"Transferring {gas_amount:.6f} ETH to main wallet")
             (
                 gas_success,
                 gas_msg,
@@ -2838,23 +3794,32 @@ class MoonwellWstethLoopStrategy(Strategy):
                 ETH_TOKEN_ID, gas_amount
             )
             if gas_success:
-                gas_transferred = gas_amount
+                transferred_items.append(f"{gas_amount:.6f} ETH")
+                logger.info(f"ETH transfer successful: {gas_amount:.6f} ETH")
             else:
-                logger.warning(f"Gas transfer failed (non-critical): {gas_msg}")
+                logger.warning(f"ETH transfer failed (non-critical): {gas_msg}")
 
-        return (
-            True,
-            f"Withdrew {usdc_amount:.2f} USDC and {gas_transferred:.6f} ETH to main wallet",
-        )
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
+
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
 
-    async def _unlend_remaining_positions(self) -> None:
+    async def _unlend_remaining_positions(self) -> tuple[bool, str]:
         """Unlend remaining collateral and convert to USDC."""
+        logger.info("UNLEND: Redeeming remaining Moonwell positions...")
+
         # Unlend remaining wstETH
         wsteth_pos = await self.moonwell_adapter.get_pos(mtoken=M_WSTETH)
         if wsteth_pos[0]:
             mtoken_bal = wsteth_pos[1].get("mtoken_balance", 0)
+            underlying = wsteth_pos[1].get("underlying_balance", 0)
             if mtoken_bal > 0:
-                await self.moonwell_adapter.unlend(mtoken=M_WSTETH, amount=mtoken_bal)
+                logger.info(f"  Unlending wstETH: {underlying / 10**18:.6f} wstETH")
+                ok, msg = await self.moonwell_adapter.unlend(
+                    mtoken=M_WSTETH, amount=mtoken_bal
+                )
+                if not ok:
+                    return (False, f"Failed to unlend wstETH: {msg}")
                 # Swap to USDC with retries
                 wsteth_bal = await self._get_balance_raw(
                     token_id=WSTETH_TOKEN_ID,
@@ -2867,23 +3832,34 @@ class MoonwellWstethLoopStrategy(Strategy):
                         amount=wsteth_bal,
                     )
                     if swap_result is None:
-                        logger.warning("Failed to swap wstETH to USDC after retries")
+                        return (False, "Failed to swap wstETH to USDC after retries")
 
         # Unlend remaining USDC
         usdc_pos = await self.moonwell_adapter.get_pos(mtoken=M_USDC)
         if usdc_pos[0]:
             mtoken_bal = usdc_pos[1].get("mtoken_balance", 0)
+            underlying = usdc_pos[1].get("underlying_balance", 0)
             if mtoken_bal > 0:
-                await self.moonwell_adapter.unlend(mtoken=M_USDC, amount=mtoken_bal)
+                logger.info(f"  Unlending USDC: {underlying / 10**6:.2f} USDC")
+                ok, msg = await self.moonwell_adapter.unlend(
+                    mtoken=M_USDC, amount=mtoken_bal
+                )
+                if not ok:
+                    return (False, f"Failed to unlend USDC: {msg}")
 
         # Claim any remaining rewards
         await self.moonwell_adapter.claim_rewards(min_rewards_usd=0)
 
         # Sweep any remaining tokens to USDC
-        await self._sweep_token_balances(
+        ok, msg = await self._sweep_token_balances(
             target_token_id=USDC_TOKEN_ID,
-            exclude={ETH_TOKEN_ID},  # Keep gas token
+            exclude={ETH_TOKEN_ID, WELL_TOKEN_ID},  # Keep gas + reward token
+            min_usd_value=float(self.sweep_min_usd),
+            strict=True,
         )
+        if not ok:
+            return (False, msg)
+        return (True, "Unlent remaining positions")
 
     async def get_peg_diff(self) -> float | dict:
         """Get stETH/ETH peg difference."""
@@ -2903,16 +3879,10 @@ class MoonwellWstethLoopStrategy(Strategy):
 
     async def _status(self) -> StatusDict:
         """Report strategy status."""
-        self._clear_price_cache()
-
-        # Fetch positions and collateral factors in parallel
-        (_totals_token, totals_usd), collateral_factors = await asyncio.gather(
-            self._aggregate_positions(),
-            self._get_collateral_factors(),
-        )
+        snap, _ = await self._accounting_snapshot()
+        totals_usd = dict(snap.totals_usd)
 
-        # Calculate LTV and health factor using pre-fetched data
-        ltv = await self.compute_ltv(totals_usd, collateral_factors=collateral_factors)
+        ltv = float(snap.ltv)
         hf = (1 / ltv) if ltv and ltv > 0 and not (ltv != ltv) else None
 
         # Get gas balance
@@ -2924,8 +3894,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         borrowable_amt = self._normalize_usd_value(borrowable_amt_raw)
 
         # Calculate credit remaining
-        weth_key = f"Base_{WETH}"
-        total_borrowed = abs(totals_usd.get(weth_key, 0))
+        total_borrowed = float(snap.debt_usd)
         credit_remaining = 1.0
         if (borrowable_amt + total_borrowed) > 0:
             credit_remaining = round(
@@ -2936,9 +3905,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         peg_diff = await self.get_peg_diff()
 
         # Calculate portfolio value
-        portfolio_value = sum(
-            v for k, v in totals_usd.items() if k != f"Base_{WETH}"
-        ) + totals_usd.get(f"Base_{WETH}", 0)
+        portfolio_value = float(snap.net_equity_usd)
 
         # Get projected earnings
         quote = await self.quote()