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

wayfinder_paths/run_strategy.py

@@ -12,8 +12,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from wayfinder_paths.core.config import StrategyJobConfig, load_config_from_env
-from wayfinder_paths.core.engine.manifest import load_manifest, validate_manifest
+from wayfinder_paths.core.config import StrategyJobConfig
 from wayfinder_paths.core.engine.StrategyJob import StrategyJob
 
 
@@ -21,82 +20,101 @@ def load_strategy(
     strategy_name: str,
     *,
     strategy_config: dict | None = None,
-    simulation: bool = False,
     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/)
         strategy_config: Configuration dict for the strategy
-        simulation: Enable simulation mode for testing
         api_key: Optional API key for service account authentication
 
     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=[""])
 
-    return strategy_class(
-        config=strategy_config, simulation=simulation, api_key=api_key
-    )
+    # 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)
 
 
 def load_config(
     config_path: str | None = None, strategy_name: str | None = None
 ) -> StrategyJobConfig:
     """
-    Load configuration from file or environment
+    Load configuration from config.json file
 
     Args:
-        config_path: Optional path to config file
+        config_path: Path to config file (defaults to "config.json")
         strategy_name: Optional strategy name for per-strategy wallet lookup
 
     Returns:
         StrategyJobConfig instance
+
+    Raises:
+        FileNotFoundError: If config file does not exist
     """
-    if config_path and Path(config_path).exists():
-        logger.info(f"Loading config from {config_path}")
-        with open(config_path) as f:
-            config_data = json.load(f)
-        return StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
-    else:
-        logger.info("Loading config from environment variables")
-        config = load_config_from_env()
-        if strategy_name:
-            config.strategy_config["_strategy_name"] = strategy_name
-            config.__post_init__()
-        return config
+    # Default to config.json if not provided
+    if not config_path:
+        config_path = "config.json"
+
+    config_file = Path(config_path)
+    if not config_file.exists():
+        raise FileNotFoundError(
+            f"Config file not found: {config_path}. "
+            "Please create config.json (see wayfinder_paths/config.example.json for template)"
+        )
+
+    logger.info(f"Loading config from {config_path}")
+    with open(config_file) as f:
+        config_data = json.load(f)
+
+    config = StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
+    if strategy_name:
+        config.strategy_config["_strategy_name"] = strategy_name
+        config.__post_init__()
+    return config
 
 
 async def run_strategy(
     strategy_name: str | None = None,
     config_path: str | None = None,
     action: str = "run",
-    manifest_path: str | None = None,
-    simulation: bool = False,
     **kwargs,
 ):
     """
@@ -109,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"
@@ -150,28 +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, simulation=simulation
-            )
-            logger.info(
-                f"Loaded strategy from manifest: {strategy_name_for_wallet or 'unnamed'}"
-            )
-        else:
-            strategy = load_strategy(
-                strategy_name,
-                strategy_config=config.strategy_config,
-                simulation=simulation,
-            )
-            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)
@@ -248,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:
@@ -318,15 +287,10 @@ 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 environment variables)"
+        "--config", help="Path to config file (defaults to config.json)"
     )
     parser.add_argument(
         "--action",
@@ -372,11 +336,6 @@ def main():
         "--duration", type=int, help="Duration in seconds for script action"
     )
     parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    parser.add_argument(
-        "--simulation",
-        action="store_true",
-        help="Run in simulation mode (no real transactions)",
-    )
     parser.add_argument(
         "--wallet-id",
         help="Wallet ID for policy rendering (replaces FORMAT_WALLET_ID in policies)",
@@ -395,13 +354,11 @@ 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,
             interval=args.interval,
             duration=args.duration,
-            simulation=args.simulation,
             wallet_id=getattr(args, "wallet_id", None),
         )
     )

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/make_wallets.py

@@ -15,27 +15,6 @@ def to_keystore_json(private_key_hex: str, password: str):
     return Account.encrypt(private_key_hex, password)
 
 
-def write_env(rows: list[dict[str, str]], out_dir: Path) -> None:
-    with open(out_dir / ".env.example", "w") as f:
-        if rows:
-            label_to_wallet = {r.get("label"): r for r in rows if r.get("label")}
-            main_w = (
-                label_to_wallet.get("main") or label_to_wallet.get("default") or rows[0]
-            )
-            strategy_w = label_to_wallet.get("strategy")
-
-            f.write("RPC_URL=https://rpc.ankr.com/eth\n")
-            # Back-compat defaults
-            f.write(f"PRIVATE_KEY={main_w['private_key_hex']}\n")
-            f.write(f"FROM_ADDRESS={main_w['address']}\n")
-            # Explicit main/strategy variables
-            f.write(f"MAIN_WALLET_ADDRESS={main_w['address']}\n")
-            if strategy_w:
-                f.write(f"STRATEGY_WALLET_ADDRESS={strategy_w['address']}\n")
-                # Optional: expose strategy private key for local dev only
-                f.write(f"PRIVATE_KEY_STRATEGY={strategy_w['private_key_hex']}\n")
-
-
 def main():
     parser = argparse.ArgumentParser(description="Generate local dev wallets")
     parser.add_argument(
@@ -48,7 +27,7 @@ def main():
         "--out-dir",
         type=Path,
         default=Path("."),
-        help="Output directory for wallets.json (and .env/keystore)",
+        help="Output directory for wallets.json (and keystore files)",
     )
     parser.add_argument(
         "--keystore-password",
@@ -161,9 +140,6 @@ def main():
                 ks_path.write_text(json.dumps(ks))
             index += 1
 
-    # Convenience outputs
-    write_env(rows, args.out_dir)
-
 
 if __name__ == "__main__":
     main()

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,19 +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,
-        },
-        simulation=args.simulation,
-    )
+    s = strategy_class(strategy_config)
 
     await s.setup()
 
@@ -94,14 +116,20 @@ 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")
-    p.add_argument("--simulation", action="store_true")
 
     sub = p.add_subparsers(dest="command", required=True)
 

wayfinder_paths/strategies/basis_trading_strategy/snapshot_mixin.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import os
 import time
 from datetime import UTC, datetime
 from decimal import ROUND_DOWN, Decimal
@@ -1007,5 +1006,4 @@ class BasisSnapshotMixin:
         )
         if isinstance(val, str) and val.strip():
             return val.strip()
-        env = os.getenv("BASIS_SNAPSHOT_PATH")
-        return env.strip() if isinstance(env, str) and env.strip() else None
+        return None