wayfinder-paths 0.1.11__py3-none-any.whl → 0.1.14__py3-none-any.whl

wayfinder_paths/adapters/hyperlend_adapter/test_adapter.py

@@ -34,31 +34,31 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_success(self, adapter, mock_hyperlend_client):
         """Test successful stable markets retrieval"""
         mock_response = {
-            "markets": [
-                {
-                    "chain_id": 999,
-                    "underlying_token": "0x1234...",
+            "markets": {
+                "0x1234...": {
                     "symbol": "USDT",
-                    "apy": 0.05,
-                    "available_liquidity": 1000000,
-                    "buffer_bps": 100,
-                    "min_buffer_tokens": 100.0,
+                    "symbol_canonical": "usdt",
+                    "display_symbol": "USDT",
+                    "reserve": {},
+                    "decimals": 6,
+                    "headroom": 1000000000000,
+                    "supply_cap": 5000000000000,
                 },
-                {
-                    "chain_id": 999,
-                    "underlying_token": "0x5678...",
+                "0x5678...": {
                     "symbol": "USDC",
-                    "apy": 0.04,
-                    "available_liquidity": 2000000,
-                    "buffer_bps": 100,
-                    "min_buffer_tokens": 100.0,
+                    "symbol_canonical": "usdc",
+                    "display_symbol": "USDC",
+                    "reserve": {},
+                    "decimals": 6,
+                    "headroom": 2000000000000,
+                    "supply_cap": 10000000000000,
                 },
-            ]
+            },
+            "notes": [],
         }
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_stable_markets(
-            chain_id=999,
             required_underlying_tokens=1000.0,
             buffer_bps=100,
             min_buffer_tokens=100.0,
@@ -67,11 +67,9 @@ class TestHyperlendAdapter:
         assert success is True
         assert data == mock_response
         mock_hyperlend_client.get_stable_markets.assert_called_once_with(
-            chain_id=999,
             required_underlying_tokens=1000.0,
             buffer_bps=100,
             min_buffer_tokens=100.0,
-            is_stable_symbol=None,
         )
 
     @pytest.mark.asyncio
@@ -80,27 +78,29 @@ class TestHyperlendAdapter:
     ):
         """Test stable markets retrieval with only required chain_id"""
         mock_response = {
-            "markets": [
-                {
-                    "chain_id": 999,
-                    "underlying_token": "0x1234...",
+            "markets": {
+                "0x1234...": {
                     "symbol": "USDT",
-                    "apy": 0.05,
+                    "symbol_canonical": "usdt",
+                    "display_symbol": "USDT",
+                    "reserve": {},
+                    "decimals": 6,
+                    "headroom": 1000000000000,
+                    "supply_cap": 5000000000000,
                 }
-            ]
+            },
+            "notes": [],
         }
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
-        success, data = await adapter.get_stable_markets(chain_id=999)
+        success, data = await adapter.get_stable_markets()
 
         assert success is True
         assert data == mock_response
         mock_hyperlend_client.get_stable_markets.assert_called_once_with(
-            chain_id=999,
             required_underlying_tokens=None,
             buffer_bps=None,
             min_buffer_tokens=None,
-            is_stable_symbol=None,
         )
 
     @pytest.mark.asyncio
@@ -108,21 +108,19 @@ class TestHyperlendAdapter:
         self, adapter, mock_hyperlend_client
     ):
         """Test stable markets retrieval with partial optional parameters"""
-        mock_response = {"markets": []}
+        mock_response = {"markets": {}, "notes": []}
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_stable_markets(
-            chain_id=999, required_underlying_tokens=500.0
+            required_underlying_tokens=500.0
         )
 
         assert success is True
         assert data == mock_response
         mock_hyperlend_client.get_stable_markets.assert_called_once_with(
-            chain_id=999,
             required_underlying_tokens=500.0,
             buffer_bps=None,
             min_buffer_tokens=None,
-            is_stable_symbol=None,
         )
 
     @pytest.mark.asyncio
@@ -132,7 +130,7 @@ class TestHyperlendAdapter:
             side_effect=Exception("API Error: Connection timeout")
         )
 
-        success, data = await adapter.get_stable_markets(chain_id=999)
+        success, data = await adapter.get_stable_markets()
 
         assert success is False
         assert "API Error: Connection timeout" in data
@@ -144,7 +142,7 @@ class TestHyperlendAdapter:
             side_effect=Exception("HTTP 404 Not Found")
         )
 
-        success, data = await adapter.get_stable_markets(chain_id=999)
+        success, data = await adapter.get_stable_markets()
 
         assert success is False
         assert "404" in data or "Not Found" in data
@@ -154,14 +152,14 @@ class TestHyperlendAdapter:
         self, adapter, mock_hyperlend_client
     ):
         """Test stable markets retrieval with empty response"""
-        mock_response = {"markets": []}
+        mock_response = {"markets": {}, "notes": []}
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
-        success, data = await adapter.get_stable_markets(chain_id=999)
+        success, data = await adapter.get_stable_markets()
 
         assert success is True
         assert data == mock_response
-        assert len(data.get("markets", [])) == 0
+        assert len(data.get("markets", {})) == 0
 
     def test_adapter_type(self, adapter):
         """Test adapter has adapter_type"""
@@ -186,59 +184,95 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_with_is_stable_symbol(
         self, adapter, mock_hyperlend_client
     ):
-        """Test stable markets retrieval with is_stable_symbol parameter"""
+        """Test stable markets retrieval with is_stable_symbol parameter (ignored by API)"""
         mock_response = {
-            "markets": [
-                {
-                    "chain_id": 999,
-                    "underlying_token": "0x1234...",
+            "markets": {
+                "0x1234...": {
                     "symbol": "USDT",
-                    "apy": 0.05,
+                    "symbol_canonical": "usdt",
+                    "display_symbol": "USDT",
+                    "reserve": {},
+                    "decimals": 6,
+                    "headroom": 1000000000000,
+                    "supply_cap": 5000000000000,
                 }
-            ]
+            },
+            "notes": [],
         }
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
-        success, data = await adapter.get_stable_markets(
-            chain_id=999, is_stable_symbol=True
-        )
+        success, data = await adapter.get_stable_markets()
 
         assert success is True
         assert data == mock_response
         mock_hyperlend_client.get_stable_markets.assert_called_once_with(
-            chain_id=999,
             required_underlying_tokens=None,
             buffer_bps=None,
             min_buffer_tokens=None,
-            is_stable_symbol=True,
         )
 
     @pytest.mark.asyncio
     async def test_get_assets_view_success(self, adapter, mock_hyperlend_client):
         """Test successful assets view retrieval"""
         mock_response = {
+            "block_number": 12345,
+            "user": "0x0c737cB5934afCb5B01965141F865F795B324080",
+            "native_balance_wei": 0,
+            "native_balance": 0.0,
             "assets": [
                 {
-                    "token_address": "0x1234...",
+                    "underlying": "0x1234...",
                     "symbol": "USDT",
-                    "balance": "1000.0",
-                    "supplied": "500.0",
-                    "borrowed": "0.0",
+                    "symbol_canonical": "usdt",
+                    "symbol_display": "USDT",
+                    "decimals": 6,
+                    "a_token": "0x...",
+                    "variable_debt_token": "0x...",
+                    "usage_as_collateral_enabled": True,
+                    "borrowing_enabled": True,
+                    "is_active": True,
+                    "is_frozen": False,
+                    "is_paused": False,
+                    "is_siloed_borrowing": False,
+                    "is_stablecoin": True,
+                    "underlying_wallet_balance": 1000.0,
+                    "underlying_wallet_balance_wei": 1000000000,
+                    "price_usd": 1.0,
+                    "supply": 500.0,
+                    "variable_borrow": 0.0,
+                    "supply_usd": 500.0,
+                    "variable_borrow_usd": 0.0,
+                    "supply_apr": 0.05,
+                    "supply_apy": 0.05,
+                    "variable_borrow_apr": 0.07,
+                    "variable_borrow_apy": 0.07,
                 }
             ],
-            "total_value": 1000.0,
+            "account_data": {
+                "total_collateral_base": 500,
+                "total_debt_base": 0,
+                "available_borrows_base": 400,
+                "current_liquidation_threshold": 8000,
+                "ltv": 7500,
+                "health_factor_wad": 115792089237316195423570985008687907853269984665640564039457584007913129639935,
+                "health_factor": 1.157920892373162e59,
+            },
+            "base_currency_info": {
+                "marketReferenceCurrencyUnit": 100000000,
+                "marketReferenceCurrencyPriceInUsd": 100000000,
+                "networkBaseTokenPriceInUsd": 0,
+                "networkBaseTokenPriceDecimals": 8,
+            },
         }
         mock_hyperlend_client.get_assets_view = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_assets_view(
-            chain_id=999,
             user_address="0x0c737cB5934afCb5B01965141F865F795B324080",
         )
 
         assert success is True
         assert data == mock_response
         mock_hyperlend_client.get_assets_view.assert_called_once_with(
-            chain_id=999,
             user_address="0x0c737cB5934afCb5B01965141F865F795B324080",
         )
 
@@ -250,7 +284,6 @@ class TestHyperlendAdapter:
         )
 
         success, data = await adapter.get_assets_view(
-            chain_id=999,
             user_address="0x0c737cB5934afCb5B01965141F865F795B324080",
         )
 
@@ -260,15 +293,36 @@ class TestHyperlendAdapter:
     @pytest.mark.asyncio
     async def test_get_assets_view_empty_response(self, adapter, mock_hyperlend_client):
         """Test assets view retrieval with empty response"""
-        mock_response = {"assets": [], "total_value": 0.0}
+        mock_response = {
+            "block_number": 12345,
+            "user": "0x0c737cB5934afCb5B01965141F865F795B324080",
+            "native_balance_wei": 0,
+            "native_balance": 0.0,
+            "assets": [],
+            "account_data": {
+                "total_collateral_base": 0,
+                "total_debt_base": 0,
+                "available_borrows_base": 0,
+                "current_liquidation_threshold": 0,
+                "ltv": 0,
+                "health_factor_wad": 0,
+                "health_factor": 0.0,
+            },
+            "base_currency_info": {
+                "marketReferenceCurrencyUnit": 100000000,
+                "marketReferenceCurrencyPriceInUsd": 100000000,
+                "networkBaseTokenPriceInUsd": 0,
+                "networkBaseTokenPriceDecimals": 8,
+            },
+        }
         mock_hyperlend_client.get_assets_view = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_assets_view(
-            chain_id=999,
             user_address="0x0c737cB5934afCb5B01965141F865F795B324080",
         )
 
         assert success is True
         assert data == mock_response
         assert len(data.get("assets", [])) == 0
-        assert data.get("total_value") == 0.0
+        # New API uses account_data; total_value may not be present
+        assert data.get("account_data", {}).get("total_collateral_base") == 0

wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -31,7 +31,7 @@ except ImportError:
 
 
 class SimpleCache:
-    """Simple in-memory cache with TTL to replace Django cache."""
+    """Simple in-memory cache with TTL for local caching."""
 
     def __init__(self):
         self._cache: dict[str, Any] = {}

wayfinder_paths/adapters/hyperliquid_adapter/executor.py

@@ -10,6 +10,7 @@ the protocol (for example, by delegating signing to a hosted signer).
 from __future__ import annotations
 
 import uuid
+from collections.abc import Mapping
 from typing import Any
 
 from loguru import logger
@@ -86,11 +87,49 @@ class LocalHyperliquidExecutor:
         )
         self.info = Info(base_url, skip_ws=True)
         self.exchange = Exchange(self._wallet, base_url)
+        self._asset_id_to_coin: dict[int, str] | None = None
 
         logger.info(
             f"LocalHyperliquidExecutor initialized for address: {self._wallet.address}"
         )
 
+    def _get_perp_coin(self, asset_id: int) -> str | None:
+        """
+        Resolve a perp coin name from a perp asset_id.
+
+        Note: newer versions of the hyperliquid SDK expose `coin_to_asset` but not
+        `asset_to_coin`, so we build the reverse mapping when needed.
+        """
+        if self._asset_id_to_coin is None:
+            mapping: dict[int, str] = {}
+
+            asset_to_coin = getattr(self.info, "asset_to_coin", None)
+            if isinstance(asset_to_coin, Mapping):
+                for k, v in asset_to_coin.items():
+                    try:
+                        asset_int = int(k)
+                    except (TypeError, ValueError):
+                        continue
+                    if v:
+                        mapping[asset_int] = str(v)
+
+            coin_to_asset = getattr(self.info, "coin_to_asset", None)
+            try:
+                coin_to_asset_dict = dict(coin_to_asset) if coin_to_asset else {}
+            except Exception:  # noqa: BLE001
+                coin_to_asset_dict = {}
+            for coin, aid in coin_to_asset_dict.items():
+                try:
+                    asset_int = int(aid)
+                except (TypeError, ValueError):
+                    continue
+                if coin and asset_int not in mapping:
+                    mapping[asset_int] = str(coin)
+
+            self._asset_id_to_coin = mapping
+
+        return self._asset_id_to_coin.get(asset_id) if self._asset_id_to_coin else None
+
     def _resolve_private_key(self, config: dict[str, Any]) -> str | None:
         """Extract private key from config."""
         # Try strategy_wallet first
@@ -172,7 +211,7 @@ class LocalHyperliquidExecutor:
                 )
             else:
                 # Perp market order
-                coin = self.info.asset_to_coin.get(asset_id)
+                coin = self._get_perp_coin(asset_id)
                 if not coin:
                     return {
                         "status": "err",
@@ -231,7 +270,7 @@ class LocalHyperliquidExecutor:
                 spot_index = asset_id - 10000
                 coin = f"@{spot_index}"
             else:
-                coin = self.info.asset_to_coin.get(asset_id)
+                coin = self._get_perp_coin(asset_id)
                 if not coin:
                     return {
                         "status": "err",
@@ -268,7 +307,7 @@ class LocalHyperliquidExecutor:
             }
 
         try:
-            coin = self.info.asset_to_coin.get(asset_id)
+            coin = self._get_perp_coin(asset_id)
             if not coin:
                 return {
                     "status": "err",
@@ -366,7 +405,7 @@ class LocalHyperliquidExecutor:
             }
 
         try:
-            coin = self.info.asset_to_coin.get(asset_id)
+            coin = self._get_perp_coin(asset_id)
             if not coin:
                 return {
                     "status": "err",
@@ -439,7 +478,7 @@ class LocalHyperliquidExecutor:
                 spot_index = asset_id - 10000
                 coin = f"@{spot_index}"
             else:
-                coin = self.info.asset_to_coin.get(asset_id)
+                coin = self._get_perp_coin(asset_id)
                 if not coin:
                     return {
                         "status": "err",

wayfinder_paths/adapters/hyperliquid_adapter/test_executor.py

@@ -0,0 +1,104 @@
+"""Tests for LocalHyperliquidExecutor."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+class TestLocalHyperliquidExecutor:
+    """Tests for LocalHyperliquidExecutor."""
+
+    @pytest.fixture
+    def mock_info_without_asset_to_coin(self):
+        """Mock Info that only exposes coin_to_asset (no asset_to_coin)."""
+        return SimpleNamespace(coin_to_asset={"HYPE": 7})
+
+    @pytest.fixture
+    def mock_exchange(self):
+        """Mock Exchange client."""
+        mock = MagicMock()
+        mock.update_leverage.return_value = {"status": "ok"}
+        mock.market_open.return_value = {"status": "ok"}
+        return mock
+
+    @pytest.mark.asyncio
+    async def test_update_leverage_works_without_asset_to_coin(
+        self, mock_info_without_asset_to_coin, mock_exchange
+    ):
+        """update_leverage should map asset_id->coin via coin_to_asset inversion."""
+        dummy_wallet = SimpleNamespace(address="0xabc")
+
+        with patch(
+            "wayfinder_paths.adapters.hyperliquid_adapter.executor.Account"
+        ) as mock_account:
+            mock_account.from_key.return_value = dummy_wallet
+            with patch(
+                "wayfinder_paths.adapters.hyperliquid_adapter.executor.Info",
+                return_value=mock_info_without_asset_to_coin,
+            ):
+                with patch(
+                    "wayfinder_paths.adapters.hyperliquid_adapter.executor.Exchange",
+                    return_value=mock_exchange,
+                ):
+                    from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
+                        LocalHyperliquidExecutor,
+                    )
+
+                    executor = LocalHyperliquidExecutor(
+                        config={"strategy_wallet": {"private_key": "0x" + "11" * 32}}
+                    )
+                    resp = await executor.update_leverage(
+                        asset_id=7,
+                        leverage=1,
+                        is_cross=True,
+                        address="0xabc",
+                    )
+
+                    assert resp.get("status") == "ok"
+                    mock_exchange.update_leverage.assert_called_once_with(
+                        leverage=1,
+                        name="HYPE",
+                        is_cross=True,
+                    )
+
+    @pytest.mark.asyncio
+    async def test_place_market_order_perp_works_without_asset_to_coin(
+        self, mock_info_without_asset_to_coin, mock_exchange
+    ):
+        """place_market_order should map asset_id->coin via coin_to_asset inversion."""
+        dummy_wallet = SimpleNamespace(address="0xabc")
+
+        with patch(
+            "wayfinder_paths.adapters.hyperliquid_adapter.executor.Account"
+        ) as mock_account:
+            mock_account.from_key.return_value = dummy_wallet
+            with patch(
+                "wayfinder_paths.adapters.hyperliquid_adapter.executor.Info",
+                return_value=mock_info_without_asset_to_coin,
+            ):
+                with patch(
+                    "wayfinder_paths.adapters.hyperliquid_adapter.executor.Exchange",
+                    return_value=mock_exchange,
+                ):
+                    from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
+                        LocalHyperliquidExecutor,
+                    )
+
+                    executor = LocalHyperliquidExecutor(
+                        config={"strategy_wallet": {"private_key": "0x" + "11" * 32}}
+                    )
+                    resp = await executor.place_market_order(
+                        asset_id=7,
+                        is_buy=True,
+                        slippage=0.01,
+                        size=1.0,
+                        address="0xabc",
+                        reduce_only=False,
+                        cloid=MagicMock(),  # Avoid Cloid conversion
+                    )
+
+                    assert resp.get("status") == "ok"
+                    mock_exchange.market_open.assert_called_once()
+                    _, kwargs = mock_exchange.market_open.call_args
+                    assert kwargs["name"] == "HYPE"

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -23,7 +23,6 @@ from wayfinder_paths.core.constants.moonwell_abi import (
     WETH_ABI,
 )
 from wayfinder_paths.core.services.base import Web3Service
-from wayfinder_paths.core.settings import settings
 
 # Moonwell Base chain addresses
 MOONWELL_DEFAULTS = {
@@ -1149,8 +1148,6 @@ class MoonwellAdapter(BaseAdapter):
 
         Includes retry logic with exponential backoff for rate-limited RPCs.
         """
-        if getattr(settings, "DRY_RUN", False):
-            return True, {"dry_run": True, "transaction": tx}
         if not self.web3:
             return False, "web3 service not configured"
 

wayfinder_paths/adapters/pool_adapter/README.md

@@ -35,8 +35,7 @@ adapter = PoolAdapter()
 
 ```python
 success, data = await adapter.get_pools_by_ids(
-    pool_ids=["pool-123", "pool-456"],
-    merge_external=True
+    pool_ids=["pool-123", "pool-456"]
 )
 if success:
     pools = data.get("pools", [])
@@ -45,44 +44,29 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Llama Matches
+### Get pools (all or filtered)
+
+Pass at least `chain_id` when fetching all pools (e.g. `chain_id=8453` for Base):
 
 ```python
-success, data = await adapter.get_llama_matches()
+success, data = await adapter.get_pools(chain_id=8453)
 if success:
     matches = data.get("matches", [])
-    print(f"Found {len(matches)} Llama matches")
     for match in matches:
-        if match.get("llama_stablecoin"):
-            print(f"Stablecoin pool: {match.get('id')} - APY: {match.get('llama_apy_pct')}%")
-else:
-    print(f"Error: {data}")
-```
-
-### Get Llama Reports
-
-```python
-success, data = await adapter.get_llama_reports(
-    identifiers=["pool-123", "usd-coin-base", "base_0x1234..."]
-)
-if success:
-    reports = data
-    for identifier, report in reports.items():
-        print(f"Report for {identifier}: APY {report.get('llama_apy_pct', 0)}%")
+        if match.get("stablecoin"):
+            print(f"Pool {match.get('id')} - APY: {match.get('apy')}%")
 else:
     print(f"Error: {data}")
 ```
 
-## Advanced Usage
+Optional: `project="lido"` to filter by project.
 
 ## API Endpoints
 
-The adapter uses the following Wayfinder API endpoints:
+The adapter uses the Wayfinder API:
 
-- `GET /api/v1/public/pools/?pool_ids=X` - Get pools by IDs
-- `GET /api/v1/public/pools/` - Get all pools
-- `GET /api/v1/public/pools/llama/matches/` - Get Llama matches
-- `GET /api/v1/public/pools/llama/reports/` - Get Llama reports
+- `GET /v1/blockchain/pools/?chain_id=1&project=lido` - List pools (filter by chain_id, optional project)
+- `POST /v1/blockchain/pools/` - Get pools by IDs (body: `{"pool_ids": ["id1", "id2"]}`)
 
 ## Error Handling