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

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -42,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(
@@ -246,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
@@ -866,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(
@@ -903,7 +894,6 @@ 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,
@@ -928,7 +918,6 @@ 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,
@@ -2382,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
@@ -101,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)")
         )

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -63,7 +63,7 @@ COLLATERAL_SAFETY_FACTOR = 0.98
 
 
 class SwapOutcomeUnknownError(RuntimeError):
-    "Raised when the outcome of a swap operation is unknown."
+    pass
 
 
 class MoonwellWstethLoopStrategy(Strategy):
@@ -196,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] = {}
@@ -239,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
@@ -377,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
@@ -1558,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)
@@ -1722,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}
@@ -1748,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(
@@ -1838,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(
@@ -1944,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(
@@ -1982,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,
@@ -2027,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)
 
@@ -2082,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
         )
@@ -2109,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"
@@ -2177,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)
@@ -2232,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,
@@ -2354,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"
@@ -2482,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:
@@ -2822,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,
@@ -2898,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:
@@ -2906,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(
@@ -3057,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}")
@@ -3540,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()
         )
@@ -3562,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()
         )
@@ -3591,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)
@@ -3603,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(),
@@ -3617,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)
@@ -3630,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},
@@ -3664,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()
@@ -3681,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,

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/test_strategy.py

@@ -56,7 +56,6 @@ def strategy():
 
 @pytest.fixture
 def mock_adapter_responses(strategy):
-    # Mock balance adapter
     strategy.balance_adapter.get_balance = AsyncMock(return_value=(True, 1000000))
     strategy.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
         return_value=(True, "success")
@@ -65,7 +64,6 @@ def mock_adapter_responses(strategy):
         return_value=(True, "success")
     )
 
-    # Mock token adapter
     strategy.token_adapter.get_token = AsyncMock(
         return_value=(True, {"decimals": 18, "symbol": "TEST"})
     )
@@ -73,7 +71,6 @@ def mock_adapter_responses(strategy):
         return_value=(True, {"current_price": 1.0})
     )
 
-    # Mock moonwell adapter
     strategy.moonwell_adapter.get_pos = AsyncMock(
         return_value=(
             True,
@@ -102,7 +99,6 @@ def mock_adapter_responses(strategy):
     strategy.moonwell_adapter.set_collateral = AsyncMock(return_value=(True, "success"))
     strategy.moonwell_adapter.claim_rewards = AsyncMock(return_value={})
 
-    # Mock brap adapter
     strategy.brap_adapter.swap_from_token_ids = AsyncMock(
         return_value=(True, {"to_amount": 1000000000000000000})
     )
@@ -116,8 +112,8 @@ async def test_smoke(strategy, mock_adapter_responses):
     examples = load_strategy_examples(Path(__file__))
     smoke_data = examples["smoke"]
 
-    # Mock quote to return positive APY
-    with patch.object(strategy, "quote", new_callable=AsyncMock) as mock_quote:
+    # Mock _quote to return positive APY
+    with patch.object(strategy, "_quote", new_callable=AsyncMock) as mock_quote:
         mock_quote.return_value = {"apy": 0.1, "data": {}}
 
         # Status test
@@ -166,7 +162,7 @@ async def test_canonical_usage(strategy, mock_adapter_responses):
 
     for example_name, example_data in canonical.items():
         # Mock methods for canonical usage tests
-        with patch.object(strategy, "quote", new_callable=AsyncMock) as mock_quote:
+        with patch.object(strategy, "_quote", new_callable=AsyncMock) as mock_quote:
             mock_quote.return_value = {"apy": 0.1, "data": {}}
 
             if "deposit" in example_data:
@@ -226,7 +222,7 @@ async def test_status_returns_status_dict(strategy, mock_adapter_responses):
             ) as mock_peg:
                 mock_peg.return_value = 0.001
                 with patch.object(
-                    strategy, "quote", new_callable=AsyncMock
+                    strategy, "_quote", new_callable=AsyncMock
                 ) as mock_quote:
                     mock_quote.return_value = {"apy": 0.1, "data": {}}
 
@@ -288,7 +284,7 @@ async def test_quote_returns_apy_info(strategy, mock_adapter_responses):
             return_value=mock_response
         )
 
-        quote = await strategy.quote()
+        quote = await strategy._quote()
 
         assert "apy" in quote
         assert "information" in quote or "data" in quote
@@ -624,7 +620,6 @@ async def test_atomic_deposit_iteration_swaps_from_eth_when_borrow_surfaces_as_e
     strategy.moonwell_adapter.borrow = AsyncMock(side_effect=borrow_side_effect)
 
     async def wrap_eth_side_effect(*, amount: int):
-        # Wrap ETH to WETH
         balances[ETH_TOKEN_ID] -= int(amount)
         balances[WETH_TOKEN_ID] += int(amount)
         return (True, {"block_number": 12346})
@@ -634,10 +629,8 @@ async def test_atomic_deposit_iteration_swaps_from_eth_when_borrow_surfaces_as_e
     async def swap_side_effect(
         *, from_token_id: str, to_token_id: str, amount: int, **_
     ):
-        # After wrapping, the swap should be WETH→wstETH
         assert from_token_id == WETH_TOKEN_ID
         assert to_token_id == WSTETH_TOKEN_ID
-        # Simulate receiving wstETH
         balances[WSTETH_TOKEN_ID] += 123
         return {"to_amount": 123}
 
@@ -897,7 +890,6 @@ async def test_partial_liquidate_prefers_wsteth_when_excess(strategy):
     strategy.token_adapter.get_token = AsyncMock(side_effect=mock_get_token)
     strategy.token_adapter.get_token_price = AsyncMock(side_effect=mock_get_price)
 
-    # Wallet balances (raw)
     balances: dict[str, int] = {USDC_TOKEN_ID: 0, WSTETH_TOKEN_ID: 0}
 
     async def mock_get_balance_raw(*, token_id: str, wallet_address: str, **_):
@@ -915,7 +907,6 @@ async def test_partial_liquidate_prefers_wsteth_when_excess(strategy):
     snap.wsteth_price = 2000.0
     snap.wsteth_dec = 18
 
-    # Collateral factors
     strategy.moonwell_adapter.get_collateral_factor = AsyncMock(
         return_value=(True, 0.8)
     )
@@ -987,7 +978,6 @@ async def test_partial_liquidate_prefers_wsteth_when_excess(strategy):
 
 @pytest.mark.asyncio
 async def test_partial_liquidate_uses_usdc_collateral_when_no_wsteth_excess(strategy):
-    # Token metadata
     strategy.token_adapter.get_token = AsyncMock(
         side_effect=lambda token_id: (
             True,