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

wayfinder_paths/mcp/tools/quotes.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from wayfinder_paths.core.clients.BRAPClient import BRAPClient
+from wayfinder_paths.core.clients.TokenClient import TokenClient
+from wayfinder_paths.core.constants.chains import CHAIN_CODE_TO_ID
+from wayfinder_paths.mcp.utils import (
+    err,
+    find_wallet_by_label,
+    normalize_address,
+    ok,
+    parse_amount_to_raw,
+)
+
+
+def _chain_id(token: dict[str, Any]) -> int | None:
+    # Token payloads often include a database/internal `id` field; do not treat that as a chain id.
+    if token.get("chain_id") is not None:
+        try:
+            return int(token.get("chain_id"))
+        except (TypeError, ValueError):
+            return None
+
+    chain = token.get("chain") or {}
+    if not isinstance(chain, dict):
+        return None
+
+    for key in ("chain_id", "chainId", "id"):
+        if chain.get(key) is None:
+            continue
+        try:
+            return int(chain.get(key))
+        except (TypeError, ValueError):
+            return None
+
+    return None
+
+
+_SIMPLE_CHAIN_SUFFIX_RE = re.compile(r"^[a-z0-9]+\s+[a-z0-9-]+$", re.IGNORECASE)
+_ASSET_CHAIN_SPLIT_RE = re.compile(
+    r"^(?P<asset>[a-z0-9]+)[- _](?P<chain>[a-z0-9-]+)$", re.IGNORECASE
+)
+
+
+def _normalize_token_query(query: str) -> str:
+    q = " ".join(str(query).strip().split())
+    if not q or "-" in q or "_" in q:
+        return q
+    if not _SIMPLE_CHAIN_SUFFIX_RE.match(q):
+        return q
+    asset, chain_code = q.rsplit(" ", 1)
+    if chain_code.lower() in CHAIN_CODE_TO_ID:
+        return f"{asset}-{chain_code}"
+    return q
+
+
+def _is_eth_like_token(meta: dict[str, Any]) -> bool:
+    asset_id = str(meta.get("asset_id") or "").lower()
+    symbol = str(meta.get("symbol") or "").lower()
+    return asset_id == "ethereum" or symbol == "eth"
+
+
+def _split_asset_chain(query: str) -> tuple[str, str] | None:
+    q = str(query).strip()
+    if not q:
+        return None
+    m = _ASSET_CHAIN_SPLIT_RE.match(q)
+    if not m:
+        return None
+    return m.group("asset").lower(), m.group("chain").lower()
+
+
+async def _resolve_token_meta(
+    token_client: TokenClient,
+    *,
+    query: str,
+) -> tuple[str, dict[str, Any]]:
+    q = _normalize_token_query(query)
+    split = _split_asset_chain(q)
+    if split:
+        asset, chain_code = split
+        if asset in {"eth", "ethereum"}:
+            try:
+                gas_meta = await token_client.get_gas_token(chain_code)
+                if isinstance(gas_meta, dict) and _is_eth_like_token(gas_meta):
+                    return q, gas_meta
+            except Exception:
+                pass
+    meta = await token_client.get_token_details(q)
+    return q, meta
+
+
+def _infer_chain_code_from_query(query: str, meta: dict[str, Any]) -> str | None:
+    q = str(query).strip().lower()
+    if not q:
+        return None
+
+    candidates: set[str] = {str(k).lower() for k in CHAIN_CODE_TO_ID.keys()}
+    addrs = meta.get("addresses") or {}
+    if isinstance(addrs, dict):
+        candidates.update(str(k).lower() for k in addrs.keys())
+
+    best: str | None = None
+    for code in candidates:
+        if q.endswith(f"-{code}"):
+            if best is None or len(code) > len(best):
+                best = code
+    return best
+
+
+def _address_for_chain(meta: dict[str, Any], chain_code: str) -> str | None:
+    addrs = meta.get("addresses") or {}
+    if not isinstance(addrs, dict):
+        return None
+    for key, val in addrs.items():
+        if str(key).lower() == chain_code and val:
+            return str(val)
+    return None
+
+
+def _select_token_chain(
+    meta: dict[str, Any], *, query: str
+) -> tuple[int | None, str | None]:
+    chain_id = _chain_id(meta)
+    token_address = meta.get("address")
+
+    desired_chain = _infer_chain_code_from_query(query, meta)
+    if desired_chain:
+        addr = _address_for_chain(meta, desired_chain)
+        if addr:
+            token_address = addr
+        if desired_chain in CHAIN_CODE_TO_ID:
+            chain_id = CHAIN_CODE_TO_ID[desired_chain]
+
+    token_address_out = str(token_address).strip() if token_address else None
+    return chain_id, token_address_out
+
+
+def _slippage_float(slippage_bps: int) -> float:
+    return max(0.0, float(int(slippage_bps)) / 10_000.0)
+
+
+async def quote_swap(
+    *,
+    wallet_label: str,
+    from_token: str,
+    to_token: str,
+    amount: str,
+    slippage_bps: int = 50,
+    recipient: str | None = None,
+    include_calldata: bool = False,
+) -> dict[str, Any]:
+    w = find_wallet_by_label(wallet_label)
+    if not w:
+        return err("not_found", f"Unknown wallet_label: {wallet_label}")
+    sender = normalize_address(w.get("address"))
+    if not sender:
+        return err("invalid_wallet", f"Wallet {wallet_label} missing address")
+
+    token_client = TokenClient()
+    brap_client = BRAPClient()
+
+    try:
+        from_q, from_meta = await _resolve_token_meta(token_client, query=from_token)
+        to_q, to_meta = await _resolve_token_meta(token_client, query=to_token)
+    except Exception as exc:  # noqa: BLE001
+        return err("token_error", str(exc))
+
+    from_chain_id, from_token_addr = _select_token_chain(from_meta, query=from_q)
+    to_chain_id, to_token_addr = _select_token_chain(to_meta, query=to_q)
+    if from_chain_id is None or to_chain_id is None:
+        return err(
+            "invalid_token",
+            "Could not resolve chain_id for one or more tokens",
+            {"from_chain_id": from_chain_id, "to_chain_id": to_chain_id},
+        )
+    if not from_token_addr or not to_token_addr:
+        return err(
+            "invalid_token",
+            "Could not resolve token address for one or more tokens",
+            {"from_token_address": from_token_addr, "to_token_address": to_token_addr},
+        )
+
+    decimals = int(from_meta.get("decimals") or 18)
+    try:
+        amount_raw = parse_amount_to_raw(amount, decimals)
+    except ValueError as exc:
+        return err("invalid_amount", str(exc))
+
+    rcpt = normalize_address(recipient) or sender
+    slip = _slippage_float(slippage_bps)
+
+    try:
+        data = await brap_client.get_quote(
+            from_token=from_token_addr,
+            to_token=to_token_addr,
+            from_chain_id=from_chain_id,
+            to_chain_id=to_chain_id,
+            from_wallet=sender,
+            amount1=str(amount_raw),
+            slippage=slip,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return err("quote_error", str(exc))
+
+    quotes_data = data.get("quotes", {}) if isinstance(data, dict) else {}
+    if not isinstance(quotes_data, dict):
+        quotes_data = {}
+    all_quotes = quotes_data.get("all_quotes", [])
+    if not isinstance(all_quotes, list):
+        all_quotes = []
+    best_quote = quotes_data.get("best_quote")
+    quote_count = quotes_data.get("quote_count", len(all_quotes))
+
+    providers: list[str] = []
+    seen: set[str] = set()
+    for q in all_quotes:
+        if not isinstance(q, dict):
+            continue
+        p = q.get("provider")
+        if not p:
+            continue
+        p_str = str(p)
+        if p_str in seen:
+            continue
+        seen.add(p_str)
+        providers.append(p_str)
+
+    best_out: dict[str, Any] | None = None
+    if isinstance(best_quote, dict):
+        calldata = best_quote.get("calldata")
+        calldata_len = len(calldata) if calldata else 0
+
+        best_out = {
+            "provider": best_quote.get("provider"),
+            "input_amount": best_quote.get("input_amount"),
+            "output_amount": best_quote.get("output_amount"),
+            "input_amount_usd": best_quote.get("input_amount_usd"),
+            "output_amount_usd": best_quote.get("output_amount_usd"),
+            "gas_estimate": best_quote.get("gas_estimate"),
+            "fee_estimate": best_quote.get("fee_estimate"),
+            "native_input": best_quote.get("native_input"),
+            "native_output": best_quote.get("native_output"),
+            "error": best_quote.get("error"),
+            "wrap_transaction": best_quote.get("wrap_transaction"),
+            "unwrap_transaction": best_quote.get("unwrap_transaction"),
+        }
+        if include_calldata:
+            best_out["calldata"] = calldata
+        else:
+            best_out["calldata_len"] = calldata_len
+
+    preview = (
+        f"Swap {amount} {from_meta.get('symbol')} → {to_meta.get('symbol')} "
+        f"(chain {from_chain_id} → {to_chain_id}). "
+        f"Sender={sender} Recipient={rcpt}. Slippage={slip:.2%}."
+    )
+    if rcpt.lower() != sender.lower():
+        preview = "⚠ RECIPIENT DIFFERS FROM SENDER\n" + preview
+
+    from_token_id = from_meta.get("token_id") or from_q
+    to_token_id = to_meta.get("token_id") or to_q
+
+    result = {
+        "preview": preview,
+        "quote": {
+            "best_quote": best_out,
+            "quote_count": quote_count,
+            "providers": providers,
+        },
+        "from_token": from_meta.get("symbol"),
+        "to_token": to_meta.get("symbol"),
+        "amount": str(amount),
+        "slippage_bps": int(slippage_bps),
+        "suggested_execute_request": {
+            "kind": "swap",
+            "wallet_label": wallet_label,
+            "from_token": from_token_id,
+            "to_token": to_token_id,
+            "amount": str(amount),
+            "slippage_bps": int(slippage_bps),
+            "recipient": rcpt,
+        },
+    }
+
+    return ok(result)

wayfinder_paths/mcp/tools/run_script.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from wayfinder_paths.mcp.preview import build_run_script_preview
+from wayfinder_paths.mcp.state.profile_store import WalletProfileStore
+from wayfinder_paths.mcp.state.store import IdempotencyStore
+from wayfinder_paths.mcp.utils import (
+    err,
+    find_wallet_by_label,
+    ok,
+    repo_root,
+    sha256_json,
+)
+
+
+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)
+
+
+def _resolve_script_path(script_path: str) -> tuple[bool, Path | dict[str, Any]]:
+    raw = str(script_path).strip()
+    if not raw:
+        return False, {"code": "invalid_request", "message": "script_path is required"}
+
+    p = Path(raw)
+    if not p.is_absolute():
+        p = repo_root() / p
+    resolved = p.resolve(strict=False)
+
+    runs_root = _runs_root()
+    try:
+        resolved.relative_to(runs_root)
+    except ValueError:
+        return (
+            False,
+            {
+                "code": "invalid_request",
+                "message": "script_path must be inside the local runs directory",
+                "details": {
+                    "runs_root": str(runs_root),
+                    "script_path": str(resolved),
+                },
+            },
+        )
+
+    if not resolved.exists():
+        return (
+            False,
+            {
+                "code": "not_found",
+                "message": "Script file not found",
+                "details": {"script_path": str(resolved)},
+            },
+        )
+
+    if resolved.suffix.lower() != ".py":
+        return (
+            False,
+            {
+                "code": "invalid_request",
+                "message": "Only .py scripts are supported",
+                "details": {"script_path": str(resolved)},
+            },
+        )
+
+    return True, resolved
+
+
+def _sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _truncate(text: str, *, max_chars: int = 20_000) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3] + "..."
+
+
+def _with_repo_pythonpath(env: dict[str, str]) -> dict[str, str]:
+    root = str(repo_root())
+    cur = env.get("PYTHONPATH", "").strip()
+    env_out = dict(env)
+    env_out["PYTHONPATH"] = f"{root}{os.pathsep}{cur}" if cur else root
+    return env_out
+
+
+_PROTOCOL_PATTERNS: list[tuple[str, str]] = [
+    ("moonwell", "moonwell"),
+    ("hyperliquid", "hyperliquid"),
+    ("hyperlend", "hyperlend"),
+    ("pendle", "pendle"),
+    ("boros", "boros"),
+    ("brap", "brap"),
+    ("swap", "brap"),
+]
+
+
+def _infer_protocol_from_script(script_path: Path) -> str | None:
+    name = script_path.stem.lower()
+    for pattern, protocol in _PROTOCOL_PATTERNS:
+        if pattern in name:
+            return protocol
+    return None
+
+
+def _annotate_script_run(
+    *,
+    script_path: str,
+    status: str,
+    wallet_label: str | None = None,
+    protocol: str | None = None,
+    idempotency_key: str | None = None,
+) -> None:
+    # Only annotates if wallet_label is provided - we must know the actual wallet
+    if not protocol:
+        return
+
+    if not wallet_label:
+        return
+
+    wallet = find_wallet_by_label(wallet_label)
+    if not wallet:
+        return
+
+    address = wallet.get("address")
+    if not address:
+        return
+
+    store = WalletProfileStore.default()
+    store.annotate_safe(
+        address=address,
+        label=wallet_label,
+        protocol=protocol,
+        action="run_script",
+        tool="run_script",
+        status=status,
+        details={"script_path": script_path},
+        idempotency_key=idempotency_key,
+    )
+
+
+async def run_script(
+    *,
+    script_path: str,
+    args: list[str] | None = None,
+    dry_run: bool = True,
+    timeout_s: int = 600,
+    env: dict[str, str] | None = None,
+    idempotency_key: str | None = None,
+    force: bool = False,
+    wallet_label: str | None = None,
+) -> dict[str, Any]:
+    ok_path, resolved_or_error = _resolve_script_path(script_path)
+    if not ok_path:
+        payload = resolved_or_error if isinstance(resolved_or_error, dict) else {}
+        return err(
+            payload.get("code") or "invalid_request",
+            payload.get("message") or "Invalid script_path",
+            payload.get("details"),
+        )
+    script = resolved_or_error
+
+    root = repo_root()
+    display_path = str(script)
+    try:
+        display_path = str(script.relative_to(root))
+    except ValueError:
+        pass
+
+    args_list: list[str] = []
+    if args:
+        args_list = [str(a) for a in args if str(a).strip()]
+
+    script_sha = None
+    try:
+        script_sha = _sha256_file(script)
+    except OSError:
+        pass
+
+    tool_input = {
+        "script_path": display_path,
+        "args": args_list,
+        "dry_run": bool(dry_run),
+        "timeout_s": int(timeout_s),
+        "env": env or {},
+        "script_sha256": script_sha,
+    }
+    preview_obj = build_run_script_preview(tool_input)
+    preview_text = str(preview_obj.get("summary") or "").strip()
+
+    store = IdempotencyStore.default()
+    key = (idempotency_key or "").strip() or sha256_json(tool_input)
+    prior = store.get(key)
+    if prior and not force:
+        try:
+            prior_result = prior.get("result") if isinstance(prior, dict) else None
+            if isinstance(prior_result, dict):
+                prior_result["status"] = "duplicate"
+                prior_result["idempotency_key"] = key
+                prior_result.setdefault("preview", preview_text)
+        except Exception:
+            pass
+        return prior
+
+    try:
+        timeout = max(1, int(timeout_s))
+    except (TypeError, ValueError):
+        timeout = 600
+
+    base_env = os.environ.copy()
+    if env:
+        base_env.update({str(k): str(v) for k, v in env.items()})
+    base_env["DRY_RUN"] = "1" if dry_run else "0"
+    exec_env = _with_repo_pythonpath(base_env)
+
+    start = time.time()
+    timed_out = False
+
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(script),
+        *args_list,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        cwd=str(root),
+        env=exec_env,
+    )
+
+    try:
+        stdout_b, stderr_b = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except TimeoutError:
+        timed_out = True
+        proc.kill()
+        stdout_b, stderr_b = await proc.communicate()
+
+    duration_s = time.time() - start
+    stdout = _truncate((stdout_b or b"").decode("utf-8", errors="replace"))
+    stderr = _truncate((stderr_b or b"").decode("utf-8", errors="replace"))
+
+    exit_code = int(proc.returncode or 0)
+    status = "timeout" if timed_out else ("completed" if exit_code == 0 else "failed")
+
+    response = ok(
+        {
+            "idempotency_key": key,
+            "status": status,
+            "dry_run": bool(dry_run),
+            "script_path": display_path,
+            "script_sha256": script_sha,
+            "args": args_list,
+            "timeout_s": timeout,
+            "duration_s": duration_s,
+            "exit_code": exit_code,
+            "stdout": stdout,
+            "stderr": stderr,
+            "preview": preview_text,
+        }
+    )
+    store.put(key, tool_input, response)
+
+    inferred_protocol = _infer_protocol_from_script(script)
+    if inferred_protocol and wallet_label:
+        _annotate_script_run(
+            script_path=display_path,
+            status=status,
+            wallet_label=wallet_label,
+            protocol=inferred_protocol,
+            idempotency_key=key,
+        )
+
+    return response