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

wayfinder_paths/core/clients/PoolClient.py

@@ -1,76 +1,150 @@
-"""
-Pool Client
-Provides read-only access to pool metadata and analytics via public endpoints.
-"""
+"""Read-only pool metadata and analytics via public endpoints."""
 
 from __future__ import annotations
 
-from typing import Any, NotRequired, Required, TypedDict
+from typing import Any, 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 PoolData(TypedDict):
-    """Individual pool data structure"""
-
-    id: Required[str]
-    name: Required[str]
-    symbol: Required[str]
-    address: Required[str]
-    chain_id: Required[int]
-    chain_code: Required[str]
-    apy: NotRequired[float]
-    tvl: NotRequired[float]
-    apy: NotRequired[float | None]
-    tvlUsd: NotRequired[float | None]
-    stablecoin: NotRequired[bool | None]
-    ilRisk: NotRequired[str | None]
-    network: NotRequired[str | None]
+class PoolPredictions(TypedDict, total=False):
+    predictedClass: str | None
+    predictedProbability: int | None
+    binnedConfidence: int | None
+
+
+class PoolData(TypedDict, total=False):
+    pool: str
+    timestamp: str
+    project: str
+    chain: str
+    symbol: str
+    poolMeta: str | None
+    underlyingTokens: list[str]
+    rewardTokens: list[str] | None
+    tvlUsd: float
+    apy: float
+    apyBase: float
+    apyReward: float | None
+    il7d: float | None
+    apyBase7d: float | None
+    volumeUsd1d: float | None
+    volumeUsd7d: float | None
+    apyBaseInception: float | None
+    url: str
+    apyPct1D: float
+    apyPct7D: float
+    apyPct30D: float
+    apyMean30d: float
+    stablecoin: bool
+    ilRisk: str
+    exposure: str
+    count: int
+    apyMeanExpanding: float
+    apyStdExpanding: float
+    mu: float
+    sigma: float
+    outlier: bool
+    project_factorized: int
+    chain_factorized: int
+    predictions: PoolPredictions
+    pool_old: str
+    pool_old_addr: str
+    pool_old_chain: str
+    apy_pct: float
+    kind: str
+    source: str
+    underlying_apy_pct: float | None
+    combined_apy_pct: float
+    id: str
+    address: str
+    network: str
+    chain_code: str
 
 
 class PoolList(TypedDict):
-    """Pool list response structure"""
-
     pools: Required[list[PoolData]]
-    total: NotRequired[int | None]
 
 
-class LlamaMatch(TypedDict):
-    """Llama match data structure"""
-
-    id: Required[str]
-    apy: Required[float]
-    tvlUsd: Required[float]
-    stablecoin: Required[bool]
-    ilRisk: Required[str]
-    network: Required[str]
+class LlamaMatchesResponse(TypedDict):
+    matches: Required[list[PoolData]]
+
+
+def _normalize_pool(raw: dict[str, Any]) -> dict[str, Any]:
+    out = dict(raw)
+    pool_id_val = out.get("pool")
+    if pool_id_val is not None:
+        if "id" not in out:
+            out["id"] = pool_id_val
+        if "token_id" not in out:
+            out["token_id"] = pool_id_val
+        if "pool_id" not in out:
+            out["pool_id"] = pool_id_val
+    if "address" not in out and "pool_old_addr" in out:
+        out["address"] = out["pool_old_addr"]
+    chain_val = out.get("pool_old_chain") or out.get("chain")
+    if chain_val is not None:
+        chain_lower = (
+            chain_val.lower() if isinstance(chain_val, str) else str(chain_val)
+        )
+        if "network" not in out:
+            out["network"] = chain_lower
+        if "chain_code" not in out:
+            out["chain_code"] = chain_lower
+    return out
 
 
 class PoolClient(WayfinderClient):
-    """Client for pool-related read operations"""
+    def __init__(self):
+        super().__init__()
+        self.api_base_url = get_api_base_url()
 
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
-        self.api_base_url = f"{get_api_base_url()}"
-        self._auth_client: AuthClient | None = AuthClient(api_key=api_key)
+    def _pools_url(self) -> str:
+        return f"{self.api_base_url}/v1/blockchain/pools/"
 
-    async def get_pools(self) -> dict[str, LlamaMatch]:
-        url = f"{self.api_base_url}/pools/"
-        response = await self._request("GET", url, headers={})
+    async def get_pools(
+        self,
+        *,
+        chain_id: int | None = None,
+        project: str | None = None,
+    ) -> LlamaMatchesResponse:
+        url = self._pools_url()
+        params: dict[str, Any] = {}
+        if chain_id is not None:
+            params["chain_id"] = chain_id
+        if project is not None:
+            params["project"] = project
+        response = await self._request("GET", url, params=params, headers={})
         response.raise_for_status()
         data = response.json()
-        return data.get("data", data)
+        if isinstance(data, list):
+            data = [_normalize_pool(p) for p in data]
+            return {"matches": data}
+        inner = data.get("data", data)
+        if isinstance(inner, list):
+            return {"matches": [_normalize_pool(p) for p in inner]}
+        return {"matches": inner.get("matches", [])}
 
     async def get_pools_by_ids(
         self,
         *,
-        pool_ids: str,
+        pool_ids: list[str] | str,
     ) -> PoolList:
-        url = f"{self.api_base_url}/pools/"
-        params: dict[str, Any] = {"pool_ids": pool_ids}
-        response = await self._request("GET", url, params=params, headers={})
+        url = self._pools_url()
+        ids = (
+            pool_ids
+            if isinstance(pool_ids, list)
+            else [s.strip() for s in str(pool_ids).split(",") if s.strip()]
+        )
+        body: dict[str, Any] = {"pool_ids": ids}
+        response = await self._request("POST", url, json=body, headers={})
         response.raise_for_status()
         data = response.json()
-        return data.get("data", data)
+        if isinstance(data, list):
+            data = [_normalize_pool(p) for p in data]
+            return {"pools": data}
+        inner = data.get("data", data)
+        if isinstance(inner, list):
+            return {"pools": [_normalize_pool(p) for p in inner]}
+        return {"pools": inner.get("pools", [])}

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()