wayfinder-paths 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -1,11 +1,3 @@
-"""
-Moonwell wstETH Loop Strategy
-
-A leveraged liquid-staking carry on Base that loops USDC → borrow WETH → swap to wstETH → lend wstETH.
-The loop repeats while keeping debt as a fraction F of borrow capacity, chosen conservatively
-so the position remains safe under a stETH/ETH depeg.
-"""
-
 import asyncio
 import time
 from collections.abc import Awaitable, Callable
@@ -67,16 +59,10 @@ COLLATERAL_SAFETY_FACTOR = 0.98
 
 
 class SwapOutcomeUnknownError(RuntimeError):
-    """Raised when a swap transaction's outcome is unknown (e.g., receipt timeout).
-
-    In this case we must not retry (risk duplicate fills) and should halt the strategy
-    so the caller can inspect on-chain state.
-    """
+    "Raised when the outcome of a swap operation is unknown."
 
 
 class MoonwellWstethLoopStrategy(Strategy):
-    """Leveraged wstETH yield strategy using Moonwell lending protocol on Base."""
-
     name = "Moonwell wstETH Loop Strategy"
     description = "Leveraged wstETH yield strategy using Moonwell lending protocol."
     summary = "Loop wstETH on Moonwell for amplified staking yields."
@@ -88,15 +74,15 @@ 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 = 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%)
+    MIN_USDC_DEPOSIT = 10.0
+    MIN_REWARD_CLAIM_USD = 0.30
+    MAX_DEPEG = 0.01
     MAX_HEALTH_FACTOR = 1.5
     MIN_HEALTH_FACTOR = 1.2
     # 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
+    HF_LEVER_UP_BUFFER = 0.05
     # Deleverage if HF drops below (TARGET - buffer).
     HF_DELEVERAGE_BUFFER = 0.05
     # Deleverage if leverage multiplier exceeds target by this much.
@@ -111,20 +97,20 @@ class MoonwellWstethLoopStrategy(Strategy):
     # 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
+    _MAX_LOOP_LIMIT = 30
 
     # Parameters
-    leverage_limit = 10  # Limit on leverage multiplier
+    leverage_limit = 10
     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
-    PRICE_STALENESS_THRESHOLD = 300  # 5 minutes - max age for cached prices
+    max_swap_retries = 3
+    swap_slippage_tolerance = 0.005
+    MAX_SLIPPAGE_TOLERANCE = 0.03
+    PRICE_STALENESS_THRESHOLD = 300
 
     # 50 basis points (0.0050) - minimum leverage gain per loop iteration to continue
     # If marginal gain drops below this, stop looping as gas costs outweigh benefit
-    _MIN_LEVERAGE_GAIN_BPS = 50e-4  # 50 bps = 0.50%
+    _MIN_LEVERAGE_GAIN_BPS = 50e-4
 
     INFO = StratDescriptor(
         description="Leveraged wstETH carry: loops USDC → borrow WETH → swap wstETH → lend. "
@@ -188,7 +174,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         *,
         main_wallet: dict | None = None,
         strategy_wallet: dict | None = None,
-        simulation: bool = False,
         api_key: str | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
@@ -206,7 +191,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             merged_config["strategy_wallet"] = strategy_wallet
 
         self.config = merged_config
-        self.simulation = simulation
 
         # Adapter references
         self.balance_adapter: BalanceAdapter | None = None
@@ -235,10 +219,8 @@ class MoonwellWstethLoopStrategy(Strategy):
                 "strategy": self.config,
             }
 
-            # Initialize adapters
             balance = BalanceAdapter(
                 adapter_config,
-                simulation=self.simulation,
                 main_wallet_signing_callback=self.main_wallet_signing_callback,
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
@@ -246,12 +228,10 @@ class MoonwellWstethLoopStrategy(Strategy):
             ledger_adapter = LedgerAdapter()
             brap_adapter = BRAPAdapter(
                 adapter_config,
-                simulation=self.simulation,
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
             moonwell_adapter = MoonwellAdapter(
                 adapter_config,
-                simulation=self.simulation,
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
@@ -276,16 +256,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             raise
 
     def _max_safe_F(self, cf_w: float) -> float:
-        """Max safe debt fraction vs borrow capacity under a depeg.
-
-        Let a = 1 - MAX_DEPEG. If the position is sized at par (a=1) with debt
-        fraction F = Debt / BorrowCapacity, then after an instantaneous depeg to a
-        the borrow capacity shrinks by cf_w * (1-a) * Debt. Requiring Debt to
-        remain <= new capacity yields:
-            F_max = 1 / (1 + cf_w * (1 - a))
-
-        Returns F_max clipped to [0, 1].
-        """
         a = 1 - self.MAX_DEPEG
         if not (0 < a):
             return 0.0
@@ -298,20 +268,14 @@ class MoonwellWstethLoopStrategy(Strategy):
         return max(0.0, min(1.0, min(f_bound, f_feasible, 1.0)))
 
     def _get_strategy_wallet_address(self) -> str:
-        """Get the strategy wallet address."""
         wallet = self.config.get("strategy_wallet", {})
         return wallet.get("address", "")
 
     def _get_main_wallet_address(self) -> str:
-        """Get the main wallet address."""
         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(
@@ -327,9 +291,9 @@ class MoonwellWstethLoopStrategy(Strategy):
         wallet_wsteth: int
         wallet_usdc: int
 
-        usdc_supplied: int  # underlying raw
-        wsteth_supplied: int  # underlying raw
-        weth_debt: int  # borrow raw
+        usdc_supplied: int
+        wsteth_supplied: int
+        weth_debt: int
 
         # prices/decimals
         eth_price: float
@@ -363,10 +327,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     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
@@ -484,7 +444,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     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:
@@ -509,9 +468,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     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
@@ -544,10 +500,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     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
 
@@ -560,17 +512,13 @@ class MoonwellWstethLoopStrategy(Strategy):
         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
+            return current_val
 
         cf_u, cf_w = collateral_factors
         usdc_key = f"Base_{M_USDC}"
@@ -608,15 +556,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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:
@@ -695,7 +634,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             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
+                mismatch = self._delta_mismatch_usd(snap)
                 short_usd = max(0.0, float(mismatch))
                 long_usd = max(0.0, float(-mismatch))
 
@@ -820,10 +759,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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)
@@ -849,7 +784,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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
@@ -989,12 +923,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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()
 
@@ -1129,7 +1057,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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")
 
@@ -1245,17 +1172,10 @@ class MoonwellWstethLoopStrategy(Strategy):
         target_debt_usd: float,
         target_hf: float | None = None,
         collateral_factors: tuple[float, float],
-        mode: str,  # "operate" or "exit"
+        mode: str,
         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}"
         )
@@ -1431,7 +1351,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
             # 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
             )
@@ -1632,7 +1551,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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:
             raise RuntimeError("Token adapter not initialized.")
 
@@ -1646,7 +1564,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                 logger.warning(f"Failed to fetch token info for {token_id}: {e}")
 
     async def _get_token_info(self, token_id: str) -> dict:
-        """Get token info from cache or fetch it."""
         if token_id in self._token_info_cache:
             return self._token_info_cache[token_id]
 
@@ -1657,10 +1574,8 @@ class MoonwellWstethLoopStrategy(Strategy):
         return {}
 
     async def _get_token_price(self, token_id: str) -> float:
-        """Get token price with staleness check."""
         now = time.time()
 
-        # Check cache with staleness
         if token_id in self._token_price_cache:
             timestamp = self._token_price_timestamps.get(token_id, 0)
             if now - timestamp < self.PRICE_STALENESS_THRESHOLD:
@@ -1682,12 +1597,10 @@ class MoonwellWstethLoopStrategy(Strategy):
         return 0.0
 
     def _clear_price_cache(self):
-        """Clear the price cache to force refresh."""
         self._token_price_cache.clear()
         self._token_price_timestamps.clear()
 
     async def _get_token_data(self, token_id: str) -> tuple[float, int]:
-        """Get price and decimals for a token in one call."""
         price = await self._get_token_price(token_id)
         info = await self._get_token_info(token_id)
         return price, info.get("decimals", 18)
@@ -1701,13 +1614,11 @@ class MoonwellWstethLoopStrategy(Strategy):
         base_slippage: float | None = None,
         preferred_providers: list[str] | None = None,
     ) -> dict | None:
-        """Swap with retries, progressive slippage, and exponential backoff."""
         if max_retries is None:
             max_retries = self.max_swap_retries
         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
         )
@@ -1842,7 +1753,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return None
 
     def _parse_balance(self, raw: Any) -> int:
-        """Parse balance value to integer, handling various formats."""
         if raw is None:
             return 0
         if isinstance(raw, dict):
@@ -1873,29 +1783,9 @@ class MoonwellWstethLoopStrategy(Strategy):
         wallet_address: str,
         block_identifier: int | str | None = None,
     ) -> int:
-        """Read a wallet balance directly from chain (falls back to adapter in simulation).
-
-        Args:
-            token_id: Token identifier (e.g., WETH_TOKEN_ID)
-            wallet_address: Address to query balance for
-            block_identifier: Block to query at. Can be:
-                - int: specific block number (for pinning to tx block)
-                - "safe": OP Stack safe block (data posted to L1)
-                - None/"latest": current head (default)
-        """
         if not token_id or not wallet_address:
             return 0
 
-        # Tests/simulations patch adapters; avoid RPC calls there.
-        if self.simulation:
-            if self.balance_adapter is None:
-                return 0
-            success, raw = await self.balance_adapter.get_balance(
-                token_id=token_id,
-                wallet_address=wallet_address,
-            )
-            return self._parse_balance(raw) if success else 0
-
         token_address = self._token_address_for_id(token_id)
         if token_id != ETH_TOKEN_ID and not token_address:
             # Try to resolve address via token metadata (not a balance read).
@@ -1959,11 +1849,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return 0
 
     def _normalize_usd_value(self, raw: Any) -> float:
-        """Normalize a USD value that may be 18-decimal scaled (Compound/Moonwell style).
-
-        Moonwell's Comptroller `getAccountLiquidity` returns USD with 18 decimals as an int.
-        Some mocks may return a float already in USD.
-        """
         if raw is None:
             return 0.0
 
@@ -1983,7 +1868,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     def _mtoken_amount_for_underlying(
         self, withdraw_info: dict[str, Any], underlying_raw: int
     ) -> int:
-        """Convert desired underlying (raw) to mToken amount (raw), capped by max withdrawable."""
         if underlying_raw <= 0:
             return 0
 
@@ -2011,7 +1895,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return min(int(ctokens_needed), max_ctokens)
 
     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
 
@@ -2035,7 +1918,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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(
@@ -2049,19 +1931,16 @@ class MoonwellWstethLoopStrategy(Strategy):
         return int(bal)
 
     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()
@@ -2080,7 +1959,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     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()
         )
@@ -2100,7 +1978,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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 (
@@ -2110,7 +1987,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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,
@@ -2122,7 +1998,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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()
         min_gas_wei = int(self._gas_keep_wei())
         if vault_gas < min_gas_wei:
@@ -2145,7 +2020,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         *,
         strict: bool = False,
     ) -> tuple[bool, str]:
-        """Sweep miscellaneous tokens above min_usd_value to target token."""
         if exclude is None:
             exclude = set()
 
@@ -2204,11 +2078,6 @@ 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
@@ -2217,11 +2086,9 @@ class MoonwellWstethLoopStrategy(Strategy):
             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(),
@@ -2229,7 +2096,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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
 
@@ -2257,7 +2123,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             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(),
@@ -2283,19 +2148,15 @@ class MoonwellWstethLoopStrategy(Strategy):
     async def deposit(
         self, main_token_amount: float = 0.0, gas_token_amount: float = 0.0
     ) -> StatusTuple:
-        """Deposit USDC and execute leverage loop."""
         self._clear_price_cache()
 
-        # Validate deposit amount is positive
         if main_token_amount <= 0:
             return (False, "Deposit amount must be positive")
 
-        # Check quote profitability
         success, message = await self._check_quote_profitability()
         if not success:
             return (False, message)
 
-        # Validate USDC deposit amount
         success, message, validated_amount = await self._validate_usdc_deposit(
             main_token_amount
         )
@@ -2303,7 +2164,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             return (False, message)
         usdc_amount = validated_amount
 
-        # Validate gas balance
         success, message = await self._validate_gas_balance()
         if not success:
             return (False, message)
@@ -2324,10 +2184,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
 
     async def _get_collateral_factors(self) -> tuple[float, float]:
-        """Fetch both collateral factors (USDC and wstETH), using adapter cache.
-
-        Returns (cf_usdc, cf_wsteth).
-        """
         cf_u_result, cf_w_result = await asyncio.gather(
             self.moonwell_adapter.get_collateral_factor(mtoken=M_USDC),
             self.moonwell_adapter.get_collateral_factor(mtoken=M_WSTETH),
@@ -2341,12 +2197,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         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:
-            snap: Optional accounting snapshot. If provided, skips snapshot fetches.
-            collateral_factors: Optional (cf_usdc, cf_wsteth) tuple; only used if `snap` is None.
-        """
         if snap is None:
             snap, _ = await self._accounting_snapshot(
                 collateral_factors=collateral_factors
@@ -2364,7 +2214,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (usdc_lend_value, wsteth_lend_value, initial_leverage)
 
     async def _get_steth_apy(self) -> float | None:
-        """Fetch wstETH APY from Lido API."""
         url = "https://eth-api.lido.fi/v1/protocol/steth/apr/sma"
         try:
             async with httpx.AsyncClient(timeout=60) as client:
@@ -2380,8 +2229,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return None
 
     async def quote(self) -> dict:
-        """Calculate projected APY for the strategy."""
-        # Get APYs and collateral factors in parallel
         (
             usdc_apy_result,
             weth_apy_result,
@@ -2413,7 +2260,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if not cf_u or cf_u <= 0:
             return {"apy": 0, "information": "Invalid collateral factor", "data": {}}
 
-        # Calculate target borrow and leverage
         denominator = self.TARGET_HEALTH_FACTOR - cf_w
         if denominator <= 0:
             return {"apy": 0, "information": "Invalid health factor params", "data": {}}
@@ -2436,7 +2282,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         }
 
     async def _atomic_deposit_iteration(self, borrow_amt_wei: int) -> int:
-        """One atomic iteration: borrow WETH → swap wstETH → lend. Returns wstETH lent."""
         safe_borrow_amt = int(borrow_amt_wei * COLLATERAL_SAFETY_FACTOR)
         strategy_address = self._get_strategy_wallet_address()
 
@@ -2458,7 +2303,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if not success:
             raise Exception(f"Borrow failed: {borrow_result}")
 
-        # 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)
 
@@ -2614,7 +2458,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                 ) from repay_exc
             raise Exception("Atomic deposit failed at swap step after all retries")
 
-        # Parse to_amount from swap result (may be int or string)
         raw_to_amount = (
             swap_result.get("to_amount", 0) if isinstance(swap_result, dict) else 0
         )
@@ -2623,7 +2466,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         except (ValueError, TypeError):
             to_amount_wei = 0
 
-        # Get actual wstETH balance
         wsteth_success, wsteth_bal_raw = await self.balance_adapter.get_balance(
             token_id=WSTETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
@@ -2640,7 +2482,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if lend_amt_wei <= 0:
             logger.warning("Swap resulted in 0 wstETH. Rolling back borrow...")
             try:
-                # Get WETH balance to repay (swap may have returned WETH or nothing)
                 weth_bal = await self._get_balance_raw(
                     token_id=WETH_TOKEN_ID, wallet_address=strategy_address
                 )
@@ -2766,7 +2607,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return lend_amt_wei
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
-        """Create USDC liquidity in the strategy wallet by safely redeeming collateral."""
         if usd_value <= 0:
             raise ValueError(f"usd_value must be positive, got {usd_value}")
 
@@ -2961,19 +2801,16 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
 
     async def _execute_deposit_loop(self, usdc_amount: float) -> tuple[bool, Any, int]:
-        """Execute the recursive leverage loop."""
         token_info = await self._get_token_info(USDC_TOKEN_ID)
         decimals = token_info.get("decimals", 6)
         initial_deposit = int(usdc_amount * 10**decimals)
 
-        # Fetch prices and collateral factors in parallel (use cache, minimal RPC)
         wsteth_price, weth_price, collateral_factors = await asyncio.gather(
             self._get_token_price(WSTETH_TOKEN_ID),
             self._get_token_price(WETH_TOKEN_ID),
             self._get_collateral_factors(),
         )
 
-        # Fetch position separately to avoid overwhelming public RPC
         weth_pos = await self.moonwell_adapter.get_pos(mtoken=M_WETH)
 
         current_borrowed_value = 0.0
@@ -3020,12 +2857,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         wsteth_lend_value: float,
         collateral_factors: tuple[float, float] | None = None,
     ) -> tuple[bool, Any, int]:
-        """Execute leverage loop until target health factor reached.
-
-        Args:
-            collateral_factors: Optional (cf_usdc, cf_wsteth) tuple.
-                                If provided, skips collateral factor fetches.
-        """
         # Ensure USDC and wstETH markets are entered as collateral before borrowing
         # This is idempotent - if already entered, Moonwell just returns success
         if usdc_lend_value > 0:
@@ -3069,7 +2900,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         else:
             cf_u, cf_w = await self._get_collateral_factors()
 
-        # Calculate depeg-aware max safe leverage fraction
         max_safe_f = self._max_safe_F(cf_w)
 
         # Guard against division by zero/negative denominator
@@ -3080,7 +2910,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             )
             return (False, initial_leverage, -1)
 
-        # Calculate target borrow value
         target_borrow_value = (
             usdc_lend_value * cf_u / denominator - current_borrowed_value
         )
@@ -3104,7 +2933,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         leverage_tracker: list[float] = [initial_leverage]
 
         for i in range(self._MAX_LOOP_LIMIT):
-            # Get borrowable amount (returns USD with 18 decimals)
             borrowable_result = await self.moonwell_adapter.get_borrowable_amount()
             if not borrowable_result[0]:
                 logger.warning("Failed to get borrowable amount")
@@ -3121,7 +2949,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
             weth_info = await self._get_token_info(WETH_TOKEN_ID)
             weth_decimals = weth_info.get("decimals", 18)
-            # Convert USD to WETH wei: (USD / price) * 10^decimals
             max_borrow_wei = int(borrowable_usd / weth_price * 10**weth_decimals)
 
             # remaining_value is how much more we need to borrow/lend THIS session
@@ -3175,7 +3002,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (True, leverage_tracker[-1], len(leverage_tracker) - 1)
 
     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")
@@ -3208,12 +3034,10 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
 
     async def _update_impl(self) -> StatusTuple:
-        """Update implementation (called by update() wrapper)."""
         logger.info("=" * 60)
         logger.info("UPDATE START")
         logger.info("=" * 60)
 
-        # Check gas balance - deposit() should have provided sufficient gas
         gas_amt = await self._get_gas_balance()
         logger.info(
             f"Gas balance: {gas_amt / 10**18:.6f} ETH (min: {self.MAINTENANCE_GAS} ETH)"
@@ -3392,18 +3216,15 @@ class MoonwellWstethLoopStrategy(Strategy):
         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)
 
-        # 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 the snapshot
         usdc_key = f"Base_{M_USDC}"
         wsteth_key = f"Base_{M_WSTETH}"
         usdc_lend_value = totals_usd.get(usdc_key, 0)
@@ -3506,7 +3327,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
 
     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
 
@@ -3515,9 +3335,7 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         # 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
+        full_repay_buffer_wei = max(10_000, remaining_debt // 10_000)
         can_repay_full = amount >= (remaining_debt + full_repay_buffer_wei)
 
         if can_repay_full:
@@ -3543,7 +3361,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     async def _swap_to_weth_and_repay(
         self, token_id: str, amount: int, remaining_debt: int
     ) -> 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,
@@ -3580,7 +3397,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return await self._repay_weth(weth_bal, remaining_debt)
 
     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")
@@ -3613,12 +3429,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (False, f"{status[1]} | {suffix}")
 
     async def _withdraw_impl(self, amount: float | None = None) -> StatusTuple:
-        """Withdraw implementation (called by withdraw() wrapper).
-
-        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")
@@ -3626,7 +3436,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         collateral_factors = await self._get_collateral_factors()
 
-        # 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}")
@@ -3670,9 +3479,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             (
                 ok,
                 msg,
-            ) = (
-                await self._unlend_remaining_positions()
-            )  # swaps wstETH->USDC internally
+            ) = await self._unlend_remaining_positions()
         except SwapOutcomeUnknownError as exc:
             return (False, f"Swap outcome unknown while unlending positions: {exc}")
         except Exception as exc:  # noqa: BLE001
@@ -3723,7 +3530,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
 
     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")
@@ -3757,7 +3563,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         gas_balance = await self._get_balance_raw(
             token_id=ETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
-        tx_fee_reserve = int(0.0002 * 10**18)  # Reserve 0.0002 ETH for tx fee
+        tx_fee_reserve = int(0.0002 * 10**18)
         transferable_gas = gas_balance - tx_fee_reserve
         if transferable_gas > 0:
             gas_amount = transferable_gas / 10**18
@@ -3780,7 +3586,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
 
     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
@@ -3828,7 +3633,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         # Sweep any remaining tokens to USDC
         ok, msg = await self._sweep_token_balances(
             target_token_id=USDC_TOKEN_ID,
-            exclude={ETH_TOKEN_ID, WELL_TOKEN_ID},  # Keep gas + reward token
+            exclude={ETH_TOKEN_ID, WELL_TOKEN_ID},
             min_usd_value=float(self.sweep_min_usd),
             strict=True,
         )
@@ -3837,7 +3642,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (True, "Unlent remaining positions")
 
     async def get_peg_diff(self) -> float | dict:
-        """Get stETH/ETH peg difference."""
         steth_price = await self._get_token_price(STETH_TOKEN_ID)
         weth_price = await self._get_token_price(WETH_TOKEN_ID)
 
@@ -3853,22 +3657,18 @@ class MoonwellWstethLoopStrategy(Strategy):
         return peg_diff
 
     async def _status(self) -> StatusDict:
-        """Report strategy status."""
         snap, _ = await self._accounting_snapshot()
         totals_usd = dict(snap.totals_usd)
 
         ltv = float(snap.ltv)
         hf = (1 / ltv) if ltv and ltv > 0 and not (ltv != ltv) else None
 
-        # Get gas balance
         gas_balance = await self._get_gas_balance()
 
-        # Get borrowable amount
         borrowable_result = await self.moonwell_adapter.get_borrowable_amount()
         borrowable_amt_raw = borrowable_result[1] if borrowable_result[0] else 0
         borrowable_amt = self._normalize_usd_value(borrowable_amt_raw)
 
-        # Calculate credit remaining
         total_borrowed = float(snap.debt_usd)
         credit_remaining = 1.0
         if (borrowable_amt + total_borrowed) > 0:
@@ -3876,13 +3676,10 @@ class MoonwellWstethLoopStrategy(Strategy):
                 borrowable_amt / (borrowable_amt + total_borrowed), 4
             )
 
-        # Get peg diff
         peg_diff = await self.get_peg_diff()
 
-        # Calculate portfolio value
         portfolio_value = float(snap.net_equity_usd)
 
-        # Get projected earnings
         quote = await self.quote()
 
         strategy_status = {
@@ -3896,7 +3693,7 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         return StatusDict(
             portfolio_value=portfolio_value,
-            net_deposit=0.0,  # Would need ledger integration
+            net_deposit=0.0,
             strategy_status=strategy_status,
             gas_available=gas_balance / 10**18,
             gassed_up=gas_balance >= int(self.MAINTENANCE_GAS * 10**18),
@@ -3904,7 +3701,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
     @staticmethod
     async def policies() -> list[str]:
-        """Return policy strings used to scope on-chain permissions."""
         return [
             # Moonwell operations
             await musdc_mint_or_approve_or_redeem(),