wayfinder-paths 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

wayfinder_paths/adapters/brap_adapter/test_adapter.py

@@ -41,14 +41,34 @@ class TestBRAPAdapter:
     async def test_get_swap_quote_success(self, adapter, mock_brap_client):
         """Test successful swap quote retrieval"""
         mock_response = {
-            "quotes": {
-                "best_quote": {
-                    "input_amount": "1000000000000000000",
-                    "output_amount": "995000000000000000",
-                    "gas_fee": "5000000000000000",
-                    "total_fee": "8000000000000000",
+            "quotes": [
+                {
+                    "provider": "enso",
+                    "input_amount": 1000000000000000000,
+                    "output_amount": 995000000000000000,
+                    "calldata": {
+                        "data": "0x",
+                        "to": "0x",
+                        "from_address": "0x",
+                        "value": "0",
+                        "chainId": 8453,
+                    },
+                    "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
                 }
-            }
+            ],
+            "best_quote": {
+                "provider": "enso",
+                "input_amount": 1000000000000000000,
+                "output_amount": 995000000000000000,
+                "calldata": {
+                    "data": "0x",
+                    "to": "0x",
+                    "from_address": "0x",
+                    "value": "0",
+                    "chainId": 8453,
+                },
+                "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
+            },
         }
         mock_brap_client.get_quote = AsyncMock(return_value=mock_response)
 
@@ -63,29 +83,35 @@ class TestBRAPAdapter:
             slippage=0.01,
         )
 
-        assert success is True
+        assert success
         assert data == mock_response
         mock_brap_client.get_quote.assert_called_once_with(
-            from_token_address="0x" + "a" * 40,
-            to_token_address="0x" + "b" * 40,
-            from_chain_id=8453,
-            to_chain_id=1,
-            from_address="0x1234567890123456789012345678901234567890",
-            to_address="0x1234567890123456789012345678901234567890",
-            amount1="1000000000000000000",
-            slippage=0.01,
-            wayfinder_fee=None,
+            from_token="0x" + "a" * 40,
+            to_token="0x" + "b" * 40,
+            from_chain=8453,
+            to_chain=1,
+            from_wallet="0x1234567890123456789012345678901234567890",
+            from_amount="1000000000000000000",
         )
 
     @pytest.mark.asyncio
     async def test_get_best_quote_success(self, adapter, mock_brap_client):
         """Test successful best quote retrieval"""
         mock_response = {
-            "best_route": {
-                "input_amount": "1000000000000000000",
-                "output_amount": "995000000000000000",
-                "total_fee": "8000000000000000",
-            }
+            "quotes": [],
+            "best_quote": {
+                "provider": "enso",
+                "input_amount": 1000000000000000000,
+                "output_amount": 995000000000000000,
+                "calldata": {
+                    "data": "0x",
+                    "to": "0x",
+                    "from_address": "0x",
+                    "value": "0",
+                    "chainId": 8453,
+                },
+                "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
+            },
         }
         mock_brap_client.get_quote = AsyncMock(return_value=mock_response)
 
@@ -99,14 +125,14 @@ class TestBRAPAdapter:
             amount="1000000000000000000",
         )
 
-        assert success is True
-        assert data["input_amount"] == "1000000000000000000"
-        assert data["output_amount"] == "995000000000000000"
+        assert success
+        assert data["input_amount"] == 1000000000000000000
+        assert data["output_amount"] == 995000000000000000
 
     @pytest.mark.asyncio
     async def test_get_best_quote_no_quotes(self, adapter, mock_brap_client):
         """Test best quote retrieval when no quotes available"""
-        mock_response = {"best_route": None}
+        mock_response = {"quotes": [], "best_quote": None}
         mock_brap_client.get_quote = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_best_quote(
@@ -126,18 +152,25 @@ class TestBRAPAdapter:
     async def test_calculate_swap_fees_success(self, adapter, mock_brap_client):
         """Test successful swap fee calculation"""
         mock_quote_response = {
-            "quotes": {
-                "best_quote": {
-                    "input_amount": "1000000000000000000",
-                    "output_amount": "995000000000000000",
-                    "gas_fee": "5000000000000000",
-                    "bridge_fee": "2000000000000000",
-                    "protocol_fee": "1000000000000000",
-                    "total_fee": "8000000000000000",
-                    "slippage": 0.01,
-                    "price_impact": 0.005,
-                }
-            }
+            "quotes": [],
+            "best_quote": {
+                "provider": "enso",
+                "input_amount": 1000000000000000000,
+                "output_amount": 995000000000000000,
+                "gas_estimate": 5000000000000000,
+                "quote": {"priceImpact": 5},
+                "fee_estimate": {
+                    "fee_total_usd": 0.008,
+                    "fee_breakdown": [],
+                },
+                "calldata": {
+                    "data": "0x",
+                    "to": "0x",
+                    "from_address": "0x",
+                    "value": "0",
+                    "chainId": 8453,
+                },
+            },
         }
         mock_brap_client.get_quote = AsyncMock(return_value=mock_quote_response)
 
@@ -150,36 +183,54 @@ class TestBRAPAdapter:
             slippage=0.01,
         )
 
-        assert success is True
-        assert data["input_amount"] == "1000000000000000000"
-        assert data["output_amount"] == "995000000000000000"
-        assert data["gas_fee"] == "5000000000000000"
-        assert data["total_fee"] == "8000000000000000"
+        assert success
+        assert data["input_amount"] == 1000000000000000000
+        assert data["output_amount"] == 995000000000000000
+        assert data["gas_fee"] == 5000000000000000
+        assert data["total_fee"] == 0.008
 
     @pytest.mark.asyncio
     async def test_compare_routes_success(self, adapter, mock_brap_client):
         """Test successful route comparison"""
         mock_response = {
-            "quotes": {
-                "quotes": [
-                    {
-                        "route": "Route 1",
-                        "output_amount": "995000000000000000",
-                        "total_fee": "8000000000000000",
-                        "estimated_time": 300,
+            "quotes": [
+                {
+                    "provider": "enso",
+                    "output_amount": 995000000000000000,
+                    "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
+                    "calldata": {
+                        "data": "0x",
+                        "to": "0x",
+                        "from_address": "0x",
+                        "value": "0",
+                        "chainId": 8453,
                     },
-                    {
-                        "route": "Route 2",
-                        "output_amount": "992000000000000000",
-                        "total_fee": "12000000000000000",
-                        "estimated_time": 180,
+                },
+                {
+                    "provider": "enso",
+                    "output_amount": 992000000000000000,
+                    "fee_estimate": {"fee_total_usd": 0.012, "fee_breakdown": []},
+                    "calldata": {
+                        "data": "0x",
+                        "to": "0x",
+                        "from_address": "0x",
+                        "value": "0",
+                        "chainId": 8453,
                     },
-                ],
-                "best_quote": {
-                    "output_amount": "995000000000000000",
-                    "total_fee": "8000000000000000",
                 },
-            }
+            ],
+            "best_quote": {
+                "provider": "enso",
+                "output_amount": 995000000000000000,
+                "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
+                "calldata": {
+                    "data": "0x",
+                    "to": "0x",
+                    "from_address": "0x",
+                    "value": "0",
+                    "chainId": 8453,
+                },
+            },
         }
         mock_brap_client.get_quote = AsyncMock(return_value=mock_response)
 
@@ -191,10 +242,10 @@ class TestBRAPAdapter:
             amount="1000000000000000000",
         )
 
-        assert success is True
+        assert success
         assert data["total_routes"] == 2
         assert len(data["all_routes"]) == 2
-        assert data["best_route"]["output_amount"] == "995000000000000000"
+        assert data["best_route"]["output_amount"] == 995000000000000000
 
     @pytest.mark.asyncio
     async def test_estimate_gas_cost_success(self, adapter):
@@ -203,7 +254,7 @@ class TestBRAPAdapter:
             from_chain_id=8453, to_chain_id=1, operation_type="swap"
         )
 
-        assert success is True
+        assert success
         assert data["from_chain"] == "base"
         assert data["to_chain"] == "ethereum"
         assert data["from_gas_estimate"] == 100000
@@ -214,7 +265,18 @@ class TestBRAPAdapter:
     async def test_validate_swap_parameters_success(self, adapter, mock_brap_client):
         """Test successful swap parameter validation"""
         mock_quote_response = {
-            "quotes": {"best_quote": {"output_amount": "995000000000000000"}}
+            "quotes": [],
+            "best_quote": {
+                "output_amount": 995000000000000000,
+                "calldata": {
+                    "data": "0x",
+                    "to": "0x",
+                    "from_address": "0x",
+                    "value": "0",
+                    "chainId": 8453,
+                },
+                "fee_estimate": {"fee_total_usd": 0.008, "fee_breakdown": []},
+            },
         }
         mock_brap_client.get_quote = AsyncMock(return_value=mock_quote_response)
 
@@ -226,7 +288,7 @@ class TestBRAPAdapter:
             amount="1000000000000000000",
         )
 
-        assert success is True
+        assert success
         assert data["valid"] is True
         assert data["quote_available"] is True
         assert data["estimated_output"] == "995000000000000000"

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -10,7 +10,7 @@ from wayfinder_paths.core.clients.HyperlendClient import (
     HyperlendClient,
     LendRateHistory,
     MarketEntry,
-    StableMarket,
+    StableMarketsHeadroomResponse,
 )
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.hyperlend_abi import (
@@ -66,55 +66,71 @@ class HyperlendAdapter(BaseAdapter):
 
     async def get_stable_markets(
         self,
-        chain_id: int,
+        *,
         required_underlying_tokens: float | None = None,
         buffer_bps: int | None = None,
         min_buffer_tokens: float | None = None,
-        is_stable_symbol: bool | None = None,
-    ) -> tuple[bool, list[StableMarket] | str]:
+    ) -> tuple[bool, StableMarketsHeadroomResponse | str]:
         try:
             data = await self.hyperlend_client.get_stable_markets(
-                chain_id=chain_id,
                 required_underlying_tokens=required_underlying_tokens,
                 buffer_bps=buffer_bps,
                 min_buffer_tokens=min_buffer_tokens,
-                is_stable_symbol=is_stable_symbol,
             )
+            # Strategies expect a dict with "markets" and "notes"; normalize if API returns a list
+            if isinstance(data, list):
+                markets: dict[str, Any] = {}
+                for i, item in enumerate(data):
+                    if isinstance(item, dict) and "address" in item:
+                        markets[item["address"]] = item
+                    elif isinstance(item, dict):
+                        markets[str(i)] = item
+                data = {"markets": markets, "notes": []}
+            elif isinstance(data, dict) and ("markets" not in data or "notes" not in data):
+                data = {
+                    "markets": data.get("markets", {}),
+                    "notes": data.get("notes", []),
+                }
             return True, data
         except Exception as exc:
             return False, str(exc)
 
     async def get_assets_view(
-        self, chain_id: int, user_address: str
+        self,
+        *,
+        user_address: str,
     ) -> tuple[bool, AssetsView | str]:
         try:
             data = await self.hyperlend_client.get_assets_view(
-                chain_id=chain_id, user_address=user_address
+                user_address=user_address
             )
             return True, data
         except Exception as exc:
             return False, str(exc)
 
     async def get_market_entry(
-        self, chain_id: int, underlying: str
+        self,
+        *,
+        token: str,
     ) -> tuple[bool, MarketEntry | str]:
         try:
-            data = await self.hyperlend_client.get_market_entry(chain_id, underlying)
+            data = await self.hyperlend_client.get_market_entry(token=token)
             return True, data
         except Exception as exc:
             return False, str(exc)
 
     async def get_lend_rate_history(
         self,
-        chain_id: int,
-        token_address: str,
+        *,
+        token: str,
         lookback_hours: int,
+        force_refresh: bool | None = None,
     ) -> tuple[bool, LendRateHistory | str]:
         try:
             data = await self.hyperlend_client.get_lend_rate_history(
-                chain_id=chain_id,
-                token_address=token_address,
+                token=token,
                 lookback_hours=lookback_hours,
+                force_refresh=force_refresh,
             )
             return True, data
         except Exception as exc: