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

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.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 = get_api_base_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,

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: