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

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -2,8 +2,7 @@ from typing import Any
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.PoolClient import (
-    LlamaMatch,
-    LlamaReport,
+    LlamaMatchesResponse,
     PoolClient,
     PoolList,
 )
@@ -31,58 +30,33 @@ class PoolAdapter(BaseAdapter):
         self.pool_client = pool_client or PoolClient()
 
     async def get_pools_by_ids(
-        self, pool_ids: list[str], merge_external: bool | None = None
+        self, pool_ids: list[str]
     ) -> tuple[bool, PoolList | str]:
         """
         Get pool information by pool IDs.
 
         Args:
             pool_ids: List of pool identifiers
-            merge_external: Whether to merge external data
 
         Returns:
             Tuple of (success, data) where data is pool information or error message
         """
         try:
-            pool_ids_str = ",".join(pool_ids)
-            data = await self.pool_client.get_pools_by_ids(
-                pool_ids=pool_ids_str, merge_external=merge_external
-            )
+            data = await self.pool_client.get_pools_by_ids(pool_ids=pool_ids)
             return (True, data)
         except Exception as e:
             self.logger.error(f"Error fetching pools by IDs: {e}")
             return (False, str(e))
 
-    async def get_llama_matches(self) -> tuple[bool, dict[str, LlamaMatch] | str]:
-        """
-        Get Llama protocol matches for pools.
-
-        Returns:
-            Tuple of (success, data) where data is Llama matches or error message
-        """
-        try:
-            data = await self.pool_client.get_llama_matches()
-            return (True, data)
-        except Exception as e:
-            self.logger.error(f"Error fetching Llama matches: {e}")
-            return (False, str(e))
-
-    async def get_llama_reports(
-        self, identifiers: list[str]
-    ) -> tuple[bool, dict[str, LlamaReport] | str]:
-        """
-        Get Llama reports for specific identifiers.
-
-        Args:
-            identifiers: List of identifiers (token IDs, addresses, pool IDs)
-
-        Returns:
-            Tuple of (success, data) where data is Llama reports or error message
-        """
+    async def get_pools(
+        self,
+        *,
+        chain_id: int | None = None,
+        project: str | None = None,
+    ) -> tuple[bool, LlamaMatchesResponse | str]:
         try:
-            identifiers_str = ",".join(identifiers)
-            data = await self.pool_client.get_llama_reports(identifiers=identifiers_str)
+            data = await self.pool_client.get_pools(chain_id=chain_id, project=project)
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching Llama reports: {e}")
+            self.logger.error(f"Error fetching pools: {e}")
             return (False, str(e))

wayfinder_paths/adapters/pool_adapter/examples.json

@@ -2,8 +2,7 @@
   "get_pools_by_ids": {
     "description": "Get pool information by pool IDs",
     "input": {
-      "pool_ids": ["pool-123", "pool-456"],
-      "merge_external": true
+      "pool_ids": ["pool-123", "pool-456"]
     },
     "output": {
       "success": true,
@@ -21,7 +20,7 @@
       }
     }
   },
-  "get_llama_matches": {
+  "get_pools": {
     "description": "Get Llama protocol matches for pools",
     "input": {},
     "output": {
@@ -30,10 +29,10 @@
         "matches": [
           {
             "id": "pool-123",
-            "llama_apy_pct": 5.2,
-            "llama_tvl_usd": 1000000,
-            "llama_stablecoin": true,
-            "llama_il_risk": "no",
+            "apy": 5.2,
+            "tvlUsd": 1000000,
+            "stablecoin": true,
+            "ilRisk": "no",
             "network": "base"
           }
         ]

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -38,33 +38,33 @@ class TestPoolAdapter:
         mock_pool_client.get_pools_by_ids = AsyncMock(return_value=mock_response)
 
         success, data = await adapter.get_pools_by_ids(
-            pool_ids=["pool-123", "pool-456"], merge_external=True
+            pool_ids=["pool-123", "pool-456"]
         )
 
         assert success is True
         assert data == mock_response
         mock_pool_client.get_pools_by_ids.assert_called_once_with(
-            pool_ids="pool-123,pool-456", merge_external=True
+            pool_ids=["pool-123", "pool-456"]
         )
 
     @pytest.mark.asyncio
-    async def test_get_llama_matches_success(self, adapter, mock_pool_client):
+    async def test_get_pools_success(self, adapter, mock_pool_client):
         """Test successful Llama matches retrieval"""
         # Mock response
         mock_response = {
             "matches": [
                 {
                     "id": "pool-123",
-                    "llama_apy_pct": 5.2,
-                    "llama_tvl_usd": 1000000,
-                    "llama_stablecoin": True,
+                    "apy": 5.2,
+                    "tvlUsd": 1000000,
+                    "stablecoin": True,
                     "network": "base",
                 }
             ]
         }
-        mock_pool_client.get_llama_matches = AsyncMock(return_value=mock_response)
+        mock_pool_client.get_pools = AsyncMock(return_value=mock_response)
 
-        success, data = await adapter.get_llama_matches()
+        success, data = await adapter.get_pools()
 
         assert success is True
         assert data == mock_response

wayfinder_paths/adapters/token_adapter/README.md

@@ -63,23 +63,11 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Token (Flexible)
-
-```python
-# Try by address first, then by token_id
-success, data = await adapter.get_token(address="0x1234...", token_id="token-123")
-if success:
-    print(f"Token data: {data}")
-else:
-    print(f"Error: {data}")
-```
-
 ## API Endpoints
 
-The adapter uses the following existing public API endpoints:
+The adapter uses the following Wayfinder API endpoint:
 
-1. **Token Details** (by address): `GET /public/tokens/detail/?query={address}&get_chart=false`
-2. **Token by ID**: `GET /public/tokens/lookup/?token_id={token_id}`
+- `GET /api/v1/blockchain/tokens/detail/?query=...&market_data=...&chain_id=...`
 
 ## Error Handling
 

wayfinder_paths/adapters/token_adapter/adapter.py

@@ -24,7 +24,9 @@ class TokenAdapter(BaseAdapter):
         super().__init__("token_adapter", config)
         self.token_client = token_client or TokenClient()
 
-    async def get_token(self, query: str) -> tuple[bool, TokenDetails | str]:
+    async def get_token(
+        self, query: str, *, chain_id: int | None = None
+    ) -> tuple[bool, TokenDetails | str]:
         """
         Get token data by address using the token-details endpoint.
 
@@ -35,7 +37,7 @@ class TokenAdapter(BaseAdapter):
             Tuple of (success, data) where data is the token information or error message
         """
         try:
-            data = await self.token_client.get_token_details(query)
+            data = await self.token_client.get_token_details(query, chain_id=chain_id)
             if not data:
                 return (False, f"No token found for: {query}")
             return (True, data)
@@ -43,7 +45,9 @@ class TokenAdapter(BaseAdapter):
             self.logger.error(f"Error getting token by query {query}: {e}")
             return (False, str(e))
 
-    async def get_token_price(self, token_id: str) -> tuple[bool, dict[str, Any] | str]:
+    async def get_token_price(
+        self, token_id: str, *, chain_id: int | None = None
+    ) -> tuple[bool, dict[str, Any] | str]:
         """
         Get token price by token ID or address using the token-details endpoint.
 
@@ -54,19 +58,21 @@ class TokenAdapter(BaseAdapter):
             Tuple of (success, data) where data is the price information or error message
         """
         try:
-            data = await self.token_client.get_token_details(token_id)
+            data = await self.token_client.get_token_details(
+                token_id, market_data=True, chain_id=chain_id
+            )
             if not data:
                 return (False, f"No token found for: {token_id}")
 
-            # Extract just the price information
+            price_change_24h = data.get("price_change_24h", 0.0)
             price_data = {
                 "current_price": data.get("current_price", 0.0),
-                "price_change_24h": data.get("price_change_24h", 0.0),
-                "price_change_percentage_24h": data.get(
-                    "price_change_percentage_24h", 0.0
-                ),
+                "price_change_24h": price_change_24h,
+                "price_change_percentage_24h": data.get("price_change_percentage_24h")
+                if data.get("price_change_percentage_24h") is not None
+                else (float(price_change_24h) * 100.0 if price_change_24h else 0.0),
                 "market_cap": data.get("market_cap", 0),
-                "total_volume": data.get("total_volume", 0),
+                "total_volume": data.get("total_volume_usd_24h", 0),
                 "symbol": data.get("symbol", ""),
                 "name": data.get("name", ""),
                 "address": data.get("address", ""),

wayfinder_paths/adapters/token_adapter/examples.json

@@ -1,19 +1,15 @@
 {
   "basic_usage": {
     "description": "Basic usage of TokenAdapter to get token information",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by address\nsuccess, data = await adapter.get_token_by_address(\"0x1234567890abcdef1234567890abcdef12345678\")\nif success:\n    print(f\"Token symbol: {data.get('symbol')}\")\n    print(f\"Token name: {data.get('name')}\")\n    print(f\"Decimals: {data.get('decimals')}\")\nelse:\n    print(f\"Error: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by address (provide chain_id when querying by address)\nsuccess, data = await adapter.get_token(\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    chain_id=8453,\n)\nif success:\n    print(f\"Token symbol: {data.get('symbol')}\")\n    print(f\"Token name: {data.get('name')}\")\n    print(f\"Decimals: {data.get('decimals')}\")\nelse:\n    print(f\"Error: {data}\")"
   },
   "get_by_token_id": {
     "description": "Get token information using token ID",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by ID\nsuccess, data = await adapter.get_token_by_id(\"token-12345\")\nif success:\n    print(f\"Token data: {data}\")\nelse:\n    print(f\"Error: {data}\")"
-  },
-  "flexible_lookup": {
-    "description": "Use flexible get_token method that tries both address and token_id",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Try both address and token_id\nsuccess, data = await adapter.get_token(\n    address=\"0x1234567890abcdef1234567890abcdef12345678\",\n    token_id=\"token-12345\"\n)\nif success:\n    print(f\"Found token: {data}\")\nelse:\n    print(f\"Token not found: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Get token by ID\nsuccess, data = await adapter.get_token(\"token-12345\")\nif success:\n    print(f\"Token data: {data}\")\nelse:\n    print(f\"Error: {data}\")"
   },
   "error_handling": {
     "description": "Proper error handling for various scenarios",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Handle missing parameters\ntry:\n    success, data = await adapter.get_token()\n    if not success:\n        print(f\"Error: {data}\")\nexcept Exception as e:\n    print(f\"Unexpected error: {e}\")\n\n# Handle API errors\nsuccess, data = await adapter.get_token_by_address(\"invalid-address\")\nif not success:\n    print(f\"API error: {data}\")\nelse:\n    print(f\"Token found: {data}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# Handle API errors\nsuccess, data = await adapter.get_token(\"invalid-address\")\nif not success:\n    print(f\"API error: {data}\")\nelse:\n    print(f\"Token found: {data}\")"
   },
   "health_check": {
     "description": "Check adapter health and connectivity",
@@ -21,6 +17,6 @@
   },
   "batch_operations": {
     "description": "Perform multiple token lookups efficiently",
-    "code": "from adapters.token_adapter.adapter import TokenAdapter\nimport asyncio\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# List of token addresses to lookup\ntoken_addresses = [\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    \"0xabcdef1234567890abcdef1234567890abcdef12\",\n    \"0x9876543210fedcba9876543210fedcba98765432\"\n]\n\n# Batch lookup\ntoken_data = {}\nfor address in token_addresses:\n    success, data = await adapter.get_token_by_address(address)\n    if success:\n        token_data[address] = data\n    else:\n        print(f\"Failed to get token for {address}: {data}\")\n\nprint(f\"Successfully retrieved {len(token_data)} tokens\")\nfor address, data in token_data.items():\n    print(f\"{address}: {data.get('symbol', 'Unknown')} - {data.get('name', 'Unknown')}\")"
+    "code": "from adapters.token_adapter.adapter import TokenAdapter\n\n# Initialize adapter (no config needed)\nadapter = TokenAdapter()\n\n# List of token addresses to lookup (Base chain)\ntoken_addresses = [\n    \"0x1234567890abcdef1234567890abcdef12345678\",\n    \"0xabcdef1234567890abcdef1234567890abcdef12\",\n    \"0x9876543210fedcba9876543210fedcba98765432\"\n]\n\n# Batch lookup\ntoken_data = {}\nfor address in token_addresses:\n    success, data = await adapter.get_token(address, chain_id=8453)\n    if success:\n        token_data[address] = data\n    else:\n        print(f\"Failed to get token for {address}: {data}\")\n\nprint(f\"Successfully retrieved {len(token_data)} tokens\")\nfor address, data in token_data.items():\n    print(f\"{address}: {data.get('symbol', 'Unknown')} - {data.get('name', 'Unknown')}\")"
   }
 }

wayfinder_paths/adapters/token_adapter/test_adapter.py

@@ -68,9 +68,8 @@ class TestTokenAdapter:
         mock_token_data = {
             "current_price": 1.50,
             "price_change_24h": 0.05,
-            "price_change_percentage_24h": 3.45,
             "market_cap": 1000000,
-            "total_volume": 50000,
+            "total_volume_usd_24h": 50000,
             "symbol": "TEST",
             "name": "Test Token",
             "address": "0x1234...",
@@ -85,6 +84,8 @@ class TestTokenAdapter:
             assert data["current_price"] == 1.50
             assert data["symbol"] == "TEST"
             assert data["name"] == "Test Token"
+            assert data["total_volume"] == 50000
+            assert data["price_change_percentage_24h"] == 5.0  # 0.05 * 100
 
     @pytest.mark.asyncio
     async def test_get_token_price_not_found(self, adapter):
@@ -99,7 +100,8 @@ class TestTokenAdapter:
     async def test_get_gas_token_success(self, adapter):
         """Test successful gas token retrieval"""
         mock_gas_token_data = {
-            "id": "ethereum-base",
+            "id": "ethereum_0x0000000000000000000000000000000000000000",
+            "token_id": "ethereum_0x0000000000000000000000000000000000000000",
             "symbol": "ETH",
             "name": "Ethereum",
             "address": "0x0000000000000000000000000000000000000000",

wayfinder_paths/core/clients/BRAPClient.py

@@ -1,6 +1,6 @@
 """
 BRAP (Bridge/Router/Adapter Protocol) Client
-Provides access to quote operations via the public quote endpoint.
+Provides access to quote operations via the blockchain quote endpoint.
 """
 
 from __future__ import annotations
@@ -10,100 +10,141 @@ from typing import Any, NotRequired, Required, TypedDict
 
 from loguru import logger
 
-from wayfinder_paths.core.clients.AuthClient import AuthClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
-from wayfinder_paths.core.settings import settings
+from wayfinder_paths.core.config import get_api_base_url
 
 
-class BRAPQuote(TypedDict):
+class QuoteTx(TypedDict, total=False):
+    """Quote transaction data structure"""
+
+    data: str
+    to: str
+    value: str
+    chainId: int
+
+
+class QuoteData(TypedDict):
+    """Quote data structure"""
+
+    gas: Required[str]
+    amountOut: Required[str]
+    priceImpact: Required[int]
+    feeAmount: Required[list[str]]
+    minAmountOut: Required[str]
+    createdAt: Required[int]
+    tx: Required[QuoteTx]
+    route: Required[list[dict[str, Any]]]
+
+
+class FeeBreakdown(TypedDict):
+    """Fee breakdown structure"""
+
+    name: Required[str]
+    amount: Required[int]
+    amount_usd: Required[float]
+    token: Required[str]
+    token_chain: Required[int]
+
+
+class FeeEstimate(TypedDict):
+    """Fee estimate structure"""
+
+    fee_total_usd: Required[float]
+    fee_breakdown: Required[list[FeeBreakdown]]
+
+
+class Calldata(TypedDict, total=False):
+    """Calldata structure"""
+
+    data: str
+    to: str
+    value: str
+    chainId: int
+
+
+class BRAPQuoteEntry(TypedDict):
+    """BRAP quote entry structure"""
+
+    provider: Required[str]
+    quote: Required[QuoteData]
+    calldata: Required[Calldata]
+    output_amount: Required[int]
+    input_amount: Required[int]
+    gas_estimate: NotRequired[int | None]
+    error: NotRequired[str | None]
+    input_amount_usd: Required[float]
+    output_amount_usd: Required[float]
+    fee_estimate: Required[FeeEstimate]
+    wrap_transaction: NotRequired[dict[str, Any] | None]
+    unwrap_transaction: NotRequired[dict[str, Any] | None]
+    native_input: Required[bool]
+    native_output: Required[bool]
+
+
+class BRAPQuoteResponse(TypedDict):
     """BRAP quote response structure"""
 
-    from_token_address: Required[str]
-    to_token_address: Required[str]
-    from_chain_id: Required[int]
-    to_chain_id: Required[int]
-    from_address: Required[str]
-    to_address: Required[str]
-    amount1: Required[str]
-    amount2: NotRequired[str]
-    routes: NotRequired[list[dict[str, Any]]]
-    best_route: NotRequired[dict[str, Any]]
-    fees: NotRequired[dict[str, Any] | None]
-    slippage: NotRequired[float | None]
-    wayfinder_fee: NotRequired[float | None]
+    quotes: Required[list[BRAPQuoteEntry]]
+    best_quote: Required[BRAPQuoteEntry]
 
 
 class BRAPClient(WayfinderClient):
     """Client for BRAP quote operations"""
 
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
-        self.api_base_url = f"{settings.WAYFINDER_API_URL}"
-        self._auth_client: AuthClient | None = AuthClient(api_key=api_key)
+    def __init__(self):
+        super().__init__()
+        self.api_base_url = f"{get_api_base_url()}/v1/blockchain/braps"
 
     async def get_quote(
         self,
         *,
-        from_token_address: str,
-        to_token_address: str,
-        from_chain_id: int,
-        to_chain_id: int,
-        from_address: str,
-        to_address: str,
-        amount1: str,
-        slippage: float | None = None,
-        wayfinder_fee: float | None = None,
-    ) -> BRAPQuote:
+        from_token: str,
+        to_token: str,
+        from_chain: int,
+        to_chain: int,
+        from_wallet: str,
+        from_amount: str,
+    ) -> BRAPQuoteResponse:  # type: ignore # noqa: E501
         """
         Get a quote for a bridge/swap operation.
 
         Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            from_address: Source wallet address
-            to_address: Destination wallet address
-            amount1: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-            wayfinder_fee: Wayfinder fee (optional)
+            from_token: Source token contract address
+            to_token: Destination token contract address
+            from_chain: Source chain ID
+            to_chain: Destination chain ID
+            from_wallet: Source wallet address
+            from_amount: Amount to swap (in smallest units)
 
         Returns:
-            Quote data including routes, amounts, fees, etc.
+            Quote response including quotes array and best_quote
         """
         logger.info(
-            f"Getting BRAP quote: {from_token_address} -> {to_token_address} (chain {from_chain_id} -> {to_chain_id})"
-        )
-        logger.debug(
-            f"Quote params: amount={amount1}, slippage={slippage}, wayfinder_fee={wayfinder_fee}"
+            f"Getting BRAP quote: {from_token} -> {to_token} (chain {from_chain} -> {to_chain})"
         )
+        logger.debug(f"Quote params: amount={from_amount}")
         start_time = time.time()
 
-        url = f"{self.api_base_url}/public/quotes/"
+        url = f"{self.api_base_url}/quote/"
 
-        payload = {
-            "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": amount1,
+        params: dict[str, Any] = {
+            "from_token": from_token,
+            "to_token": to_token,
+            "from_chain": from_chain,
+            "to_chain": to_chain,
+            "from_wallet": from_wallet,
+            "from_amount": from_amount,
         }
 
-        # Only add optional parameters if they're provided
-        if slippage is not None:
-            payload["slippage"] = slippage
-        if wayfinder_fee is not None:
-            payload["wayfinder_fee"] = wayfinder_fee
-
         try:
-            response = await self._request("POST", url, json=payload, headers={})
+            response = await self._authed_request("GET", url, params=params, headers={})
             response.raise_for_status()
             data = response.json()
+            result = data.get("data", data)
+
             elapsed = time.time() - start_time
             logger.info(f"BRAP quote request completed successfully in {elapsed:.2f}s")
-            return data.get("data", data)
+            return result
         except Exception as e:
             elapsed = time.time() - start_time
             logger.error(f"BRAP quote request failed after {elapsed:.2f}s: {e}")

wayfinder_paths/core/clients/ClientManager.py

@@ -5,7 +5,6 @@ Consolidated client management for all API interactions
 
 from typing import Any
 
-from wayfinder_paths.core.clients.AuthClient import AuthClient
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.HyperlendClient import HyperlendClient
 from wayfinder_paths.core.clients.LedgerClient import LedgerClient
@@ -37,7 +36,6 @@ class ClientManager:
         self,
         clients: dict[str, Any] | None = None,
         skip_auth: bool = False,
-        api_key: str | None = None,
     ):
         """
         Initialize ClientManager.
@@ -45,14 +43,10 @@ class ClientManager:
         Args:
             clients: Optional dict of pre-instantiated clients to inject directly.
             skip_auth: If True, skips authentication (for SDK usage).
-            api_key: Optional API key for service account authentication.
         """
         self._injected_clients = clients or {}
         self._skip_auth = skip_auth
-        self._api_key = api_key
-        self._access_token: str | None = None
 
-        self._auth_client: AuthClient | None = None
         self._token_client: TokenClientProtocol | None = None
         self._wallet_client: WalletClientProtocol | None = None
         self._ledger_client: LedgerClientProtocol | None = None
@@ -79,25 +73,10 @@ class ClientManager:
         """
         client = getattr(self, client_attr)
         if not client:
-            client = self._injected_clients.get(injected_key) or client_class(
-                api_key=self._api_key
-            )
+            client = self._injected_clients.get(injected_key) or client_class()
             setattr(self, client_attr, client)
-            if self._access_token and hasattr(client, "set_bearer_token"):
-                client.set_bearer_token(self._access_token)
         return client
 
-    @property
-    def auth(self) -> AuthClient | None:
-        """Get or create auth client. Returns None if skip_auth=True."""
-        if self._skip_auth:
-            return None
-        if not self._auth_client:
-            self._auth_client = AuthClient(api_key=self._api_key)
-            if self._access_token:
-                self._auth_client.set_bearer_token(self._access_token)
-        return self._auth_client
-
     @property
     def token(self) -> TokenClientProtocol:
         """Get or create token client"""
@@ -130,55 +109,9 @@ class ClientManager:
         """Get or create BRAP client"""
         return self._get_or_create_client("_brap_client", "brap", BRAPClient)
 
-    async def authenticate(
-        self,
-        username: str | None = None,
-        password: str | None = None,
-        *,
-        refresh_token: str | None = None,
-    ) -> dict[str, Any]:
-        """Authenticate with the API. Raises ValueError if skip_auth=True."""
-        if self._skip_auth:
-            raise ValueError(
-                "Authentication is disabled in SDK mode. SDK users handle their own authentication."
-            )
-        auth_client = self.auth
-        if auth_client is None:
-            raise ValueError("Auth client is not available")
-        data = await auth_client.authenticate(
-            username, password, refresh_token=refresh_token
-        )
-        access = data.get("access") or data.get("access_token")
-        if access:
-            self.set_access_token(access)
-        return data
-
-    def set_access_token(self, access_token: str) -> None:
-        """Set and propagate access token to all initialized clients."""
-        self._access_token = access_token
-        if self._auth_client:
-            self._auth_client.set_bearer_token(access_token)
-        if self._token_client and hasattr(self._token_client, "set_bearer_token"):
-            self._token_client.set_bearer_token(access_token)
-        if self._transaction_client and hasattr(
-            self._transaction_client, "set_bearer_token"
-        ):
-            self._transaction_client.set_bearer_token(access_token)
-        if self._ledger_client and hasattr(self._ledger_client, "set_bearer_token"):
-            self._ledger_client.set_bearer_token(access_token)
-        if self._pool_client and hasattr(self._pool_client, "set_bearer_token"):
-            self._pool_client.set_bearer_token(access_token)
-        if self._hyperlend_client and hasattr(
-            self._hyperlend_client, "set_bearer_token"
-        ):
-            self._hyperlend_client.set_bearer_token(access_token)
-        if self._wallet_client and hasattr(self._wallet_client, "set_bearer_token"):
-            self._wallet_client.set_bearer_token(access_token)
-
     def get_all_clients(self) -> dict[str, Any]:
         """Get all initialized clients for direct access"""
         return {
-            "auth": self._auth_client,
             "token": self._token_client,
             "transaction": self._transaction_client,
             "ledger": self._ledger_client,