wayfinder-paths 0.1.11__py3-none-any.whl → 0.1.14__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -282,8 +282,25 @@ class TestBasisTradingStrategy:
                 assert success is False, "Expected deposit to fail"
 
     @pytest.mark.asyncio
-    async def test_update_without_deposit(self, strategy):
+    async def test_update_without_deposit(self, strategy, mock_hyperliquid_adapter):
         """Test update fails without deposit."""
+        strategy.deposit_amount = 0.0
+
+        # No USDC in perp withdrawable or spot.
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {"accountValue": "0"},
+                    "withdrawable": "0",
+                    "assetPositions": [],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": []})
+        )
+
         success, msg = await strategy.update()
         assert success is False
         assert "No deposit" in msg
@@ -347,15 +364,6 @@ class TestBasisTradingStrategy:
         z = strategy._z_from_conf(0.99)
         assert 2.5 < z < 2.6  # ~2.576 for 99% two-sided confidence
 
-    def test_calculate_funding_stats(self, strategy):
-        """Test funding statistics calculation."""
-        hourly_funding = [0.0001, 0.0002, -0.0001, 0.0003, 0.0001]
-        stats = strategy._calculate_funding_stats(hourly_funding)
-
-        assert stats["points"] == 5
-        assert stats["mean_hourly"] > 0
-        assert stats["neg_hour_fraction"] == 0.2  # 1/5 negative
-
     @pytest.mark.asyncio
     async def test_build_batch_snapshot_and_filter(self, strategy):
         snap = await strategy.build_batch_snapshot(
@@ -521,7 +529,7 @@ class TestBasisTradingStrategy:
             )
         )
         mock_hyperliquid_adapter.get_valid_order_size = MagicMock(
-            side_effect=lambda aid, sz: sz
+            side_effect=lambda _aid, sz: sz
         )
         mock_hyperliquid_adapter.transfer_perp_to_spot = AsyncMock(
             return_value=(True, "ok")
@@ -763,3 +771,212 @@ class TestBasisTradingStrategy:
 
         # deposit_amount should now be set from detected balance
         assert strategy.deposit_amount == 50.0
+
+    @pytest.mark.asyncio
+    async def test_update_spot_usdc_only_rebalances_before_open(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """
+        If funds are mostly in spot USDC (e.g., after liquidation), update() should:
+          - detect deposit from spot+perp USDC
+          - transfer spot->perp to reach the target split before opening.
+        """
+        strategy.deposit_amount = 0.0
+        strategy.current_position = None
+
+        # Perp account has $0 withdrawable, spot has $100 USDC
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {"accountValue": "0"},
+                    "withdrawable": "0",
+                    "assetPositions": [],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(
+                True,
+                {"balances": [{"coin": "USDC", "total": "100"}]},
+            )
+        )
+
+        # Avoid running the full solver; return a deterministic best trade.
+        strategy.find_best_trade_with_backtest = AsyncMock(
+            return_value={
+                "coin": "ETH",
+                "spot_asset_id": 10000,
+                "perp_asset_id": 1,
+                "net_apy": 0.1,
+                "best_L": 2,
+                "safe": {
+                    "7": {
+                        "safe_leverage": 2,
+                        "spot_usdc": 66.67,
+                        "spot_amount": 0.033335,
+                        "perp_amount": 0.033335,
+                    }
+                },
+            }
+        )
+
+        # Mock the paired filler to avoid actual execution
+        with patch(
+            "wayfinder_paths.strategies.basis_trading_strategy.strategy.PairedFiller"
+        ) as mock_filler_class:
+            mock_filler = MagicMock()
+            mock_filler.fill_pair_units = AsyncMock(
+                return_value=(0.5, 0.5, 1000.0, 1000.0, [], [])
+            )
+            mock_filler_class.return_value = mock_filler
+
+            success, _ = await strategy.update()
+            assert success is True
+
+        # Target spot was $66.67, so we should transfer $33.33 spot->perp.
+        mock_hyperliquid_adapter.transfer_spot_to_perp.assert_called_once()
+        _, kwargs = mock_hyperliquid_adapter.transfer_spot_to_perp.call_args
+        assert kwargs["address"] == "0x5678"
+        assert abs(kwargs["amount"] - 33.33) < 1e-6
+
+        # Should not attempt perp->spot when spot already has sufficient USDC.
+        mock_hyperliquid_adapter.transfer_perp_to_spot.assert_not_called()
+
+        assert strategy.deposit_amount == 100.0
+
+    @pytest.mark.asyncio
+    async def test_update_near_liquidation_closes_and_redeploys(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """Near-liquidation should trigger an emergency close+redeploy (bypasses cooldown)."""
+        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+            BasisPosition,
+        )
+
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="HYPE",
+            spot_asset_id=10107,
+            perp_asset_id=7,
+            spot_amount=1.0,
+            perp_amount=1.0,
+            entry_price=100.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        # Price is exactly 75% of the way from entry -> liquidation:
+        # (175 - 100) / (200 - 100) = 0.75
+        mock_hyperliquid_adapter.get_all_mid_prices = AsyncMock(
+            return_value=(True, {"HYPE": 175.0})
+        )
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "100",
+                        "withdrawable": "0",
+                        "totalNtlPos": "100",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "HYPE",
+                                "szi": "-1.0",
+                                "entryPx": "100",
+                                "liquidationPx": "200",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(
+                True,
+                {"balances": [{"coin": "HYPE", "total": "1.0"}]},
+            )
+        )
+
+        # Ensure cooldown would block a normal rebalance, but emergency should bypass it.
+        strategy._is_rotation_allowed = AsyncMock(return_value=(False, "cooldown"))
+        strategy._close_position = AsyncMock(return_value=(True, "closed"))
+        strategy._find_and_open_position = AsyncMock(return_value=(True, "redeployed"))
+
+        success, msg = await strategy.update()
+        assert success is True
+        assert msg == "redeployed"
+        strategy._close_position.assert_awaited_once()
+        strategy._find_and_open_position.assert_awaited_once()
+        strategy._is_rotation_allowed.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_net_deposit_handles_float_return(self, strategy):
+        """Test that strategy correctly handles float from get_strategy_net_deposit.
+
+        The ledger adapter returns (success, float) not (success, dict).
+        This test ensures the strategy doesn't try to call .get() on the float,
+        which would raise "'float' object has no attribute 'get'".
+        """
+        # Mock ledger adapter to return a float (not a dict)
+        strategy.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+            return_value=(True, 1500.0)
+        )
+
+        # Call status() which internally uses get_strategy_net_deposit
+        status = await strategy.status()
+
+        # Verify net_deposit is correctly set from the float
+        assert status["net_deposit"] == 1500.0
+
+    @pytest.mark.asyncio
+    async def test_setup_handles_float_net_deposit(
+        self, mock_hyperliquid_adapter, ledger_adapter
+    ):
+        """Test that setup() correctly handles float from get_strategy_net_deposit.
+
+        This catches if code is changed to expect a dict with .get('net_deposit').
+        """
+        with patch(
+            "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
+            return_value=mock_hyperliquid_adapter,
+        ):
+            with patch(
+                "wayfinder_paths.strategies.basis_trading_strategy.strategy.BalanceAdapter"
+            ):
+                with patch(
+                    "wayfinder_paths.strategies.basis_trading_strategy.strategy.TokenAdapter"
+                ):
+                    with patch(
+                        "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
+                        return_value=ledger_adapter,
+                    ):
+                        with patch(
+                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
+                        ):
+                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                                BasisTradingStrategy,
+                            )
+
+                            s = BasisTradingStrategy(
+                                config={
+                                    "main_wallet": {"address": "0x1234"},
+                                    "strategy_wallet": {"address": "0x5678"},
+                                },
+                            )
+                            s.hyperliquid_adapter = mock_hyperliquid_adapter
+                            s.ledger_adapter = ledger_adapter
+
+                            # Mock get_strategy_net_deposit to return float (not dict)
+                            s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+                                return_value=(True, 2500.0)
+                            )
+
+                            # Run setup - should not raise AttributeError
+                            await s.setup()
+
+                            # Verify deposit_amount was set from the float
+                            assert s.deposit_amount == 2500.0

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -66,7 +66,7 @@ Allocates USDT0 on HyperEVM across HyperLend stablecoin markets. The strategy:
 # Install dependencies
 poetry install
 
-# Generate main wallet (writes wallets.json)
+# Generate main wallet (writes config.json)
 # Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
@@ -82,4 +82,4 @@ poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strateg
 poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action withdraw --config $(pwd)/config.json
 ```
 
-Wallet addresses/labels are auto-resolved from `wallets.json`. Set `NETWORK=testnet` in your config to run the orchestration without touching live HyperEVM endpoints.
+Wallet addresses/labels are auto-resolved from `config.json`. Set `NETWORK=testnet` in your config to run the orchestration without touching live HyperEVM endpoints.

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -104,6 +104,7 @@ class HyperlendStableYieldStrategy(Strategy):
             f"rotation band (dwell={HYSTERESIS_DWELL_HOURS}h, z={HYSTERESIS_Z:.2f}) to avoid churn while still "
             "short-circuiting when yield gaps are extreme."
         ),
+        risk_description="Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risk includes rate volatility between sampling windows, swap slippage on HYPE ⇄ stable legs, HyperLend protocol risk, and rotation gas costs eroding yield if APY edges are thin. Strategy requires a small HYPE balance for gas on HyperEVM.",
         gas_token_symbol="HYPE",
         gas_token_id="hyperliquid-hyperevm",
         deposit_token_id="usdt0-hyperevm",
@@ -196,9 +197,8 @@ class HyperlendStableYieldStrategy(Strategy):
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
         web3_service: Web3Service = None,
-        api_key: str | None = None,
     ):
-        super().__init__(api_key=api_key)
+        super().__init__()
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -349,7 +349,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_usdt0_balance,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.usdt_token_info.get("token_id"),
+            query=self.usdt_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -362,7 +362,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_hype_balance,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.hype_token_info.get("token_id"),
+            query=self.hype_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -529,11 +529,10 @@ class HyperlendStableYieldStrategy(Strategy):
                 return self._assets_snapshot
 
             _, snapshot = await self.hyperlend_adapter.get_assets_view(
-                chain_id=self.hype_token_info.get("chain").get("id"),
                 user_address=self._get_strategy_wallet_address(),
             )
 
-            assets = snapshot.get("assets_view", {}).get("assets", [])
+            assets = snapshot.get("assets", [])
             asset_map = {}
 
             for asset in assets:
@@ -581,11 +580,9 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, data = await self.hyperlend_adapter.get_stable_markets(
-                chain_id=self.hype_token_info.get("chain").get("id"),
                 required_underlying_tokens=required_tokens,
                 buffer_bps=self.SUPPLY_CAP_BUFFER_BPS,
                 min_buffer_tokens=self.SUPPLY_CAP_MIN_BUFFER_TOKENS,
-                is_stable_symbol=True,
             )
             markets = data.get("markets", {}) if isinstance(data, dict) else {}
         except Exception:
@@ -608,7 +605,7 @@ class HyperlendStableYieldStrategy(Strategy):
     async def _get_lent_positions(self, snapshot=None) -> dict[str, dict[str, Any]]:
         if not snapshot:
             snapshot = await self._get_assets_snapshot()
-        assets = snapshot.get("assets_view", {}).get("assets", None)
+        assets = snapshot.get("assets", None)
 
         if not assets:
             return {}
@@ -629,7 +626,14 @@ class HyperlendStableYieldStrategy(Strategy):
                 continue
 
             try:
-                success, token = await self.token_adapter.get_token(checksum)
+                chain_id = None
+                try:
+                    chain_id = int((self.hype_token_info.get("chain") or {}).get("id"))
+                except Exception:
+                    chain_id = None
+                success, token = await self.token_adapter.get_token(
+                    checksum, chain_id=chain_id
+                )
                 if not success or not isinstance(token, dict):
                     logger.info(f"Error getting token for asset: {asset}")
                     continue
@@ -715,8 +719,8 @@ class HyperlendStableYieldStrategy(Strategy):
                     result,
                     tx_data,
                 ) = await self.brap_adapter.swap_from_token_ids(
-                    from_token_id=from_token_id,
-                    to_token_id=to_token_id,
+                    from_query=from_token_id,
+                    to_query=to_token_id,
                     from_address=strategy_address,
                     amount=amount_wei_str,
                     slippage=slippage,
@@ -861,7 +865,7 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, total_usdt_wei = await self.balance_adapter.get_balance(
-                token_id=self.usdt_token_info.get("token_id"),
+                query=self.usdt_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
         except Exception:
@@ -890,7 +894,7 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, total_hype_wei = await self.balance_adapter.get_balance(
-                token_id=self.hype_token_info.get("token_id"),
+                query=self.hype_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
         except Exception:
@@ -986,7 +990,7 @@ class HyperlendStableYieldStrategy(Strategy):
                     success,
                     message,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    token_id=token_info.get("token_id"),
+                    query=token_info.get("token_id"),
                     amount=amount_tokens,
                     strategy_name=self.name,
                 )
@@ -1548,11 +1552,9 @@ class HyperlendStableYieldStrategy(Strategy):
         )
 
         _, stable_markets = await self.hyperlend_adapter.get_stable_markets(
-            chain_id=self.hype_token_info.get("chain").get("id"),
             required_underlying_tokens=required_underlying_tokens,
             buffer_bps=self.SUPPLY_CAP_BUFFER_BPS,
             min_buffer_tokens=self.SUPPLY_CAP_MIN_BUFFER_TOKENS,
-            is_stable_symbol=True,
         )
         filtered_notes = stable_markets.get("notes", [])
         filtered_map = stable_markets.get("markets", {})
@@ -1584,8 +1586,7 @@ class HyperlendStableYieldStrategy(Strategy):
             if current_checksum_lower not in existing_addresses:
                 try:
                     _, current_entry = await self.hyperlend_adapter.get_market_entry(
-                        chain_id=self.hype_token_info.get("chain").get("id"),
-                        token_address=current_checksum_value,
+                        token=current_checksum_value,
                     )
                 except Exception:
                     current_entry = None
@@ -1632,8 +1633,7 @@ class HyperlendStableYieldStrategy(Strategy):
         histories = await asyncio.gather(
             *[
                 self.hyperlend_adapter.get_lend_rate_history(
-                    chain_id=self.hype_token_info.get("chain").get("id"),
-                    token_address=addr,
+                    token=addr,
                     lookback_hours=lookback_hours,
                 )
                 for addr, _ in filtered
@@ -1655,7 +1655,7 @@ class HyperlendStableYieldStrategy(Strategy):
             if not history_status:
                 continue
             history_data = history[1]
-            for row in history_data.get("rate_history", []):
+            for row in history_data.get("history", []):
                 ts_ms = row.get("timestamp_ms")
                 if ts_ms is None:
                     continue
@@ -1811,7 +1811,14 @@ class HyperlendStableYieldStrategy(Strategy):
         token = None
         if address:
             try:
-                success, token = await self.token_adapter.get_token(address.lower())
+                chain_id = None
+                try:
+                    chain_id = int((self.hype_token_info.get("chain") or {}).get("id"))
+                except Exception:
+                    chain_id = None
+                success, token = await self.token_adapter.get_token(
+                    address.lower(), chain_id=chain_id
+                )
             except Exception:
                 token = None
             if not success:
@@ -2127,7 +2134,16 @@ class HyperlendStableYieldStrategy(Strategy):
                     continue
 
                 try:
-                    success, token = await self.token_adapter.get_token(checksum)
+                    chain_id = None
+                    try:
+                        chain_id = int(
+                            (self.hype_token_info.get("chain") or {}).get("id")
+                        )
+                    except Exception:
+                        chain_id = None
+                    success, token = await self.token_adapter.get_token(
+                        checksum, chain_id=chain_id
+                    )
                     if not success or not isinstance(token, dict):
                         continue
                 except Exception:
@@ -2238,7 +2254,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             strategy_hype_balance_wei,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.hype_token_info.get("token_id"),
+            query=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

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -50,7 +50,10 @@ 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(token_id, wallet_address, **kwargs):
+        def get_balance_side_effect(query, wallet_address, **kwargs):
+            token_id = (
+                query if isinstance(query, str) else (query or {}).get("token_id")
+            )
             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
@@ -209,7 +212,31 @@ def strategy():
 
     if hasattr(s, "hyperlend_adapter") and s.hyperlend_adapter:
         s.hyperlend_adapter.get_assets_view = AsyncMock(
-            return_value=(True, {"assets_view": {"assets": []}})
+            return_value=(
+                True,
+                {
+                    "block_number": 12345,
+                    "user": "0x0",
+                    "native_balance_wei": 0,
+                    "native_balance": 0.0,
+                    "assets": [],
+                    "account_data": {
+                        "total_collateral_base": 0,
+                        "total_debt_base": 0,
+                        "available_borrows_base": 0,
+                        "current_liquidation_threshold": 0,
+                        "ltv": 0,
+                        "health_factor_wad": 0,
+                        "health_factor": 0.0,
+                    },
+                    "base_currency_info": {
+                        "marketReferenceCurrencyUnit": 100000000,
+                        "marketReferenceCurrencyPriceInUsd": 100000000,
+                        "networkBaseTokenPriceInUsd": 0,
+                        "networkBaseTokenPriceDecimals": 8,
+                    },
+                },
+            )
         )
         s.hyperlend_adapter.get_stable_markets = AsyncMock(
             return_value=(
@@ -232,14 +259,24 @@ def strategy():
                 },
             )
         )
+        # Block bootstrap needs at least BLOCK_LEN (6) rows; provide enough history
+        _history_base = {
+            "timestamp_ms": 1700000000000,
+            "timestamp": 1700000000.0,
+            "supply_apr": 0.05,
+            "supply_apy": 0.05,
+            "borrow_apr": 0.07,
+            "borrow_apy": 0.07,
+            "token": "0x1234567890123456789012345678901234567890",
+            "symbol": "usdt0",
+            "display_symbol": "USDT0",
+        }
+        history_rows = [
+            {**_history_base, "timestamp_ms": 1700000000000 + i * 3600000}
+            for i in range(24)
+        ]
         s.hyperlend_adapter.get_lend_rate_history = AsyncMock(
-            return_value=(
-                True,
-                {
-                    "rates": [{"rate": 5.0, "timestamp": 1700000000}],
-                    "avg_rate": 5.0,
-                },
-            )
+            return_value=(True, {"history": history_rows})
         )
 
     s.usdt_token_info = {
@@ -259,6 +296,14 @@ def strategy():
         "chain": {"code": "hyperevm", "id": 9999, "name": "HyperEVM"},
     }
     s.current_token = None
+    # Attributes normally set in setup()
+    s.rotation_policy = "hysteresis"
+    s.hys_dwell_hours = 168
+    s.hys_z = 1.15
+    s.rotation_tx_cost = 0.002
+    s.last_summary = None
+    s.last_dominance = None
+    s.last_samples = None
 
     if hasattr(s, "token_adapter") and s.token_adapter:
         if not hasattr(s.token_adapter, "get_token_price"):

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/README.md

@@ -86,7 +86,7 @@ The position is **delta-neutral**: WETH debt offsets wstETH collateral, so PnL i
 # Install dependencies
 poetry install
 
-# Generate wallets (writes wallets.json)
+# Generate wallets (writes config.json)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
 # Copy config and edit credentials

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -81,7 +81,8 @@ class MoonwellWstethLoopStrategy(Strategy):
     summary = "Loop wstETH on Moonwell for amplified staking yields."
 
     # Strategy parameters
-    MIN_GAS = 0.002  # Minimum Base ETH (in ETH) required for gas fees (Base L2)
+    # Minimum Base ETH (in ETH) required for gas fees (Base L2)
+    MIN_GAS = 0.002
     MAINTENANCE_GAS = MIN_GAS / 10
     # 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.
@@ -110,6 +111,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         description="Leveraged wstETH carry: loops USDC → borrow WETH → swap wstETH → lend. "
         "Depeg-aware sizing with safety factor. ETH-neutral: WETH debt vs wstETH collateral.",
         summary="Leveraged wstETH carry on Base with depeg-aware sizing.",
+        risk_description=f"Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include weth/wsteth depegging (this strategy tracks the peg and is robust up to {int(MAX_DEPEG * 100)}% depeg). The rate spread between weth borrow and wsteth lend may also turn negative. This will likely only be temporary and is very rare. If this persists manual withdraw may be needed.",
         gas_token_symbol="ETH",
         gas_token_id=ETH_TOKEN_ID,
         deposit_token_id=USDC_TOKEN_ID,
@@ -506,7 +508,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             if self.balance_adapter is None:
                 return 0
             success, raw = await self.balance_adapter.get_balance(
-                token_id=token_id,
+                query=token_id,
                 wallet_address=wallet_address,
             )
             return self._parse_balance(raw) if success else 0
@@ -532,11 +534,9 @@ class MoonwellWstethLoopStrategy(Strategy):
             return 0
 
         try:
-            evm = getattr(self.web3_service, "evm_transactions", None)
-            if evm is None:
-                return 0
-            ok, bal = await evm.get_balance(
-                wallet_address, token_address, BASE_CHAIN_ID, block_identifier
+            ok, bal = await self.balance_adapter.get_balance(
+                query=token_id,
+                wallet_address=wallet_address,
             )
             return int(bal) if ok else 0
         except Exception as exc:
@@ -1340,7 +1340,8 @@ class MoonwellWstethLoopStrategy(Strategy):
         for mtoken in mtoken_list:
             pos = await self.moonwell_adapter.get_pos(mtoken=mtoken)
             positions.append(pos)
-            await asyncio.sleep(2.0)  # 2s delay between positions for public RPC
+            # 2s delay between positions for public RPC
+            await asyncio.sleep(2.0)
 
         # Token data can be fetched in parallel (uses cache, minimal RPC)
         token_data = await asyncio.gather(
@@ -1718,7 +1719,7 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         # 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()
+            query=WSTETH_TOKEN_ID, wallet_address=self._get_strategy_wallet_address()
         )
         if not wsteth_success:
             raise Exception("Failed to get wstETH balance after swap")