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

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -1,5 +1,3 @@
-"""Tests for BasisTradingStrategy."""
-
 import json
 from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, patch
@@ -12,21 +10,17 @@ from wayfinder_paths.tests.test_utils import load_strategy_examples
 
 
 def load_examples():
-    """Load test examples from examples.json using shared utility."""
     return load_strategy_examples(Path(__file__))
 
 
 class TestBasisTradingStrategy:
-    """Tests for BasisTradingStrategy."""
-
     @pytest.fixture
     def mock_hyperliquid_adapter(self):
-        """Create mock HyperliquidAdapter."""
         mock = MagicMock()
         # Provide enough points to satisfy the strategy's lookback checks without making tests too slow.
         n_points = 1200
         start_ms = 1700000000000
-        step_ms = 3600 * 1000  # 1h
+        step_ms = 3600 * 1000
         mock.get_meta_and_asset_ctxs = AsyncMock(
             return_value=(
                 True,
@@ -93,8 +87,8 @@ class TestBasisTradingStrategy:
                 True,
                 {
                     "levels": [
-                        [{"px": "1999", "sz": "100", "n": 10}],  # bids
-                        [{"px": "2001", "sz": "100", "n": 10}],  # asks
+                        [{"px": "1999", "sz": "100", "n": 10}],
+                        [{"px": "2001", "sz": "100", "n": 10}],
                     ],
                     "midPx": "2000",
                 },
@@ -120,7 +114,7 @@ class TestBasisTradingStrategy:
                 True,
                 {
                     "marginSummary": {"accountValue": "0"},
-                    "withdrawable": "100.0",  # Top-level withdrawable for withdraw() method
+                    "withdrawable": "100.0",
                     "assetPositions": [],
                 },
             )
@@ -139,9 +133,7 @@ class TestBasisTradingStrategy:
         mock.get_open_orders = AsyncMock(return_value=(True, []))
         mock.get_frontend_open_orders = AsyncMock(return_value=(True, []))
         mock.get_valid_order_size = MagicMock(side_effect=lambda _asset, size: size)
-        mock.wait_for_deposit = AsyncMock(
-            return_value=(True, 100.0)  # (deposit_confirmed, final_balance)
-        )
+        mock.wait_for_deposit = AsyncMock(return_value=(True, 100.0))
         mock.wait_for_withdrawal = AsyncMock(
             # tx_hash -> amount (float)
             return_value=(True, {"0x123456": 100.0})
@@ -150,13 +142,11 @@ class TestBasisTradingStrategy:
 
     @pytest.fixture
     def ledger_adapter(self, tmp_path):
-        """Create real LedgerAdapter with temp directory."""
         ledger_client = LedgerClient(ledger_dir=tmp_path)
         return LedgerAdapter(ledger_client=ledger_client)
 
     @pytest.fixture
     def strategy(self, mock_hyperliquid_adapter, ledger_adapter):
-        """Create strategy with mocked market adapters but real ledger."""
         with patch(
             "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
             return_value=mock_hyperliquid_adapter,
@@ -222,7 +212,6 @@ class TestBasisTradingStrategy:
     @pytest.mark.asyncio
     @pytest.mark.smoke
     async def test_smoke(self, strategy):
-        """Smoke test: deposit → update → status → withdraw lifecycle."""
         examples = load_examples()
         smoke = examples["smoke"]
 
@@ -241,7 +230,6 @@ class TestBasisTradingStrategy:
             success, msg = await strategy.deposit(**deposit_params)
             assert success, f"Deposit failed: {msg}"
 
-            # Update
             success, msg = await strategy.update()
             assert success, f"Update failed: {msg}"
 
@@ -255,7 +243,6 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     async def test_deposit_minimum(self, strategy):
-        """Test minimum deposit validation."""
         examples = load_examples()
         min_fail = examples.get("min_deposit_fail", {})
 
@@ -269,7 +256,6 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     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.
@@ -293,13 +279,11 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     async def test_withdraw_without_deposit(self, strategy):
-        """Test withdraw fails without deposit."""
         success, msg = await strategy.withdraw()
         assert success is False
 
     @pytest.mark.asyncio
     async def test_status(self, strategy):
-        """Test status returns expected fields."""
         status = await strategy.status()
         assert "portfolio_value" in status
         assert "net_deposit" in status
@@ -307,8 +291,6 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     async def test_ledger_records_snapshot(self, strategy, tmp_path):
-        """Test that status() records a snapshot to the ledger."""
-        # Get status (should record snapshot)
         status = await strategy.status()
         assert status is not None
 
@@ -325,30 +307,27 @@ class TestBasisTradingStrategy:
         assert snapshot["portfolio_value"] == status["portfolio_value"]
 
     def test_maintenance_rate(self):
-        """Test maintenance rate calculation."""
         from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
             BasisTradingStrategy,
         )
 
         rate = BasisTradingStrategy.maintenance_rate_from_max_leverage(50)
-        assert rate == 0.01  # 0.5 / 50
+        assert rate == 0.01
 
         rate = BasisTradingStrategy.maintenance_rate_from_max_leverage(10)
-        assert rate == 0.05  # 0.5 / 10
+        assert rate == 0.05
 
     def test_rolling_min_sum(self, strategy):
-        """Test rolling minimum sum calculation."""
         arr = [1, -2, 3, -4, 5]
         result = strategy._rolling_min_sum(arr, 2)
-        assert result == -1  # min of [1-2, -2+3, 3-4, -4+5] = [-1, 1, -1, 1]
+        assert result == -1
 
     def test_z_from_conf(self, strategy):
-        """Test z-score calculation."""
         z = strategy._z_from_conf(0.95)
-        assert 1.9 < z < 2.0  # ~1.96 for 95% two-sided confidence
+        assert 1.9 < z < 2.0
 
         z = strategy._z_from_conf(0.99)
-        assert 2.5 < z < 2.6  # ~2.576 for 99% two-sided confidence
+        assert 2.5 < z < 2.6
 
     @pytest.mark.asyncio
     async def test_build_batch_snapshot_and_filter(self, strategy):
@@ -373,7 +352,6 @@ class TestBasisTradingStrategy:
     async def test_get_undeployed_capital_empty(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Test _get_undeployed_capital with no capital."""
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
                 True,
@@ -395,7 +373,6 @@ class TestBasisTradingStrategy:
     async def test_get_undeployed_capital_with_margin(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Test _get_undeployed_capital with withdrawable margin."""
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
                 True,
@@ -418,7 +395,6 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     async def test_scale_up_position_no_position(self, strategy):
-        """Test _scale_up_position fails without existing position."""
         success, msg = await strategy._scale_up_position(100.0)
         assert success is False
         assert "No position to scale up" in msg
@@ -427,7 +403,6 @@ class TestBasisTradingStrategy:
     async def test_scale_up_position_below_minimum(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Test _scale_up_position rejects below minimum notional."""
         from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
             BasisPosition,
         )
@@ -447,14 +422,13 @@ class TestBasisTradingStrategy:
         # Try to scale with $5 (below $10 minimum notional)
         # With 2x leverage, order_usd = 5 * (2/3) = 3.33, below $10
         success, msg = await strategy._scale_up_position(5.0)
-        assert success  # Returns success=True but with message
+        assert success
         assert "below minimum notional" in msg
 
     @pytest.mark.asyncio
     async def test_update_with_idle_capital_scales_up(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Test update() calls _scale_up_position when idle capital exists."""
         from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
             BasisPosition,
         )
@@ -486,7 +460,7 @@ class TestBasisTradingStrategy:
                     "marginSummary": {
                         "accountValue": "120",
                         "withdrawable": "12",
-                        "totalNtlPos": "112",  # Deployed capital
+                        "totalNtlPos": "112",
                     },
                     "assetPositions": [
                         {
@@ -555,7 +529,6 @@ class TestBasisTradingStrategy:
     async def test_ensure_builder_fee_approved_already_approved(
         self, mock_hyperliquid_adapter, ledger_adapter
     ):
-        """Test ensure_builder_fee_approved when already approved."""
         with patch(
             "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
             return_value=mock_hyperliquid_adapter,
@@ -588,7 +561,7 @@ class TestBasisTradingStrategy:
                             return_value=(
                                 True,
                                 30,
-                            )  # Already approved for 30 tenths bp
+                            )
                         )
                         mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
                             return_value=(True, {"status": "ok"})
@@ -604,7 +577,6 @@ class TestBasisTradingStrategy:
     async def test_ensure_builder_fee_approved_needs_approval(
         self, mock_hyperliquid_adapter, ledger_adapter
     ):
-        """Test ensure_builder_fee_approved when approval is needed."""
         with patch(
             "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
             return_value=mock_hyperliquid_adapter,
@@ -634,7 +606,7 @@ class TestBasisTradingStrategy:
 
                         # Mock get_max_builder_fee returning insufficient approval
                         mock_hyperliquid_adapter.get_max_builder_fee = AsyncMock(
-                            return_value=(True, 0)  # Not approved yet
+                            return_value=(True, 0)
                         )
                         mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
                             return_value=(True, {"status": "ok"})
@@ -650,7 +622,6 @@ class TestBasisTradingStrategy:
     async def test_portfolio_value_includes_spot_holdings(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Portfolio value should include non-USDC spot holdings."""
         # Perp account has $100
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
@@ -678,11 +649,10 @@ class TestBasisTradingStrategy:
         total, hl_value, vault_value = await strategy._get_total_portfolio_value()
         # 100 (perp) + 50 (USDC) + 0.5*2000 (ETH) = 1150
         assert hl_value == 1150.0
-        assert total == 1150.0  # No vault balance
+        assert total == 1150.0
 
     @pytest.mark.asyncio
     async def test_portfolio_value_usdc_only(self, strategy, mock_hyperliquid_adapter):
-        """Portfolio value with only USDC spot balance."""
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
                 True,
@@ -704,7 +674,6 @@ class TestBasisTradingStrategy:
 
     @pytest.mark.asyncio
     async def test_withdraw_detects_spot_usdc(self, strategy, mock_hyperliquid_adapter):
-        """Withdraw should detect funds in spot USDC (not perp margin)."""
         # Perp is empty
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
@@ -732,7 +701,6 @@ class TestBasisTradingStrategy:
     async def test_update_detects_hl_balance_when_deposit_zero(
         self, strategy, mock_hyperliquid_adapter
     ):
-        """Update should detect Hyperliquid balance when deposit_amount is 0."""
         strategy.deposit_amount = 0
 
         # Hyperliquid has $50 in perp account
@@ -756,11 +724,6 @@ class TestBasisTradingStrategy:
     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
 
@@ -829,7 +792,6 @@ class TestBasisTradingStrategy:
     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,
         )
@@ -895,18 +857,11 @@ class TestBasisTradingStrategy:
 
     @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
@@ -916,10 +871,6 @@ class TestBasisTradingStrategy:
     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,

wayfinder_paths/strategies/basis_trading_strategy/types.py

@@ -6,8 +6,6 @@ from typing import Any
 
 @dataclass
 class BasisCandidate:
-    """Represents a potential basis trading opportunity."""
-
     coin: str
     spot_pair: str
     spot_asset_id: int
@@ -26,8 +24,6 @@ class BasisCandidate:
 
 @dataclass
 class BasisPosition:
-    """Tracks an active basis position."""
-
     coin: str
     spot_asset_id: int
     perp_asset_id: int

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -1,84 +1,93 @@
-# Hyperlend Stable Yield Strategy
+# HyperLend Stable Yield Strategy
 
-- Entrypoint: `strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
-- Examples: `examples.json`
-- Tests: `test_strategy.py`
+Stablecoin yield optimization on HyperLend (HyperEVM).
 
-## What it does
+- **Module**: `wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
+- **Chain**: HyperEVM
+- **Token**: USDT0
 
-Allocates USDT0 on HyperEVM across HyperLend stablecoin markets. The strategy:
+## Overview
 
-1. Pulls USDT0 (plus a configurable HYPE gas buffer) from the main wallet into the strategy wallet.
-2. Samples HyperLend hourly rate history, applies a bootstrap tournament (horizon = 6h, blocks = 6h, 4,000 trials, 7-day half-life) to estimate which stablecoin should outperform.
-3. Tops up the small HYPE gas buffer if needed, swaps USDT0 into the target stablecoin, and supplies it to HyperLend.
-4. Enforces a hysteresis rotation policy so minor APY noise does not churn capital.
+This strategy allocates USDT0 across HyperLend stablecoin markets by:
+1. Transferring USDT0 (plus HYPE gas buffer) from main wallet to strategy wallet
+2. Sampling HyperLend hourly rate history
+3. Running bootstrap tournament analysis to identify best-performing stablecoin
+4. Swapping and supplying to HyperLend
+5. Enforcing hysteresis rotation policy to prevent excessive churn
 
-## Key parameters
+## Key Parameters
 
-- `MIN_USDT0_DEPOSIT_AMOUNT = 1`
-- `GAS_MAXIMUM = 0.1` HYPE (max accepted per deposit)
-- `HORIZON_HOURS = 6`, `BLOCK_LEN = 6`, `TRIALS = 4000`
-- `HYSTERESIS_DWELL_HOURS = 168`, `HYSTERESIS_Z = 1.15`
-- `ROTATION_COOLDOWN = 168 hours`
-- `APY_REBALANCE_THRESHOLD = 0.0035` (35 bps edge required to rotate when not short-circuiting)
-- `MIN_STABLE_SWAP_TOKENS = 1e-3` → dust threshold when sweeping balances
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| `MIN_USDT0_DEPOSIT_AMOUNT` | 1 | Minimum deposit amount |
+| `GAS_MAXIMUM` | 0.1 HYPE | Maximum gas per deposit |
+| `HORIZON_HOURS` | 6 | Analysis horizon |
+| `TRIALS` | 4000 | Bootstrap simulation trials |
+| `HYSTERESIS_DWELL_HOURS` | 168 | Rotation cooldown |
+| `HYSTERESIS_Z` | 1.15 | APY improvement threshold |
+| `ROTATION_COOLDOWN` | 168 hours | Minimum time between rotations |
+| `APY_REBALANCE_THRESHOLD` | 0.0035 | 35 bps edge required to rotate |
 
-## Adapters used
+## Adapters Used
 
-- `BalanceAdapter` for token/pool balances and orchestrating wallet transfers with ledger tracking.
-- `TokenAdapter` for metadata (USDT0, HYPE, wrapping info).
-- `LedgerAdapter` for net deposit + rotation history.
-- `BRAPAdapter` to source quotes/swap stablecoins.
-- `HyperlendAdapter` for asset views, lend/withdraw ops, supply caps.
+- **BalanceAdapter**: Token/pool balances, wallet transfers
+- **TokenAdapter**: Token metadata (USDT0, HYPE)
+- **LedgerAdapter**: Net deposit, rotation history
+- **BRAPAdapter**: Swap quotes and execution
+- **HyperlendAdapter**: Asset views, lend/withdraw operations
 
 ## Actions
 
 ### Deposit
 
-- Validates USDT0 and HYPE balances in the main wallet.
-- Transfers HYPE into the strategy wallet when a top-up is required, ensuring the strategy maintains the configured buffer.
-- Moves USDT0 from the main wallet into the strategy wallet through `BalanceAdapter.move_from_main_wallet_to_strategy_wallet`.
-- Clears cached asset snapshots so the next update starts from on-chain reality.
+```bash
+poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy \
+    --action deposit --main-token-amount 25 --gas-token-amount 0.02 --config config.json
+```
+
+- Validates USDT0 and HYPE balances in main wallet
+- Transfers HYPE for gas buffer
+- Moves USDT0 to strategy wallet
+- Clears cached asset snapshots
 
 ### Update
 
-- Refreshes HyperLend asset snapshots, calculates tournament winners, and filters markets that respect supply caps + buffer requirements.
-- Reads rotation history through `LedgerAdapter.get_strategy_latest_transactions` to enforce the cooldown (unless the short-circuit policy is triggered).
-- If a new asset wins the tournament and passes hysteresis checks, BRAP quotes are fetched and executed to rotate into the better performer.
-- Sweeps residual stable balances, lends via `HyperlendAdapter`, and records ledger operations.
+```bash
+poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy \
+    --action update --config config.json
+```
+
+- Refreshes HyperLend asset snapshots
+- Runs tournament analysis to find winner
+- Enforces cooldown (unless short-circuit triggered)
+- Executes rotation via BRAP if new asset wins
+- Sweeps residual balances and lends via HyperlendAdapter
 
 ### Status
 
-`_status()` returns:
+```bash
+poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy \
+    --action status --config config.json
+```
 
-- `portfolio_value`: active lend balance (converted to float),
-- `net_deposit`: fetched from `LedgerAdapter`,
-- `strategy_status`: includes current lent asset, APY, idle balances, and tournament projections.
+Returns:
+- `portfolio_value`: Active lend balance
+- `net_deposit`: From LedgerAdapter
+- `strategy_status`: Current asset, APY, balances, tournament projections
 
 ### Withdraw
 
-- Unwinds existing HyperLend positions, swaps back to USDT0 when necessary, returns USDT0 and residual HYPE to the main wallet via `BalanceAdapter`, and clears cached state.
-
-## Running locally
-
 ```bash
-# Install dependencies
-poetry install
-
-# 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
+poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy \
+    --action withdraw --config config.json
+```
 
-# Copy config and edit credentials
-cp wayfinder_paths/config.example.json config.json
+- Unwinds HyperLend positions
+- Swaps back to USDT0 if needed
+- Returns USDT0 and residual HYPE to main wallet
 
-# Check status / health
-poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action status --config $(pwd)/config.json
+## Testing
 
-# Perform a deposit/update/withdraw cycle
-poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action deposit --main-token-amount 25 --gas-token-amount 0.02 --config $(pwd)/config.json
-poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action update --config $(pwd)/config.json
-poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action withdraw --config $(pwd)/config.json
+```bash
+poetry run pytest wayfinder_paths/strategies/hyperlend_stable_yield_strategy/ -v
 ```
-
-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

@@ -74,12 +74,12 @@ class HyperlendStableYieldStrategy(Strategy):
     ASSETS_SNAPSHOT_TTL_SECONDS = 20.0
     DEFAULT_LOOKBACK_HOURS = 24 * 7
     APY_REBALANCE_THRESHOLD = 0.0035
-    TOURNAMENT_MODE = "joint"  # "joint" or "independent"
+    TOURNAMENT_MODE = "joint"
     ROTATION_COOLDOWN = timedelta(hours=168)
     P_BEST_ROTATION_THRESHOLD = 0.4
     MAX_CANDIDATES = 5
     MIN_STABLE_SWAP_TOKENS = 1e-3
-    MAX_GAS = 0.1  # hype float
+    MAX_GAS = 0.1
 
     INFO = StratDescriptor(
         description=f"""Multi-strategy allocator that converts USDT0 into the most consistently rewarding HyperLend stablecoin and continuously checks if a rotation is justified.
@@ -104,7 +104,7 @@ class HyperlendStableYieldStrategy(Strategy):
         gas_token_id="hyperliquid-hyperevm",
         deposit_token_id="usdt0-hyperevm",
         minimum_net_deposit=10,
-        gas_maximum=MAX_GAS,  # hype float
+        gas_maximum=MAX_GAS,
         gas_threshold=MAX_GAS / 3,
         # risk indicators
         volatility=Volatility.LOW,
@@ -218,7 +218,6 @@ class HyperlendStableYieldStrategy(Strategy):
             main_wallet_cfg = self.config.get("main_wallet")
             strategy_wallet_cfg = self.config.get("strategy_wallet")
 
-            # Validate wallets are configured
             if not strategy_wallet_cfg or not strategy_wallet_cfg.get("address"):
                 raise ValueError(
                     "strategy_wallet not configured. Provide strategy_wallet address in config or ensure wallet is properly configured for your wallet provider"
@@ -428,8 +427,6 @@ class HyperlendStableYieldStrategy(Strategy):
         return total_tokens
 
     def _amount_to_wei(self, token: dict[str, Any], amount: Decimal) -> int:
-        """Convert ``amount`` tokens into base units using existing helpers."""
-
         if amount <= 0:
             return 0
 
@@ -746,21 +743,6 @@ class HyperlendStableYieldStrategy(Strategy):
     def _get_token_address(
         self, token: dict[str, Any] | None, chain_code: str = "hyperevm"
     ) -> str | None:
-        """
-        Extract token address from various token data structures.
-
-        Handles:
-        1. Top-level 'address' field (e.g., hype_token_info)
-        2. 'addresses' dict with chain_code key (e.g., addresses: {'hyperevm': '0x...'})
-        3. 'chain_addresses' dict with chain_code key (e.g., chain_addresses: {'hyperevm': {'address': '0x...'}})
-
-        Args:
-            token: Token dictionary with address information
-            chain_code: Chain code to look up in nested structures (default: 'hyperevm')
-
-        Returns:
-            Token address string or None if not found
-        """
         if not token:
             return None
 
@@ -910,7 +892,6 @@ class HyperlendStableYieldStrategy(Strategy):
         return (True, ". ".join(messages))
 
     async def exit(self, **kwargs) -> StatusTuple:
-        """Transfer funds from strategy wallet to main wallet."""
         self.logger.info("EXIT: Transferring remaining funds to main wallet")
 
         strategy_address = self._get_strategy_wallet_address()
@@ -953,7 +934,7 @@ class HyperlendStableYieldStrategy(Strategy):
         )
         if hype_ok and hype_raw:
             hype_balance = float(hype_raw.get("balance", 0))
-            tx_fee_reserve = 0.1  # Reserve 0.1 HYPE for tx fees
+            tx_fee_reserve = 0.1
             transferable_hype = hype_balance - tx_fee_reserve
             if transferable_hype > 0.01:
                 self.logger.info(
@@ -1050,8 +1031,6 @@ class HyperlendStableYieldStrategy(Strategy):
         return actions
 
     async def update(self) -> StatusTuple:
-        """Rebalance or update positions."""
-
         await self._hydrate_position_from_chain()
 
         redeploy_tokens = await self._estimate_redeploy_tokens()
@@ -2194,7 +2173,6 @@ class HyperlendStableYieldStrategy(Strategy):
 
                 raw_balance_wei = asset.get("underlying_wallet_balance_wei")
                 try:
-                    # Handle both "decimals" (plural) and "decimal" (singular) from API
                     token_decimals = token.get("decimals") or token.get("decimal")
                     asset_decimals = asset.get("decimals") or asset.get("decimal")
                     if token_decimals is not None:
@@ -2392,7 +2370,6 @@ class HyperlendStableYieldStrategy(Strategy):
 
     @staticmethod
     async def policies() -> list[str]:
-        """Return policy strings used to scope on-chain permissions."""
         return [
             any_hyperliquid_l1_payload(),
             any_hyperliquid_user_payload(),

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -15,7 +15,6 @@ elif sys.path.index(_wayfinder_path_str) > 0:
 
 import pytest  # noqa: E402
 
-# Import test utilities
 try:
     from tests.test_utils import get_canonical_examples, load_strategy_examples
 except ImportError:
@@ -36,7 +35,6 @@ from wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy import
 
 @pytest.fixture
 def strategy():
-    """Create a strategy instance for testing with minimal config."""
     mock_config = {
         "main_wallet": {"address": "0x1234567890123456789012345678901234567890"},
         "strategy_wallet": {"address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"},
@@ -339,7 +337,6 @@ def strategy():
 @pytest.mark.asyncio
 @pytest.mark.smoke
 async def test_smoke(strategy):
-    """REQUIRED: Basic smoke test - verifies strategy lifecycle."""
     examples = load_strategy_examples(Path(__file__))
     smoke_data = examples["smoke"]
 
@@ -355,7 +352,6 @@ async def test_smoke(strategy):
     assert isinstance(msg, str)
 
     result = await strategy.update(**smoke_data.get("update", {}))
-    # update() returns (ok, msg, should_notify) or (ok, msg)
     ok = result[0]
     assert isinstance(ok, bool)
 
@@ -365,11 +361,6 @@ async def test_smoke(strategy):
 
 @pytest.mark.asyncio
 async def test_canonical_usage(strategy):
-    """REQUIRED: Test canonical usage examples from examples.json (minimum).
-
-    Canonical usage = all positive usage examples (excluding error cases).
-    This is the MINIMUM requirement - feel free to add more test cases here.
-    """
     examples = load_strategy_examples(Path(__file__))
     canonical = get_canonical_examples(examples)
 
@@ -394,7 +385,6 @@ async def test_canonical_usage(strategy):
 
 @pytest.mark.asyncio
 async def test_error_cases(strategy):
-    """OPTIONAL: Test error scenarios from examples.json."""
     examples = load_strategy_examples(Path(__file__))
 
     for example_name, example_data in examples.items():