wayfinder-paths 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -18,6 +18,7 @@ from wayfinder_paths.adapters.hyperlend_adapter.adapter import HyperlendAdapter
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.constants.base import DEFAULT_SLIPPAGE
+from wayfinder_paths.core.constants.contracts import HYPEREVM_WHYPE
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -41,6 +42,7 @@ from wayfinder_paths.policies.hyperliquid import (
     any_hyperliquid_l1_payload,
     any_hyperliquid_user_payload,
 )
+from wayfinder_paths.policies.lifi import LIFI_ROUTERS, lifi_swap
 from wayfinder_paths.policies.prjx import PRJX_ROUTER, prjx_swap
 
 SYMBOL_TRANSLATION_TABLE = str.maketrans(
@@ -50,7 +52,7 @@ SYMBOL_TRANSLATION_TABLE = str.maketrans(
         "Ξ": "X",
     }
 )
-WRAPPED_HYPE_ADDRESS = "0x5555555555555555555555555555555555555555"
+WRAPPED_HYPE_ADDRESS = HYPEREVM_WHYPE
 
 
 class HyperlendStableYieldStrategy(Strategy):
@@ -245,15 +247,6 @@ class HyperlendStableYieldStrategy(Strategy):
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
-            self.register_adapters(
-                [
-                    balance,
-                    token_adapter,
-                    ledger_adapter,
-                    brap_adapter,
-                    hyperlend_adapter,
-                ]
-            )
             self.balance_adapter = balance
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
@@ -338,7 +331,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_usdt0_balance,
         ) = await self.balance_adapter.get_balance(
-            query=self.usdt_token_info.get("token_id"),
+            token_id=self.usdt_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -351,7 +344,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_hype_balance,
         ) = await self.balance_adapter.get_balance(
-            query=self.hype_token_info.get("token_id"),
+            token_id=self.hype_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -839,7 +832,7 @@ class HyperlendStableYieldStrategy(Strategy):
         total_usdt = 0.0
         try:
             _, total_usdt_wei = await self.balance_adapter.get_balance(
-                query=self.usdt_token_info.get("token_id"),
+                token_id=self.usdt_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if total_usdt_wei and total_usdt_wei > 0:
@@ -852,7 +845,7 @@ class HyperlendStableYieldStrategy(Strategy):
         total_hype = 0.0
         try:
             _, total_hype_wei = await self.balance_adapter.get_balance(
-                query=self.hype_token_info.get("token_id"),
+                token_id=self.hype_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if total_hype_wei and total_hype_wei > 0:
@@ -865,7 +858,6 @@ class HyperlendStableYieldStrategy(Strategy):
         if sweep_actions:
             messages.append(f"Residual sweeps: {'; '.join(sweep_actions)}.")
 
-        # Report balances in strategy wallet
         balance_parts = []
         if total_usdt > 0:
             balance_parts.append(
@@ -902,13 +894,12 @@ class HyperlendStableYieldStrategy(Strategy):
 
         transferred_items = []
 
-        # Transfer USDT0 to main wallet
         usdt_ok, usdt_raw = await self.balance_adapter.get_balance(
             token_id="usdt0-hyperevm",
             wallet_address=strategy_address,
         )
         if usdt_ok and usdt_raw:
-            usdt_balance = float(usdt_raw.get("balance", 0))
+            usdt_balance = float(usdt_raw) / 1e6  # USDT has 6 decimals
             if usdt_balance > 1.0:
                 self.logger.info(
                     f"Transferring {usdt_balance:.2f} USDT0 to main wallet"
@@ -917,7 +908,7 @@ class HyperlendStableYieldStrategy(Strategy):
                     success,
                     msg,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query="usdt0-hyperevm",
+                    token_id="usdt0-hyperevm",
                     amount=usdt_balance,
                     strategy_name=self.name,
                     skip_ledger=False,
@@ -927,13 +918,12 @@ class HyperlendStableYieldStrategy(Strategy):
                 else:
                     self.logger.warning(f"USDT0 transfer failed: {msg}")
 
-        # Transfer HYPE (minus reserve for tx fees) to main wallet
         hype_ok, hype_raw = await self.balance_adapter.get_balance(
             token_id="hyperliquid-hyperevm",
             wallet_address=strategy_address,
         )
         if hype_ok and hype_raw:
-            hype_balance = float(hype_raw.get("balance", 0))
+            hype_balance = float(hype_raw) / 1e18  # HYPE has 18 decimals
             tx_fee_reserve = 0.1
             transferable_hype = hype_balance - tx_fee_reserve
             if transferable_hype > 0.01:
@@ -944,7 +934,7 @@ class HyperlendStableYieldStrategy(Strategy):
                     success,
                     msg,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query="hyperliquid-hyperevm",
+                    token_id="hyperliquid-hyperevm",
                     amount=transferable_hype,
                     strategy_name=self.name,
                     skip_ledger=False,
@@ -1014,7 +1004,7 @@ class HyperlendStableYieldStrategy(Strategy):
                     success,
                     message,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query=token_info.get("token_id"),
+                    token_id=token_info.get("token_id"),
                     amount=amount_tokens,
                     strategy_name=self.name,
                 )
@@ -2275,7 +2265,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             strategy_hype_balance_wei,
         ) = await self.balance_adapter.get_balance(
-            query=self.hype_token_info.get("token_id"),
+            token_id=self.hype_token_info.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
         )
         hype_price = asset_map.get(WRAPPED_HYPE_ADDRESS, {}).get("price_usd") or 0.0
@@ -2381,4 +2371,6 @@ class HyperlendStableYieldStrategy(Strategy):
             await enso_swap(),
             erc20_spender_for_any_token(PRJX_ROUTER),
             await prjx_swap(),
+            erc20_spender_for_any_token(LIFI_ROUTERS[999]),
+            await lifi_swap(999),
         ]

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -1,36 +1,15 @@
-import sys
 from pathlib import Path
 from unittest.mock import AsyncMock
 
-# Ensure wayfinder-paths is on path for tests.test_utils import
-# This is a workaround until conftest loading order is resolved
-_wayfinder_path_dir = Path(__file__).parent.parent.parent.resolve()
-_wayfinder_path_str = str(_wayfinder_path_dir)
-if _wayfinder_path_str not in sys.path:
-    sys.path.insert(0, _wayfinder_path_str)
-elif sys.path.index(_wayfinder_path_str) > 0:
-    # Move to front to take precedence
-    sys.path.remove(_wayfinder_path_str)
-    sys.path.insert(0, _wayfinder_path_str)
-
-import pytest  # noqa: E402
-
-try:
-    from tests.test_utils import get_canonical_examples, load_strategy_examples
-except ImportError:
-    # Fallback if path setup didn't work
-    import importlib.util
-
-    test_utils_path = Path(_wayfinder_path_dir) / "tests" / "test_utils.py"
-    spec = importlib.util.spec_from_file_location("tests.test_utils", test_utils_path)
-    test_utils = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(test_utils)
-    get_canonical_examples = test_utils.get_canonical_examples
-    load_strategy_examples = test_utils.load_strategy_examples
-
-from wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy import (  # noqa: E402
+import pytest
+
+from wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy import (
     HyperlendStableYieldStrategy,
 )
+from wayfinder_paths.tests.test_utils import (
+    get_canonical_examples,
+    load_strategy_examples,
+)
 
 
 @pytest.fixture
@@ -48,10 +27,9 @@ def strategy():
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
         # Mock balances: 1000 USDT0 (with 6 decimals) and 2 HYPE (with 18 decimals)
-        def get_balance_side_effect(query, wallet_address, **kwargs):
-            token_id = (
-                query if isinstance(query, str) else (query or {}).get("token_id")
-            )
+        def get_balance_side_effect(
+            *, wallet_address, token_id=None, token_address=None, chain_id=None
+        ):
             token_id_str = str(token_id).lower() if token_id else ""
             if "usdt0" in token_id_str or token_id_str == "usdt0":
                 # 1000 USDT0 with 6 decimals = 1000 * 10^6 = 1000000000
@@ -102,7 +80,6 @@ def strategy():
         )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
-        # Mock the main methods first
         s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
@@ -145,9 +122,7 @@ def strategy():
             )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
-        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
-            return_value=(True, {"net_deposit": 0})
-        )
+        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(return_value=(True, 0.0))
         s.ledger_adapter.get_strategy_transactions = AsyncMock(
             return_value=(True, {"transactions": []})
         )
@@ -155,46 +130,36 @@ def strategy():
     if hasattr(s, "brap_adapter") and s.brap_adapter:
         usdt0_address = "0x1234567890123456789012345678901234567890"
 
-        def get_swap_quote_side_effect(*args, **kwargs):
+        def best_quote_side_effect(*args, **kwargs):
             to_token_address = kwargs.get("to_token_address", "")
             if to_token_address == usdt0_address:
-                return (
-                    True,
-                    {
-                        "quotes": {
-                            "best_quote": {
-                                "output_amount": "99900000",
-                            }
-                        }
-                    },
-                )
+                return (True, {"output_amount": "99900000"})
             return (
                 True,
                 {
-                    "quotes": {
-                        "best_quote": {
-                            "output_amount": "105000000",
-                            "input_amount": "50000000000000",
-                            "toAmount": "105000000",
-                            "estimatedGas": "1000000000",
-                            "fromAmount": "100000000",
-                            "fromToken": {"symbol": "USDT0"},
-                            "toToken": {"symbol": "HYPE"},
-                        }
-                    }
+                    "output_amount": "105000000",
+                    "input_amount": "50000000000000",
+                    "toAmount": "105000000",
+                    "estimatedGas": "1000000000",
+                    "fromAmount": "100000000",
+                    "fromToken": {"symbol": "USDT0"},
+                    "toToken": {"symbol": "HYPE"},
                 },
             )
 
-        s.brap_adapter.get_swap_quote = AsyncMock(
-            side_effect=get_swap_quote_side_effect
-        )
+        s.brap_adapter.best_quote = AsyncMock(side_effect=best_quote_side_effect)
 
     if (
         hasattr(s, "brap_adapter")
         and s.brap_adapter
         and hasattr(s.brap_adapter, "swap_from_quote")
     ):
-        s.brap_adapter.swap_from_quote = AsyncMock(return_value=None)
+        s.brap_adapter.swap_from_quote = AsyncMock(
+            return_value=(
+                True,
+                {"tx_hash": "0xmockhash", "from_amount": "100", "to_amount": "99"},
+            )
+        )
 
     if hasattr(s, "hyperlend_adapter") and s.hyperlend_adapter:
         s.hyperlend_adapter.get_assets_view = AsyncMock(

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -13,7 +13,17 @@ 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.chains import CHAIN_ID_BASE
+from wayfinder_paths.core.constants.contracts import BASE_USDC, BASE_WSTETH
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
+from wayfinder_paths.core.constants.tokens import (
+    TOKEN_ID_ETH_BASE,
+    TOKEN_ID_STETH,
+    TOKEN_ID_USDC_BASE,
+    TOKEN_ID_WELL_BASE,
+    TOKEN_ID_WETH_BASE,
+    TOKEN_ID_WSTETH_BASE,
+)
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -38,28 +48,22 @@ from wayfinder_paths.policies.moonwell import (
     weth_deposit,
 )
 
-# Token addresses on Base
-USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-WSTETH = "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452"
-
-# Token IDs
-USDC_TOKEN_ID = "usd-coin-base"
-WETH_TOKEN_ID = "l2-standard-bridged-weth-base-base"
-WSTETH_TOKEN_ID = "superbridge-bridged-wsteth-base-base"
-ETH_TOKEN_ID = "ethereum-base"
-WELL_TOKEN_ID = "moonwell-artemis-base"
-STETH_TOKEN_ID = "staked-ether-ethereum"
+USDC = BASE_USDC
+WSTETH = BASE_WSTETH
 
-# Base chain ID
-BASE_CHAIN_ID = 8453
+USDC_TOKEN_ID = TOKEN_ID_USDC_BASE
+WETH_TOKEN_ID = TOKEN_ID_WETH_BASE
+WSTETH_TOKEN_ID = TOKEN_ID_WSTETH_BASE
+ETH_TOKEN_ID = TOKEN_ID_ETH_BASE
+WELL_TOKEN_ID = TOKEN_ID_WELL_BASE
+STETH_TOKEN_ID = TOKEN_ID_STETH
 
-# Safety parameters
-# 0.98 = 2% safety margin when borrowing to avoid hitting exact liquidation threshold
+BASE_CHAIN_ID = CHAIN_ID_BASE
 COLLATERAL_SAFETY_FACTOR = 0.98
 
 
 class SwapOutcomeUnknownError(RuntimeError):
-    "Raised when the outcome of a swap operation is unknown."
+    pass
 
 
 class MoonwellWstethLoopStrategy(Strategy):
@@ -192,14 +196,12 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         self.config = merged_config
 
-        # Adapter references
         self.balance_adapter: BalanceAdapter | None = None
         self.moonwell_adapter: MoonwellAdapter | None = None
         self.brap_adapter: BRAPAdapter | None = None
         self.token_adapter: TokenAdapter | None = None
         self.ledger_adapter: LedgerAdapter | None = None
 
-        # Token info cache
         self._token_info_cache: dict[str, dict] = {}
         self._token_price_cache: dict[str, float] = {}
         self._token_price_timestamps: dict[str, float] = {}
@@ -235,16 +237,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
-            self.register_adapters(
-                [
-                    balance,
-                    token_adapter,
-                    ledger_adapter,
-                    brap_adapter,
-                    moonwell_adapter,
-                ]
-            )
-
             self.balance_adapter = balance
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
@@ -373,11 +365,9 @@ class MoonwellWstethLoopStrategy(Strategy):
             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
@@ -1554,7 +1544,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if self.token_adapter is None:
             raise RuntimeError("Token adapter not initialized.")
 
-        # Pre-fetch token info
         for token_id in [USDC_TOKEN_ID, WETH_TOKEN_ID, WSTETH_TOKEN_ID, ETH_TOKEN_ID]:
             try:
                 success, info = await self.token_adapter.get_token(token_id)
@@ -1718,7 +1707,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                     logger.info(
                         f"Swap succeeded on attempt {i + 1} with slippage {slippage * 100:.1f}%"
                     )
-                    # Ensure result is a dict with to_amount
                     if isinstance(result, dict):
                         return result
                     return {"to_amount": result if isinstance(result, int) else 0}
@@ -1744,7 +1732,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                     f"failed with slippage {slippage * 100:.1f}%: {e}"
                 )
             if i < max_retries - 1:
-                # Exponential backoff: 1s, 2s, 4s
                 await asyncio.sleep(2**i)
 
         logger.error(
@@ -1834,7 +1821,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                 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(
@@ -1940,6 +1926,34 @@ class MoonwellWstethLoopStrategy(Strategy):
             token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
 
+    async def _get_wallet_balances_usd(self) -> dict[str, dict]:
+        strategy_addr = self._get_strategy_wallet_address()
+
+        weth_raw, usdc_raw, wsteth_raw = await asyncio.gather(
+            self._get_balance_raw(token_id=WETH_TOKEN_ID, wallet_address=strategy_addr),
+            self._get_balance_raw(token_id=USDC_TOKEN_ID, wallet_address=strategy_addr),
+            self._get_balance_raw(
+                token_id=WSTETH_TOKEN_ID, wallet_address=strategy_addr
+            ),
+        )
+
+        # Get token data (prices cached from _aggregate_positions)
+        token_data = await asyncio.gather(
+            self._get_token_data(WETH_TOKEN_ID),
+            self._get_token_data(USDC_TOKEN_ID),
+            self._get_token_data(WSTETH_TOKEN_ID),
+        )
+
+        def calc(raw: int, decimals: int, price: float) -> dict:
+            tokens = raw / 10**decimals if raw > 0 else 0.0
+            return {"tokens": tokens, "usd": tokens * price}
+
+        return {
+            "WETH": calc(weth_raw, token_data[0][1], token_data[0][0]),
+            "USDC": calc(usdc_raw, token_data[1][1], token_data[1][0]),
+            "wstETH": calc(wsteth_raw, token_data[2][1], token_data[2][0]),
+        }
+
     async def _validate_gas_balance(self) -> tuple[bool, str]:
         gas_balance = await self._get_gas_balance()
         main_gas = await self._get_balance_raw(
@@ -1978,7 +1992,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         return (True, "USDC deposit amount validated", usdc_amount)
 
     async def _check_quote_profitability(self) -> tuple[bool, str]:
-        quote = await self.quote()
+        quote = await self._quote()
         if quote.get("apy", 0) < 0:
             return (
                 False,
@@ -2023,7 +2037,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if exclude is None:
             exclude = set()
 
-        # Always exclude gas token and target
         exclude.add(ETH_TOKEN_ID)
         exclude.add(target_token_id)
 
@@ -2078,7 +2091,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 rewards if above threshold
         claimed_ok, claimed = await self.moonwell_adapter.claim_rewards(
             min_rewards_usd=self.MIN_REWARD_CLAIM_USD
         )
@@ -2105,7 +2117,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             )
             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"
@@ -2173,7 +2184,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         if not success:
             return (False, message)
 
-        # Transfer USDC to vault wallet
         success, message = await self._transfer_usdc_to_vault(usdc_amount)
         if not success:
             return (False, message)
@@ -2228,7 +2238,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             logger.warning(f"Failed to fetch stETH APY: {e}")
         return None
 
-    async def quote(self) -> dict:
+    async def _quote(self) -> dict:
         (
             usdc_apy_result,
             weth_apy_result,
@@ -2350,7 +2360,6 @@ class MoonwellWstethLoopStrategy(Strategy):
         weth_bal = int(weth_after)
 
         if eth_delta > 0 and usable_eth > 0:
-            # Borrow arrived as native ETH - wrap it first
             wrap_amt = min(int(safe_borrow_amt), int(usable_eth))
             logger.info(
                 f"Borrow arrived as native ETH, wrapping {wrap_amt / 10**18:.6f} ETH to WETH"
@@ -2478,7 +2487,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             min(to_amount_wei, wsteth_bal) if wsteth_bal > 0 else to_amount_wei
         )
 
-        # If swap produced 0 wstETH, rollback the borrow
         if lend_amt_wei <= 0:
             logger.warning("Swap resulted in 0 wstETH. Rolling back borrow...")
             try:
@@ -2818,7 +2826,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             borrow_bal = weth_pos[1].get("borrow_balance", 0)
             current_borrowed_value = (borrow_bal / 10**18) * weth_price
 
-        # Lend USDC and enable as collateral
         success, msg = await self.moonwell_adapter.lend(
             mtoken=M_USDC,
             underlying_token=USDC,
@@ -2894,7 +2901,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             )
         logger.info("Entered M_WETH market to enable borrowing")
 
-        # Use provided collateral factors or fetch them
         if collateral_factors is not None:
             cf_u, cf_w = collateral_factors
         else:
@@ -2902,7 +2908,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         max_safe_f = self._max_safe_F(cf_w)
 
-        # Guard against division by zero/negative denominator
         denominator = self.TARGET_HEALTH_FACTOR + 0.001 - cf_w
         if denominator <= 0:
             logger.warning(
@@ -3053,7 +3058,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         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}")
@@ -3410,7 +3414,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         err: Exception | None = None
 
         try:
-            status = await self._withdraw_impl(amount)
+            status = await self._withdraw_impl()
         except Exception as exc:
             err = exc
             if isinstance(exc, SwapOutcomeUnknownError):
@@ -3428,8 +3432,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
         return (False, f"{status[1]} | {suffix}")
 
-    async def _withdraw_impl(self, amount: float | None = None) -> StatusTuple:
-        # NOTE: amount is currently unused; withdraw() is all-or-nothing in this strategy.
+    async def _withdraw_impl(self) -> StatusTuple:
         logger.info("=" * 60)
         logger.info("WITHDRAW START - Full position unwind")
         logger.info("=" * 60)
@@ -3537,7 +3540,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         transferred_items = []
 
-        # Transfer USDC to main wallet
         usdc_balance = await self._get_balance_raw(
             token_id=USDC_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
@@ -3559,7 +3561,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             transferred_items.append(f"{usdc_amount:.2f} USDC")
             logger.info(f"USDC transfer successful: {usdc_amount:.2f} USDC")
 
-        # 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()
         )
@@ -3588,7 +3589,6 @@ class MoonwellWstethLoopStrategy(Strategy):
     async def _unlend_remaining_positions(self) -> tuple[bool, str]:
         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)
@@ -3600,7 +3600,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                 )
                 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,
                     wallet_address=self._get_strategy_wallet_address(),
@@ -3614,7 +3613,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                     if swap_result is None:
                         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)
@@ -3627,10 +3625,8 @@ class MoonwellWstethLoopStrategy(Strategy):
                 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
         ok, msg = await self._sweep_token_balances(
             target_token_id=USDC_TOKEN_ID,
             exclude={ETH_TOKEN_ID, WELL_TOKEN_ID},
@@ -3661,6 +3657,27 @@ class MoonwellWstethLoopStrategy(Strategy):
         totals_usd = dict(snap.totals_usd)
 
         ltv = float(snap.ltv)
+
+        wallet_balances: dict[str, dict[str, float]] = {}
+        wallet_tokens = {
+            "WETH": ("wallet_weth", TOKEN_ID_WETH_BASE),
+            "USDC": ("wallet_usdc", TOKEN_ID_USDC_BASE),
+            "wstETH": ("wallet_wsteth", TOKEN_ID_WSTETH_BASE),
+        }
+        # Assume snapshot exposes token prices and decimals keyed by token id
+        prices_usd = getattr(snap, "prices_usd", {}) or {}
+        token_decimals = getattr(snap, "token_decimals", {}) or {}
+        for symbol, (attr_name, token_id) in wallet_tokens.items():
+            raw_balance = getattr(snap, attr_name, 0) or 0
+            if raw_balance:
+                decimals = token_decimals.get(token_id, 18)
+                price = prices_usd.get(token_id, 0.0) or 0.0
+                tokens = float(raw_balance) / float(10**decimals)
+                usd_value = tokens * float(price)
+                wallet_balances[symbol] = {
+                    "tokens": tokens,
+                    "usd": usd_value,
+                }
         hf = (1 / ltv) if ltv and ltv > 0 and not (ltv != ltv) else None
 
         gas_balance = await self._get_gas_balance()
@@ -3678,12 +3695,21 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         peg_diff = await self.get_peg_diff()
 
-        portfolio_value = float(snap.net_equity_usd)
+        # Calculate displayed portfolio value.
+        # Note: snap.net_equity_usd represents net equity (wallet + supplies - debt),
+        # so wallet_value is added here only for this aggregate display metric.
+        net_equity_value = float(snap.net_equity_usd)
+        wallet_value = sum(wb["usd"] for wb in wallet_balances.values())
+        portfolio_value = net_equity_value + wallet_value
 
-        quote = await self.quote()
+        quote = await self._quote()
 
         strategy_status = {
             "current_positions_usd_value": totals_usd,
+            "wallet_balances": {
+                k: v for k, v in wallet_balances.items() if v["tokens"] > 0
+            },
+            "wallet_balances_total_usd": wallet_value,
             "credit_remaining": f"{credit_remaining * 100:.2f}%",
             "LTV": ltv,
             "health_factor": hf,