wayfinder-paths 0.1.13__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/pool_adapter/README.md

@@ -44,30 +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_pools()
+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("stablecoin"):
-            print(f"Stablecoin pool: {match.get('id')} - APY: {match.get('apy')}%")
+            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
 

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.PoolClient import (
-    LlamaMatch,
+    LlamaMatchesResponse,
     PoolClient,
     PoolList,
 )
@@ -48,16 +48,15 @@ class PoolAdapter(BaseAdapter):
             self.logger.error(f"Error fetching pools by IDs: {e}")
             return (False, str(e))
 
-    async def get_pools(self) -> tuple[bool, dict[str, LlamaMatch] | str]:
-        """
-        Get Llama protocol matches for pools.
-
-        Returns:
-            Tuple of (success, data) where data is Llama matches or error message
-        """
+    async def get_pools(
+        self,
+        *,
+        chain_id: int | None = None,
+        project: str | None = None,
+    ) -> tuple[bool, LlamaMatchesResponse | str]:
         try:
-            data = await self.pool_client.get_pools()
+            data = await self.pool_client.get_pools(chain_id=chain_id, project=project)
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching Llama matches: {e}")
+            self.logger.error(f"Error fetching pools: {e}")
             return (False, str(e))

wayfinder_paths/adapters/token_adapter/README.md

@@ -63,23 +63,11 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Token (Flexible)
-
-```python
-# Try by address first, then by token_id
-success, data = await adapter.get_token(address="0x1234...", token_id="token-123")
-if success:
-    print(f"Token data: {data}")
-else:
-    print(f"Error: {data}")
-```
-
 ## API Endpoints
 
-The adapter uses the following existing public API endpoints:
+The adapter uses the following Wayfinder API endpoint:
 
-1. **Token Details** (by address): `GET /public/tokens/detail/?query={address}&get_chart=false`
-2. **Token by ID**: `GET /public/tokens/lookup/?token_id={token_id}`
+- `GET /api/v1/blockchain/tokens/detail/?query=...&market_data=...&chain_id=...`
 
 ## Error Handling
 

wayfinder_paths/adapters/token_adapter/adapter.py

@@ -24,7 +24,9 @@ class TokenAdapter(BaseAdapter):
         super().__init__("token_adapter", config)
         self.token_client = token_client or TokenClient()
 
-    async def get_token(self, query: str) -> tuple[bool, TokenDetails | str]:
+    async def get_token(
+        self, query: str, *, chain_id: int | None = None
+    ) -> tuple[bool, TokenDetails | str]:
         """
         Get token data by address using the token-details endpoint.
 
@@ -35,7 +37,7 @@ class TokenAdapter(BaseAdapter):
             Tuple of (success, data) where data is the token information or error message
         """
         try:
-            data = await self.token_client.get_token_details(query)
+            data = await self.token_client.get_token_details(query, chain_id=chain_id)
             if not data:
                 return (False, f"No token found for: {query}")
             return (True, data)
@@ -43,7 +45,9 @@ class TokenAdapter(BaseAdapter):
             self.logger.error(f"Error getting token by query {query}: {e}")
             return (False, str(e))
 
-    async def get_token_price(self, token_id: str) -> tuple[bool, dict[str, Any] | str]:
+    async def get_token_price(
+        self, token_id: str, *, chain_id: int | None = None
+    ) -> tuple[bool, dict[str, Any] | str]:
         """
         Get token price by token ID or address using the token-details endpoint.
 
@@ -54,19 +58,21 @@ class TokenAdapter(BaseAdapter):
             Tuple of (success, data) where data is the price information or error message
         """
         try:
-            data = await self.token_client.get_token_details(token_id)
+            data = await self.token_client.get_token_details(
+                token_id, market_data=True, chain_id=chain_id
+            )
             if not data:
                 return (False, f"No token found for: {token_id}")
 
-            # Extract just the price information
+            price_change_24h = data.get("price_change_24h", 0.0)
             price_data = {
                 "current_price": data.get("current_price", 0.0),
-                "price_change_24h": data.get("price_change_24h", 0.0),
-                "price_change_percentage_24h": data.get(
-                    "price_change_percentage_24h", 0.0
-                ),
+                "price_change_24h": price_change_24h,
+                "price_change_percentage_24h": data.get("price_change_percentage_24h")
+                if data.get("price_change_percentage_24h") is not None
+                else (float(price_change_24h) * 100.0 if price_change_24h else 0.0),
                 "market_cap": data.get("market_cap", 0),
-                "total_volume": data.get("total_volume", 0),
+                "total_volume": data.get("total_volume_usd_24h", 0),
                 "symbol": data.get("symbol", ""),
                 "name": data.get("name", ""),
                 "address": data.get("address", ""),

wayfinder_paths/adapters/token_adapter/examples.json

@@ -1,19 +1,15 @@
 {
   "basic_usage": {
     "description": "Basic usage of TokenAdapter to get token information",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by address\nsuccess, data = await adapter.get_token_by_address(\"0x1234567890abcdef1234567890abcdef12345678\")\nif success:\n    print(f\"Token symbol: {data.get('symbol')}\")\n    print(f\"Token name: {data.get('name')}\")\n    print(f\"Decimals: {data.get('decimals')}\")\nelse:\n    print(f\"Error: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by address (provide chain_id when querying by address)\nsuccess, data = await adapter.get_token(\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    chain_id=8453,\n)\nif success:\n    print(f\"Token symbol: {data.get('symbol')}\")\n    print(f\"Token name: {data.get('name')}\")\n    print(f\"Decimals: {data.get('decimals')}\")\nelse:\n    print(f\"Error: {data}\")"
   },
   "get_by_token_id": {
     "description": "Get token information using token ID",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by ID\nsuccess, data = await adapter.get_token_by_id(\"token-12345\")\nif success:\n    print(f\"Token data: {data}\")\nelse:\n    print(f\"Error: {data}\")"
-  },
-  "flexible_lookup": {
-    "description": "Use flexible get_token method that tries both address and token_id",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Try both address and token_id\nsuccess, data = await adapter.get_token(\n    address=\"0x1234567890abcdef1234567890abcdef12345678\",\n    token_id=\"token-12345\"\n)\nif success:\n    print(f\"Found token: {data}\")\nelse:\n    print(f\"Token not found: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by ID\nsuccess, data = await adapter.get_token(\"token-12345\")\nif success:\n    print(f\"Token data: {data}\")\nelse:\n    print(f\"Error: {data}\")"
   },
   "error_handling": {
     "description": "Proper error handling for various scenarios",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Handle missing parameters\ntry:\n    success, data = await adapter.get_token()\n    if not success:\n        print(f\"Error: {data}\")\nexcept Exception as e:\n    print(f\"Unexpected error: {e}\")\n\n# Handle API errors\nsuccess, data = await adapter.get_token_by_address(\"invalid-address\")\nif not success:\n    print(f\"API error: {data}\")\nelse:\n    print(f\"Token found: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Handle API errors\nsuccess, data = await adapter.get_token(\"invalid-address\")\nif not success:\n    print(f\"API error: {data}\")\nelse:\n    print(f\"Token found: {data}\")"
   },
   "health_check": {
     "description": "Check adapter health and connectivity",
@@ -21,6 +17,6 @@
   },
   "batch_operations": {
     "description": "Perform multiple token lookups efficiently",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\nimport asyncio\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# List of token addresses to lookup\ntoken_addresses = [\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    \"0xabcdef1234567890abcdef1234567890abcdef12\",\n    \"0x9876543210fedcba9876543210fedcba98765432\"\n]\n\n# Batch lookup\ntoken_data = {}\nfor address in token_addresses:\n    success, data = await adapter.get_token_by_address(address)\n    if success:\n        token_data[address] = data\n    else:\n        print(f\"Failed to get token for {address}: {data}\")\n\nprint(f\"Successfully retrieved {len(token_data)} tokens\")\nfor address, data in token_data.items():\n    print(f\"{address}: {data.get('symbol', 'Unknown')} - {data.get('name', 'Unknown')}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# List of token addresses to lookup (Base chain)\ntoken_addresses = [\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    \"0xabcdef1234567890abcdef1234567890abcdef12\",\n    \"0x9876543210fedcba9876543210fedcba98765432\"\n]\n\n# Batch lookup\ntoken_data = {}\nfor address in token_addresses:\n    success, data = await adapter.get_token(address, chain_id=8453)\n    if success:\n        token_data[address] = data\n    else:\n        print(f\"Failed to get token for {address}: {data}\")\n\nprint(f\"Successfully retrieved {len(token_data)} tokens\")\nfor address, data in token_data.items():\n    print(f\"{address}: {data.get('symbol', 'Unknown')} - {data.get('name', 'Unknown')}\")"
   }
 }

wayfinder_paths/adapters/token_adapter/test_adapter.py

@@ -68,9 +68,8 @@ class TestTokenAdapter:
         mock_token_data = {
             "current_price": 1.50,
             "price_change_24h": 0.05,
-            "price_change_percentage_24h": 3.45,
             "market_cap": 1000000,
-            "total_volume": 50000,
+            "total_volume_usd_24h": 50000,
             "symbol": "TEST",
             "name": "Test Token",
             "address": "0x1234...",
@@ -85,6 +84,8 @@ class TestTokenAdapter:
             assert data["current_price"] == 1.50
             assert data["symbol"] == "TEST"
             assert data["name"] == "Test Token"
+            assert data["total_volume"] == 50000
+            assert data["price_change_percentage_24h"] == 5.0  # 0.05 * 100
 
     @pytest.mark.asyncio
     async def test_get_token_price_not_found(self, adapter):
@@ -99,7 +100,8 @@ class TestTokenAdapter:
     async def test_get_gas_token_success(self, adapter):
         """Test successful gas token retrieval"""
         mock_gas_token_data = {
-            "id": "ethereum-base",
+            "id": "ethereum_0x0000000000000000000000000000000000000000",
+            "token_id": "ethereum_0x0000000000000000000000000000000000000000",
             "symbol": "ETH",
             "name": "Ethereum",
             "address": "0x0000000000000000000000000000000000000000",