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

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -8,13 +8,15 @@ from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.adapters.models import SWAP
-from wayfinder_paths.core.clients.BRAPClient import BRAPClient, BRAPQuote
+from wayfinder_paths.core.clients.BRAPClient import (
+    BRAPClient,
+    BRAPQuoteResponse,
+)
 from wayfinder_paths.core.clients.LedgerClient import TransactionRecord
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.constants import DEFAULT_SLIPPAGE, ZERO_ADDRESS
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.services.base import Web3Service
-from wayfinder_paths.core.settings import settings
 
 _NEEDS_CLEAR_APPROVAL = {
     (1, "0xdac17f958d2ee523a2206206994597c13d831ec7"),
@@ -62,7 +64,7 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float | None = None,
         wayfinder_fee: float | None = None,
-    ) -> tuple[bool, BRAPQuote | str]:
+    ) -> tuple[bool, BRAPQuoteResponse | str]:
         """
         Get a quote for a cross-chain swap operation.
 
@@ -78,19 +80,16 @@ class BRAPAdapter(BaseAdapter):
             wayfinder_fee: Wayfinder fee (optional)
 
         Returns:
-            Tuple of (success, data) where data is quote information or error message
+            Tuple of (success, data) where data is quote response or error message
         """
         try:
             data = await self.brap_client.get_quote(
-                from_token_address=from_token_address,
-                to_token_address=to_token_address,
-                from_chain_id=from_chain_id,
-                to_chain_id=to_chain_id,
-                from_address=from_address,
-                to_address=to_address,
-                amount1=amount,
-                slippage=slippage,
-                wayfinder_fee=wayfinder_fee,
+                from_token=from_token_address,
+                to_token=to_token_address,
+                from_chain=from_chain_id,
+                to_chain=to_chain_id,
+                from_wallet=from_address,
+                from_amount=amount,
             )
             return (True, data)
         except Exception as e:
@@ -131,22 +130,28 @@ class BRAPAdapter(BaseAdapter):
         """
         try:
             data = await self.brap_client.get_quote(
-                from_token_address=from_token_address,
-                to_token_address=to_token_address,
-                from_chain_id=from_chain_id,
-                to_chain_id=to_chain_id,
-                from_address=from_address,
-                to_address=to_address,
-                amount1=amount,
-                slippage=slippage,
-                wayfinder_fee=wayfinder_fee,
+                from_token=from_token_address,
+                to_token=to_token_address,
+                from_chain=from_chain_id,
+                to_chain=to_chain_id,
+                from_wallet=from_address,
+                from_amount=amount,
             )
 
-            quotes_container = data.get("quotes", {})
-            # BRAP returns quotes in "all_quotes" not "quotes"
-            all_quotes = quotes_container.get("all_quotes", []) or quotes_container.get(
-                "quotes", []
-            )
+            raw_quotes = data.get("quotes")
+            if isinstance(raw_quotes, list):
+                all_quotes = raw_quotes
+                best_quote = data.get("best_quote") or data.get("best_route")
+            else:
+                quotes_container = raw_quotes or {}
+                all_quotes = quotes_container.get(
+                    "all_quotes", []
+                ) or quotes_container.get("quotes", [])
+                best_quote = (
+                    quotes_container.get("best_quote")
+                    or data.get("best_quote")
+                    or data.get("best_route")
+                )
 
             # If preferred providers specified, select by provider preference
             if preferred_providers and all_quotes:
@@ -157,13 +162,6 @@ class BRAPAdapter(BaseAdapter):
                     return (True, selected_quote)
                 # Fall through to best_quote if no preferred provider found
 
-            # Extract best quote from response - check nested quotes first, then top level
-            best_quote = (
-                quotes_container.get("best_quote")
-                or data.get("best_quote")
-                or data.get("best_route")
-            )
-
             if not best_quote:
                 return (False, "No quotes available")
 
@@ -254,8 +252,8 @@ class BRAPAdapter(BaseAdapter):
                 to_token_address=to_token_address,
                 from_chain_id=from_chain_id,
                 to_chain_id=to_chain_id,
-                from_address="0x0000000000000000000000000000000000000000",  # Dummy address
-                to_address="0x0000000000000000000000000000000000000000",  # Dummy address
+                from_address="0x0000000000000000000000000000000000000000",
+                to_address="0x0000000000000000000000000000000000000000",
                 amount=amount,
                 slippage=slippage,
             )
@@ -263,22 +261,22 @@ class BRAPAdapter(BaseAdapter):
             if not success:
                 return (False, quote_data)
 
-            quotes = quote_data.get("quotes", {})
-            best_quote = quotes.get("best_quote")
+            best_quote = quote_data.get("best_quote")
 
             if not best_quote:
                 return (False, "No quote available for fee calculation")
 
             # Extract fee information
+            fee_estimate = best_quote.get("fee_estimate", {})
             fees = {
                 "input_amount": best_quote.get("input_amount", 0),
                 "output_amount": best_quote.get("output_amount", 0),
-                "gas_fee": best_quote.get("gas_fee", 0),
-                "bridge_fee": best_quote.get("bridge_fee", 0),
-                "protocol_fee": best_quote.get("protocol_fee", 0),
-                "total_fee": best_quote.get("total_fee", 0),
-                "slippage": best_quote.get("slippage", 0),
-                "price_impact": best_quote.get("price_impact", 0),
+                "gas_fee": best_quote.get("gas_estimate") or 0,
+                "bridge_fee": 0,
+                "protocol_fee": fee_estimate.get("fee_total_usd", 0),
+                "total_fee": fee_estimate.get("fee_total_usd", 0),
+                "slippage": 0,
+                "price_impact": best_quote.get("quote", {}).get("priceImpact", 0),
             }
 
             return (True, fees)
@@ -311,19 +309,26 @@ class BRAPAdapter(BaseAdapter):
         """
         try:
             data = await self.brap_client.get_quote(
-                from_token_address=from_token_address,
-                to_token_address=to_token_address,
-                from_chain_id=from_chain_id,
-                to_chain_id=to_chain_id,
-                from_address="0x0000000000000000000000000000000000000000",  # Dummy address
-                to_address="0x0000000000000000000000000000000000000000",  # Dummy address
-                amount1=amount,
-                slippage=slippage,
+                from_token=from_token_address,
+                to_token=to_token_address,
+                from_chain=from_chain_id,
+                to_chain=to_chain_id,
+                from_wallet="0x0000000000000000000000000000000000000000",
+                from_amount=amount,
             )
 
-            quotes = data.get("quotes", {})
-            all_quotes = quotes.get("all_quotes", []) or quotes.get("quotes", [])
-            best_quote = quotes.get("best_quote")
+            raw_quotes = data.get("quotes")
+            if isinstance(raw_quotes, list):
+                all_quotes = raw_quotes
+                best_quote = data.get("best_quote") or data.get("best_route")
+            else:
+                quotes = raw_quotes or {}
+                all_quotes = quotes.get("all_quotes", []) or quotes.get("quotes", [])
+                best_quote = (
+                    quotes.get("best_quote")
+                    or data.get("best_quote")
+                    or data.get("best_route")
+                )
 
             if not all_quotes:
                 return (False, "No routes available")
@@ -339,16 +344,21 @@ class BRAPAdapter(BaseAdapter):
                 "all_routes": sorted_quotes,
                 "route_analysis": {
                     "highest_output": sorted_quotes[0] if sorted_quotes else None,
-                    "lowest_fees": min(
-                        all_quotes, key=lambda x: int(x.get("total_fee", 0))
-                    )
-                    if all_quotes
-                    else None,
-                    "fastest": min(
-                        all_quotes, key=lambda x: int(x.get("estimated_time", 0))
-                    )
-                    if all_quotes
-                    else None,
+                    "lowest_fees": (
+                        min(
+                            all_quotes,
+                            key=lambda x: float(
+                                x.get("fee_estimate", {}).get("fee_total_usd", 0)
+                            ),
+                        )
+                        if all_quotes
+                        else None
+                    ),
+                    "fastest": (
+                        min(all_quotes, key=lambda x: int(x.get("estimated_time", 0)))
+                        if all_quotes
+                        else None
+                    ),
                 },
             }
 
@@ -423,10 +433,13 @@ class BRAPAdapter(BaseAdapter):
         chain = from_token.get("chain") or {}
         chain_id = self._chain_id(chain)
 
-        transaction = dict(quote.get("calldata") or {})
-        if not transaction:
+        calldata = quote.get("calldata") or {}
+        transaction = dict(calldata)
+        if not transaction or not transaction.get("data"):
             return (False, "Quote missing calldata")
         transaction["chainId"] = chain_id
+        # Always set the sender to the strategy wallet for broadcast.
+        # (Calldata may include either "from" or "from_address" depending on provider.)
         transaction["from"] = to_checksum_address(from_address)
 
         spender = transaction.get("to")
@@ -517,8 +530,8 @@ class BRAPAdapter(BaseAdapter):
             to_token_address=to_token_address,
             from_chain_id=from_chain_id,
             to_chain_id=to_chain_id,
-            from_address="0x0000000000000000000000000000000000000000",  # Dummy address
-            to_address="0x0000000000000000000000000000000000000000",  # Dummy address
+            from_address="0x0000000000000000000000000000000000000000",
+            to_address="0x0000000000000000000000000000000000000000",
             amount=amount,
             slippage=slippage,
         )
@@ -635,14 +648,15 @@ class BRAPAdapter(BaseAdapter):
                 validation_errors.append(f"Swap not possible: {quote_data}")
                 return (False, {"valid": False, "errors": validation_errors})
 
+            best_quote = (
+                quote_data.get("best_quote", {}) if isinstance(quote_data, dict) else {}
+            )
             return (
                 True,
                 {
                     "valid": True,
                     "quote_available": True,
-                    "estimated_output": quote_data.get("quotes", {})
-                    .get("best_quote", {})
-                    .get("output_amount", "0"),
+                    "estimated_output": str(best_quote.get("output_amount", 0)),
                 },
             )
         except Exception as e:
@@ -698,8 +712,6 @@ class BRAPAdapter(BaseAdapter):
     async def _broadcast_transaction(
         self, transaction: dict[str, Any], confirmations: int = 0
     ) -> tuple[bool, Any]:
-        if getattr(settings, "DRY_RUN", False):
-            return True, {"dry_run": True, "transaction": transaction}
         return await self.wallet_provider.broadcast_transaction(
             transaction,
             wait_for_receipt=True,
@@ -782,7 +794,7 @@ class BRAPAdapter(BaseAdapter):
 
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
-            chain_id = chain.get("id") or chain.get("chain_id")
+            chain_id = chain.get("id")
         else:
             chain_id = getattr(chain, "id", None)
         if chain_id is None:

wayfinder_paths/adapters/brap_adapter/examples.json

@@ -14,25 +14,37 @@
     "output": {
       "success": true,
       "data": {
-        "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,
-            "estimated_time": 300
-          },
-          "quotes": [
-            {
-              "route": "Route 1",
-              "output_amount": "995000000000000000",
-              "total_fee": "8000000000000000"
+        "quotes": [
+          {
+            "provider": "enso",
+            "input_amount": 1000000000000000000,
+            "output_amount": 995000000000000000,
+            "fee_estimate": {
+              "fee_total_usd": 0.08,
+              "fee_breakdown": []
+            },
+            "calldata": {
+              "data": "0x",
+              "to": "0x",
+              "value": "0",
+              "chainId": 8453
             }
-          ]
+          }
+        ],
+        "best_quote": {
+          "provider": "enso",
+          "input_amount": 1000000000000000000,
+          "output_amount": 995000000000000000,
+          "fee_estimate": {
+            "fee_total_usd": 0.08,
+            "fee_breakdown": []
+          },
+          "calldata": {
+            "data": "0x",
+            "to": "0x",
+            "value": "0",
+            "chainId": 8453
+          }
         }
       }
     }
@@ -52,15 +64,19 @@
     "output": {
       "success": true,
       "data": {
-        "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,
-        "estimated_time": 300
+        "provider": "enso",
+        "input_amount": 1000000000000000000,
+        "output_amount": 995000000000000000,
+        "fee_estimate": {
+          "fee_total_usd": 0.08,
+          "fee_breakdown": []
+        },
+        "calldata": {
+          "data": "0x",
+          "to": "0x",
+          "value": "0",
+          "chainId": 8453
+        }
       }
     }
   },
@@ -77,14 +93,14 @@
     "output": {
       "success": true,
       "data": {
-        "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
+        "input_amount": 1000000000000000000,
+        "output_amount": 995000000000000000,
+        "gas_fee": 567840,
+        "bridge_fee": 0,
+        "protocol_fee": 0.08,
+        "total_fee": 0.08,
+        "slippage": 0,
+        "price_impact": 6888
       }
     }
   },
@@ -101,35 +117,30 @@
     "output": {
       "success": true,
       "data": {
-        "total_routes": 3,
+        "total_routes": 2,
         "best_route": {
-          "input_amount": "1000000000000000000",
-          "output_amount": "995000000000000000",
-          "total_fee": "8000000000000000"
+          "provider": "enso",
+          "output_amount": 995000000000000000,
+          "fee_estimate": { "fee_total_usd": 0.08, "fee_breakdown": [] }
         },
         "all_routes": [
           {
-            "route": "Route 1",
-            "output_amount": "995000000000000000",
-            "total_fee": "8000000000000000",
-            "estimated_time": 300
+            "provider": "enso",
+            "output_amount": 995000000000000000,
+            "fee_estimate": { "fee_total_usd": 0.08, "fee_breakdown": [] }
           },
           {
-            "route": "Route 2",
-            "output_amount": "992000000000000000",
-            "total_fee": "12000000000000000",
-            "estimated_time": 180
+            "provider": "enso",
+            "output_amount": 992000000000000000,
+            "fee_estimate": { "fee_total_usd": 0.12, "fee_breakdown": [] }
           }
         ],
         "route_analysis": {
           "highest_output": {
-            "output_amount": "995000000000000000"
+            "output_amount": 995000000000000000
           },
           "lowest_fees": {
-            "total_fee": "8000000000000000"
-          },
-          "fastest": {
-            "estimated_time": 180
+            "fee_estimate": { "fee_total_usd": 0.08, "fee_breakdown": [] }
           }
         }
       }