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

wayfinder_paths/adapters/balance_adapter/README.md

@@ -23,24 +23,23 @@ balance = BalanceAdapter(config, web3_service=web3_service)
 
 ## API surface
 
-### `get_balance(token_id: str, wallet_address: str)`
-Returns the raw balance (as an integer) for a specific token on a wallet.
+### `get_balance(*, query: str | dict, wallet_address: str, chain_id: int | None = None)`
+Returns the raw balance (as an integer) for a specific token or pool on a wallet.
+
+`query`: token_id/address string or a dict with a `"token_id"` key. When `query` is a token identifier (e.g. `"usd-coin-base"`), `chain_id` is auto-resolved from token info; when it is a pool address, `chain_id` must be provided.
 
 ```python
+# Token balance (chain_id auto-resolved)
 success, balance = await balance.get_balance(
-    token_id="usd-coin-base",
+    query="usd-coin-base",
     wallet_address=config["main_wallet"]["address"],
 )
-```
 
-### `get_pool_balance(pool_address: str, chain_id: int, user_address: str)`
-Fetches the amount supplied to a specific pool, using the `/wallets/pool-balance` endpoint.
-
-```python
-success, amount = await balance.get_pool_balance(
-    pool_address="0xPool",
+# Pool balance (chain_id required)
+success, pool_balance = await balance.get_balance(
+    query="0xPool...",
+    wallet_address=config["strategy_wallet"]["address"],
     chain_id=8453,
-    user_address=config["strategy_wallet"]["address"],
 )
 ```
 
@@ -80,10 +79,10 @@ class MyStrategy(Strategy):
         self.balance_adapter = balance_adapter
 
     async def _status(self):
-        success, pool_balance = await self.balance_adapter.get_pool_balance(
-            pool_address=self.current_pool["address"],
+        success, pool_balance = await self.balance_adapter.get_balance(
+            query=self.current_pool["address"],
+            wallet_address=self.config["strategy_wallet"]["address"],
             chain_id=self.current_pool["chain"]["id"],
-            user_address=self.config["strategy_wallet"]["address"],
         )
         return {"portfolio_value": float(pool_balance or 0), ...}
 ```

wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -42,16 +42,39 @@ class BalanceAdapter(BaseAdapter):
     async def get_balance(
         self,
         *,
-        token_id: str,
+        query: str | dict[str, Any],
         wallet_address: str,
+        chain_id: int | None = None,
     ) -> tuple[bool, str | int]:
-        """Get token balance for a wallet."""
+        """Get token or pool balance for a wallet.
+
+        query: token_id/address string or a dict with a "token_id" key.
+        """
+        resolved = query if isinstance(query, str) else (query or {}).get("token_id")
+        if not resolved:
+            return (False, "missing query")
         try:
-            data = await self.wallet_client.get_token_balance_for_wallet(
-                token_id=token_id,
+            if chain_id is None:
+                token_info = await self.token_client.get_token_details(resolved)
+                if not token_info:
+                    return (False, f"Token not found: {resolved}")
+                resolved_chain_id = resolve_chain_id(token_info, self.logger)
+                if resolved_chain_id is None:
+                    return (False, f"Token {resolved} is missing a chain id")
+                chain_id = resolved_chain_id
+
+            data = await self.wallet_client.get_token_balance_for_address(
                 wallet_address=wallet_address,
+                query=resolved,
+                chain_id=int(chain_id),
             )
-            return (True, data.get("balance"))
+            # Use _parse_balance for consistent parsing (handles balance_raw or balance)
+            raw = (
+                data.get("balance_raw") or data.get("balance")
+                if isinstance(data, dict)
+                else None
+            )
+            return (True, self._parse_balance(raw))
         except Exception as e:
             return (False, str(e))
 
@@ -159,6 +182,7 @@ class BalanceAdapter(BaseAdapter):
 
         usd_value = await self._token_amount_usd(token_info, amount)
         try:
+            token_id = token_info.get("token_id") or token_info.get("id")
             success, response = await ledger_method(
                 wallet_address=wallet_address,
                 chain_id=chain_id,
@@ -166,7 +190,7 @@ class BalanceAdapter(BaseAdapter):
                 token_amount=str(amount),
                 usd_value=usd_value,
                 data={
-                    "token_id": token_info.get("token_id"),
+                    "token_id": token_id,
                     "amount": str(amount),
                     "usd_value": usd_value,
                 },
@@ -176,15 +200,16 @@ class BalanceAdapter(BaseAdapter):
                 self.logger.warning(
                     "Ledger entry failed",
                     wallet=wallet_address,
-                    token_id=token_info.get("token_id"),
+                    token_id=token_id,
                     amount=amount,
                     error=response,
                 )
         except Exception as exc:  # noqa: BLE001
+            token_id = token_info.get("token_id") or token_info.get("id")
             self.logger.warning(
                 f"Ledger entry raised: {exc}",
                 wallet=wallet_address,
-                token_id=token_info.get("token_id"),
+                token_id=token_id,
             )
 
     async def _token_amount_usd(
@@ -208,27 +233,3 @@ class BalanceAdapter(BaseAdapter):
         if isinstance(evm_wallet, dict):
             return evm_wallet.get("address")
         return None
-
-    async def get_pool_balance(
-        self,
-        *,
-        pool_address: str,
-        chain_id: int,
-        user_address: str,
-    ) -> tuple[bool, Any]:
-        """Get pool balance for a wallet."""
-        try:
-            data = await self.wallet_client.get_pool_balance_for_wallet(
-                pool_address=pool_address,
-                chain_id=chain_id,
-                user_address=user_address,
-                human_readable=False,
-            )
-            raw = (
-                data.get("balance_raw") or data.get("balance")
-                if isinstance(data, dict)
-                else None
-            )
-            return (True, self._parse_balance(raw))
-        except Exception as e:
-            return (False, str(e))

wayfinder_paths/adapters/balance_adapter/test_adapter.py

@@ -57,3 +57,126 @@ class TestBalanceAdapter:
     def test_adapter_type(self, adapter):
         """Test adapter has adapter_type"""
         assert adapter.adapter_type == "BALANCE"
+
+    @pytest.mark.asyncio
+    async def test_get_balance_with_query_string(
+        self, adapter, mock_token_client, mock_wallet_client
+    ):
+        """Test get_balance with query as string (auto-resolves chain_id)."""
+        mock_token_client.get_token_details = AsyncMock(
+            return_value={
+                "token_id": "usd-coin-base",
+                "address": "0x123",
+                "chain": {"id": 8453, "code": "base"},
+            }
+        )
+        mock_wallet_client.get_token_balance_for_address = AsyncMock(
+            return_value={"balance": 1000000}
+        )
+
+        success, balance = await adapter.get_balance(
+            query="usd-coin-base",
+            wallet_address="0xWallet",
+        )
+
+        assert success is True
+        assert balance == 1000000
+        mock_token_client.get_token_details.assert_called_once_with("usd-coin-base")
+        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
+            wallet_address="0xWallet",
+            query="usd-coin-base",
+            chain_id=8453,
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_balance_with_query_dict(
+        self, adapter, mock_token_client, mock_wallet_client
+    ):
+        """get_balance accepts query= as dict with token_id key."""
+        mock_token_client.get_token_details = AsyncMock(
+            return_value={
+                "token_id": "wsteth-base",
+                "address": "0x456",
+                "chain": {"id": 8453, "code": "base"},
+            }
+        )
+        mock_wallet_client.get_token_balance_for_address = AsyncMock(
+            return_value={"balance": 3000000}
+        )
+
+        success, balance = await adapter.get_balance(
+            query={"token_id": "wsteth-base"},
+            wallet_address="0x123",
+        )
+        assert success is True
+        assert balance == 3000000
+        mock_token_client.get_token_details.assert_called_once_with("wsteth-base")
+        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
+            wallet_address="0x123",
+            query="wsteth-base",
+            chain_id=8453,
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_balance_missing_query(self, adapter):
+        """get_balance returns error when query is empty or missing token_id."""
+        success, result = await adapter.get_balance(query={}, wallet_address="0xabc")
+        assert success is False
+        assert "missing query" in str(result)
+
+    @pytest.mark.asyncio
+    async def test_get_balance_with_pool_address(
+        self, adapter, mock_token_client, mock_wallet_client
+    ):
+        """Test get_balance with pool address (explicit chain_id)"""
+        mock_wallet_client.get_token_balance_for_address = AsyncMock(
+            return_value={"balance": 5000000}
+        )
+        mock_token_client.get_token_details = AsyncMock()
+
+        success, balance = await adapter.get_balance(
+            query="0xPoolAddress",
+            wallet_address="0xWallet",
+            chain_id=8453,
+        )
+
+        assert success is True
+        assert balance == 5000000
+        mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
+            wallet_address="0xWallet",
+            query="0xPoolAddress",
+            chain_id=8453,
+        )
+        mock_token_client.get_token_details.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_get_balance_token_not_found(self, adapter, mock_token_client):
+        """Test get_balance when token is not found"""
+        mock_token_client.get_token_details = AsyncMock(return_value=None)
+
+        success, error = await adapter.get_balance(
+            query="invalid-token",
+            wallet_address="0xWallet",
+        )
+
+        assert success is False
+        assert "Token not found" in str(error)
+
+    @pytest.mark.asyncio
+    async def test_get_balance_missing_chain_id(self, adapter, mock_token_client):
+        """Test get_balance when chain_id cannot be resolved"""
+        mock_token_client.get_token_details = AsyncMock(
+            return_value={
+                "token_id": "token-without-chain",
+                "address": "0x123",
+                "chain": {},
+            }
+        )
+
+        success, error = await adapter.get_balance(
+            query="token-without-chain",
+            wallet_address="0xWallet",
+        )
+
+        assert success is False
+        assert "missing a chain id" in str(error)

wayfinder_paths/adapters/brap_adapter/README.md

@@ -46,10 +46,9 @@ success, data = await adapter.get_swap_quote(
     slippage=0.01  # 1% slippage
 )
 if success:
-    quotes = data.get("quotes", {})
-    best_quote = quotes.get("best_quote", {})
+    best_quote = data.get("best_quote", {})
     print(f"Output amount: {best_quote.get('output_amount')}")
-    print(f"Total fee: {best_quote.get('total_fee')}")
+    print(f"Fee estimate: {best_quote.get('fee_estimate', {}).get('fee_total_usd')}")
 else:
     print(f"Error: {data}")
 ```
@@ -68,8 +67,7 @@ success, data = await adapter.get_best_quote(
 )
 if success:
     print(f"Best output: {data.get('output_amount')}")
-    print(f"Gas fee: {data.get('gas_fee')}")
-    print(f"Bridge fee: {data.get('bridge_fee')}")
+    print(f"Fee estimate (USD): {data.get('fee_estimate', {}).get('fee_total_usd')}")
 else:
     print(f"Error: {data}")
 ```
@@ -88,10 +86,8 @@ success, data = await adapter.calculate_swap_fees(
 if success:
     print(f"Input amount: {data.get('input_amount')}")
     print(f"Output amount: {data.get('output_amount')}")
-    print(f"Gas fee: {data.get('gas_fee')}")
-    print(f"Bridge fee: {data.get('bridge_fee')}")
-    print(f"Protocol fee: {data.get('protocol_fee')}")
-    print(f"Total fee: {data.get('total_fee')}")
+    print(f"Gas estimate: {data.get('gas_fee')}")
+    print(f"Total fee (USD): {data.get('total_fee')}")
     print(f"Price impact: {data.get('price_impact')}")
 else:
     print(f"Error: {data}")
@@ -112,7 +108,7 @@ if success:
     print(f"Best route output: {data.get('best_route', {}).get('output_amount')}")
     
     for i, route in enumerate(data.get('all_routes', [])):
-        print(f"Route {i+1}: Output {route.get('output_amount')}, Fee {route.get('total_fee')}")
+        print(f\"Route {i+1}: Output {route.get('output_amount')}, Fee USD {route.get('fee_estimate', {}).get('fee_total_usd')}\")
 else:
     print(f"Error: {data}")
 ```
@@ -170,7 +166,7 @@ success, data = await adapter.get_bridge_quote(
     slippage=0.01
 )
 if success:
-    print(f"Bridge quote received: {data.get('quotes', {}).get('best_quote', {}).get('output_amount')}")
+    print(f"Bridge quote received: {data.get('best_quote', {}).get('output_amount')}")
 else:
     print(f"Error: {data}")
 ```
@@ -196,8 +192,7 @@ if success:
     fastest = analysis.get("fastest")
     
     print(f"Highest output route: {highest_output.get('output_amount')}")
-    print(f"Lowest fees route: {lowest_fees.get('total_fee')}")
-    print(f"Fastest route: {fastest.get('estimated_time')} seconds")
+    print(f\"Lowest fees route (USD): {lowest_fees.get('fee_estimate', {}).get('fee_total_usd')}\")
 ```
 
 ### Fee Analysis
@@ -215,19 +210,19 @@ success, data = await adapter.calculate_swap_fees(
 if success:
     input_amount = int(data.get("input_amount", 0))
     output_amount = int(data.get("output_amount", 0))
-    total_fee = int(data.get("total_fee", 0))
+    total_fee_usd = float(data.get("total_fee", 0))
     
     # Calculate effective rate
     effective_rate = (input_amount - output_amount) / input_amount
     print(f"Effective rate: {effective_rate:.4f} ({effective_rate * 100:.2f}%)")
-    print(f"Total fees: {total_fee / 1e18:.6f} tokens")
+    print(f"Total fees: ${total_fee_usd:.4f}")
 ```
 
 ## API Endpoints
 
 The adapter uses the following Wayfinder API endpoints:
 
-- `POST /api/v1/public/quotes/` - Get swap/bridge quotes
+- `GET /api/v1/blockchain/braps/quote/` - Get swap/bridge quotes
 
 ## Error Handling
 

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,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")
@@ -516,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,
         )
@@ -634,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:
@@ -779,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: