wayfinder-paths 0.1.30__tar.gz → 0.1.31__tar.gz

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.30
+Version: 0.1.31
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wayfinder-paths"
-version = "0.1.30"
+version = "0.1.31"
 description = "Wayfinder Path: strategies and adapters"
 readme = "README.md"
 authors = ["Wayfinder <dev@wayfinder.ai>"]

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -603,9 +603,23 @@ class HyperliquidAdapter(BaseAdapter):
         if not self._exchange:
             raise NotImplementedError("No Hyperliquid exchange configured.")
 
+        try:
+            order_id_int = int(order_id)
+        except (TypeError, ValueError):
+            return (
+                False,
+                {
+                    "status": "err",
+                    "response": {
+                        "type": "error",
+                        "data": f"Invalid order_id for cancel_order: {order_id}",
+                    },
+                },
+            )
+
         result = await self._exchange.cancel_order(
             asset_id=asset_id,
-            order_id=str(order_id) if isinstance(order_id, int) else order_id,
+            order_id=order_id_int,
             address=address,
         )
 

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/adapters/hyperliquid_adapter/exchange.py

@@ -84,7 +84,7 @@ class Exchange:
     ):
         """Place a market order (IOC limit with slippage)."""
         asset_name = self.info.asset_to_coin[asset_id]
-        mids = await self.info.all_dex_mid_prices()
+        mids = self.info.all_mids()
         midprice = float(mids[asset_name])
 
         if slippage >= 1 or slippage < 0:
@@ -152,14 +152,14 @@ class Exchange:
         )
         return await self.sign_and_broadcast_hypecore(order_actions, address)
 
-    async def cancel_order(self, asset_id: int, order_id: str, address: str):
+    async def cancel_order(self, asset_id: int, order_id: int, address: str):
         """Cancel an open order."""
         order_actions = {
             "type": "cancel",
             "cancels": [
                 {
                     "a": asset_id,
-                    "o": order_id,
+                    "o": int(order_id),
                 }
             ],
         }

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/adapters/hyperliquid_adapter/paired_filler.py

@@ -243,7 +243,7 @@ class LegConfirmer:
             if asset_id is None:
                 continue
             try:
-                await self.adapter.cancel_order(asset_id, str(oid_int), address)
+                await self.adapter.cancel_order(asset_id, oid_int, address)
                 attempted.add(oid_int)
             except Exception as exc:
                 logger.info(f"Cancel failed for oid {oid_int}: {exc}")

wayfinder_paths-0.1.31/wayfinder_paths/adapters/hyperliquid_adapter/test_cancel_order.py

@@ -0,0 +1,57 @@
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
+from wayfinder_paths.adapters.hyperliquid_adapter.exchange import Exchange
+
+
+class TestHyperliquidCancelOrder:
+    @pytest.mark.asyncio
+    async def test_exchange_cancel_order_uses_int_oid(self):
+        ex = Exchange(
+            info=SimpleNamespace(),
+            util=SimpleNamespace(),
+            sign_callback=AsyncMock(return_value="0x"),
+            signing_type="eip712",
+        )
+        ex.sign_and_broadcast_hypecore = AsyncMock(return_value={"status": "ok"})
+
+        await ex.cancel_order(asset_id=10210, order_id=306356655993, address="0xabc")
+
+        args, _ = ex.sign_and_broadcast_hypecore.await_args
+        action = args[0]
+        assert action["type"] == "cancel"
+        assert action["cancels"][0]["a"] == 10210
+        assert isinstance(action["cancels"][0]["o"], int)
+        assert action["cancels"][0]["o"] == 306356655993
+
+    @pytest.mark.asyncio
+    async def test_adapter_cancel_order_parses_string_oid(self):
+        adapter = object.__new__(HyperliquidAdapter)
+        adapter.simulation = False
+        adapter._exchange = SimpleNamespace()
+        adapter._exchange.cancel_order = AsyncMock(return_value={"status": "ok"})
+
+        ok, _ = await adapter.cancel_order(
+            asset_id=10210, order_id="306356655993", address="0xabc"
+        )
+        assert ok is True
+
+        adapter._exchange.cancel_order.assert_awaited_once_with(
+            asset_id=10210, order_id=306356655993, address="0xabc"
+        )
+
+    @pytest.mark.asyncio
+    async def test_adapter_cancel_order_rejects_bad_oid(self):
+        adapter = object.__new__(HyperliquidAdapter)
+        adapter.simulation = False
+        adapter._exchange = SimpleNamespace()
+        adapter._exchange.cancel_order = AsyncMock(return_value={"status": "ok"})
+
+        ok, res = await adapter.cancel_order(
+            asset_id=1, order_id="not-a-number", address="0xabc"
+        )
+        assert ok is False
+        assert res["status"] == "err"

wayfinder_paths-0.1.31/wayfinder_paths/adapters/hyperliquid_adapter/test_exchange_mid_prices.py

@@ -0,0 +1,52 @@
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from wayfinder_paths.adapters.hyperliquid_adapter.exchange import Exchange
+
+
+class _InfoStub(SimpleNamespace):
+    def all_mids(self):
+        return {"HYPE": "1.0"}
+
+    async def all_dex_mid_prices(self):  # pragma: no cover
+        raise AssertionError(
+            "Exchange must use Info.all_mids(), not all_dex_mid_prices"
+        )
+
+
+class _UtilStub(SimpleNamespace):
+    def get_price_decimals_for_hypecore_asset(self, asset_id: int) -> int:
+        return 6
+
+
+class TestExchangeMidPriceFetch:
+    @pytest.mark.asyncio
+    async def test_place_market_order_uses_all_mids(self):
+        info = _InfoStub(asset_to_coin={7: "HYPE"})
+        util = _UtilStub()
+        ex = Exchange(
+            info=info,
+            util=util,
+            sign_callback=AsyncMock(return_value="0x"),
+            signing_type="eip712",
+        )
+
+        async def _no_broadcast(action, address):
+            return action
+
+        ex.sign_and_broadcast_hypecore = _no_broadcast
+
+        action = await ex.place_market_order(
+            asset_id=7,
+            is_buy=True,
+            slippage=0.01,
+            size=1.0,
+            address="0xabc",
+        )
+
+        assert action["type"] == "order"
+        assert action["orders"][0]["a"] == 7
+        assert action["orders"][0]["b"] is True
+        assert action["orders"][0]["p"] == "1.01"

wayfinder_paths-0.1.31/wayfinder_paths/adapters/hyperliquid_adapter/test_hyperliquid_sdk_live.py

@@ -0,0 +1,64 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
+from wayfinder_paths.adapters.hyperliquid_adapter.exchange import Exchange
+
+
+@pytest.fixture
+def live_adapter():
+    return HyperliquidAdapter(config={}, simulation=True)
+
+
+class TestHyperliquidSdkCompat:
+    @pytest.mark.asyncio
+    async def test_util_mid_prices_live(self, live_adapter):
+        mids = await live_adapter.util.get_hypecore_all_dex_mid_prices()
+        assert isinstance(mids, dict)
+        assert len(mids) > 0
+
+        # Sanity check some common keys exist (perp coins or spot tickers like @107).
+        assert "HYPE" in mids or "BTC" in mids or any(k.startswith("@") for k in mids)
+
+    @pytest.mark.asyncio
+    async def test_util_meta_live(self, live_adapter):
+        meta = await live_adapter.util.get_hypecore_all_dex_meta_universe()
+        assert isinstance(meta, dict)
+        assert "universe" in meta
+
+
+class TestExchangeUsesLiveMids:
+    @pytest.mark.asyncio
+    async def test_place_market_order_builds_ioc_limit(self, live_adapter):
+        # Use a perp id to avoid spot naming edge-cases.
+        asset_id = live_adapter.coin_to_asset["HYPE"]
+
+        ex = Exchange(
+            info=live_adapter.info,
+            util=live_adapter.util,
+            sign_callback=AsyncMock(return_value="0x"),
+            signing_type="eip712",
+        )
+
+        async def _no_broadcast(action, address):
+            return action
+
+        ex.sign_and_broadcast_hypecore = _no_broadcast
+
+        action = await ex.place_market_order(
+            asset_id=asset_id,
+            is_buy=True,
+            slippage=0.01,
+            size=1.0,
+            address="0x0000000000000000000000000000000000000000",
+        )
+
+        assert action["type"] == "order"
+        assert action["orders"][0]["a"] == asset_id
+        assert action["orders"][0]["b"] is True
+
+        # Price should be at/above current mid for a buy (within rounding tolerance).
+        mid = float(live_adapter.info.all_mids()["HYPE"])
+        px = float(action["orders"][0]["p"])
+        assert px >= mid * 0.999

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/adapters/hyperliquid_adapter/util.py

@@ -1,4 +1,3 @@
-import asyncio
 import time
 from decimal import ROUND_DOWN, Decimal
 from typing import Any
@@ -61,10 +60,12 @@ class Util:
         return assets.get(asset_name)
 
     async def get_hypecore_all_dex_mid_prices(self):
-        return await self.info.all_dex_mid_prices()
+        # Backwards compatible wrapper: the Hyperliquid SDK now exposes `all_mids()`.
+        return self.info.all_mids()
 
     async def get_hypecore_all_dex_meta_universe(self):
-        return await self.info.all_dex_meta_universe()
+        # Backwards compatible wrapper: the Hyperliquid SDK now exposes `meta()`.
+        return self.info.meta()
 
     def get_size_decimals_for_hypecore_asset(self, asset_id: int):
         return self.info.asset_to_sz_decimals[asset_id]
@@ -107,11 +108,9 @@ class Util:
         return perp_user_state
 
     async def get_hypecore_user(self, address):
-        perp_user_state, spot_user_state, open_orders = await asyncio.gather(
-            self.info.all_dex_user_state(address),
-            self.info.spot_user_state(address),
-            self.info.all_dex_open_orders(address),
-        )
+        perp_user_state = self.info.user_state(address)
+        spot_user_state = self.info.spot_user_state(address)
+        open_orders = self.info.open_orders(address)
         formatted_perp_state = self._reformat_perp_user_state(perp_user_state)
         state = {
             "perp_user_state": formatted_perp_state,
@@ -172,7 +171,7 @@ class Util:
         out = []
         while True:
             try:
-                batch = await self.info.user_fills_by_time(wallet, start, end, False)
+                batch = self.info.user_fills_by_time(wallet, start, end, False)
             except Exception as e:
                 logger.error(f"Failed to fetch fills via node/public/SDK: {e}")
                 break
@@ -185,7 +184,7 @@ class Util:
         return out
 
     async def get_hypecore_position(self, address, asset_name):
-        perp_user_state = await self.info.all_dex_user_state(address)
+        perp_user_state = self.info.user_state(address)
         formatted_perp_user_state = self._reformat_perp_user_state(perp_user_state)
 
         for pos in formatted_perp_user_state.get("assetPositions", []):

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/core/clients/PoolClient.py

@@ -99,7 +99,7 @@ class PoolClient(WayfinderClient):
         self.api_base_url = get_api_base_url()
 
     def _pools_url(self) -> str:
-        return f"{self.api_base_url}/v1/blockchain/pools/"
+        return f"{self.api_base_url}/blockchain/pools/"
 
     async def get_pools(
         self,

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/mcp/tools/execute.py

@@ -257,19 +257,40 @@ def _compact_quote(
     """Create a compact summary of quote data, stripping verbose nested structures."""
     result: dict[str, Any] = {}
 
-    # Extract provider list from quotes (API returns quotes as a list at top level)
-    all_quotes = quote_data.get("quotes", [])
-    if not isinstance(all_quotes, list):
-        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)
+    # Extract provider list from quotes. BRAP quotes may appear as either:
+    # 1) {"quotes": [...], "best_quote": {...}}
+    # 2) {"quotes": {"all_quotes": [...], "best_quote": {...}, "quote_count": N}}
+    all_quotes: list[dict[str, Any]] = []
+    raw_quotes = quote_data.get("quotes", [])
+    quote_count = None
+
+    if isinstance(raw_quotes, list):
+        all_quotes = [q for q in raw_quotes if isinstance(q, dict)]
+    elif isinstance(raw_quotes, dict):
+        nested = raw_quotes.get("all_quotes") or raw_quotes.get("quotes") or []
+        if isinstance(nested, list):
+            all_quotes = [q for q in nested if isinstance(q, dict)]
+        qc = raw_quotes.get("quote_count")
+        try:
+            quote_count = int(qc) if qc is not None else None
+        except (TypeError, ValueError):
+            quote_count = None
+
+    providers: list[str] = []
+    seen: set[str] = set()
+    for q in all_quotes:
+        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)
+
+    if providers:
+        result["providers"] = providers
+    result["quote_count"] = quote_count if quote_count is not None else len(all_quotes)
 
     # Compact best_quote - only essential fields
     if isinstance(best_quote, dict):
@@ -511,9 +532,20 @@ async def execute(
             store.put(key, tool_input, response)
             return response
 
-        best_quote = (
-            quote_data.get("best_quote") if isinstance(quote_data, dict) else None
-        )
+        # BRAP quote responses have historically appeared in two shapes:
+        # 1) {"quotes": [...], "best_quote": {...}}
+        # 2) {"quotes": {"all_quotes": [...], "best_quote": {...}, "quote_count": N}}
+        best_quote = None
+        if isinstance(quote_data, dict):
+            if isinstance(quote_data.get("best_quote"), dict):
+                best_quote = quote_data.get("best_quote")
+            else:
+                quotes_block = quote_data.get("quotes")
+                if isinstance(quotes_block, dict) and isinstance(
+                    quotes_block.get("best_quote"), dict
+                ):
+                    best_quote = quotes_block.get("best_quote")
+
         if not isinstance(best_quote, dict):
             response = err(
                 "quote_error", "No best_quote returned", {"quote": quote_data}

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/mcp/tools/hyperliquid.py

@@ -5,9 +5,6 @@ import re
 from typing import Any, Literal
 
 from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
-from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
-    LocalHyperliquidExecutor,
-)
 from wayfinder_paths.core.constants.hyperliquid import (
     DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP,
     HYPE_FEE_WALLET,
@@ -404,16 +401,7 @@ async def hyperliquid_execute(
 
     effects: list[dict[str, Any]] = []
 
-    executor = None
-    if not dry:
-        try:
-            executor = LocalHyperliquidExecutor(config=config, network="mainnet")
-        except Exception as exc:  # noqa: BLE001
-            response = err("executor_error", str(exc))
-            store.put(key, tool_input, response)
-            return response
-
-    adapter = HyperliquidAdapter(config=config, simulation=dry, executor=executor)
+    adapter = HyperliquidAdapter(config=config, simulation=dry)
 
     if action == "withdraw":
         if amount_usdc is None:

{wayfinder_paths-0.1.30 → wayfinder_paths-0.1.31}/wayfinder_paths/mcp/tools/quotes.py

@@ -21,6 +21,47 @@ def _slippage_float(slippage_bps: int) -> float:
     return max(0.0, float(int(slippage_bps)) / 10_000.0)
 
 
+def _unwrap_brap_quote_response(
+    data: Any,
+) -> tuple[list[dict[str, Any]], dict[str, Any] | None, int]:
+    """
+    BRAP quote responses have historically appeared in two shapes:
+
+    1) {"quotes": [...], "best_quote": {...}}
+    2) {"quotes": {"all_quotes": [...], "best_quote": {...}, "quote_count": N}}
+
+    This helper normalizes both to (all_quotes, best_quote, quote_count).
+    """
+    if not isinstance(data, dict):
+        return [], None, 0
+
+    raw_quotes = data.get("quotes")
+    best_quote = data.get("best_quote")
+
+    if isinstance(raw_quotes, list) or isinstance(best_quote, dict):
+        all_quotes = raw_quotes if isinstance(raw_quotes, list) else []
+        best = best_quote if isinstance(best_quote, dict) else None
+        return all_quotes, best, len(all_quotes)
+
+    # Legacy/nested payload under `quotes`
+    if isinstance(raw_quotes, dict):
+        all_quotes = raw_quotes.get("all_quotes") or raw_quotes.get("quotes") or []
+        if not isinstance(all_quotes, list):
+            all_quotes = []
+        best = raw_quotes.get("best_quote")
+        best_out = best if isinstance(best, dict) else None
+
+        quote_count = raw_quotes.get("quote_count")
+        try:
+            quote_count_i = int(quote_count)
+        except (TypeError, ValueError):
+            quote_count_i = len(all_quotes)
+
+        return all_quotes, best_out, quote_count_i
+
+    return [], None, 0
+
+
 async def quote_swap(
     *,
     wallet_label: str,
@@ -84,13 +125,7 @@ async def quote_swap(
     except Exception as exc:  # noqa: BLE001
         return err("quote_error", str(exc))
 
-    # API returns {"quotes": [...], "best_quote": {...}} at top level
-    raw_quotes = data.get("quotes", []) if isinstance(data, dict) else []
-    if not isinstance(raw_quotes, list):
-        raw_quotes = []
-    all_quotes = raw_quotes
-    best_quote = data.get("best_quote") if isinstance(data, dict) else None
-    quote_count = len(all_quotes)
+    all_quotes, best_quote, quote_count = _unwrap_brap_quote_response(data)
 
     providers: list[str] = []
     seen: set[str] = set()

wayfinder_paths-0.1.31/wayfinder_paths/strategies/basis_trading_strategy/manifest.yaml

@@ -0,0 +1,24 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.basis_trading_strategy.strategy.BasisTradingStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow Hyperliquid EIP-712 order/transfer actions
+      (action.type == 'hyperliquid_order') OR
+      (action.type == 'hyperliquid_cancel') OR
+      (action.type == 'hyperliquid_transfer') OR
+      (action.type == 'hyperliquid_withdraw') OR
+      # Allow USDC transfers to Hyperliquid bridge
+      (action.type == 'erc20_transfer' AND action.to == '0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "HYPERLIQUID"
+    capabilities: ["market.read", "market.meta", "market.funding", "market.candles", "market.orderbook", "order.execute", "order.cancel", "position.manage", "transfer", "withdraw"]