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

wayfinder_paths/mcp/tools/balances.py

@@ -3,93 +3,10 @@ from __future__ import annotations
 import asyncio
 from typing import Any, Literal
 
-import httpx
-
-from wayfinder_paths.core.config import get_api_base_url, get_api_key
-from wayfinder_paths.core.constants.base import DEFAULT_HTTP_TIMEOUT
+from wayfinder_paths.core.clients import BalanceClient
 from wayfinder_paths.mcp.utils import err, find_wallet_by_label, normalize_address, ok
 
 
-class _BalanceClient:
-    def __init__(self):
-        self.api_base_url = get_api_base_url()
-        timeout = httpx.Timeout(DEFAULT_HTTP_TIMEOUT)
-        self.client = httpx.AsyncClient(timeout=timeout)
-        self._headers = {"Content-Type": "application/json"}
-        api_key = get_api_key()
-        if api_key:
-            self._headers["X-API-KEY"] = api_key
-
-    async def close(self):
-        await self.client.aclose()
-
-    async def get_enriched_wallet_balances(
-        self,
-        *,
-        wallet_address: str,
-        exclude_spam_tokens: bool = True,
-    ) -> dict:
-        url = f"{self.api_base_url}/blockchain/balances/enriched/"
-        params = {
-            "address": wallet_address,
-            "exclude_spam_tokens": str(exclude_spam_tokens).lower(),
-        }
-        response = await self.client.get(url, params=params, headers=self._headers)
-        response.raise_for_status()
-        return response.json()
-
-    async def get_wallet_activity(
-        self,
-        *,
-        wallet_address: str,
-        limit: int = 20,
-        offset: str | None = None,
-    ) -> dict:
-        url = f"{self.api_base_url}/blockchain/balances/activity/"
-        params: dict[str, str | int] = {"address": wallet_address, "limit": limit}
-        if offset:
-            params["offset"] = offset
-        response = await self.client.get(url, params=params, headers=self._headers)
-        response.raise_for_status()
-        return response.json()
-
-    async def get_token_balance(
-        self,
-        *,
-        wallet_address: str,
-        token_id: str,
-        human_readable: bool = True,
-    ) -> dict:
-        url = f"{self.api_base_url}/public/balances/token/"
-        params = {
-            "wallet_address": wallet_address,
-            "token_id": token_id,
-            "human_readable": str(human_readable).lower(),
-        }
-        response = await self.client.get(url, params=params, headers=self._headers)
-        response.raise_for_status()
-        return response.json()
-
-    async def get_pool_balance(
-        self,
-        *,
-        pool_address: str,
-        chain_id: int,
-        user_address: str,
-        human_readable: bool = True,
-    ) -> dict:
-        url = f"{self.api_base_url}/public/balances/pool/"
-        params = {
-            "pool_address": pool_address,
-            "chain_id": chain_id,
-            "user_address": user_address,
-            "human_readable": str(human_readable).lower(),
-        }
-        response = await self.client.get(url, params=params, headers=self._headers)
-        response.raise_for_status()
-        return response.json()
-
-
 def _dedupe_ordered(items: list[str]) -> list[str]:
     seen: set[str] = set()
     out: list[str] = []
@@ -145,146 +62,137 @@ async def balances(
             "invalid_request", "wallet_label or wallet_address is required for balances"
         )
 
-    client = _BalanceClient()
+    client = BalanceClient()
 
-    try:
-        if action == "enriched":
-            try:
-                data = await client.get_enriched_wallet_balances(
-                    wallet_address=waddr,
-                    exclude_spam_tokens=bool(exclude_spam_tokens),
-                )
-                if (
-                    not include_solana
-                    and _is_evm_address(waddr)
-                    and isinstance(data, dict)
-                    and isinstance(data.get("balances"), list)
-                ):
-                    balances_list = [b for b in data["balances"] if isinstance(b, dict)]
-                    filtered = [
-                        b
-                        for b in balances_list
-                        if str(b.get("network", "")).lower() != "solana"
-                    ]
-                    if len(filtered) != len(balances_list):
-                        out = dict(data)
-                        out["balances"] = filtered
-                        out["total_balance_usd"] = sum(
-                            _balance_usd(b) for b in filtered
-                        )
-                        breakdown: dict[str, float] = {}
-                        for b in filtered:
-                            net = str(b.get("network") or "").strip()
-                            if not net:
-                                continue
-                            breakdown[net] = breakdown.get(net, 0.0) + _balance_usd(b)
-                        out["chain_breakdown"] = breakdown
-                        out["filtered"] = {
-                            "excluded_networks": ["solana"],
-                            "original_count": len(balances_list),
-                            "filtered_count": len(filtered),
-                        }
-                        data = out
+    if action == "enriched":
+        try:
+            data = await client.get_enriched_wallet_balances(
+                wallet_address=waddr,
+                exclude_spam_tokens=bool(exclude_spam_tokens),
+            )
+            if (
+                not include_solana
+                and _is_evm_address(waddr)
+                and isinstance(data, dict)
+                and isinstance(data.get("balances"), list)
+            ):
+                balances_list = [b for b in data["balances"] if isinstance(b, dict)]
+                filtered = [
+                    b
+                    for b in balances_list
+                    if str(b.get("network", "")).lower() != "solana"
+                ]
+                if len(filtered) != len(balances_list):
+                    out = dict(data)
+                    out["balances"] = filtered
+                    out["total_balance_usd"] = sum(_balance_usd(b) for b in filtered)
+                    breakdown: dict[str, float] = {}
+                    for b in filtered:
+                        net = str(b.get("network") or "").strip()
+                        if not net:
+                            continue
+                        breakdown[net] = breakdown.get(net, 0.0) + _balance_usd(b)
+                    out["chain_breakdown"] = breakdown
+                    out["filtered"] = {
+                        "excluded_networks": ["solana"],
+                        "original_count": len(balances_list),
+                        "filtered_count": len(filtered),
+                    }
+                    data = out
 
-                return ok(data)
-            except Exception as exc:  # noqa: BLE001
-                return err("balance_error", str(exc))
+            return ok(data)
+        except Exception as exc:  # noqa: BLE001
+            return err("balance_error", str(exc))
+
+    if action == "activity":
+        try:
+            data = await client.get_wallet_activity(
+                wallet_address=waddr,
+                limit=int(limit),
+                offset=offset,
+            )
+            return ok(
+                {
+                    "wallet_address": waddr,
+                    "activity": data.get("activity", []),
+                    "next_offset": data.get("next_offset"),
+                }
+            )
+        except Exception as exc:  # noqa: BLE001
+            return err("activity_error", str(exc))
+
+    if action == "token":
+        raw_ids: list[str] = []
+        if token_id:
+            raw_ids.append(str(token_id).strip())
+        if token_ids:
+            raw_ids.extend(str(x).strip() for x in token_ids)
+
+        ids = _dedupe_ordered([x for x in raw_ids if x])
+        if not ids:
+            return err(
+                "invalid_request",
+                "token_id or token_ids is required for balances(action=token)",
+            )
 
-        if action == "activity":
+        async def _one(tid: str) -> dict[str, Any]:
             try:
-                data = await client.get_wallet_activity(
+                data = await client.get_token_balance(
+                    token_id=tid,
                     wallet_address=waddr,
-                    limit=int(limit),
-                    offset=offset,
-                )
-                return ok(
-                    {
-                        "wallet_address": waddr,
-                        "activity": data.get("activity", []),
-                        "next_offset": data.get("next_offset"),
-                    }
+                    human_readable=bool(human_readable),
                 )
+                return {"ok": True, "token_id": tid, "data": data}
             except Exception as exc:  # noqa: BLE001
-                return err("activity_error", str(exc))
-
-        if action == "token":
-            raw_ids: list[str] = []
-            if token_id:
-                raw_ids.append(str(token_id).strip())
-            if token_ids:
-                raw_ids.extend(str(x).strip() for x in token_ids)
-
-            ids = _dedupe_ordered([x for x in raw_ids if x])
-            if not ids:
-                return err(
-                    "invalid_request",
-                    "token_id or token_ids is required for balances(action=token)",
-                )
+                return {"ok": False, "token_id": tid, "error": str(exc)}
 
-            async def _one(tid: str) -> dict[str, Any]:
-                try:
-                    data = await client.get_token_balance(
-                        token_id=tid,
-                        wallet_address=waddr,
-                        human_readable=bool(human_readable),
-                    )
-                    return {"ok": True, "token_id": tid, "data": data}
-                except Exception as exc:  # noqa: BLE001
-                    return {"ok": False, "token_id": tid, "error": str(exc)}
+        results = await asyncio.gather(*[_one(tid) for tid in ids])
+        return ok({"wallet_address": waddr, "balances": results})
 
-            results = await asyncio.gather(*[_one(tid) for tid in ids])
-            return ok({"wallet_address": waddr, "balances": results})
-
-        if action == "pool":
-            if chain_id is None:
-                return err(
-                    "invalid_request", "chain_id is required for balances(action=pool)"
-                )
-
-            raw_pools: list[str] = []
-            if pool_address:
-                raw_pools.append(str(pool_address).strip())
-            if pool_addresses:
-                raw_pools.extend(str(x).strip() for x in pool_addresses)
-
-            pools = _dedupe_ordered([x for x in raw_pools if x])
-            if not pools:
-                return err(
-                    "invalid_request",
-                    "pool_address or pool_addresses is required for balances(action=pool)",
-                )
-
-            async def _one_pool(paddr: str) -> dict[str, Any]:
-                try:
-                    data = await client.get_pool_balance(
-                        pool_address=paddr,
-                        chain_id=int(chain_id),  # type: ignore[arg-type]
-                        user_address=waddr,
-                        human_readable=bool(human_readable),
-                    )
-                    return {
-                        "ok": True,
-                        "pool_address": paddr,
-                        "chain_id": int(chain_id),  # type: ignore[arg-type]
-                        "data": data,
-                    }
-                except Exception as exc:  # noqa: BLE001
-                    return {
-                        "ok": False,
-                        "pool_address": paddr,
-                        "chain_id": int(chain_id),  # type: ignore[arg-type]
-                        "error": str(exc),
-                    }
+    if action == "pool":
+        if chain_id is None:
+            return err(
+                "invalid_request", "chain_id is required for balances(action=pool)"
+            )
 
-            results = await asyncio.gather(*[_one_pool(p) for p in pools])
-            return ok(
-                {"wallet_address": waddr, "chain_id": int(chain_id), "pools": results}
+        raw_pools: list[str] = []
+        if pool_address:
+            raw_pools.append(str(pool_address).strip())
+        if pool_addresses:
+            raw_pools.extend(str(x).strip() for x in pool_addresses)
+
+        pools = _dedupe_ordered([x for x in raw_pools if x])
+        if not pools:
+            return err(
+                "invalid_request",
+                "pool_address or pool_addresses is required for balances(action=pool)",
             )
 
-        return err("invalid_request", f"Unknown balances action: {action}")
+        async def _one_pool(paddr: str) -> dict[str, Any]:
+            try:
+                data = await client.get_pool_balance(
+                    pool_address=paddr,
+                    chain_id=int(chain_id),  # type: ignore[arg-type]
+                    user_address=waddr,
+                    human_readable=bool(human_readable),
+                )
+                return {
+                    "ok": True,
+                    "pool_address": paddr,
+                    "chain_id": int(chain_id),  # type: ignore[arg-type]
+                    "data": data,
+                }
+            except Exception as exc:  # noqa: BLE001
+                return {
+                    "ok": False,
+                    "pool_address": paddr,
+                    "chain_id": int(chain_id),  # type: ignore[arg-type]
+                    "error": str(exc),
+                }
+
+        results = await asyncio.gather(*[_one_pool(p) for p in pools])
+        return ok(
+            {"wallet_address": waddr, "chain_id": int(chain_id), "pools": results}
+        )
 
-    finally:
-        try:
-            await client.close()
-        except Exception:  # noqa: BLE001
-            pass
+    return err("invalid_request", f"Unknown balances action: {action}")

wayfinder_paths/mcp/tools/execute.py

@@ -13,7 +13,6 @@ from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.constants import ZERO_ADDRESS
 from wayfinder_paths.core.constants.chains import CHAIN_CODE_TO_ID
-from wayfinder_paths.core.constants.contracts import TOKENS_REQUIRING_APPROVAL_RESET
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.constants.hyperliquid import (
     ARBITRUM_USDC_ADDRESS,
@@ -21,8 +20,7 @@ from wayfinder_paths.core.constants.hyperliquid import (
     HYPERLIQUID_BRIDGE_ADDRESS,
 )
 from wayfinder_paths.core.utils.tokens import (
-    build_approve_transaction,
-    get_token_allowance,
+    ensure_allowance,
 )
 from wayfinder_paths.core.utils.transaction import send_transaction
 from wayfinder_paths.mcp.preview import build_execution_preview
@@ -108,10 +106,6 @@ class ExecutionRequest(BaseModel):
         return self
 
 
-def _slippage_float(bps: int) -> float:
-    return max(0.0, float(int(bps)) / 10_000.0)
-
-
 def _addr_lower(addr: str | None) -> str | None:
     if not addr:
         return None
@@ -257,6 +251,59 @@ def _sanitize_for_json(obj: Any) -> Any:
     return obj
 
 
+def _compact_quote(
+    quote_data: dict[str, Any], best_quote: dict[str, Any] | None
+) -> dict[str, Any]:
+    """Create a compact summary of quote data, stripping verbose nested structures."""
+    result: dict[str, Any] = {}
+
+    # Extract provider list from all_quotes
+    all_quotes = quote_data.get("quotes", {}).get("all_quotes", [])
+    if isinstance(all_quotes, list):
+        result["providers"] = list(
+            {
+                q.get("provider")
+                for q in all_quotes
+                if isinstance(q, dict) and q.get("provider")
+            }
+        )
+        result["quote_count"] = len(all_quotes)
+
+    # Compact best_quote - only essential fields
+    if isinstance(best_quote, dict):
+        result["best"] = {
+            "provider": best_quote.get("provider"),
+            "input_amount": best_quote.get("input_amount"),
+            "output_amount": best_quote.get("output_amount"),
+            "input_usd": best_quote.get("input_amount_usd"),
+            "output_usd": best_quote.get("output_amount_usd"),
+        }
+        # Compact fee info
+        fee = best_quote.get("fee_estimate")
+        if isinstance(fee, dict):
+            result["best"]["fee_usd"] = fee.get("fee_total_usd")
+        # Extract route summary (just protocol names)
+        quote_inner = best_quote.get("quote", {})
+        if isinstance(quote_inner, dict):
+            route = quote_inner.get("route", [])
+            if isinstance(route, list):
+                result["best"]["route"] = [
+                    r.get("protocol")
+                    for r in route
+                    if isinstance(r, dict) and r.get("protocol")
+                ]
+            # Or from includedSteps
+            steps = quote_inner.get("includedSteps", [])
+            if isinstance(steps, list) and not result["best"].get("route"):
+                result["best"]["route"] = [
+                    s.get("tool")
+                    for s in steps
+                    if isinstance(s, dict) and s.get("tool")
+                ]
+
+    return result
+
+
 def _is_dry_run() -> bool:
     return os.getenv("DRY_RUN", "").lower() in ("1", "true")
 
@@ -298,41 +345,16 @@ async def _ensure_allowance(
     # May emit 0-allowance clear tx for tokens requiring approval reset (e.g. USDT)
     effects: list[dict[str, Any]] = []
 
-    allowance = await get_token_allowance(
+    sent_ok, sent = await ensure_allowance(
         token_address=token_address,
+        owner=owner,
+        spender=spender,
+        amount=amount,
         chain_id=chain_id,
-        owner_address=owner,
-        spender_address=spender,
+        signing_callback=sign_callback,
     )
-
-    token_checksum = to_checksum_address(token_address)
-    if (chain_id, token_checksum) in TOKENS_REQUIRING_APPROVAL_RESET and allowance > 0:
-        clear_tx = await build_approve_transaction(
-            from_address=owner,
-            chain_id=chain_id,
-            token_address=token_checksum,
-            spender_address=spender,
-            amount=0,
-        )
-        sent_ok, sent = await _broadcast(sign_callback, clear_tx, chain_id=chain_id)
-        effects.append({"type": "tx", "label": "approve_clear", **sent})
-        if not sent_ok:
-            return False, effects
-        # After clear, we will still submit a fresh approve below.
-
-    if allowance >= int(amount):
-        return True, effects
-
-    approve_tx = await build_approve_transaction(
-        from_address=owner,
-        chain_id=chain_id,
-        token_address=token_checksum,
-        spender_address=spender,
-        amount=int(amount),
-    )
-
-    sent_ok, sent = await _broadcast(sign_callback, approve_tx, chain_id=chain_id)
-    effects.append({"type": "tx", "label": "approve", **sent})
+    if isinstance(sent, dict) and sent:
+        effects.append({"type": "tx", "label": "approve", **sent})
     return sent_ok, effects
 
 
@@ -550,7 +572,7 @@ async def execute(
                         "recipient": rcpt,
                         "preview": preview_text,
                         "effects": effects,
-                        "raw": {"quote": quote_data},
+                        "raw": _compact_quote(quote_data, None),
                     }
                 )
                 store.put(key, tool_input, response)
@@ -576,7 +598,7 @@ async def execute(
                 "recipient": rcpt,
                 "preview": preview_text,
                 "effects": effects,
-                "raw": {"quote": quote_data, "best_quote": best_quote},
+                "raw": _compact_quote(quote_data, best_quote),
             }
         )
         store.put(key, tool_input, response)

wayfinder_paths/mcp/tools/quotes.py

@@ -196,10 +196,10 @@ async def quote_swap(
         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_chain=from_chain_id,
+            to_chain=to_chain_id,
             from_wallet=sender,
-            amount1=str(amount_raw),
+            from_amount=str(amount_raw),
             slippage=slip,
         )
     except Exception as exc:  # noqa: BLE001
@@ -244,9 +244,20 @@ async def quote_swap(
             "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"),
         }
+
+        # Strip data fields from wrap/unwrap transactions to reduce response size
+        wrap_tx = best_quote.get("wrap_transaction")
+        if isinstance(wrap_tx, dict):
+            best_out["wrap_transaction"] = {
+                k: v for k, v in wrap_tx.items() if k != "data"
+            }
+        unwrap_tx = best_quote.get("unwrap_transaction")
+        if isinstance(unwrap_tx, dict):
+            best_out["unwrap_transaction"] = {
+                k: v for k, v in unwrap_tx.items() if k != "data"
+            }
+
         if include_calldata:
             best_out["calldata"] = calldata
         else:

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -14,9 +14,6 @@ from typing import Any
 
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
-from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
-    LocalHyperliquidExecutor,
-)
 from wayfinder_paths.adapters.hyperliquid_adapter.paired_filler import (
     MIN_NOTIONAL_USD,
     FillConfig,
@@ -51,9 +48,6 @@ from wayfinder_paths.core.analytics import (
 from wayfinder_paths.core.analytics import (
     z_from_conf as analytics_z_from_conf,
 )
-from wayfinder_paths.core.clients.protocols import (
-    HyperliquidExecutorProtocol as HyperliquidExecutor,
-)
 from wayfinder_paths.core.constants.contracts import HYPERLIQUID_BRIDGE
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
@@ -64,6 +58,7 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
+from wayfinder_paths.core.types import HyperliquidSignCallback
 from wayfinder_paths.policies.erc20 import any_erc20_function
 from wayfinder_paths.policies.hyperliquid import (
     any_hyperliquid_l1_payload,
@@ -188,16 +183,15 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        hyperliquid_executor: HyperliquidExecutor | None = None,
-        api_key: str | None = None,
+        strategy_sign_typed_data: HyperliquidSignCallback | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
     ) -> None:
         super().__init__(
-            api_key=api_key,
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+            strategy_sign_typed_data=strategy_sign_typed_data,
         )
 
         merged_config = dict(config or {})
@@ -228,24 +222,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             "strategy": self.config,
         }
 
-        # This is only required for placing/canceling orders (not market reads).
-        hl_executor = hyperliquid_executor
-        if hl_executor is None:
-            try:
-                hl_executor = LocalHyperliquidExecutor(config=adapter_config)
-                self.logger.info("Created LocalHyperliquidExecutor for real execution")
-            except Exception as e:
-                self.logger.warning(
-                    f"Could not create LocalHyperliquidExecutor: {e}. "
-                    "Real Hyperliquid execution will not be available."
-                )
-
         # Hyperliquid market data adapter should be usable even when wallet/web3
         # configuration is missing (e.g. local --action analyze).
+        # The adapter will create Exchange internally with local signer from config
+        # if no sign_callback is provided.
         try:
             self.hyperliquid_adapter = HyperliquidAdapter(
                 config=adapter_config,
-                executor=hl_executor,
+                sign_callback=strategy_sign_typed_data,
             )
         except Exception as e:
             self.logger.warning(f"Could not initialize HyperliquidAdapter: {e}")