wayfinder-paths 0.1.13__py3-none-any.whl → 0.1.15__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))
 
@@ -93,6 +116,46 @@ class BalanceAdapter(BaseAdapter):
             skip_ledger=skip_ledger,
         )
 
+    async def send_to_address(
+        self,
+        token_id: str,
+        amount: float,
+        from_wallet: dict[str, Any] | None,
+        to_address: str,
+        skip_ledger: bool = True,
+    ) -> tuple[bool, Any]:
+        """Send tokens from a wallet to an arbitrary address (e.g., bridge contract)."""
+        if self.token_transactions is None:
+            return False, "Token transaction service not configured"
+
+        from_address = self._wallet_address(from_wallet)
+        if not from_address:
+            return False, "from_wallet missing or invalid"
+
+        if not to_address:
+            return False, "to_address is required"
+
+        token_info = await self.token_client.get_token_details(token_id)
+        if not token_info:
+            return False, f"Token not found: {token_id}"
+
+        build_success, tx_data = await self.token_transactions.build_send(
+            token_id=token_id,
+            amount=amount,
+            from_address=from_address,
+            to_address=to_address,
+            token_info=token_info,
+        )
+        if not build_success:
+            return False, tx_data
+
+        tx = tx_data
+        broadcast_result = await self.wallet_provider.broadcast_transaction(
+            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
+        )
+
+        return broadcast_result
+
     async def _move_between_wallets(
         self,
         *,
@@ -159,6 +222,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 +230,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 +240,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 +273,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
+        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
+        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
+        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