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

wayfinder_paths/core/clients/TokenClient.py

@@ -7,83 +7,138 @@ from __future__ import annotations
 
 from typing import NotRequired, Required, TypedDict
 
-from wayfinder_paths.core.clients.AuthClient import AuthClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 from wayfinder_paths.core.config import get_api_base_url
 
 
+class TokenLinks(TypedDict):
+    """Token links structure"""
+
+    github: NotRequired[list[str]]
+    reddit: NotRequired[str]
+    discord: NotRequired[str]
+    twitter: NotRequired[str]
+    homepage: NotRequired[list[str]]
+    telegram: NotRequired[str]
+
+
+class ChainAddress(TypedDict):
+    """Chain address structure"""
+
+    address: Required[str]
+    token_id: Required[str]
+    is_contract: NotRequired[bool]
+    chain_id: NotRequired[int]
+
+
+class ChainInfo(TypedDict):
+    """Chain information structure"""
+
+    id: Required[int]
+    name: Required[str]
+    code: Required[str]
+
+
+class TokenMetadata(TypedDict):
+    """Token metadata structure"""
+
+    query_processed: NotRequired[str]
+    query_type: NotRequired[str]
+    has_addresses: NotRequired[bool]
+    address_count: NotRequired[int]
+    has_price_data: NotRequired[bool]
+
+
 class TokenDetails(TypedDict):
     """Token details response structure"""
 
-    id: Required[str]
-    address: Required[str]
-    symbol: Required[str]
+    asset_id: NotRequired[str]
+    token_ids: NotRequired[list[str]]
     name: Required[str]
+    symbol: Required[str]
     decimals: Required[int]
-    chain_id: Required[int]
-    chain_code: Required[str]
-    price_usd: NotRequired[float]
-    price: NotRequired[float]
+    description: NotRequired[str]
+    links: NotRequired[TokenLinks]
+    categories: NotRequired[list[str]]
+    current_price: NotRequired[float]
+    market_cap: NotRequired[float]
+    total_volume_usd_24h: NotRequired[float]
+    price_change_24h: NotRequired[float]
+    price_change_7d: NotRequired[float]
+    price_change_30d: NotRequired[float]
+    price_change_1y: NotRequired[float]
+    addresses: NotRequired[dict[str, str]]
+    chain_addresses: NotRequired[dict[str, ChainAddress]]
+    chain_ids: NotRequired[dict[str, int]]
+    id: NotRequired[int]
+    token_id: Required[str]
+    address: Required[str]
+    chain: NotRequired[ChainInfo]
+    query: NotRequired[str]
+    query_type: NotRequired[str]
+    metadata: NotRequired[TokenMetadata]
     image_url: NotRequired[str | None]
-    coingecko_id: NotRequired[str | None]
 
 
 class GasToken(TypedDict):
     """Gas token response structure"""
 
     id: Required[str]
-    address: Required[str]
-    symbol: Required[str]
+    coingecko_id: NotRequired[str]
+    token_id: Required[str]
     name: Required[str]
+    symbol: Required[str]
+    address: Required[str]
     decimals: Required[int]
-    chain_id: Required[int]
-    chain_code: Required[str]
-    price_usd: NotRequired[float]
+    chain: NotRequired[ChainInfo]
 
 
 class TokenClient(WayfinderClient):
     """Adapter for token-related operations"""
 
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
-        self.api_base_url = f"{self.api_base_url}/tokens"
-        self._auth_client: AuthClient | None = AuthClient(api_key=api_key)
-
-    # ============== Public (No-Auth) Endpoints ==============
+    def __init__(self):
+        super().__init__()
+        self.api_base_url = f"{get_api_base_url()}/v1/blockchain/tokens"
 
     async def get_token_details(
-        self, token_id: str, force_refresh: bool = False
+        self, query: str, market_data: bool = False, chain_id: int | None = None
     ) -> TokenDetails:
         """
-        Get token data including price from the token-details endpoint
+        Get token data including price from the token-details endpoint.
 
         Args:
-            token_id: Token identifier or address
+            query: Token identifier, address, or symbol to query
+            market_data: Whether to include market data (default: True)
+            chain_id: Optional chain ID
 
         Returns:
             Full token data including price information
         """
-        url = f"{get_api_base_url()}/public/tokens/detail/"
+        url = f"{self.api_base_url}/detail/"
         params = {
-            "query": token_id,
-            "get_chart": "false",
-            "force_refresh": str(force_refresh),
+            "query": query,
+            "market_data": market_data,
         }
-        # Public endpoint: do not pass auth headers
-        response = await self._request("GET", url, params=params, headers={})
+        if chain_id is not None:
+            params["chain_id"] = chain_id
+        response = await self._authed_request("GET", url, params=params)
         response.raise_for_status()
         data = response.json()
         return data.get("data", data)
 
-    async def get_gas_token(self, chain_code: str) -> GasToken:
+    async def get_gas_token(self, query: str) -> GasToken:
         """
-        Fetch the native gas token for a given chain code via public endpoint.
-        Example: GET /api/v1/public/tokens/gas/?chain_code=base
+        Fetch the native gas token for a given chain code or query.
+
+        Args:
+            query: Chain code or query string
+
+        Returns:
+            Gas token information including chain details
         """
-        url = f"{get_api_base_url()}/public/tokens/gas/"
-        params = {"chain_code": chain_code}
-        # Public endpoint: do not pass auth headers
-        response = await self._request("GET", url, params=params, headers={})
+        url = f"{self.api_base_url}/gas/"
+        params = {"query": query}
+        response = await self._authed_request("GET", url, params=params)
         response.raise_for_status()
         data = response.json()
         return data.get("data", data)

wayfinder_paths/core/clients/WalletClient.py

@@ -7,80 +7,50 @@ from __future__ import annotations
 
 from typing import NotRequired, Required, TypedDict
 
-from wayfinder_paths.core.clients.AuthClient import AuthClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 from wayfinder_paths.core.config import get_api_base_url
 
 
-class TokenBalance(TypedDict):
-    """Token balance response structure"""
+class AddressBalance(TypedDict):
+    """Balance response structure for address/query lookups."""
 
-    token_id: Required[str]
-    wallet_address: Required[str]
-    balance: Required[str]
-    balance_human: NotRequired[float | None]
-    usd_value: NotRequired[float | None]
-
-
-class PoolBalance(TypedDict):
-    """Pool balance response structure"""
-
-    pool_address: Required[str]
-    chain_id: Required[int]
-    user_address: Required[str]
-    balance: Required[str]
+    balance: Required[int]
     balance_human: NotRequired[float | None]
     usd_value: NotRequired[float | None]
+    address: NotRequired[str]
+    token_id: NotRequired[str | None]
+    wallet_address: NotRequired[str]
+    chain_id: NotRequired[int]
 
 
 class WalletClient(WayfinderClient):
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
+    def __init__(self):
+        super().__init__()
         self.api_base_url = get_api_base_url()
-        self._auth_client = AuthClient(api_key=api_key)
 
-    async def get_token_balance_for_wallet(
+    async def get_token_balance_for_address(
         self,
         *,
-        token_id: str,
         wallet_address: str,
-        human_readable: bool = True,
-    ) -> TokenBalance:
+        query: str,
+        chain_id: int | None = None,
+    ) -> AddressBalance:
         """
-        Fetch a single token balance for an explicit wallet address.
+        Fetch a balance for a wallet address + chain + query.
 
-        Mirrors POST /api/v1/public/balances/token/
+        Args:
+            wallet_address: Wallet address
+            query: Token address, pool address, or equivalent identifier
+            chain_id: Chain ID (required)
         """
-        url = f"{self.api_base_url}/public/balances/token/"
-        payload = {
-            "token_id": token_id,
-            "wallet_address": wallet_address,
-            "human_readable": human_readable,
-        }
-        response = await self._authed_request("POST", url, json=payload)
-        data = response.json()
-        return data.get("data", data)
+        if chain_id is None:
+            raise ValueError("chain_id is required")
 
-    async def get_pool_balance_for_wallet(
-        self,
-        *,
-        pool_address: str,
-        chain_id: int,
-        user_address: str,
-        human_readable: bool = True,
-    ) -> PoolBalance:
-        """
-        Fetch a wallet's LP/share balance for a given pool address and chain.
-
-        Mirrors POST /api/v1/public/balances/pool/
-        """
-        url = f"{self.api_base_url}/public/balances/pool/"
-        payload = {
-            "pool_address": pool_address,
+        url = f"{self.api_base_url}/v1/blockchain/balances/address/"
+        params = {
+            "wallet_address": wallet_address,
             "chain_id": chain_id,
-            "user_address": user_address,
-            "human_readable": human_readable,
+            "query": query,
         }
-        response = await self._authed_request("POST", url, json=payload)
-        data = response.json()
-        return data.get("data", data)
+        response = await self._authed_request("GET", url, params=params)
+        return response.json()

wayfinder_paths/core/clients/WayfinderClient.py

@@ -1,5 +1,4 @@
 import json
-import os
 import time
 from typing import Any
 
@@ -11,13 +10,11 @@ from wayfinder_paths.core.constants.base import DEFAULT_HTTP_TIMEOUT
 
 
 class WayfinderClient:
-    def __init__(self, api_key: str | None = None):
+    def __init__(self):
         """
         Initialize WayfinderClient.
 
-        Args:
-            api_key: Optional API key for service account authentication.
-                    If provided, uses API key auth. Otherwise falls back to config.json.
+        API key is loaded from system.api_key in config.json.
         """
         self.api_base_url = f"{get_api_base_url()}/"
         timeout = httpx.Timeout(DEFAULT_HTTP_TIMEOUT)
@@ -27,153 +24,51 @@ class WayfinderClient:
             "Content-Type": "application/json",
         }
 
-        self._api_key: str | None = api_key
-        self._access_token: str | None = None
-        self._refresh_token: str | None = None
-
-    def set_bearer_token(self, token: str) -> None:
-        """
-        Set runtime OAuth/JWT Bearer token for Wayfinder services.
-        """
-        self.headers["Authorization"] = f"Bearer {token}"
-        self._access_token = token
-
-    def set_tokens(self, access: str | None, refresh: str | None) -> None:
-        """Set both access and refresh tokens and configure Authorization header."""
-        if access:
-            self.set_bearer_token(access)
-        if refresh:
-            self._refresh_token = refresh
-
     def clear_auth(self) -> None:
-        """Clear Authorization headers (useful for logout or auth mode switch)."""
-        self.headers.pop("Authorization", None)
-
-    async def _refresh_access_token(self) -> bool:
-        """Attempt to refresh access token using stored refresh token."""
-        if not self._refresh_token:
-            logger.debug("No refresh token available")
-            return False
-        try:
-            logger.info("Attempting to refresh access token")
-            start_time = time.time()
-            url = f"{get_api_base_url()}/auth/token/refresh/"
-            payload = {"refresh": self._refresh_token}
-            response = await self.client.post(
-                url, json=payload, headers={"Content-Type": "application/json"}
-            )
-            if response.status_code != 200:
-                logger.warning(
-                    f"Token refresh failed with status {response.status_code}"
-                )
-                return False
-            data = response.json()
-            new_access = data.get("access") or data.get("access_token")
-            if not new_access:
-                logger.warning("No access token in refresh response")
-                return False
-            self.set_bearer_token(new_access)
-            elapsed = time.time() - start_time
-            logger.info(f"Access token refreshed successfully in {elapsed:.2f}s")
-            return True
-        except Exception as e:
-            elapsed = time.time() - start_time
-            logger.error(f"Token refresh failed after {elapsed:.2f}s: {e}")
-            return False
+        """Clear X-API-KEY header."""
+        self.headers.pop("X-API-KEY", None)
 
     def _load_config_credentials(self) -> dict[str, str | None]:
         """
-        Load credentials from config.json.
+        Load API key from config.json.
         Expected shape:
         {
-          "user": { "username": ..., "password": ..., "refresh_token": ..., "api_key": ... },
           "system": { "api_key": ... }
         }
         """
         try:
             with open("config.json") as f:
                 cfg = json.load(f)
-            user = cfg.get("user", {}) if isinstance(cfg, dict) else {}
             system = cfg.get("system", {}) if isinstance(cfg, dict) else {}
-            return {
-                "username": user.get("username"),
-                "password": user.get("password"),
-                "refresh_token": user.get("refresh_token"),
-                "api_key": user.get("api_key") or system.get("api_key"),
-            }
+            api_key = system.get("api_key")
+            return {"api_key": api_key}
         except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
             logger.debug(f"Could not load config file at config.json: {e}")
-            return {
-                "username": None,
-                "password": None,
-                "refresh_token": None,
-                "api_key": None,
-            }
+            return {"api_key": None}
         except Exception as e:
             logger.warning(f"Unexpected error loading config file at config.json: {e}")
-            return {
-                "username": None,
-                "password": None,
-                "refresh_token": None,
-                "api_key": None,
-            }
+            return {"api_key": None}
 
-    async def _ensure_bearer_token(self) -> bool:
+    def _ensure_api_key(self) -> bool:
         """
-        Ensure Authorization header is set. Priority: existing header > constructor api_key > config.json api_key > config.json tokens > username/password.
-        Raises PermissionError if no credentials found.
+        Ensure X-API-KEY header is set from system.api_key in config.json.
+        Raises PermissionError if no API key found.
         """
-        if self.headers.get("Authorization"):
+        if self.headers.get("X-API-KEY"):
             return True
 
-        # Check for API key: constructor > config.json
-        api_key = self._api_key
-        if not api_key:
-            creds = self._load_config_credentials()
-            api_key = creds.get("api_key") or os.getenv("WAYFINDER_API_KEY")
+        creds = self._load_config_credentials()
+        api_key = creds.get("api_key")
 
         if api_key:
             api_key = api_key.strip() if isinstance(api_key, str) else api_key
             if not api_key:
                 raise ValueError("API key cannot be empty")
-            self.headers["Authorization"] = f"Bearer {api_key}"
+            self.headers["X-API-KEY"] = api_key
             return True
 
-        # Fall back to OAuth token-based auth
-        creds = self._load_config_credentials()
-        refresh = creds.get("refresh_token")
-
-        if refresh:
-            self._refresh_token = refresh
-            refreshed = await self._refresh_access_token()
-            if refreshed:
-                return True
-
-        username = creds.get("username")
-        password = creds.get("password")
-
-        if username and password:
-            try:
-                url = f"{get_api_base_url()}/auth/token/"
-                payload = {"username": username, "password": password}
-                response = await self.client.post(
-                    url,
-                    json=payload,
-                    headers={"Content-Type": "application/json"},
-                )
-                if response.status_code == 200:
-                    data = response.json()
-                    access = data.get("access") or data.get("access_token")
-                    refresh = data.get("refresh") or data.get("refresh_token")
-                self.set_tokens(access, refresh)
-                return bool(access)
-            except Exception as e:
-                logger.debug(f"Failed to authenticate with username/password: {e}")
-                pass
-
         raise PermissionError(
-            "Not authenticated: provide api_key (via constructor or config.json) for service account auth, "
-            "or username+password/refresh_token in config.json for personal access"
+            "Not authenticated: provide api_key in system.api_key in config.json"
         )
 
     async def _request(
@@ -182,49 +77,32 @@ class WayfinderClient:
         url: str,
         *,
         headers: dict[str, str] | None = None,
-        retry_on_401: bool = True,
+        retry_on_401: bool = False,
         **kwargs: Any,
     ) -> httpx.Response:
         """
-        Wrapper around httpx that injects headers and auto-refreshes tokens on 401 once.
-        Ensures API key or bearer token is set in headers when available (for service account auth and rate limits).
+        Wrapper around httpx that injects X-API-KEY header.
+        Ensures API key is set in headers when available (for authentication and rate limiting).
         """
         logger.debug(f"Making {method} request to {url}")
         start_time = time.time()
 
-        # Ensure API key or bearer token is set in headers if available and not already set
+        # Ensure API key is set in headers if available and not already set
         # This ensures API keys are passed to all endpoints (including public ones) for rate limiting
-        if not self.headers.get("Authorization"):
-            # Try to get API key from constructor or config
-            api_key = self._api_key
-            if not api_key:
-                creds = self._load_config_credentials()
-                api_key = creds.get("api_key") or os.getenv("WAYFINDER_API_KEY")
+        if not self.headers.get("X-API-KEY"):
+            creds = self._load_config_credentials()
+            api_key = creds.get("api_key")
 
             if api_key:
                 api_key = api_key.strip() if isinstance(api_key, str) else api_key
                 if api_key:
-                    self.headers["Authorization"] = f"Bearer {api_key}"
+                    self.headers["X-API-KEY"] = api_key
 
         merged_headers = dict(self.headers)
         if headers:
             merged_headers.update(headers)
         resp = await self.client.request(method, url, headers=merged_headers, **kwargs)
 
-        if resp.status_code == 401 and retry_on_401 and self._refresh_token:
-            logger.info("Received 401, attempting token refresh and retry")
-            refreshed = await self._refresh_access_token()
-            if refreshed:
-                merged_headers = dict(self.headers)
-                if headers:
-                    merged_headers.update(headers)
-                resp = await self.client.request(
-                    method, url, headers=merged_headers, **kwargs
-                )
-                logger.info("Retry after token refresh successful")
-            else:
-                logger.error("Token refresh failed, request will fail")
-
         elapsed = time.time() - start_time
         if resp.status_code >= 400:
             logger.warning(
@@ -247,17 +125,7 @@ class WayfinderClient:
         **kwargs: Any,
     ) -> httpx.Response:
         """
-        Ensure Authorization (via env/config creds) and perform the request.
-        Retries once on 401 by re-acquiring tokens.
+        Ensure X-API-KEY header is set (from system.api_key in config.json) and perform the request.
         """
-        ok = await self._ensure_bearer_token()
-        if not ok:
-            raise PermissionError("Not authenticated: set env tokens or credentials")
-        try:
-            return await self._request(method, url, headers=headers, **kwargs)
-        except httpx.HTTPStatusError as e:
-            if e.response is not None and e.response.status_code == 401:
-                # Retry after attempting re-acquire/refresh
-                await self._ensure_bearer_token()
-                return await self._request(method, url, headers=headers, **kwargs)
-            raise
+        self._ensure_api_key()
+        return await self._request(method, url, headers=headers, **kwargs)

wayfinder_paths/core/clients/__init__.py

@@ -2,7 +2,6 @@
 Core client modules for API communication
 """
 
-from wayfinder_paths.core.clients.AuthClient import AuthClient
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.ClientManager import ClientManager
 from wayfinder_paths.core.clients.HyperlendClient import HyperlendClient
@@ -23,7 +22,6 @@ from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 __all__ = [
     "WayfinderClient",
     "ClientManager",
-    "AuthClient",
     "TokenClient",
     "WalletClient",
     "LedgerClient",