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

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -8,7 +8,10 @@ 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
@@ -61,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.
 
@@ -77,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:
@@ -130,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:
@@ -156,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")
 
@@ -253,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,
             )
@@ -262,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)
@@ -310,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,7 +345,12 @@ class BRAPAdapter(BaseAdapter):
                 "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)))
+                        min(
+                            all_quotes,
+                            key=lambda x: float(
+                                x.get("fee_estimate", {}).get("fee_total_usd", 0)
+                            ),
+                        )
                         if all_quotes
                         else None
                     ),
@@ -422,13 +433,40 @@ 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")
+        def _as_address(value: Any) -> str | None:
+            if not isinstance(value, str):
+                return None
+            v = value.strip()
+            if (
+                v.startswith("0x")
+                and len(v) == 42
+                and v.lower() != ZERO_ADDRESS.lower()
+            ):
+                return v
+            return None
+
+        spender = (
+            _as_address(transaction.get("allowanceTarget"))
+            or _as_address(transaction.get("allowance_target"))
+            or _as_address(transaction.get("approvalAddress"))
+            or _as_address(transaction.get("approval_address"))
+            or _as_address(transaction.get("spender"))
+            or _as_address(quote.get("allowanceTarget"))
+            or _as_address(quote.get("allowance_target"))
+            or _as_address(quote.get("approvalAddress"))
+            or _as_address(quote.get("approval_address"))
+            or _as_address(quote.get("spender"))
+            or _as_address(transaction.get("to"))
+        )
         approve_amount = (
             quote.get("input_amount")
             or quote.get("inputAmount")
@@ -455,13 +493,35 @@ class BRAPAdapter(BaseAdapter):
         broadcast_success, broadcast_response = await self._broadcast_transaction(
             transaction
         )
-        self.logger.info(
-            f"Swap broadcast result: success={broadcast_success}, "
-            f"response={broadcast_response}"
-        )
+        # Log only key fields to avoid spamming raw HexBytes logs
+        if isinstance(broadcast_response, dict):
+            tx_hash_log = broadcast_response.get("tx_hash", "unknown")
+            block_log = broadcast_response.get("block_number", "unknown")
+            status_log = (
+                broadcast_response.get("receipt", {}).get("status", "unknown")
+                if isinstance(broadcast_response.get("receipt"), dict)
+                else "unknown"
+            )
+            self.logger.info(
+                f"Swap broadcast: success={broadcast_success}, tx={tx_hash_log}, block={block_log}, status={status_log}"
+            )
+        else:
+            self.logger.info(f"Swap broadcast: success={broadcast_success}")
         if not broadcast_success:
             return (False, broadcast_response)
 
+        tx_hash = None
+        block_number = None
+        confirmations = None
+        confirmed_block_number = None
+        if isinstance(broadcast_response, dict):
+            tx_hash = broadcast_response.get("tx_hash") or broadcast_response.get(
+                "transaction_hash"
+            )
+            block_number = broadcast_response.get("block_number")
+            confirmations = broadcast_response.get("confirmations")
+            confirmed_block_number = broadcast_response.get("confirmed_block_number")
+
         # Record the swap operation in ledger - but don't let ledger errors fail the swap
         # since the on-chain transaction already succeeded
         try:
@@ -477,15 +537,20 @@ class BRAPAdapter(BaseAdapter):
             self.logger.warning(
                 f"Ledger recording failed (swap succeeded on-chain): {e}"
             )
-            # Return the quote with output amount so caller can proceed
-            ledger_record = {
-                "to_amount": quote.get("output_amount"),
-                "from_amount": quote.get("input_amount"),
-                "tx_hash": broadcast_response.get("tx_hash")
-                if isinstance(broadcast_response, dict)
-                else None,
-            }
-        return (True, ledger_record)
+            ledger_record = {}
+
+        result_payload: dict[str, Any] = {
+            "from_amount": quote.get("input_amount"),
+            "to_amount": quote.get("output_amount"),
+            "tx_hash": tx_hash,
+            "block_number": block_number,
+            "confirmations": confirmations,
+            "confirmed_block_number": confirmed_block_number,
+        }
+        if isinstance(ledger_record, dict):
+            result_payload.update(ledger_record)
+
+        return (True, result_payload)
 
     async def get_bridge_quote(
         self,
@@ -516,8 +581,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,
         )
@@ -634,14 +699,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:
@@ -695,7 +761,7 @@ class BRAPAdapter(BaseAdapter):
         return await self._broadcast_transaction(approve_tx, confirmations=2)
 
     async def _broadcast_transaction(
-        self, transaction: dict[str, Any], confirmations: int = 0
+        self, transaction: dict[str, Any], confirmations: int | None = None
     ) -> tuple[bool, Any]:
         return await self.wallet_provider.broadcast_transaction(
             transaction,
@@ -779,7 +845,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": [] }
           }
         }
       }