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

wayfinder_paths/run_strategy.py

@@ -2,345 +2,142 @@
 
 import argparse
 import asyncio
+import importlib
+import inspect
 import json
 import sys
-from pathlib import Path
+from typing import Any
 
 from loguru import logger
 
-from wayfinder_paths.core.config import StrategyJobConfig
-from wayfinder_paths.core.engine.StrategyJob import StrategyJob
+from wayfinder_paths.core.config import CONFIG
+from wayfinder_paths.core.strategies.Strategy import Strategy
 from wayfinder_paths.core.utils.evm_helpers import resolve_private_key_for_from_address
 from wayfinder_paths.core.utils.web3 import get_transaction_chain_id, web3_from_chain_id
 
 
-def load_strategy(
-    strategy_name: str,
-    *,
-    config: StrategyJobConfig,
-):
-    strategies_dir = Path(__file__).parent / "strategies"
-    strategy_dir = strategies_dir / strategy_name
+def get_strategy_config(strategy_name: str) -> dict[str, Any]:
+    config = dict(CONFIG.get("strategy", {}))
+    wallets = {w["label"]: w for w in CONFIG.get("wallets", [])}
 
-    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 / "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}"
-        )
-
-    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 "main_wallet" not in config and "main" in wallets:
+        config["main_wallet"] = {"address": wallets["main"]["address"]}
+    if "strategy_wallet" not in config and strategy_name in wallets:
+        config["strategy_wallet"] = {"address": wallets[strategy_name]["address"]}
 
-    if strategy_class is None:
-        raise ValueError(f"No Strategy class found in {module_path}")
+    by_addr = {w["address"].lower(): w for w in CONFIG.get("wallets", [])}
+    for key in ("main_wallet", "strategy_wallet"):
+        if wallet := config.get(key):
+            if entry := by_addr.get(wallet.get("address", "").lower()):
+                if pk := entry.get("private_key") or entry.get("private_key_hex"):
+                    wallet["private_key_hex"] = pk
+    return config
 
-    main_wallet = config.strategy_config.get("main_wallet") or {}
-    strategy_wallet = config.strategy_config.get("strategy_wallet") or {}
-    main_wallet_address = main_wallet.get("address")
-    strategy_wallet_address = strategy_wallet.get("address")
 
-    async def main_wallet_signing_callback(transaction):
-        private_key = resolve_private_key_for_from_address(
-            main_wallet_address, config.strategy_config
-        )
+def create_signing_callback(address: str, config: dict[str, Any]):
+    async def sign(transaction: dict) -> str:
+        pk = resolve_private_key_for_from_address(address, config)
         async with web3_from_chain_id(get_transaction_chain_id(transaction)) as web3:
-            signed = web3.eth.account.sign_transaction(transaction, private_key)
-            return signed.raw_transaction.hex()
-
-    async def strategy_wallet_signing_callback(transaction):
-        private_key = resolve_private_key_for_from_address(
-            strategy_wallet_address,
-            config.strategy_config,
-        )
-        async with web3_from_chain_id(get_transaction_chain_id(transaction)) as web3:
-            signed = web3.eth.account.sign_transaction(transaction, private_key)
-            return signed.raw_transaction.hex()
-
-    return strategy_class(
-        config=config.strategy_config,
-        main_wallet_signing_callback=main_wallet_signing_callback,
-        strategy_wallet_signing_callback=strategy_wallet_signing_callback,
-    )
-
-
-def load_config(
-    config_path: str | None = None, strategy_name: str | None = None
-) -> StrategyJobConfig:
-    # Default to config.json if not provided
-    if not config_path:
-        config_path = "config.json"
+            return web3.eth.account.sign_transaction(
+                transaction, pk
+            ).raw_transaction.hex()
 
-    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)
+    return sign
 
-    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
 
+def find_strategy_class(module) -> type[Strategy]:
+    for _, obj in inspect.getmembers(module, inspect.isclass):
+        if issubclass(obj, Strategy) and obj is not Strategy:
+            return obj
+    raise ValueError(f"No Strategy subclass found in {module.__name__}")
 
-async def run_strategy(
-    strategy_name: str | None = None,
-    config_path: str | None = None,
-    action: str = "run",
-    **kwargs,
-):
-    try:
-        if not strategy_name:
-            raise ValueError("strategy_name is required")
 
-        logger.debug(f"Loading strategy by name: {strategy_name}")
+async def run_strategy(strategy_name: str, action: str = "status", **kw):
+    config = get_strategy_config(strategy_name)
 
-        logger.debug(f"Config path provided: {config_path}")
-        config = load_config(config_path, strategy_name=strategy_name)
-        main_wallet_cfg = config.strategy_config.get("main_wallet") or {}
-        strategy_wallet_cfg = config.strategy_config.get("strategy_wallet") or {}
-        logger.debug(
-            "Loaded config: wallets(main={} strategy={})",
-            main_wallet_cfg.get("address") or "none",
-            strategy_wallet_cfg.get("address") or "none",
-        )
+    def signing_cb(key: str):
+        if addr := config.get(key, {}).get("address"):
+            return create_signing_callback(addr, config)
+        return None
 
-        # Authentication is via system.api_key in config.json
-
-        strategy = load_strategy(
-            strategy_name,
-            config=config,
+    module = importlib.import_module(
+        f"wayfinder_paths.strategies.{strategy_name}.strategy"
+    )
+    strategy_cls = find_strategy_class(module)
+    strategy = strategy_cls(
+        config,
+        main_wallet_signing_callback=signing_cb("main_wallet"),
+        strategy_wallet_signing_callback=signing_cb("strategy_wallet"),
+    )
+    await strategy.setup()
+
+    if action == "policy":
+        policies = strategy.policies() if hasattr(strategy, "policies") else []
+        if wallet_id := kw.get("wallet_id"):
+            policies = [p.replace("FORMAT_WALLET_ID", wallet_id) for p in policies]
+        result = {"policies": policies}
+    elif action == "status":
+        result = await strategy.status()
+    elif action == "deposit":
+        result = await strategy.deposit(
+            main_token_amount=kw.get("main_token_amount", 0.0),
+            gas_token_amount=kw.get("gas_token_amount", 0.0),
         )
-        logger.info(f"Loaded strategy: {strategy.name}")
-
-        strategy_job = StrategyJob(strategy, config)
-
-        logger.info("Setting up strategy job...")
-        logger.debug("Auth mode: API key (from system.api_key)")
-        await strategy_job.setup()
-
-        # Execute action
-        if action == "run":
-            logger.info("Starting continuous execution...")
-            await strategy_job.run_continuous(interval_seconds=kwargs.get("interval"))
-
-        elif action == "deposit":
-            main_token_amount = kwargs.get("main_token_amount")
-            gas_token_amount = kwargs.get("gas_token_amount")
-
-            if main_token_amount is None and gas_token_amount is None:
-                raise ValueError(
-                    "Either main token amount or gas token amount required for deposit (use --main-token-amount and/or --gas-token-amount)"
-                )
-
-            # Default to 0.0 if not provided
-            if main_token_amount is None:
-                main_token_amount = 0.0
-            if gas_token_amount is None:
-                gas_token_amount = 0.0
-
-            result = await strategy_job.execute_strategy(
-                "deposit",
-                main_token_amount=main_token_amount,
-                gas_token_amount=gas_token_amount,
-            )
-            logger.info(f"Deposit result: {result}")
-
-        elif action == "withdraw":
-            amount = kwargs.get("amount")
-            result = await strategy_job.execute_strategy("withdraw", amount=amount)
-            logger.info(f"Withdraw result: {result}")
-
-        elif action == "status":
-            result = await strategy_job.execute_strategy("status")
-            logger.info(f"Status: {json.dumps(result, indent=2)}")
-
-        elif action == "update":
-            result = await strategy_job.execute_strategy("update")
-            logger.info(f"Update result: {result}")
-
-        elif action == "exit":
-            result = await strategy_job.execute_strategy("exit")
-            logger.info(f"Exit result: {result}")
-
-        elif action == "partial-liquidate":
-            usd_value = kwargs.get("amount")
-            if not usd_value:
-                raise ValueError("Amount (USD value) required for partial-liquidate")
-            result = await strategy_job.execute_strategy(
-                "partial_liquidate", usd_value=usd_value
-            )
-            logger.info(f"Partial liquidation result: {result}")
-
-        elif action == "policy":
-            policies: list[str] = []
-
+    elif action == "withdraw":
+        result = await strategy.withdraw(amount=kw.get("amount"))
+    elif action == "update":
+        result = await strategy.update()
+    elif action == "exit":
+        result = await strategy.exit()
+    elif action == "run":
+        while True:
             try:
-                spols = getattr(strategy, "policies", None)
-                if callable(spols):
-                    result = spols()  # type: ignore[misc]
-                    if isinstance(result, list) and result:
-                        policies = [p for p in result if isinstance(p, str)]
-            except Exception:
-                pass
-
-            seen = set()
-            deduped: list[str] = []
-            for p in policies:
-                if p not in seen:
-                    seen.add(p)
-                    deduped.append(p)
-
-            wallet_id = kwargs.get("wallet_id")
-            if not wallet_id:
-                wallet_id = config.strategy_config.get("wallet_id")
-            if not wallet_id:
-                wallet_id = config.system.wallet_id
-
-            # Render policies with wallet_id if available
-            if wallet_id:
-                rendered = [
-                    p.replace("FORMAT_WALLET_ID", str(wallet_id)) for p in deduped
-                ]
-            else:
-                rendered = deduped
-                logger.info(
-                    "Policy rendering without wallet_id - policies contain FORMAT_WALLET_ID placeholder"
-                )
-
-            logger.info(json.dumps({"policies": rendered}, indent=2))
-
-        elif action == "script":
-            duration = kwargs.get("duration") or 300
-            logger.info(f"Running script mode for {duration}s...")
-            task = asyncio.create_task(
-                strategy_job.run_continuous(
-                    interval_seconds=kwargs.get("interval") or 60
-                )
-            )
-            await asyncio.sleep(duration)
-            task.cancel()
-            try:
-                await task
+                result = await strategy.update()
+                logger.info(f"Update: {result}")
+                await asyncio.sleep(kw.get("interval", 60))
             except asyncio.CancelledError:
-                logger.info("Script mode execution completed")
-
-        else:
-            raise ValueError(f"Unknown action: {action}")
-
-    except KeyboardInterrupt:
-        logger.info("Shutting down...")
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        sys.exit(1)
-    finally:
-        if "strategy_job" in locals():
-            await strategy_job.stop()
+                result = (True, "stopped")
+                break
+    else:
+        raise ValueError(f"Unknown action: {action}")
+
+    print(
+        json.dumps(result, indent=2)
+        if isinstance(result, dict)
+        else f"{action}: {result}"
+    )
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Run strategy strategies")
-    parser.add_argument(
-        "strategy",
-        help="Strategy to run (stablecoin_yield_strategy)",
-    )
-    parser.add_argument(
-        "--config", help="Path to config file (defaults to config.json)"
-    )
-    parser.add_argument(
+    p = argparse.ArgumentParser()
+    p.add_argument("strategy")
+    p.add_argument(
         "--action",
-        default="run",
-        choices=[
-            "run",
-            "deposit",
-            "withdraw",
-            "status",
-            "update",
-            "exit",
-            "policy",
-            "script",
-            "partial-liquidate",
-        ],
-        help="Action to perform (default: run)",
+        default="status",
+        choices=["run", "deposit", "withdraw", "status", "update", "exit", "policy"],
     )
-    parser.add_argument(
-        "--amount",
-        type=float,
-        help="Amount for withdraw/partial-liquidate actions",
+    p.add_argument("--amount", type=float)
+    p.add_argument("--main-token-amount", type=float, dest="main_token_amount")
+    p.add_argument(
+        "--gas-token-amount", type=float, dest="gas_token_amount", default=0.0
     )
-    parser.add_argument(
-        "--main-token-amount",
-        "--main_token_amount",
-        type=float,
-        dest="main_token_amount",
-        help="Main token amount for deposit action",
-    )
-    parser.add_argument(
-        "--gas-token-amount",
-        "--gas_token_amount",
-        type=float,
-        dest="gas_token_amount",
-        default=0.0,
-        help="Gas token amount for deposit action (default: 0.0)",
-    )
-    parser.add_argument(
-        "--interval",
-        type=int,
-        help="Update interval in seconds for continuous/script modes",
-    )
-    parser.add_argument(
-        "--duration", type=int, help="Duration in seconds for script action"
-    )
-    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    parser.add_argument(
-        "--wallet-id",
-        help="Wallet ID for policy rendering (replaces FORMAT_WALLET_ID in policies)",
-    )
-
-    args = parser.parse_args()
+    p.add_argument("--interval", type=int, default=60)
+    p.add_argument("--wallet-id", dest="wallet_id")
+    p.add_argument("--debug", action="store_true")
+    args = p.parse_args()
 
-    # Configure logging
-    log_level = "DEBUG" if args.debug else "INFO"
     logger.remove()
-    logger.add(sys.stderr, level=log_level)
+    logger.add(sys.stderr, level="DEBUG" if args.debug else "INFO")
 
-    # Run strategy
     asyncio.run(
         run_strategy(
-            strategy_name=args.strategy,
-            config_path=args.config,
-            action=args.action,
+            args.strategy,
+            args.action,
             amount=args.amount,
             main_token_amount=args.main_token_amount,
             gas_token_amount=args.gas_token_amount,
             interval=args.interval,
-            duration=args.duration,
-            wallet_id=getattr(args, "wallet_id", None),
+            wallet_id=args.wallet_id,
         )
     )
 

wayfinder_paths/strategies/basis_trading_strategy/constants.py

@@ -1 +1,3 @@
-USDC_ARBITRUM_TOKEN_ID = "usd-coin-arbitrum"
+from wayfinder_paths.core.constants.tokens import TOKEN_ID_USDC_ARBITRUM
+
+USDC_ARBITRUM_TOKEN_ID = TOKEN_ID_USDC_ARBITRUM