wayfinder-paths 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

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/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/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/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/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/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/core/constants/hype_oft_abi.py

@@ -0,0 +1,151 @@
+"""LayerZero OFT ABI subset used for bridging native HYPE from HyperEVM."""
+
+HYPE_OFT_ABI = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {"internalType": "bool", "name": "_payInLzToken", "type": "bool"},
+        ],
+        "name": "quoteSend",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "",
+                "type": "tuple",
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "_fee",
+                "type": "tuple",
+            },
+            {"internalType": "address", "name": "_refundAddress", "type": "address"},
+        ],
+        "name": "send",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "bytes32", "name": "guid", "type": "bytes32"},
+                    {"internalType": "uint64", "name": "nonce", "type": "uint64"},
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint256",
+                                "name": "nativeFee",
+                                "type": "uint256",
+                            },
+                            {
+                                "internalType": "uint256",
+                                "name": "lzTokenFee",
+                                "type": "uint256",
+                            },
+                        ],
+                        "internalType": "struct MessagingFee",
+                        "name": "fee",
+                        "type": "tuple",
+                    },
+                ],
+                "internalType": "struct MessagingReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "amountSentLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "amountReceivedLD",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct OFTReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+        ],
+        "stateMutability": "payable",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "sharedDecimals",
+        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "decimalConversionRate",
+        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+]

wayfinder_paths/core/strategies/Strategy.py

@@ -8,7 +8,6 @@ from loguru import logger
 
 from wayfinder_paths.core.clients.TokenClient import TokenDetails
 from wayfinder_paths.core.strategies.descriptors import StratDescriptor
-from wayfinder_paths.core.types import HyperliquidSignCallback
 
 
 class StatusDict(TypedDict):
@@ -52,7 +51,7 @@ class Strategy(ABC):
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
-        strategy_sign_typed_data: HyperliquidSignCallback | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)

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/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: