wayfinder-paths 0.1.11__py3-none-any.whl → 0.1.14__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)
 
@@ -66,26 +86,32 @@ class TestBRAPAdapter:
         assert success is True
         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)
 
@@ -100,13 +126,13 @@ class TestBRAPAdapter:
         )
 
         assert success is True
-        assert data["input_amount"] == "1000000000000000000"
-        assert data["output_amount"] == "995000000000000000"
+        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)
 
@@ -151,35 +184,53 @@ class TestBRAPAdapter:
         )
 
         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 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)
 
@@ -194,7 +245,7 @@ class TestBRAPAdapter:
         assert success is True
         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):
@@ -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)
 

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 (
@@ -18,7 +18,6 @@ from wayfinder_paths.core.constants.hyperlend_abi import (
     WRAPPED_TOKEN_GATEWAY_ABI,
 )
 from wayfinder_paths.core.services.base import Web3Service
-from wayfinder_paths.core.settings import settings
 
 HYPERLEND_DEFAULTS = {
     "pool": "0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b",
@@ -67,55 +66,57 @@ 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,
             )
             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:
@@ -136,7 +137,7 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
-            tx = self._encode_call(
+            tx = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="depositETH",
@@ -156,7 +157,7 @@ class HyperlendAdapter(BaseAdapter):
             )
             if not approved[0]:
                 return approved
-            tx = self._encode_call(
+            tx = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="supply",
@@ -181,7 +182,7 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
-            tx = self._encode_call(
+            tx = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="withdrawETH",
@@ -191,7 +192,7 @@ class HyperlendAdapter(BaseAdapter):
             )
         else:
             token_addr = self._checksum(underlying_token)
-            tx = self._encode_call(
+            tx = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="withdraw",
@@ -237,13 +238,11 @@ class HyperlendAdapter(BaseAdapter):
         )
 
     async def _broadcast_transaction(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        if getattr(settings, "DRY_RUN", False):
-            return True, {"dry_run": True, "transaction": tx}
         return await self.web3.evm_transactions.broadcast_transaction(
             tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
         )
 
-    def _encode_call(
+    async def _encode_call(
         self,
         *,
         target: str,
@@ -258,7 +257,7 @@ class HyperlendAdapter(BaseAdapter):
         web3 = self.web3.get_web3(chain_id)
         contract = web3.eth.contract(address=target, abi=abi)
         try:
-            data = getattr(contract.functions, fn_name)(*args).build_transaction(
+            data = await getattr(contract.functions, fn_name)(*args).build_transaction(
                 {"from": from_address}
             )["data"]
         except ValueError as exc: