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

wayfinder_paths/core/engine/StrategyJob.py

@@ -1,110 +0,0 @@
-import asyncio
-from typing import Any
-
-from loguru import logger
-
-from wayfinder_paths.core.clients.ClientManager import ClientManager
-from wayfinder_paths.core.config import StrategyJobConfig
-from wayfinder_paths.core.strategies.Strategy import Strategy
-
-
-class StrategyJob:
-    def __init__(
-        self,
-        strategy: Strategy,
-        config: StrategyJobConfig,
-        clients: dict[str, Any] | None = None,
-        skip_auth: bool = False,
-    ):
-        self.strategy = strategy
-        self.config = config
-
-        self.job_id = strategy.name or "unknown"
-        self.clients = ClientManager(clients=clients, skip_auth=skip_auth)
-
-    def _setup_strategy(self):
-        if not self.strategy:
-            raise ValueError("No strategy provided to StrategyJob")
-
-        self.strategy.log = self.log
-
-    async def setup(self):
-        self._setup_strategy()
-
-        # Ensure API key is set for API calls
-        # All clients inherit from WayfinderClient and have _ensure_api_key()
-        if not self.clients._skip_auth:
-            # Ensure API key on any client (they all share the same method)
-            token_client = self.clients.token
-            if token_client:
-                token_client._ensure_api_key()
-
-        existing_cfg = dict(getattr(self.strategy, "config", {}) or {})
-        strategy_cfg = dict(self.config.strategy_config or {})
-        merged_cfg = {**strategy_cfg, **existing_cfg}
-        self.strategy.config = merged_cfg
-        self.strategy.clients = self.clients
-        await self.strategy.setup()
-
-    async def execute_strategy(self, action: str, **kwargs) -> dict[str, Any]:
-        try:
-            if action == "deposit":
-                result = await self.strategy.deposit(**kwargs)
-            elif action == "withdraw":
-                result = await self.strategy.withdraw(**kwargs)
-            elif action == "update":
-                result = await self.strategy.update()
-            elif action == "status":
-                result = await self.strategy.status()
-            elif action == "exit":
-                result = await self.strategy.exit(**kwargs)
-            elif action == "partial_liquidate":
-                usd_value = kwargs.get("usd_value")
-                if usd_value is None:
-                    result = (
-                        False,
-                        "usd_value parameter is required for partial_liquidate",
-                    )
-                else:
-                    result = await self.strategy.partial_liquidate(usd_value)
-            else:
-                result = {"success": False, "message": f"Unknown action: {action}"}
-
-            await self.log(f"Strategy action '{action}' completed: {result}")
-            return result
-
-        except Exception as e:
-            error_msg = f"Strategy action '{action}' failed: {str(e)}"
-            await self.log(error_msg)
-            await self.handle_error({"error": str(e), "action": action})
-            return {"success": False, "error": str(e)}
-
-    async def run_continuous(self, interval_seconds: int | None = None):
-        interval = interval_seconds or self.config.system.update_interval
-        logger.info(
-            f"Starting continuous execution for strategy: {self.strategy.name} with interval {interval}s"
-        )
-
-        while True:
-            try:
-                await self.execute_strategy("update")
-                await asyncio.sleep(interval)
-
-            except asyncio.CancelledError:
-                logger.info("Continuous execution cancelled")
-                break
-            except Exception as e:
-                logger.error(f"Error in continuous execution: {str(e)}")
-                await asyncio.sleep(interval)
-
-    async def log(self, msg: str):
-        logger.info(f"Job {self.job_id}: {msg}")
-
-    async def handle_error(self, error_data: dict[str, Any]) -> None:
-        pass
-
-    async def stop(self):
-        if hasattr(self.strategy, "stop"):
-            await self.strategy.stop()
-
-        logger.info(f"Strategy job {self.job_id} stopped")

wayfinder_paths/core/services/test_local_evm_txn.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from wayfinder_paths.core.services.local_evm_txn import BASE_CHAIN_ID, LocalEvmTxn
-
-
-class _FakeTxHash:
-    def __init__(self, value: str):
-        self._value = value
-
-    def hex(self) -> str:
-        return self._value
-
-
-@pytest.mark.asyncio
-async def test_base_defaults_to_two_confirmations():
-    txn = LocalEvmTxn(config={})
-
-    fake_web3 = MagicMock()
-    fake_web3.eth = MagicMock()
-    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
-    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
-        return_value={
-            "status": 1,
-            "blockNumber": 100,
-            "transactionHash": "0x1",
-            "gasUsed": 21_000,
-            "logs": [],
-        }
-    )
-
-    txn.get_web3 = MagicMock(return_value=fake_web3)
-    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
-    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
-    txn._sign_transaction = MagicMock(return_value=b"signed")
-    txn._close_web3 = AsyncMock()
-    txn._wait_for_confirmations = AsyncMock()
-
-    ok, result = await txn.broadcast_transaction(
-        {
-            "chainId": BASE_CHAIN_ID,
-            "from": "0x0000000000000000000000000000000000000001",
-            "to": "0x0000000000000000000000000000000000000002",
-            "value": 0,
-        },
-        wait_for_receipt=True,
-        timeout=1,
-    )
-
-    assert ok is True
-    txn._wait_for_confirmations.assert_awaited_once_with(fake_web3, 100, 2)
-    assert result["confirmations"] == 2
-    assert result["confirmed_block_number"] == 102
-
-
-@pytest.mark.asyncio
-async def test_non_base_defaults_to_zero_confirmations():
-    txn = LocalEvmTxn(config={})
-
-    fake_web3 = MagicMock()
-    fake_web3.eth = MagicMock()
-    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
-    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
-        return_value={
-            "status": 1,
-            "blockNumber": 100,
-            "transactionHash": "0x1",
-            "gasUsed": 21_000,
-            "logs": [],
-        }
-    )
-
-    txn.get_web3 = MagicMock(return_value=fake_web3)
-    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
-    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
-    txn._sign_transaction = MagicMock(return_value=b"signed")
-    txn._close_web3 = AsyncMock()
-    txn._wait_for_confirmations = AsyncMock()
-
-    ok, result = await txn.broadcast_transaction(
-        {
-            "chainId": 1,
-            "from": "0x0000000000000000000000000000000000000001",
-            "to": "0x0000000000000000000000000000000000000002",
-            "value": 0,
-        },
-        wait_for_receipt=True,
-        timeout=1,
-    )
-
-    assert ok is True
-    txn._wait_for_confirmations.assert_not_awaited()
-    assert result["confirmations"] == 0
-    assert result["confirmed_block_number"] == 100
-
-
-@pytest.mark.asyncio
-async def test_explicit_confirmations_override_defaults():
-    txn = LocalEvmTxn(config={})
-
-    fake_web3 = MagicMock()
-    fake_web3.eth = MagicMock()
-    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
-    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
-        return_value={
-            "status": 1,
-            "blockNumber": 100,
-            "transactionHash": "0x1",
-            "gasUsed": 21_000,
-            "logs": [],
-        }
-    )
-
-    txn.get_web3 = MagicMock(return_value=fake_web3)
-    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
-    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
-    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
-    txn._sign_transaction = MagicMock(return_value=b"signed")
-    txn._close_web3 = AsyncMock()
-    txn._wait_for_confirmations = AsyncMock()
-
-    ok, result = await txn.broadcast_transaction(
-        {
-            "chainId": BASE_CHAIN_ID,
-            "from": "0x0000000000000000000000000000000000000001",
-            "to": "0x0000000000000000000000000000000000000002",
-            "value": 0,
-        },
-        wait_for_receipt=True,
-        timeout=1,
-        confirmations=0,
-    )
-
-    assert ok is True
-    txn._wait_for_confirmations.assert_not_awaited()
-    assert result["confirmations"] == 0
-    assert result["confirmed_block_number"] == 100

wayfinder_paths/scripts/create_strategy.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import re
-import shutil
-from pathlib import Path
-
-from wayfinder_paths.core.utils.wallets import make_random_wallet, write_wallet_to_json
-
-
-def sanitize_name(name: str) -> str:
-    # Replace spaces and special chars with underscores, lowercase
-    name = re.sub(r"[^a-zA-Z0-9_-]", "_", name)
-    name = re.sub(r"_+", "_", name)
-    name = name.strip("_")
-    return name.lower()
-
-
-def update_strategy_file(strategy_path: Path, class_name: str) -> None:
-    content = strategy_path.read_text()
-    # Replace MyStrategy with the new class name
-    content = content.replace("MyStrategy", class_name)
-    # Replace my_strategy references in docstrings/comments
-    content = re.sub(
-        r"my_strategy", class_name.lower().replace("Strategy", ""), content
-    )
-    strategy_path.write_text(content)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Create a new strategy from template with dedicated wallet"
-    )
-    parser.add_argument(
-        "name",
-        help="Strategy name (e.g., 'my_awesome_strategy' or 'My Awesome Strategy')",
-    )
-    parser.add_argument(
-        "--template-dir",
-        type=Path,
-        default=Path(__file__).parent.parent / "templates" / "strategy",
-        help="Path to strategy template directory",
-    )
-    parser.add_argument(
-        "--strategies-dir",
-        type=Path,
-        default=Path(__file__).parent.parent / "strategies",
-        help="Path to strategies directory",
-    )
-    parser.add_argument(
-        "--wallets-file",
-        type=Path,
-        default=Path(__file__).parent.parent.parent / "config.json",
-        help="Path to config.json file",
-    )
-    parser.add_argument(
-        "--override",
-        action="store_true",
-        help="Override existing strategy directory if it exists",
-    )
-    args = parser.parse_args()
-
-    # Sanitize name for directory
-    dir_name = sanitize_name(args.name)
-    strategy_dir = args.strategies_dir / dir_name
-
-    if strategy_dir.exists() and not args.override:
-        raise SystemExit(
-            f"Strategy directory already exists: {strategy_dir}\n"
-            "Use --override to replace it"
-        )
-
-    if not args.template_dir.exists():
-        raise SystemExit(f"Template directory not found: {args.template_dir}")
-
-    if strategy_dir.exists():
-        print(f"Removing existing directory: {strategy_dir}")
-        shutil.rmtree(strategy_dir)
-    strategy_dir.mkdir(parents=True, exist_ok=True)
-    print(f"Created strategy directory: {strategy_dir}")
-
-    # Copy template files
-    template_files = [
-        "strategy.py",
-        "test_strategy.py",
-        "examples.json",
-        "README.md",
-    ]
-    for filename in template_files:
-        src = args.template_dir / filename
-        if src.exists():
-            dst = strategy_dir / filename
-            shutil.copy2(src, dst)
-            print(f"  Copied {filename}")
-
-    # Generate class name from strategy name
-    class_name = "".join(word.capitalize() for word in dir_name.split("_"))
-    if not class_name.endswith("Strategy"):
-        class_name += "Strategy"
-
-    strategy_file = strategy_dir / "strategy.py"
-    if strategy_file.exists():
-        update_strategy_file(strategy_file, class_name)
-        print(f"  Updated strategy.py with class name: {class_name}")
-
-    # Generate wallet with label matching directory name (strategy identifier)
-    # If config.json doesn't exist, create it with a main wallet first
-    if not args.wallets_file.exists():
-        print("  Creating new config.json with main wallet...")
-        main_wallet = make_random_wallet()
-        main_wallet["label"] = "main"
-        write_wallet_to_json(
-            main_wallet,
-            out_dir=args.wallets_file.parent,
-            filename=args.wallets_file.name,
-        )
-        print(f"  Generated main wallet: {main_wallet['address']}")
-
-    # Generate strategy wallet (will append to existing config.json)
-    wallet = make_random_wallet()
-    wallet["label"] = dir_name
-    write_wallet_to_json(
-        wallet, out_dir=args.wallets_file.parent, filename=args.wallets_file.name
-    )
-    print(f"  Generated strategy wallet: {wallet['address']} (label: {dir_name})")
-
-    print("\n✅ Strategy created successfully!")
-    print(f"   Directory: {strategy_dir}")
-    print(f"   Name: {dir_name}")
-    print(f"   Class: {class_name}")
-    print(f"   Wallet: {wallet['address']}")
-    print("\nNext steps:")
-    print(f"   1. Edit {strategy_dir / 'strategy.py'} to implement your strategy")
-    print("   2. Add required adapters in __init__")
-    print(f"   3. Test with: just test-strategy {dir_name}")
-
-
-if __name__ == "__main__":
-    main()

wayfinder_paths/scripts/make_wallets.py

@@ -1,142 +0,0 @@
-import argparse
-import json
-from pathlib import Path
-
-from eth_account import Account
-
-from wayfinder_paths.core.utils.wallets import (
-    load_wallets,
-    make_random_wallet,
-    write_wallet_to_json,
-)
-
-
-def to_keystore_json(private_key_hex: str, password: str):
-    return Account.encrypt(private_key_hex, password)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Generate local dev wallets")
-    parser.add_argument(
-        "-n",
-        type=int,
-        default=0,
-        help="Number of wallets to create (ignored if --label is used)",
-    )
-    parser.add_argument(
-        "--out-dir",
-        type=Path,
-        default=Path("."),
-        help="Output directory for config.json (and keystore files)",
-    )
-    parser.add_argument(
-        "--keystore-password",
-        type=str,
-        default=None,
-        help="Optional password to write geth-compatible keystores",
-    )
-    parser.add_argument(
-        "--label",
-        type=str,
-        default=None,
-        help="Create a wallet with a custom label (e.g., strategy name). If not provided, auto-generates labels.",
-    )
-    parser.add_argument(
-        "--default",
-        action="store_true",
-        help="Create a default 'main' wallet if none exists (used by CI)",
-    )
-    args = parser.parse_args()
-
-    # --default is equivalent to -n 1 (create main wallet if needed)
-    if args.default and args.n == 0 and not args.label:
-        args.n = 1
-
-    args.out_dir.mkdir(parents=True, exist_ok=True)
-
-    existing = load_wallets(args.out_dir, "config.json")
-    has_main = any(w.get("label") in ("main", "default") for w in existing)
-
-    rows: list[dict[str, str]] = []
-    index = 0
-
-    # Custom labeled wallet (e.g., for strategy name)
-    if args.label:
-        # Check if label already exists - if so, skip (don't create duplicate)
-        if any(w.get("label") == args.label for w in existing):
-            print(f"Wallet with label '{args.label}' already exists, skipping...")
-        else:
-            w = make_random_wallet()
-            w["label"] = args.label
-            rows.append(w)
-            print(f"[{index}] {w['address']}  (label: {args.label})")
-            write_wallet_to_json(w, out_dir=args.out_dir, filename="config.json")
-            if args.keystore_password:
-                ks = to_keystore_json(w["private_key_hex"], args.keystore_password)
-                ks_path = args.out_dir / f"keystore_{w['address']}.json"
-                ks_path.write_text(json.dumps(ks))
-            index += 1
-
-            # If no wallets existed before, also create a "main" wallet
-            if not existing:
-                main_w = make_random_wallet()
-                main_w["label"] = "main"
-                rows.append(main_w)
-                print(f"[{index}] {main_w['address']}  (main)")
-                write_wallet_to_json(
-                    main_w, out_dir=args.out_dir, filename="config.json"
-                )
-                if args.keystore_password:
-                    ks = to_keystore_json(
-                        main_w["private_key_hex"], args.keystore_password
-                    )
-                    ks_path = args.out_dir / f"keystore_{main_w['address']}.json"
-                    ks_path.write_text(json.dumps(ks))
-                index += 1
-    else:
-        if args.n == 0:
-            args.n = 1
-
-        # Find next temporary number
-        existing_labels = {
-            w.get("label", "")
-            for w in existing
-            if w.get("label", "").startswith("temporary_")
-        }
-        temp_numbers = set()
-        for label in existing_labels:
-            try:
-                num = int(label.replace("temporary_", ""))
-                temp_numbers.add(num)
-            except ValueError:
-                pass
-        next_temp_num = 1
-        if temp_numbers:
-            next_temp_num = max(temp_numbers) + 1
-
-        for i in range(args.n):
-            w = make_random_wallet()
-            # Label first wallet as "main" if main doesn't exist, otherwise use temporary_N
-            if i == 0 and not has_main:
-                w["label"] = "main"
-                rows.append(w)
-                print(f"[{index}] {w['address']}  (main)")
-            else:
-                # Find next available temporary number
-                while next_temp_num in temp_numbers:
-                    next_temp_num += 1
-                w["label"] = f"temporary_{next_temp_num}"
-                temp_numbers.add(next_temp_num)
-                rows.append(w)
-                print(f"[{index}] {w['address']}  (label: temporary_{next_temp_num})")
-
-            write_wallet_to_json(w, out_dir=args.out_dir, filename="config.json")
-            if args.keystore_password:
-                ks = to_keystore_json(w["private_key_hex"], args.keystore_password)
-                ks_path = args.out_dir / f"keystore_{w['address']}.json"
-                ks_path.write_text(json.dumps(ks))
-            index += 1
-
-
-if __name__ == "__main__":
-    main()

wayfinder_paths/templates/adapter/README.md

@@ -1,150 +0,0 @@
-# Adapter Template
-
-Adapters expose protocol-specific capabilities to strategies. They wrap one or more clients from `wayfinder_paths.core.clients`.
-
-## Quick Start
-
-1. Copy the template:
-   ```bash
-   cp -r wayfinder_paths/templates/adapter wayfinder_paths/adapters/my_adapter
-   ```
-2. Rename `MyAdapter` in `adapter.py` to match your adapter's purpose.
-3. Set `adapter_type` to a unique identifier (e.g., `"MY_PROTOCOL"`).
-4. Implement your public methods.
-5. Add tests in `test_adapter.py`.
-
-## Directory Structure
-
-```
-my_adapter/
-├── adapter.py          # Adapter implementation
-├── examples.json       # Example payloads (optional)
-├── test_adapter.py     # Pytest tests
-└── README.md           # Adapter documentation
-```
-
-## Adapter Structure
-
-```python
-from typing import Any
-
-from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.clients.SomeClient import SomeClient
-
-
-class MyAdapter(BaseAdapter):
-    """Adapter for MyProtocol operations."""
-
-    adapter_type = "MY_PROTOCOL"
-
-    def __init__(self, config: dict[str, Any] | None = None):
-        super().__init__("my_adapter", config)
-        self.client = SomeClient()
-
-    async def connect(self) -> bool:
-        """Optional: Establish connectivity."""
-        return True
-
-    async def do_something(self, param: str) -> tuple[bool, Any]:
-        """
-        Execute an operation.
-
-        Args:
-            param: Operation parameter
-
-        Returns:
-            Tuple of (success, data) where data is result or error message
-        """
-        try:
-            result = await self.client.call(param)
-            return (True, result)
-        except Exception as e:
-            self.logger.error(f"Operation failed: {e}")
-            return (False, str(e))
-```
-
-## Key Conventions
-
-1. **Return tuples**: All methods return `(success: bool, data: Any)`
-2. **Adapter type**: Set `adapter_type` for registry lookups
-3. **Config access**: Use `self.config` for configuration
-4. **Logging**: Use `self.logger` for consistent logging
-5. **Error handling**: Catch exceptions and return `(False, error_message)`
-
-## BaseAdapter Interface
-
-```python
-class BaseAdapter(ABC):
-    adapter_type: str | None = None
-
-    def __init__(self, name: str, config: dict | None = None):
-        self.name = name
-        self.config = config or {}
-        self.logger = logger.bind(adapter=self.__class__.__name__)
-
-    async def connect(self) -> bool:
-        """Establish connectivity (default: True)."""
-        return True
-
-    async def get_balance(self, asset: str) -> dict:
-        """Get balance (raises NotImplementedError by default)."""
-        raise NotImplementedError
-
-    async def health_check(self) -> dict:
-        """Check adapter health."""
-        ...
-
-    async def close(self) -> None:
-        """Clean up resources."""
-        pass
-```
-
-## Testing
-
-Create `test_adapter.py`:
-
-```python
-import pytest
-from unittest.mock import AsyncMock, patch
-from .adapter import MyAdapter
-
-
-class TestMyAdapter:
-    @pytest.fixture
-    def adapter(self):
-        return MyAdapter()
-
-    @pytest.mark.asyncio
-    async def test_do_something_success(self, adapter):
-        with patch.object(adapter, "client") as mock_client:
-            mock_client.call = AsyncMock(return_value={"result": "ok"})
-
-            success, data = await adapter.do_something(param="test")
-
-            assert success
-            assert data["result"] == "ok"
-
-    @pytest.mark.asyncio
-    async def test_do_something_failure(self, adapter):
-        with patch.object(adapter, "client") as mock_client:
-            mock_client.call = AsyncMock(side_effect=Exception("API error"))
-
-            success, data = await adapter.do_something(param="test")
-
-            assert not success
-            assert "error" in data.lower()
-```
-
-Run tests:
-
-```bash
-poetry run pytest wayfinder_paths/adapters/my_adapter/ -v
-```
-
-## Best Practices
-
-- Keep adapters thin - business logic belongs in strategies
-- Mock clients in tests, not adapters
-- Document each public method with Args/Returns docstrings
-- Use type hints for all parameters and return values
-- Log errors with context for debugging