wayfinder-paths 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

wayfinder_paths/core/services/local_token_txn.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from decimal import ROUND_DOWN, Decimal
 from typing import Any
 
@@ -27,7 +28,6 @@ class LocalTokenTxnService(TokenTxn):
         self.wallet_provider = wallet_provider
         self.logger = logger.bind(service="DefaultEvmTransactionService")
         self.token_client = TokenClient()
-        self.builder = _EvmTransactionBuilder(wallet_provider)
 
     async def build_send(
         self,
@@ -61,7 +61,7 @@ class LocalTokenTxnService(TokenTxn):
             amount_wei = self._to_base_units(amount, decimals)
 
         try:
-            tx = await self.builder.build_send_transaction(
+            tx = await self.build_send_transaction(
                 from_address=from_address,
                 to_address=to_address,
                 token_address=token_address,
@@ -93,7 +93,7 @@ class LocalTokenTxnService(TokenTxn):
         except (TypeError, ValueError) as exc:
             return False, str(exc)
 
-        approve_tx = self.builder.build_erc20_approval_transaction(
+        approve_tx = self.build_erc20_approval_transaction(
             chain_id=chain_id,
             token_address=token_checksum,
             from_address=from_checksum,
@@ -104,28 +104,53 @@ class LocalTokenTxnService(TokenTxn):
         return True, approve_tx
 
     async def read_erc20_allowance(
-        self, chain: Any, token_address: str, from_address: str, spender_address: str
+        self,
+        chain: Any,
+        token_address: str,
+        from_address: str,
+        spender_address: str,
+        max_retries: int = 3,
     ) -> dict[str, Any]:
         try:
             chain_id = self._chain_id(chain)
         except (TypeError, ValueError) as exc:
             return {"error": str(exc), "allowance": 0}
 
-        w3 = self.get_web3(chain_id)
-        try:
-            contract = w3.eth.contract(
-                address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
-            )
-            allowance = await contract.functions.allowance(
-                to_checksum_address(from_address),
-                to_checksum_address(spender_address),
-            ).call()
-            return (True, {"allowance": int(allowance)})
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"Failed to read allowance: {exc}")
-            return {"error": f"Allowance query failed: {exc}", "allowance": 0}
-        finally:
-            await self._close_web3(w3)
+        last_error = None
+        for attempt in range(max_retries):
+            w3 = self.wallet_provider.get_web3(chain_id)
+            try:
+                contract = w3.eth.contract(
+                    address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
+                )
+                allowance = await contract.functions.allowance(
+                    to_checksum_address(from_address),
+                    to_checksum_address(spender_address),
+                ).call()
+                return {"allowance": int(allowance)}
+            except Exception as exc:  # noqa: BLE001
+                last_error = exc
+                error_str = str(exc)
+                if "429" in error_str or "Too Many Requests" in error_str:
+                    if attempt < max_retries - 1:
+                        wait_time = 3.0 * (2**attempt)  # 3, 6, 12 seconds
+                        self.logger.warning(
+                            f"Rate limited reading allowance, retrying in {wait_time}s..."
+                        )
+                        await asyncio.sleep(wait_time)
+                        continue
+                self.logger.error(f"Failed to read allowance: {exc}")
+                return {"error": f"Allowance query failed: {exc}", "allowance": 0}
+            finally:
+                await self.wallet_provider._close_web3(w3)
+
+        self.logger.error(
+            f"Failed to read allowance after {max_retries} retries: {last_error}"
+        )
+        return {
+            "error": f"Allowance query failed after retries: {last_error}",
+            "allowance": 0,
+        }
 
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
@@ -144,13 +169,6 @@ class LocalTokenTxnService(TokenTxn):
         )
         return int(quantized)
 
-
-class _EvmTransactionBuilder:
-    """Helpers that only build transaction dictionaries for sends and approvals."""
-
-    def __init__(self, wallet_provider: EvmTxn) -> None:
-        self.wallet_provider = wallet_provider
-
     async def build_send_transaction(
         self,
         *,
@@ -200,6 +218,7 @@ class _EvmTransactionBuilder:
         web3: AsyncWeb3,
     ) -> dict[str, Any]:
         """Build an ERC20 approval transaction dict."""
+        del web3  # Use sync Web3 for encoding (AsyncContract doesn't have encodeABI)
         token_checksum = to_checksum_address(token_address)
         spender_checksum = to_checksum_address(spender)
         from_checksum = to_checksum_address(from_address)
@@ -208,6 +227,7 @@ class _EvmTransactionBuilder:
         # Use synchronous Web3 for encoding (encodeABI doesn't exist in web3.py v7)
         w3_sync = Web3()
         contract = w3_sync.eth.contract(address=token_checksum, abi=ERC20_APPROVAL_ABI)
+
         # In web3.py v7, use _encode_transaction_data to encode without network calls
         data = contract.functions.approve(
             spender_checksum, amount_int

wayfinder_paths/core/strategies/descriptors.py

@@ -66,7 +66,7 @@ class StratDescriptor(BaseModel):
 
     # risk indicators
     volatility: Volatility
-    volatility_description_short: str
+    volatility_description: str
     directionality: Directionality
     directionality_description: str
     complexity: Complexity

wayfinder_paths/run_strategy.py

@@ -13,7 +13,6 @@ from pathlib import Path
 from loguru import logger
 
 from wayfinder_paths.core.config import StrategyJobConfig
-from wayfinder_paths.core.engine.manifest import load_manifest, validate_manifest
 from wayfinder_paths.core.engine.StrategyJob import StrategyJob
 
 
@@ -24,7 +23,7 @@ def load_strategy(
     api_key: str | None = None,
 ):
     """
-    Dynamically load a strategy by name using its manifest
+    Dynamically load a strategy by name
 
     Args:
         strategy_name: Name of the strategy to load (directory name in strategies/)
@@ -34,28 +33,42 @@ def load_strategy(
     Returns:
         Strategy instance
     """
-    # Find strategy manifest by scanning for manifest.yaml in the strategy directory
+    # Build the expected module path from strategy name
     strategies_dir = Path(__file__).parent / "strategies"
     strategy_dir = strategies_dir / strategy_name
-    manifest_path = strategy_dir / "manifest.yaml"
 
-    if not manifest_path.exists():
+    if not strategy_dir.exists():
         # List available strategies for better error message
         available = []
         if strategies_dir.exists():
             for path in strategies_dir.iterdir():
-                if path.is_dir() and (path / "manifest.yaml").exists():
+                if path.is_dir() and (path / "strategy.py").exists():
                     available.append(path.name)
         available_str = ", ".join(available) if available else "none"
         raise ValueError(
             f"Unknown strategy: {strategy_name}. Available strategies: {available_str}"
         )
 
-    # Load manifest and use its entrypoint
-    manifest = load_manifest(str(manifest_path))
-    module_path, class_name = manifest.entrypoint.rsplit(".", 1)
-    module = __import__(module_path, fromlist=[class_name])
-    strategy_class = getattr(module, class_name)
+    # Import strategy module and find Strategy class
+    module_path = f"strategies.{strategy_name}.strategy"
+    module = __import__(module_path, fromlist=[""])
+
+    # Find the Strategy subclass in the module
+    from wayfinder_paths.core.strategies.Strategy import Strategy
+
+    strategy_class = None
+    for attr_name in dir(module):
+        attr = getattr(module, attr_name)
+        if (
+            isinstance(attr, type)
+            and issubclass(attr, Strategy)
+            and attr is not Strategy
+        ):
+            strategy_class = attr
+            break
+
+    if strategy_class is None:
+        raise ValueError(f"No Strategy class found in {module_path}")
 
     return strategy_class(config=strategy_config, api_key=api_key)
 
@@ -102,7 +115,6 @@ async def run_strategy(
     strategy_name: str | None = None,
     config_path: str | None = None,
     action: str = "run",
-    manifest_path: str | None = None,
     **kwargs,
 ):
     """
@@ -115,37 +127,14 @@ async def run_strategy(
         **kwargs: Additional arguments for the action
     """
     try:
-        # Determine strategy name for wallet lookup BEFORE loading config
-        # This ensures wallets are properly matched during config initialization
-        manifest = None
-        strategy_name_for_wallet = None
-        if manifest_path:
-            logger.debug(f"Loading strategy via manifest: {manifest_path}")
-            manifest = load_manifest(manifest_path)
-            validate_manifest(manifest)
-            # Extract directory name from manifest path for wallet lookup
-            # Use the directory name (strategy identifier) for wallet lookup
-            manifest_dir = Path(manifest_path).parent
-            strategies_dir = Path(__file__).parent / "strategies"
-            try:
-                # Try to get relative path - if it's under strategies_dir, use directory name
-                rel_path = manifest_dir.relative_to(strategies_dir)
-                strategy_name_for_wallet = (
-                    rel_path.parts[0] if rel_path.parts else manifest_dir.name
-                )
-            except ValueError:
-                # Not under strategies_dir, fallback to directory name or manifest name
-                strategy_name_for_wallet = manifest_dir.name or manifest.name
-        else:
-            if not strategy_name:
-                raise ValueError("Either strategy_name or --manifest must be provided")
-            logger.debug(f"Loading strategy by name: {strategy_name}")
-            # Use directory name (strategy_name) directly for wallet lookup
-            strategy_name_for_wallet = strategy_name
+        if not strategy_name:
+            raise ValueError("strategy_name is required")
+
+        logger.debug(f"Loading strategy by name: {strategy_name}")
 
         # Load configuration with strategy name for wallet lookup
         logger.debug(f"Config path provided: {config_path}")
-        config = load_config(config_path, strategy_name=strategy_name_for_wallet)
+        config = load_config(config_path, strategy_name=strategy_name)
         logger.debug(
             "Loaded config: creds=%s wallets(main=%s strategy=%s)",
             "yes"
@@ -156,25 +145,12 @@ async def run_strategy(
             (config.user.strategy_wallet_address or "none"),
         )
 
-        # Validate required configuration
-        # No user id required; authentication is via credentials or refresh token
-
         # Load strategy with the enriched config
-        if manifest_path:
-            # Load strategy class from manifest
-            module_path, class_name = manifest.entrypoint.rsplit(".", 1)
-            module = __import__(module_path, fromlist=[class_name])
-            strategy_class = getattr(module, class_name)
-            strategy = strategy_class(config=config.strategy_config)
-            logger.info(
-                f"Loaded strategy from manifest: {strategy_name_for_wallet or 'unnamed'}"
-            )
-        else:
-            strategy = load_strategy(
-                strategy_name,
-                strategy_config=config.strategy_config,
-            )
-            logger.info(f"Loaded strategy: {strategy.name}")
+        strategy = load_strategy(
+            strategy_name,
+            strategy_config=config.strategy_config,
+        )
+        logger.info(f"Loaded strategy: {strategy.name}")
 
         # Create strategy job
         strategy_job = StrategyJob(strategy, config)
@@ -251,16 +227,6 @@ async def run_strategy(
             except Exception:
                 pass
 
-            if not policies and manifest and getattr(manifest, "permissions", None):
-                try:
-                    mpol = manifest.permissions.get("policy")
-                    if isinstance(mpol, str):
-                        policies = [mpol]
-                    elif isinstance(mpol, list):
-                        policies = [p for p in mpol if isinstance(p, str)]
-                except Exception:
-                    pass
-
             seen = set()
             deduped: list[str] = []
             for p in policies:
@@ -321,13 +287,8 @@ def main():
     parser = argparse.ArgumentParser(description="Run strategy strategies")
     parser.add_argument(
         "strategy",
-        nargs="?",
         help="Strategy to run (stablecoin_yield_strategy)",
     )
-    parser.add_argument(
-        "--manifest",
-        help="Path to strategy manifest YAML (alternative to strategy name)",
-    )
     parser.add_argument(
         "--config", help="Path to config file (defaults to config.json)"
     )
@@ -393,7 +354,6 @@ def main():
             strategy_name=args.strategy,
             config_path=args.config,
             action=args.action,
-            manifest_path=args.manifest,
             amount=args.amount,
             main_token_amount=args.main_token_amount,
             gas_token_amount=args.gas_token_amount,

wayfinder_paths/scripts/create_strategy.py

@@ -5,7 +5,7 @@ Create a new strategy from template and generate a dedicated wallet for it.
 This script:
 1. Copies the strategy template to a new directory
 2. Generates a wallet with label matching the strategy name
-3. Updates the manifest with the strategy name
+3. Updates the strategy files with the correct names
 """
 
 import argparse
@@ -13,8 +13,6 @@ import re
 import shutil
 from pathlib import Path
 
-import yaml
-
 from wayfinder_paths.core.utils.wallets import make_random_wallet, write_wallet_to_json
 
 
@@ -29,18 +27,6 @@ def sanitize_name(name: str) -> str:
     return name.lower()
 
 
-def update_manifest(manifest_path: Path, strategy_name: str, entrypoint: str) -> None:
-    """Update manifest.yaml with strategy name and entrypoint."""
-    with open(manifest_path) as f:
-        manifest_data = yaml.safe_load(f)
-
-    manifest_data["name"] = strategy_name
-    manifest_data["entrypoint"] = entrypoint
-
-    with open(manifest_path, "w") as f:
-        yaml.dump(manifest_data, f, default_flow_style=False, sort_keys=False)
-
-
 def update_strategy_file(strategy_path: Path, class_name: str) -> None:
     """Update strategy.py with new class name."""
     content = strategy_path.read_text()
@@ -111,7 +97,6 @@ def main():
     # Copy template files
     template_files = [
         "strategy.py",
-        "manifest.yaml",
         "test_strategy.py",
         "examples.json",
         "README.md",
@@ -135,15 +120,6 @@ def main():
         update_strategy_file(strategy_file, class_name)
         print(f"  Updated strategy.py with class name: {class_name}")
 
-    # Generate entrypoint path
-    entrypoint = f"strategies.{dir_name}.strategy.{class_name}"
-
-    # Update manifest with name (using directory name) and entrypoint
-    manifest_path = strategy_dir / "manifest.yaml"
-    if manifest_path.exists():
-        update_manifest(manifest_path, dir_name, entrypoint)
-        print(f"  Updated manifest.yaml with name: {dir_name}")
-
     # Generate wallet with label matching directory name (strategy identifier)
     # If wallets.json doesn't exist, create it with a main wallet first
     if not args.wallets_file.exists():
@@ -169,11 +145,10 @@ def main():
     print(f"   Directory: {strategy_dir}")
     print(f"   Name: {dir_name}")
     print(f"   Class: {class_name}")
-    print(f"   Entrypoint: {entrypoint}")
     print(f"   Wallet: {wallet['address']}")
     print("\nNext steps:")
     print(f"   1. Edit {strategy_dir / 'strategy.py'} to implement your strategy")
-    print(f"   2. Update {strategy_dir / 'manifest.yaml'} with required adapters")
+    print("   2. Add required adapters in __init__")
     print(f"   3. Test with: just test-strategy {dir_name}")
 
 

wayfinder_paths/scripts/run_strategy.py

@@ -14,6 +14,15 @@ def _load_wallets(path: Path) -> list[dict[str, Any]]:
     return [w for w in data if isinstance(w, dict)]
 
 
+def _load_config(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected a dict in {path}")
+    return data
+
+
 def _find_wallet(wallets: list[dict[str, Any]], label: str) -> dict[str, Any]:
     for w in wallets:
         if w.get("label") == label:
@@ -36,6 +45,13 @@ def _get_strategy_class(strategy: str):
 
         return HyperlendStableYieldStrategy
 
+    if strategy == "moonwell_wsteth_loop_strategy":
+        from wayfinder_paths.strategies.moonwell_wsteth_loop_strategy.strategy import (
+            MoonwellWstethLoopStrategy,
+        )
+
+        return MoonwellWstethLoopStrategy
+
     raise ValueError(f"Unknown strategy: {strategy}")
 
 
@@ -44,18 +60,25 @@ async def _run(args: argparse.Namespace) -> int:
     wallets_path = (
         Path(args.wallets).resolve() if args.wallets else repo_root / "wallets.json"
     )
+    config_path = (
+        Path(args.config).resolve() if args.config else repo_root / "config.json"
+    )
+
     wallets = _load_wallets(wallets_path)
+    config = _load_config(config_path)
 
     main_wallet = _find_wallet(wallets, args.main_wallet_label)
     strategy_wallet = _find_wallet(wallets, args.strategy_wallet_label)
 
+    # Merge config with wallet info
+    strategy_config = {
+        "main_wallet": main_wallet,
+        "strategy_wallet": strategy_wallet,
+        **config.get("strategy", {}),
+    }
+
     strategy_class = _get_strategy_class(args.strategy)
-    s = strategy_class(
-        {
-            "main_wallet": main_wallet,
-            "strategy_wallet": strategy_wallet,
-        },
-    )
+    s = strategy_class(strategy_config)
 
     await s.setup()
 
@@ -93,11 +116,18 @@ def main() -> int:
     p.add_argument(
         "--strategy",
         default="basis_trading_strategy",
-        choices=["basis_trading_strategy", "hyperlend_stable_yield_strategy"],
+        choices=[
+            "basis_trading_strategy",
+            "hyperlend_stable_yield_strategy",
+            "moonwell_wsteth_loop_strategy",
+        ],
     )
     p.add_argument(
         "--wallets", default=None, help="Path to wallets.json (default: repo root)"
     )
+    p.add_argument(
+        "--config", default=None, help="Path to config.json (default: repo root)"
+    )
     p.add_argument("--main-wallet-label", default="main")
     p.add_argument("--strategy-wallet-label", default="basis_trading_strategy")
 

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -164,7 +164,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         gas_maximum=GAS_MAXIMUM,
         gas_threshold=GAS_MAXIMUM / 3,
         volatility=Volatility.MEDIUM,
-        volatility_description_short="Delta-neutral but funding can flip negative.",
+        volatility_description="Delta-neutral but funding can flip negative.",
         directionality=Directionality.DELTA_NEUTRAL,
         directionality_description="Matched spot long and perp short cancels directional exposure.",
         complexity=Complexity.MEDIUM,

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -1,7 +1,6 @@
 # Hyperlend Stable Yield Strategy
 
 - Entrypoint: `strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
-- Manifest: `manifest.yaml`
 - Examples: `examples.json`
 - Tests: `test_strategy.py`
 
@@ -14,14 +13,6 @@ Allocates USDT0 on HyperEVM across HyperLend stablecoin markets. The strategy:
 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.
 
-## Policy
-
-The manifest policy simply locks transactions to the strategy wallet ID:
-
-```
-(wallet.id == 'FORMAT_WALLET_ID')
-```
-
 ## Key parameters
 
 - `MIN_USDT0_DEPOSIT_AMOUNT = 1`
@@ -91,10 +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
 ```
 
-Use the manifest directly if you prefer:
-
-```bash
-poetry run python wayfinder_paths/run_strategy.py --manifest wayfinder_paths/strategies/hyperlend_stable_yield_strategy/manifest.yaml --action status --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.

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -112,7 +112,7 @@ class HyperlendStableYieldStrategy(Strategy):
         gas_threshold=MAX_GAS / 3,
         # risk indicators
         volatility=Volatility.LOW,
-        volatility_description_short=(
+        volatility_description=(
             "Pure HyperLend stablecoin lending keeps NAV steady aside from rate drift."
         ),
         directionality=Directionality.MARKET_NEUTRAL,

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/README.md

@@ -0,0 +1,108 @@
+# Moonwell wstETH Loop Strategy
+
+- Entrypoint: `strategies.moonwell_wsteth_loop_strategy.strategy.MoonwellWstethLoopStrategy`
+- Examples: `examples.json`
+- Tests: `test_strategy.py`
+
+## What it does
+
+A leveraged liquid-staking carry trade on Base that loops USDC collateral into wstETH exposure. The strategy:
+
+1. Deposits USDC as initial collateral on Moonwell lending protocol.
+2. Borrows WETH against the USDC collateral.
+3. Swaps WETH to wstETH via Aerodrome/BRAP routing.
+4. Lends wstETH back to Moonwell as additional collateral.
+5. Repeats the loop until target leverage is reached or marginal gains fall below threshold.
+
+The position is **delta-neutral**: WETH debt offsets wstETH collateral, so PnL is driven by the spread between wstETH staking yield and WETH borrow cost.
+
+## Key parameters
+
+- `MIN_GAS = 0.002` ETH (minimum Base ETH for gas)
+- `MIN_USDC_DEPOSIT = 20` USDC (minimum initial collateral)
+- `MAX_DEPEG = 0.01` (1% max stETH/ETH depeg threshold)
+- `MIN_HEALTH_FACTOR = 1.2` (triggers deleveraging if below)
+- `MAX_HEALTH_FACTOR = 1.5` (triggers leverage loop if above)
+- `leverage_limit = 10` (maximum leverage multiplier)
+- `COLLATERAL_SAFETY_FACTOR = 0.98` (2% safety buffer on borrows)
+- `MAX_SLIPPAGE_TOLERANCE = 0.03` (3% max slippage to prevent MEV)
+- `_MIN_LEVERAGE_GAIN_BPS = 50e-4` (stop looping if marginal gain < 50 bps)
+
+## Safety features
+
+- **Depeg guard**: `_max_safe_F()` calculates leverage ceiling based on wstETH collateral factor and max depeg tolerance.
+- **Delta-neutrality**: `_balance_weth_debt()` rebalances when WETH debt exceeds wstETH collateral value.
+- **Swap retries**: `_swap_with_retries()` uses progressive slippage (0.5% → 1% → 1.5%) with exponential backoff.
+- **Health monitoring**: Automatic deleveraging when health factor drops below `MIN_HEALTH_FACTOR`.
+- **Rollback protection**: Checks actual balances before rollback swaps to prevent failed transactions.
+
+## Adapters used
+
+- `BalanceAdapter` for token balances and wallet transfers with ledger tracking.
+- `TokenAdapter` for token metadata and price feeds.
+- `LedgerAdapter` for net deposit tracking.
+- `BRAPAdapter` for swap quotes and execution via Aerodrome/routing.
+- `MoonwellAdapter` for lending, borrowing, collateral management, and position queries.
+- `LocalTokenTxnService` via `DefaultWeb3Service` for low-level sends/approvals.
+
+## Actions
+
+### Deposit
+
+- Validates USDC and ETH balances in the main wallet.
+- Transfers ETH (gas) into the strategy wallet if needed.
+- Moves USDC from main wallet to strategy wallet.
+- Lends USDC on Moonwell and enables as collateral.
+- Executes leverage loop: borrow WETH → swap to wstETH → lend wstETH → repeat.
+
+### Update
+
+- Checks gas balance meets maintenance threshold.
+- Balances WETH debt against wstETH collateral for delta-neutrality.
+- Computes health factor from aggregated positions.
+- If HF < MIN: triggers deleveraging via `_repay_debt_loop()`.
+- If HF > MAX: executes additional leverage loops to optimize yield.
+- Claims WELL rewards if above minimum threshold.
+
+### Status
+
+`_status()` returns:
+
+- `portfolio_value`: sum of all position values (USDC lent + wstETH lent - WETH debt)
+- `net_deposit`: fetched from LedgerAdapter
+- `strategy_status`: includes current leverage, health factor, LTV, peg diff, credit remaining
+
+### Withdraw
+
+- Sweeps miscellaneous token balances to WETH.
+- Repays all WETH debt via `_repay_debt_loop()`.
+- Unlends wstETH, swaps to USDC.
+- Unlends USDC collateral.
+- Returns USDC and remaining ETH to main wallet.
+
+## Running locally
+
+```bash
+# Install dependencies
+poetry install
+
+# Generate wallets (writes wallets.json)
+poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
+
+# Copy config and edit credentials
+cp wayfinder_paths/config.example.json config.json
+
+# Check status / health
+poetry run python wayfinder_paths/run_strategy.py moonwell_wsteth_loop_strategy --action status --config $(pwd)/config.json
+
+# Perform a deposit/update/withdraw cycle
+poetry run python wayfinder_paths/run_strategy.py moonwell_wsteth_loop_strategy --action deposit --main-token-amount 100 --gas-token-amount 0.01 --config $(pwd)/config.json
+poetry run python wayfinder_paths/run_strategy.py moonwell_wsteth_loop_strategy --action update --config $(pwd)/config.json
+poetry run python wayfinder_paths/run_strategy.py moonwell_wsteth_loop_strategy --action withdraw --config $(pwd)/config.json
+```
+
+## Testing
+
+```bash
+poetry run pytest wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/ -v
+```

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/examples.json

@@ -0,0 +1,11 @@
+{
+  "smoke": {
+    "deposit": {
+      "main_token_amount": 0.1,
+      "gas_token_amount": 0.001
+    },
+    "update": {},
+    "status": {},
+    "withdraw": {}
+  }
+}