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

wayfinder_paths/core/clients/HyperlendClient.py

@@ -1,97 +1,163 @@
 """
 Hyperlend Client
-Provides access to Hyperlend stable markets data via public endpoints.
+Provides access to Hyperlend stable markets data via blockchain endpoints.
 """
 
 from __future__ import annotations
 
-from typing import Any, NotRequired, Required, TypedDict
+from typing import Any, Required, TypedDict
 
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 from wayfinder_paths.core.config import get_api_base_url
 
 
-class StableMarket(TypedDict):
-    """Stable market data structure"""
-
-    chain_id: Required[int]
-    token_address: Required[str]
-    symbol: Required[str]
-    name: Required[str]
-    underlying_tokens: Required[float]
-    buffer_bps: Required[int]
-    min_buffer_tokens: Required[float]
-    is_stable_symbol: Required[bool]
-
-
 class AssetsView(TypedDict):
     """Assets view response structure"""
 
-    chain_id: Required[int]
-    user_address: Required[str]
-    assets: Required[list[dict[str, Any]]]
-    total_value: NotRequired[float | None]
+    block_number: Required[int]
+    user: Required[str]
+    native_balance_wei: Required[int]
+    native_balance: Required[float]
+    assets: Required[list[AssetInfo]]
+    account_data: Required[AccountData]
+    base_currency_info: Required[BaseCurrencyInfo]
 
 
 class MarketEntry(TypedDict):
     """Market entry data structure"""
 
-    chain_id: Required[int]
-    token_address: Required[str]
-    market_data: Required[dict[str, Any]]
+    symbol: Required[str]
+    symbol_canonical: Required[str]
+    display_symbol: Required[str]
+    reserve: Required[dict[str, Any]]
 
 
 class LendRateHistory(TypedDict):
     """Lend rate history response structure"""
 
-    chain_id: Required[int]
-    token_address: Required[str]
-    lookback_hours: Required[int]
-    rates: Required[list[dict[str, Any]]]
+    history: Required[list[RateHistoryEntry]]
+
+
+class MarketHeadroom(TypedDict):
+    """Market headroom data structure"""
+
+    symbol: Required[str]
+    symbol_canonical: Required[str]
+    display_symbol: Required[str]
+    reserve: Required[dict[str, Any]]
+    decimals: Required[int]
+    headroom: Required[int]
+    supply_cap: Required[int]
+
+
+class StableMarketsHeadroomResponse(TypedDict):
+    """Stable markets headroom response structure"""
+
+    markets: Required[dict[str, MarketHeadroom]]
+    notes: Required[list[str]]
+
+
+class RateHistoryEntry(TypedDict):
+    """Rate history entry data structure"""
+
+    timestamp_ms: Required[int]
+    timestamp: Required[float]
+    supply_apr: Required[float]
+    supply_apy: Required[float]
+    borrow_apr: Required[float]
+    borrow_apy: Required[float]
+    token: Required[str]
+    symbol: Required[str]
+    display_symbol: Required[str]
+
+
+class AssetInfo(TypedDict):
+    """Asset information structure"""
+
+    underlying: Required[str]
+    symbol: Required[str]
+    symbol_canonical: Required[str]
+    symbol_display: Required[str]
+    decimals: Required[int]
+    a_token: Required[str]
+    variable_debt_token: Required[str]
+    usage_as_collateral_enabled: Required[bool]
+    borrowing_enabled: Required[bool]
+    is_active: Required[bool]
+    is_frozen: Required[bool]
+    is_paused: Required[bool]
+    is_siloed_borrowing: Required[bool]
+    is_stablecoin: Required[bool]
+    underlying_wallet_balance: Required[float]
+    underlying_wallet_balance_wei: Required[int]
+    price_usd: Required[float]
+    supply: Required[float]
+    variable_borrow: Required[float]
+    supply_usd: Required[float]
+    variable_borrow_usd: Required[float]
+    supply_apr: Required[float]
+    supply_apy: Required[float]
+    variable_borrow_apr: Required[float]
+    variable_borrow_apy: Required[float]
+
+
+class AccountData(TypedDict):
+    """Account data structure"""
+
+    total_collateral_base: Required[int | float]
+    total_debt_base: Required[int | float]
+    available_borrows_base: Required[int | float]
+    current_liquidation_threshold: Required[int | float]
+    ltv: Required[int | float]
+    health_factor_wad: Required[int]
+    health_factor: Required[float]
+
+
+class BaseCurrencyInfo(TypedDict):
+    """Base currency information structure"""
+
+    marketReferenceCurrencyUnit: Required[int]
+    marketReferenceCurrencyPriceInUsd: Required[int]
+    networkBaseTokenPriceInUsd: Required[int]
+    networkBaseTokenPriceDecimals: Required[int]
 
 
 class HyperlendClient(WayfinderClient):
     """Client for Hyperlend-related operations"""
 
-    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()
 
     async def get_stable_markets(
         self,
         *,
-        chain_id: int,
         required_underlying_tokens: float | None = None,
         buffer_bps: int | None = None,
         min_buffer_tokens: float | None = None,
-        is_stable_symbol: bool | None = None,
-    ) -> list[StableMarket]:
+    ) -> StableMarketsHeadroomResponse:
         """
-        Fetch stable markets from Hyperlend.
+        Fetch stable markets headroom from Hyperlend.
 
         Args:
-            chain_id: Chain ID to query markets for
             required_underlying_tokens: Required underlying tokens amount
             buffer_bps: Buffer in basis points
             min_buffer_tokens: Minimum buffer in tokens
-            is_stable_symbol: Filter by stable symbol (optional)
 
         Example:
-            GET /api/v1/public/hyperlend/stable-markets/?chain_id=999&required_underlying_tokens=1000.0&buffer_bps=100&min_buffer_tokens=100.0&is_stable_symbol=true
+            GET /api/v1/blockchain/hyperlend/stable_markets_headroom/?required_underlying_tokens=1000&buffer_bps=50&min_buffer_tokens=100
 
         Returns:
-            Dictionary containing stable markets data
+            Dictionary containing stable markets headroom data with markets and notes
         """
-        url = f"{self.api_base_url}/public/hyperlend/stable-markets/"
-        params: dict[str, Any] = {"chain_id": chain_id}
+        url = f"{self.api_base_url}/v1/blockchain/hyperlend/stable_markets_headroom/"
+        params: dict[str, Any] = {}
         if required_underlying_tokens is not None:
             params["required_underlying_tokens"] = required_underlying_tokens
         if buffer_bps is not None:
             params["buffer_bps"] = buffer_bps
         if min_buffer_tokens is not None:
             params["min_buffer_tokens"] = min_buffer_tokens
-        if is_stable_symbol is not None:
-            params["is_stable_symbol"] = "true" if is_stable_symbol else "false"
 
         response = await self._authed_request("GET", url, params=params, headers={})
         response.raise_for_status()
@@ -101,25 +167,22 @@ class HyperlendClient(WayfinderClient):
     async def get_assets_view(
         self,
         *,
-        chain_id: int,
         user_address: str,
     ) -> AssetsView:
         """
         Fetch assets view for a user address from Hyperlend.
 
         Args:
-            chain_id: Chain ID to query assets for
             user_address: User wallet address to query assets for
 
         Example:
-            GET /api/v1/public/hyperlend/assets-view/?chain_id=999&user_address=0x0c737cB5934afCb5B01965141F865F795B324080
+            GET /api/v1/blockchain/hyperlend/assets/?user_address=0x0c737cB5934afCb5B01965141F865F795B324080
 
         Returns:
-            Dictionary containing assets view data
+            Dictionary containing assets view data with account information and base currency info
         """
-        url = f"{self.api_base_url}/public/hyperlend/assets-view/"
+        url = f"{self.api_base_url}/v1/blockchain/hyperlend/assets/"
         params: dict[str, Any] = {
-            "chain_id": chain_id,
             "user_address": user_address,
         }
 
@@ -131,26 +194,23 @@ class HyperlendClient(WayfinderClient):
     async def get_market_entry(
         self,
         *,
-        chain_id: int,
-        token_address: str,
+        token: str,
     ) -> MarketEntry:
         """
         Fetch market entry from Hyperlend.
 
         Args:
-            chain_id: Chain ID to query market for
-            token_address: Token address to query market for
+            token: Token address to query market for
 
         Example:
-            GET /api/v1/public/hyperlend/market-entry/?chain_id=999&token_address=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
+            GET /api/v1/blockchain/hyperlend/market_entry/?token=0x5555555555555555555555555555555555555555
 
         Returns:
-            Dictionary containing market entry data
+            Dictionary containing market entry data with symbol and reserve information
         """
-        url = f"{self.api_base_url}/public/hyperlend/market-entry/"
+        url = f"{self.api_base_url}/v1/blockchain/hyperlend/market_entry/"
         params: dict[str, Any] = {
-            "chain_id": chain_id,
-            "token_address": token_address,
+            "token": token,
         }
 
         response = await self._authed_request("GET", url, params=params, headers={})
@@ -161,30 +221,31 @@ class HyperlendClient(WayfinderClient):
     async def get_lend_rate_history(
         self,
         *,
-        chain_id: int,
-        token_address: str,
+        token: str,
         lookback_hours: int,
+        force_refresh: bool | None = None,
     ) -> LendRateHistory:
         """
         Fetch lend rate history from Hyperlend.
 
         Args:
-            chain_id: Chain ID to query rate history for
-            token_address: Token address to query rate history for
+            token: Token address to query rate history for
             lookback_hours: Number of hours to look back for rate history
+            force_refresh: Whether to force refresh the data (optional)
 
         Example:
-            GET /api/v1/public/hyperlend/lend-rate-history/?chain_id=999&token_address=0x5555555555555555555555555555555555555555&lookback_hours=24
+            GET /api/v1/blockchain/hyperlend/lend_rate_history/?token=0x5555555555555555555555555555555555555555&lookback_hours=24&force_refresh=false
 
         Returns:
-            Dictionary containing lend rate history data
+            Dictionary containing lend rate history data with history array
         """
-        url = f"{self.api_base_url}/public/hyperlend/lend-rate-history/"
+        url = f"{self.api_base_url}/v1/blockchain/hyperlend/lend_rate_history/"
         params: dict[str, Any] = {
-            "chain_id": chain_id,
-            "token_address": token_address,
+            "token": token,
             "lookback_hours": lookback_hours,
         }
+        if force_refresh is not None:
+            params["force_refresh"] = "true" if force_refresh else "false"
 
         response = await self._authed_request("GET", url, params=params, headers={})
         response.raise_for_status()

wayfinder_paths/core/clients/LedgerClient.py

@@ -63,14 +63,11 @@ class LedgerClient:
     - POST record snapshot
     """
 
-    def __init__(
-        self, api_key: str | None = None, ledger_dir: Path | str | None = None
-    ) -> None:
+    def __init__(self, ledger_dir: Path | str | None = None) -> None:
         """
         Initialize the ledger client.
 
         Args:
-            api_key: Unused, kept for backward compatibility
             ledger_dir: Directory to store ledger JSON files. Defaults to .ledger in project root
         """
         if ledger_dir is None:

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", [])}