wayfinder-paths 0.1.1__py3-none-any.whl

wayfinder_paths/scripts/make_wallets.py

@@ -0,0 +1,160 @@
+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 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]
+            )
+            vault_w = label_to_wallet.get("vault")
+
+            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/vault variables
+            f.write(f"MAIN_WALLET_ADDRESS={main_w['address']}\n")
+            if vault_w:
+                f.write(f"VAULT_WALLET_ADDRESS={vault_w['address']}\n")
+                # Optional: expose vault private key for local dev only
+                f.write(f"PRIVATE_KEY_VAULT={vault_w['private_key_hex']}\n")
+
+
+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 wallets.json (and .env/keystore)",
+    )
+    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.",
+    )
+    args = parser.parse_args()
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load existing wallets
+    existing = load_wallets(args.out_dir, "wallets.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:
+            # Create wallet with specified label
+            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="wallets.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="wallets.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:
+        # Create wallets with auto-generated labels: first one is "main" if main doesn't exist, others are "temporary_N"
+        if args.n == 0:
+            args.n = 1  # Default to 1 wallet if neither -n nor --label specified
+
+        # 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="wallets.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
+
+    # Convenience outputs
+    write_env(rows, args.out_dir)
+
+
+if __name__ == "__main__":
+    main()

wayfinder_paths/scripts/validate_manifests.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+Manifest Validator
+
+Validates all adapter and strategy manifests in the repository.
+"""
+
+import sys
+from pathlib import Path
+
+from loguru import logger
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.engine.manifest import (
+    load_adapter_manifest,
+    load_strategy_manifest,
+)
+from wayfinder_paths.core.strategies.Strategy import Strategy
+
+
+def verify_entrypoint(entrypoint: str) -> tuple[bool, str | None]:
+    """Verify entrypoint is importable. Returns (success, error_message)."""
+    try:
+        module_path, class_name = entrypoint.rsplit(".", 1)
+        module = __import__(module_path, fromlist=[class_name], level=0)
+        getattr(module, class_name)  # Verify class exists
+        return True, None
+    except ImportError as e:
+        return False, f"Import error: {str(e)}"
+    except AttributeError as e:
+        return False, f"Class not found: {str(e)}"
+    except Exception as e:
+        return False, f"Unexpected error: {str(e)}"
+
+
+def verify_adapter_class(entrypoint: str) -> tuple[bool, str | None]:
+    """Verify entrypoint is an adapter class."""
+    valid, error = verify_entrypoint(entrypoint)
+    if not valid:
+        return False, error
+
+    try:
+        module_path, class_name = entrypoint.rsplit(".", 1)
+        module = __import__(module_path, fromlist=[class_name], level=0)
+        adapter_class = getattr(module, class_name)
+
+        if not issubclass(adapter_class, BaseAdapter):
+            return False, f"{class_name} is not a BaseAdapter"
+        return True, None
+    except Exception as e:
+        return False, f"Error verifying adapter: {str(e)}"
+
+
+def verify_strategy_class(entrypoint: str) -> tuple[bool, str | None]:
+    """Verify entrypoint is a strategy class."""
+    valid, error = verify_entrypoint(entrypoint)
+    if not valid:
+        return False, error
+
+    try:
+        module_path, class_name = entrypoint.rsplit(".", 1)
+        module = __import__(module_path, fromlist=[class_name], level=0)
+        strategy_class = getattr(module, class_name)
+
+        if not issubclass(strategy_class, Strategy):
+            return False, f"{class_name} is not a Strategy"
+        return True, None
+    except Exception as e:
+        return False, f"Error verifying strategy: {str(e)}"
+
+
+# Capabilities are only declared in manifest - no code validation needed
+# Manifest is the single source of truth for capabilities
+
+
+def verify_dependencies(dependencies: list[str]) -> tuple[bool, list[str]]:
+    """Verify dependencies are importable. Returns (valid, error_messages)."""
+    errors = []
+
+    for dep in dependencies:
+        # Try to import from core.clients
+        try:
+            __import__(f"core.clients.{dep}", fromlist=[dep], level=0)
+        except ImportError:
+            errors.append(f"Dependency '{dep}' not found in core.clients")
+        except Exception as e:
+            errors.append(f"Error importing dependency '{dep}': {str(e)}")
+
+    return len(errors) == 0, errors
+
+
+def validate_adapter_manifest(manifest_path: str) -> tuple[bool, list[str]]:
+    """Validate adapter manifest. Returns (valid, error_messages)."""
+    errors = []
+
+    try:
+        manifest = load_adapter_manifest(manifest_path)
+    except Exception as e:
+        return False, [f"Schema error: {str(e)}"]
+
+    # Verify entrypoint
+    valid, error = verify_adapter_class(manifest.entrypoint)
+    if not valid:
+        errors.append(f"Entrypoint validation failed: {error}")
+        return False, errors
+
+    # Verify dependencies
+    valid, dep_errors = verify_dependencies(manifest.dependencies)
+    if not valid:
+        errors.extend(dep_errors)
+
+    return len(errors) == 0, errors
+
+
+def validate_strategy_manifest(manifest_path: str) -> tuple[bool, list[str]]:
+    """Validate strategy manifest. Returns (valid, error_messages)."""
+    errors = []
+
+    try:
+        manifest = load_strategy_manifest(manifest_path)
+    except Exception as e:
+        return False, [f"Schema error: {str(e)}"]
+
+    # Verify entrypoint
+    valid, error = verify_strategy_class(manifest.entrypoint)
+    if not valid:
+        errors.append(f"Entrypoint validation failed: {error}")
+        return False, errors
+
+    # Permissions are already validated by Pydantic model
+
+    return len(errors) == 0, errors
+
+
+def find_adapter_manifests() -> list[Path]:
+    """Find all adapter manifest files."""
+    manifests = []
+    adapter_dir = Path(__file__).parent.parent / "vaults" / "adapters"
+    if adapter_dir.exists():
+        for adapter_path in adapter_dir.iterdir():
+            manifest_path = adapter_path / "manifest.yaml"
+            if manifest_path.exists():
+                manifests.append(manifest_path)
+    return manifests
+
+
+def find_strategy_manifests() -> list[Path]:
+    """Find all strategy manifest files."""
+    manifests = []
+    strategy_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+    if strategy_dir.exists():
+        for strategy_path in strategy_dir.iterdir():
+            manifest_path = strategy_path / "manifest.yaml"
+            if manifest_path.exists():
+                manifests.append(manifest_path)
+    return manifests
+
+
+def main() -> int:
+    """Main validation function. Returns 0 on success, 1 on failure."""
+    logger.info("Validating all manifests...")
+
+    all_valid = True
+    error_count = 0
+
+    # Validate adapter manifests
+    logger.info("\n=== Validating Adapter Manifests ===")
+    adapter_manifests = find_adapter_manifests()
+    for manifest_path in sorted(adapter_manifests):
+        logger.info(f"Validating {manifest_path}...")
+        valid, errors = validate_adapter_manifest(str(manifest_path))
+        if valid:
+            logger.success(f"✅ {manifest_path.name} - Valid")
+        else:
+            logger.error(f"❌ {manifest_path.name} - Invalid")
+            for error in errors:
+                logger.error(f"   {error}")
+            all_valid = False
+            error_count += len(errors)
+
+    # Validate strategy manifests
+    logger.info("\n=== Validating Strategy Manifests ===")
+    strategy_manifests = find_strategy_manifests()
+    for manifest_path in sorted(strategy_manifests):
+        logger.info(f"Validating {manifest_path}...")
+        valid, errors = validate_strategy_manifest(str(manifest_path))
+        if valid:
+            logger.success(f"✅ {manifest_path.name} - Valid")
+        else:
+            logger.error(f"❌ {manifest_path.name} - Invalid")
+            for error in errors:
+                logger.error(f"   {error}")
+            all_valid = False
+            error_count += len(errors)
+
+    # Summary
+    logger.info("\n=== Summary ===")
+    if all_valid:
+        logger.success(
+            f"✅ All manifests valid! ({len(adapter_manifests)} adapters, "
+            f"{len(strategy_manifests)} strategies)"
+        )
+        return 0
+    else:
+        logger.error(f"❌ Validation failed with {error_count} error(s)")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wayfinder_paths/tests/test_smoke_manifest.py

@@ -0,0 +1,48 @@
+import pytest
+
+from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
+
+
+class FakeAdapter(BaseAdapter):
+    adapter_type = "FAKE"
+
+    async def connect(self) -> bool:
+        return True
+
+    async def get_balance(self, asset: str):
+        return {"asset": asset, "amount": 100}
+
+
+class FakeStrategy(Strategy):
+    name = "Fake Strategy"
+
+    async def deposit(self, amount: float = 0) -> StatusTuple:
+        return (True, "deposited")
+
+    async def update(self) -> StatusTuple:
+        return (True, "updated")
+
+    async def withdraw(self, amount: float = 0) -> StatusTuple:
+        return (True, "withdrew")
+
+    async def status(self) -> StatusDict:
+        return {"total_earned": 0.0, "strategy_status": {"ok": True}}
+
+    @staticmethod
+    def policy() -> str:
+        return "wallet.id == 'TEST'"
+
+
+@pytest.mark.asyncio
+async def test_smoke_deposit_update_withdraw_status():
+    s = FakeStrategy()
+    s.register_adapters([FakeAdapter("fake")])
+    ok, msg = await s.deposit(amount=1)
+    assert ok
+    ok, msg = await s.update()
+    assert ok
+    ok, msg = await s.withdraw(amount=1)
+    assert ok
+    st = await s.status()
+    assert "total_earned" in st

wayfinder_paths/tests/test_test_coverage.py

@@ -0,0 +1,212 @@
+"""Test to ensure all adapters and strategies have corresponding test files."""
+
+from pathlib import Path
+
+import pytest
+
+
+def test_all_adapters_have_tests():
+    """Verify that all adapters have a test_adapter.py file."""
+    adapters_dir = Path(__file__).parent.parent / "vaults" / "adapters"
+
+    if not adapters_dir.exists():
+        pytest.skip("Adapters directory not found")
+
+    missing_tests = []
+
+    # Find all adapter directories (directories containing adapter.py)
+    for adapter_dir in adapters_dir.iterdir():
+        if not adapter_dir.is_dir() or adapter_dir.name.startswith("_"):
+            continue
+
+        adapter_py = adapter_dir / "adapter.py"
+        test_adapter_py = adapter_dir / "test_adapter.py"
+
+        # If adapter.py exists, test_adapter_py must exist
+        if adapter_py.exists() and not test_adapter_py.exists():
+            missing_tests.append(adapter_dir.name)
+
+    if missing_tests:
+        pytest.fail(
+            f"The following adapters are missing test files:\n"
+            f"{', '.join(missing_tests)}\n"
+            f"Please create test_adapter.py for each adapter."
+        )
+
+
+def test_all_strategies_have_tests():
+    """Verify that all strategies have a test_strategy.py file."""
+    strategies_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing_tests = []
+
+    # Find all strategy directories (directories containing strategy.py)
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        test_strategy_py = strategy_dir / "test_strategy.py"
+
+        # If strategy.py exists, test_strategy.py must exist
+        if strategy_py.exists() and not test_strategy_py.exists():
+            missing_tests.append(strategy_dir.name)
+
+    if missing_tests:
+        pytest.fail(
+            f"The following strategies are missing test files:\n"
+            f"{', '.join(missing_tests)}\n"
+            f"Please create test_strategy.py for each strategy."
+        )
+
+
+def test_all_strategies_have_examples_json():
+    """Verify that all strategies have an examples.json file (REQUIRED)."""
+    strategies_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing_examples = []
+
+    # Find all strategy directories (directories containing strategy.py)
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        examples_json = strategy_dir / "examples.json"
+
+        # If strategy.py exists, examples.json must exist
+        if strategy_py.exists() and not examples_json.exists():
+            missing_examples.append(strategy_dir.name)
+
+    if missing_examples:
+        pytest.fail(
+            f"The following strategies are missing examples.json files:\n"
+            f"{', '.join(missing_examples)}\n"
+            f"examples.json is REQUIRED for all strategies.\n"
+            f"See TESTING.md for the required structure."
+        )
+
+
+def test_strategy_tests_use_examples_json():
+    """Verify that strategy test files load examples.json using the shared utility."""
+    strategies_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    violations = []
+
+    # Find all strategy test files
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        test_file = strategy_dir / "test_strategy.py"
+        if not test_file.exists():
+            continue
+
+        # Read the test file content
+        try:
+            content = test_file.read_text()
+
+            # Check if it imports load_strategy_examples from tests.test_utils
+            # (wayfinder_paths/ is added to path by conftest.py or inline)
+            has_import = (
+                "from tests.test_utils import load_strategy_examples" in content
+                or "from wayfinder_paths.tests.test_utils import load_strategy_examples"
+                in content  # alternative
+                or "import tests.test_utils" in content
+                or "import wayfinder_paths.tests.test_utils" in content  # alternative
+                or (
+                    "tests.test_utils" in content
+                    and "load_strategy_examples" in content
+                )  # fallback importlib pattern
+            )
+
+            # Check if it calls load_strategy_examples
+            has_usage = "load_strategy_examples" in content
+
+            # If it doesn't use the shared utility, check for alternative patterns
+            if not (has_import and has_usage):
+                # Check for hardcoded examples.json loading (old pattern)
+                has_hardcoded = (
+                    'Path(__file__).parent / "examples.json"' in content
+                    or "examples.json" in content
+                ) and "load_strategy_examples" not in content
+
+                if has_hardcoded:
+                    violations.append(
+                        f"{strategy_dir.name}: Uses hardcoded examples.json loading "
+                        f"instead of load_strategy_examples() from tests.test_utils"
+                    )
+                elif has_usage and not has_import:
+                    violations.append(
+                        f"{strategy_dir.name}: Uses load_strategy_examples but missing import"
+                    )
+                elif not has_usage:
+                    violations.append(
+                        f"{strategy_dir.name}: Test file does not appear to load examples.json"
+                    )
+        except Exception as e:
+            violations.append(f"{strategy_dir.name}: Error reading test file: {e}")
+
+    if violations:
+        pytest.fail(
+            f"The following strategy tests need to use load_strategy_examples():\n"
+            f"{chr(10).join(violations)}\n"
+            f"All strategy tests MUST use load_strategy_examples() from tests.test_utils.\n"
+            f"See TESTING.md for examples."
+        )
+
+
+def test_strategy_examples_have_smoke():
+    """Verify that all strategy examples.json files have a 'smoke' entry."""
+    strategies_dir = Path(__file__).parent.parent / "vaults" / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    import json
+
+    missing_smoke = []
+
+    # Find all strategy directories
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        examples_json = strategy_dir / "examples.json"
+
+        # Only check strategies that exist
+        if not strategy_py.exists():
+            continue
+
+        if not examples_json.exists():
+            # This will be caught by test_all_strategies_have_examples_json
+            continue
+
+        try:
+            with open(examples_json) as f:
+                examples = json.load(f)
+
+            if "smoke" not in examples:
+                missing_smoke.append(strategy_dir.name)
+        except json.JSONDecodeError:
+            missing_smoke.append(f"{strategy_dir.name} (invalid JSON)")
+        except Exception as e:
+            missing_smoke.append(f"{strategy_dir.name} (error: {e})")
+
+    if missing_smoke:
+        pytest.fail(
+            f"The following strategies' examples.json are missing 'smoke' entry:\n"
+            f"{', '.join(missing_smoke)}\n"
+            f"All strategies MUST have a 'smoke' example in examples.json.\n"
+            f"See TESTING.md for the required structure."
+        )