wayfinder-paths 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

wayfinder_paths/mcp/state/profile_store.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from wayfinder_paths.mcp.utils import repo_root
+
+logger = logging.getLogger(__name__)
+
+
+def _now_iso() -> str:
+    return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+def _runs_root() -> Path:
+    candidate = (os.getenv("WAYFINDER_RUNS_DIR") or ".wayfinder_runs").strip()
+    p = Path(candidate)
+    if not p.is_absolute():
+        p = repo_root() / p
+    return p.resolve(strict=False)
+
+
+class WalletProfileStore:
+    SCHEMA_VERSION = "1.0"
+    MAX_TRANSACTIONS = 100  # Bound history size per wallet
+
+    def __init__(self, path: Path | None = None):
+        if path is None:
+            path = _runs_root() / "wallet_profiles.json"
+        self.path = path
+
+    @staticmethod
+    def default() -> WalletProfileStore:
+        return WalletProfileStore()
+
+    def _ensure_dir(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> dict[str, Any]:
+        if not self.path.exists():
+            return {"schema_version": self.SCHEMA_VERSION, "profiles": {}}
+        try:
+            data = json.loads(self.path.read_text())
+            if not isinstance(data, dict):
+                return {"schema_version": self.SCHEMA_VERSION, "profiles": {}}
+            if not isinstance(data.get("profiles"), dict):
+                data["profiles"] = {}
+            return data
+        except Exception as exc:
+            logger.warning(f"Failed to load wallet profiles: {exc}")
+            return {"schema_version": self.SCHEMA_VERSION, "profiles": {}}
+
+    def _save(self, data: dict[str, Any]) -> None:
+        self._ensure_dir()
+        data["schema_version"] = self.SCHEMA_VERSION
+        self.path.write_text(json.dumps(data, indent=2, sort_keys=False))
+
+    def _normalize_address(self, address: str) -> str:
+        addr = str(address).strip().lower()
+        if addr.startswith("0x"):
+            return addr
+        return addr
+
+    def get_profile(self, address: str) -> dict[str, Any] | None:
+        data = self._load()
+        norm = self._normalize_address(address)
+        profile = data["profiles"].get(norm)
+        if profile:
+            return {"address": norm, **profile}
+        return None
+
+    def list_profiles(self) -> list[dict[str, Any]]:
+        data = self._load()
+        results: list[dict[str, Any]] = []
+        for addr, profile in data.get("profiles", {}).items():
+            protocols = list((profile.get("protocols") or {}).keys())
+            tx_count = len(profile.get("transactions") or [])
+            results.append(
+                {
+                    "address": addr,
+                    "label": profile.get("label"),
+                    "protocols": protocols,
+                    "protocol_count": len(protocols),
+                    "transaction_count": tx_count,
+                    "last_activity": profile.get("last_activity"),
+                }
+            )
+        return results
+
+    def get_protocols_for_wallet(self, address: str) -> list[str]:
+        profile = self.get_profile(address)
+        if not profile:
+            return []
+        return list((profile.get("protocols") or {}).keys())
+
+    def annotate(
+        self,
+        *,
+        address: str,
+        label: str | None = None,
+        protocol: str,
+        action: str,
+        tool: str,
+        status: str,
+        chain_id: int | None = None,
+        details: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> None:
+        data = self._load()
+        norm = self._normalize_address(address)
+        now = _now_iso()
+
+        if norm not in data["profiles"]:
+            data["profiles"][norm] = {
+                "label": label,
+                "protocols": {},
+                "transactions": [],
+            }
+
+        profile = data["profiles"][norm]
+
+        if label:
+            profile["label"] = label
+
+        if protocol not in profile["protocols"]:
+            profile["protocols"][protocol] = {
+                "first_seen": now,
+                "last_seen": now,
+                "interaction_count": 0,
+                "chains": [],
+            }
+
+        proto_info = profile["protocols"][protocol]
+        proto_info["last_seen"] = now
+        proto_info["interaction_count"] = proto_info.get("interaction_count", 0) + 1
+        if chain_id is not None:
+            chains = proto_info.get("chains") or []
+            if chain_id not in chains:
+                chains.append(chain_id)
+                proto_info["chains"] = chains
+
+        tx = {
+            "timestamp": now,
+            "protocol": protocol,
+            "action": action,
+            "tool": tool,
+            "status": status,
+        }
+        if chain_id is not None:
+            tx["chain_id"] = chain_id
+        if details:
+            tx["details"] = details
+        if idempotency_key:
+            tx["idempotency_key"] = idempotency_key
+
+        transactions = profile.get("transactions") or []
+        transactions.insert(0, tx)
+        if len(transactions) > self.MAX_TRANSACTIONS:
+            transactions = transactions[: self.MAX_TRANSACTIONS]
+        profile["transactions"] = transactions
+        profile["last_activity"] = now
+        self._save(data)
+
+    def annotate_safe(
+        self,
+        *,
+        address: str,
+        label: str | None = None,
+        protocol: str,
+        action: str,
+        tool: str,
+        status: str,
+        chain_id: int | None = None,
+        details: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> None:
+        # Best-effort: logs but doesn't raise on failure so annotation doesn't block main operation
+        try:
+            self.annotate(
+                address=address,
+                label=label,
+                protocol=protocol,
+                action=action,
+                tool=tool,
+                status=status,
+                chain_id=chain_id,
+                details=details,
+                idempotency_key=idempotency_key,
+            )
+        except Exception as exc:
+            logger.warning(f"Failed to annotate wallet profile: {exc}")

wayfinder_paths/mcp/state/store.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any
+
+from wayfinder_paths.mcp.utils import repo_root
+
+
+class _HexBytesEncoder(json.JSONEncoder):
+    """JSON encoder that handles HexBytes and other byte-like objects."""
+
+    def default(self, obj: Any) -> Any:
+        if hasattr(obj, "hex") and callable(obj.hex):
+            return obj.hex()
+        if isinstance(obj, bytes):
+            return obj.hex()
+        return super().default(obj)
+
+
+class IdempotencyStore:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    @staticmethod
+    def default() -> IdempotencyStore:
+        candidate = (
+            os.getenv("WAYFINDER_MCP_STATE_PATH") or ".cache/wayfinder_mcp.sqlite3"
+        )
+        path = Path(candidate)
+        if not path.is_absolute():
+            path = repo_root() / path
+        return IdempotencyStore(path)
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_db(self) -> None:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS idempotency (
+                    idempotency_key TEXT PRIMARY KEY,
+                    created_at INTEGER NOT NULL,
+                    request_json TEXT NOT NULL,
+                    response_json TEXT NOT NULL
+                )
+                """
+            )
+            conn.commit()
+
+    def get(self, key: str) -> dict[str, Any] | None:
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT response_json FROM idempotency WHERE idempotency_key = ?",
+                (key,),
+            ).fetchone()
+            if row is None:
+                return None
+            try:
+                parsed = json.loads(row["response_json"])
+            except Exception:
+                return None
+            return parsed if isinstance(parsed, dict) else None
+
+    def put(self, key: str, request: Any, response: Any) -> None:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO idempotency
+                    (idempotency_key, created_at, request_json, response_json)
+                VALUES
+                    (?, ?, ?, ?)
+                """,
+                (
+                    key,
+                    int(time.time()),
+                    json.dumps(request, sort_keys=True, cls=_HexBytesEncoder),
+                    json.dumps(response, sort_keys=True, cls=_HexBytesEncoder),
+                ),
+            )
+            conn.commit()

wayfinder_paths/mcp/test_scripting.py

@@ -0,0 +1,267 @@
+"""Tests for wayfinder_paths.mcp.scripting module."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from wayfinder_paths.adapters.boros_adapter import BorosAdapter
+from wayfinder_paths.adapters.hyperlend_adapter import HyperlendAdapter
+from wayfinder_paths.adapters.moonwell_adapter import MoonwellAdapter
+from wayfinder_paths.adapters.pendle_adapter import PendleAdapter
+from wayfinder_paths.mcp.scripting import (
+    _detect_callback_params,
+    _make_sign_callback,
+    get_adapter,
+)
+
+
+class TestDetectCallbackParams:
+    """Tests for _detect_callback_params function."""
+
+    def test_detects_strategy_wallet_signing_callback(self):
+        """Should detect strategy_wallet_signing_callback parameter."""
+
+        class MockAdapter:
+            def __init__(self, config=None, strategy_wallet_signing_callback=None):
+                pass
+
+        result = _detect_callback_params(MockAdapter)
+        assert "strategy_wallet_signing_callback" in result
+
+    def test_detects_sign_callback(self):
+        """Should detect sign_callback parameter."""
+
+        class MockAdapter:
+            def __init__(self, config=None, *, sign_callback=None):
+                pass
+
+        result = _detect_callback_params(MockAdapter)
+        assert "sign_callback" in result
+
+    def test_detects_custom_signing_callback_suffix(self):
+        """Should detect params ending with _signing_callback."""
+
+        class MockAdapter:
+            def __init__(self, config=None, custom_signing_callback=None):
+                pass
+
+        result = _detect_callback_params(MockAdapter)
+        assert "custom_signing_callback" in result
+
+    def test_returns_empty_for_no_callback_params(self):
+        """Should return empty set when no callback params found."""
+
+        class MockAdapter:
+            def __init__(self, config=None, timeout=30):
+                pass
+
+        result = _detect_callback_params(MockAdapter)
+        assert result == set()
+
+    def test_detects_multiple_callback_params(self):
+        """Should detect all matching callback params."""
+
+        class MockAdapter:
+            def __init__(
+                self,
+                config=None,
+                strategy_wallet_signing_callback=None,
+                sign_callback=None,
+            ):
+                pass
+
+        result = _detect_callback_params(MockAdapter)
+        assert "strategy_wallet_signing_callback" in result
+        assert "sign_callback" in result
+
+    def test_real_moonwell_adapter(self):
+        """Should detect callback param from MoonwellAdapter."""
+        result = _detect_callback_params(MoonwellAdapter)
+        assert "strategy_wallet_signing_callback" in result
+
+    def test_real_boros_adapter(self):
+        """Should detect callback param from BorosAdapter."""
+        result = _detect_callback_params(BorosAdapter)
+        assert "sign_callback" in result
+
+    def test_real_hyperlend_adapter(self):
+        """Should detect callback param from HyperlendAdapter."""
+        result = _detect_callback_params(HyperlendAdapter)
+        assert "strategy_wallet_signing_callback" in result
+
+    def test_real_pendle_adapter(self):
+        """Should detect callback param from PendleAdapter."""
+        result = _detect_callback_params(PendleAdapter)
+        assert "strategy_wallet_signing_callback" in result
+
+
+class TestMakeSignCallback:
+    """Tests for _make_sign_callback function."""
+
+    @pytest.mark.asyncio
+    async def test_creates_working_callback(self):
+        """Should create a callback that signs transactions."""
+        # Test private key (DO NOT USE IN PRODUCTION)
+        test_pk = "0x" + "ab" * 32
+
+        callback = _make_sign_callback(test_pk)
+
+        # Create a minimal transaction
+        tx = {
+            "to": "0x" + "00" * 20,
+            "value": 0,
+            "gas": 21000,
+            "gasPrice": 1000000000,
+            "nonce": 0,
+            "chainId": 1,
+        }
+
+        result = await callback(tx)
+        assert isinstance(result, bytes)
+        assert len(result) > 0
+
+
+class TestGetAdapter:
+    """Tests for get_adapter function."""
+
+    def test_raises_when_wallet_not_found(self):
+        """Should raise ValueError when wallet label not found."""
+
+        class MockAdapter:
+            def __init__(self, config=None):
+                pass
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.find_wallet_by_label", return_value=None
+        ):
+            with pytest.raises(ValueError, match="not found"):
+                get_adapter(MockAdapter, "nonexistent")
+
+    def test_raises_when_wallet_missing_private_key(self):
+        """Should raise ValueError when wallet has no private key."""
+
+        class MockAdapter:
+            def __init__(self, config=None):
+                pass
+
+        wallet = {"label": "test", "address": "0x" + "11" * 20}
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.find_wallet_by_label", return_value=wallet
+        ):
+            with pytest.raises(ValueError, match="missing private_key"):
+                get_adapter(MockAdapter, "test")
+
+    def test_works_without_wallet_for_readonly(self):
+        """Should work without wallet for read-only adapters."""
+
+        class MockAdapter:
+            def __init__(self, config=None):
+                self.config = config
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.load_config_json",
+            return_value={"foo": "bar"},
+        ):
+            adapter = get_adapter(MockAdapter)
+            assert adapter.config == {"foo": "bar"}
+
+    def test_wires_strategy_wallet_into_config(self):
+        """Should wire wallet into config['strategy_wallet']."""
+
+        class MockAdapter:
+            def __init__(self, config=None, strategy_wallet_signing_callback=None):
+                self.config = config
+                self.callback = strategy_wallet_signing_callback
+
+        wallet = {
+            "label": "main",
+            "address": "0x" + "11" * 20,
+            "private_key_hex": "0x" + "ab" * 32,
+        }
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.find_wallet_by_label", return_value=wallet
+        ):
+            with patch(
+                "wayfinder_paths.mcp.scripting.load_config_json", return_value={}
+            ):
+                adapter = get_adapter(MockAdapter, "main")
+                assert adapter.config["strategy_wallet"] == wallet
+                assert adapter.callback is not None
+
+    def test_applies_config_overrides(self):
+        """Should merge config_overrides into loaded config."""
+
+        class MockAdapter:
+            def __init__(self, config=None):
+                self.config = config
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.load_config_json",
+            return_value={"base": "value"},
+        ):
+            adapter = get_adapter(MockAdapter, config_overrides={"override": "yes"})
+            assert adapter.config["base"] == "value"
+            assert adapter.config["override"] == "yes"
+
+    def test_passes_kwargs_to_adapter(self):
+        """Should pass additional kwargs to adapter constructor."""
+
+        class MockAdapter:
+            def __init__(self, config=None, custom_arg=None):
+                self.config = config
+                self.custom_arg = custom_arg
+
+        with patch("wayfinder_paths.mcp.scripting.load_config_json", return_value={}):
+            adapter = get_adapter(MockAdapter, custom_arg="my_value")
+            assert adapter.custom_arg == "my_value"
+
+    def test_caller_kwargs_override_auto_wired_callback(self):
+        """Should allow caller to override auto-wired signing callback."""
+
+        class MockAdapter:
+            def __init__(self, config=None, strategy_wallet_signing_callback=None):
+                self.callback = strategy_wallet_signing_callback
+
+        wallet = {
+            "label": "main",
+            "address": "0x" + "11" * 20,
+            "private_key_hex": "0x" + "ab" * 32,
+        }
+
+        custom_callback = MagicMock()
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.find_wallet_by_label", return_value=wallet
+        ):
+            with patch(
+                "wayfinder_paths.mcp.scripting.load_config_json", return_value={}
+            ):
+                adapter = get_adapter(
+                    MockAdapter,
+                    "main",
+                    strategy_wallet_signing_callback=custom_callback,
+                )
+                assert adapter.callback is custom_callback
+
+    def test_integration_with_real_adapter_mocked_wallet(self):
+        """Integration test with real adapter class and mocked wallet."""
+        wallet = {
+            "label": "main",
+            "address": "0x" + "11" * 20,
+            "private_key_hex": "0x" + "ab" * 32,
+        }
+
+        with patch(
+            "wayfinder_paths.mcp.scripting.find_wallet_by_label", return_value=wallet
+        ):
+            with patch(
+                "wayfinder_paths.mcp.scripting.load_config_json", return_value={}
+            ):
+                adapter = get_adapter(MoonwellAdapter, "main")
+                assert isinstance(adapter, MoonwellAdapter)
+                assert adapter.strategy_wallet_signing_callback is not None
+                assert adapter.strategy_wallet_address == wallet["address"]