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

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",

wayfinder_paths/core/clients/protocols.py

@@ -4,7 +4,7 @@ Protocol definitions for API clients.
 These protocols define the interface that all client implementations must satisfy.
 When used as an SDK, users can provide custom implementations that match these protocols.
 
-Note: AuthClient is excluded as SDK users handle their own authentication.
+Note: Authentication is handled via X-API-KEY header in WayfinderClient base class.
 """
 
 from __future__ import annotations
@@ -12,19 +12,19 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Protocol
 
 if TYPE_CHECKING:
-    from wayfinder_paths.core.clients.BRAPClient import BRAPQuote
+    from wayfinder_paths.core.clients.BRAPClient import BRAPQuoteResponse
     from wayfinder_paths.core.clients.HyperlendClient import (
         AssetsView,
         LendRateHistory,
         MarketEntry,
-        StableMarket,
+        StableMarketsHeadroomResponse,
     )
     from wayfinder_paths.core.clients.LedgerClient import (
         StrategyTransactionList,
         TransactionRecord,
     )
     from wayfinder_paths.core.clients.PoolClient import (
-        LlamaMatch,
+        LlamaMatchesResponse,
         PoolList,
     )
     from wayfinder_paths.core.clients.TokenClient import (
@@ -32,8 +32,7 @@ if TYPE_CHECKING:
         TokenDetails,
     )
     from wayfinder_paths.core.clients.WalletClient import (
-        PoolBalance,
-        TokenBalance,
+        AddressBalance,
     )
 
 
@@ -41,7 +40,10 @@ class TokenClientProtocol(Protocol):
     """Protocol for token-related operations"""
 
     async def get_token_details(
-        self, token_id: str, force_refresh: bool = False
+        self,
+        query: str,
+        market_data: bool = True,
+        chain_id: int | None = None,
     ) -> TokenDetails:
         """Get token data including price from the token-details endpoint"""
         ...
@@ -57,19 +59,16 @@ class HyperlendClientProtocol(Protocol):
     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]:
-        """Fetch stable markets from Hyperlend"""
+    ) -> StableMarketsHeadroomResponse:
+        """Fetch stable markets headroom from Hyperlend"""
         ...
 
     async def get_assets_view(
         self,
         *,
-        chain_id: int,
         user_address: str,
     ) -> AssetsView:
         """Fetch assets view for a user address from Hyperlend"""
@@ -78,8 +77,7 @@ class HyperlendClientProtocol(Protocol):
     async def get_market_entry(
         self,
         *,
-        chain_id: int,
-        token_address: str,
+        token: str,
     ) -> MarketEntry:
         """Fetch market entry from Hyperlend"""
         ...
@@ -87,9 +85,9 @@ class HyperlendClientProtocol(Protocol):
     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"""
         ...
@@ -161,25 +159,14 @@ class LedgerClientProtocol(Protocol):
 class WalletClientProtocol(Protocol):
     """Protocol for wallet-related operations"""
 
-    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:
-        """Fetch a single token balance for an explicit wallet address"""
-        ...
-
-    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"""
+        query: str,
+        chain_id: int | None = None,
+    ) -> AddressBalance:
+        """Fetch a balance for an address + chain + query (supports compound query formats)"""
         ...
 
 
@@ -189,13 +176,18 @@ class PoolClientProtocol(Protocol):
     async def get_pools_by_ids(
         self,
         *,
-        pool_ids: str,
+        pool_ids: list[str] | str,
     ) -> PoolList:
-        """Fetch pools by comma-separated pool ids"""
+        """Fetch pools by pool IDs (list or comma-separated string)"""
         ...
 
-    async def get_pools(self) -> dict[str, LlamaMatch]:
-        """Fetch Llama matches for pools"""
+    async def get_pools(
+        self,
+        *,
+        chain_id: int | None = None,
+        project: str | None = None,
+    ) -> LlamaMatchesResponse:
+        """Fetch pools (optionally filtered by chain_id and project)"""
         ...
 
 
@@ -205,16 +197,13 @@ class BRAPClientProtocol(Protocol):
     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:
         """Get a quote for a bridge/swap operation"""
         ...
 

wayfinder_paths/core/clients/sdk_example.py

@@ -38,59 +38,74 @@ class MockHyperlendClient:
     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,
     ) -> dict[str, Any]:
         return {
-            "markets": [
-                {
-                    "chain_id": chain_id,
-                    "token_address": "0xMockToken",
+            "markets": {
+                "0xMockToken": {
                     "symbol": "USDC",
-                    "lend_rate": 0.05,
-                    "available_liquidity": 1000000.0,
+                    "symbol_canonical": "usdc",
+                    "display_symbol": "USDC",
+                    "reserve": {},
+                    "decimals": 6,
+                    "headroom": 1000000000000,
+                    "supply_cap": 5000000000000,
                 }
-            ]
+            },
+            "notes": [],
         }
 
     async def get_assets_view(
         self,
         *,
-        chain_id: int,
         user_address: str,
     ) -> dict[str, Any]:
         return {
-            "user_address": user_address,
-            "chain_id": chain_id,
+            "block_number": 12345,
+            "user": user_address,
+            "native_balance_wei": 0,
+            "native_balance": 0.0,
             "assets": [],
+            "account_data": {
+                "total_collateral_base": 0,
+                "total_debt_base": 0,
+                "available_borrows_base": 0,
+                "current_liquidation_threshold": 0,
+                "ltv": 0,
+                "health_factor_wad": 0,
+                "health_factor": 0.0,
+            },
+            "base_currency_info": {
+                "marketReferenceCurrencyUnit": 100000000,
+                "marketReferenceCurrencyPriceInUsd": 100000000,
+                "networkBaseTokenPriceInUsd": 0,
+                "networkBaseTokenPriceDecimals": 8,
+            },
         }
 
     async def get_market_entry(
         self,
         *,
-        chain_id: int,
-        token_address: str,
+        token: str,
     ) -> dict[str, Any]:
         return {
-            "chain_id": chain_id,
-            "token_address": token_address,
-            "market_data": {},
+            "symbol": "USDC",
+            "symbol_canonical": "usdc",
+            "display_symbol": "USDC",
+            "reserve": {},
         }
 
     async def get_lend_rate_history(
         self,
         *,
-        chain_id: int,
-        token_address: str,
+        token: str,
         lookback_hours: int,
+        force_refresh: bool | None = None,
     ) -> dict[str, Any]:
         return {
-            "chain_id": chain_id,
-            "token_address": token_address,
-            "rates": [],
+            "history": [],
         }
 
 

wayfinder_paths/core/engine/StrategyJob.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from typing import Any
 
 from loguru import logger
@@ -16,7 +15,6 @@ class StrategyJob:
         config: StrategyJobConfig,
         clients: dict[str, Any] | None = None,
         skip_auth: bool = False,
-        api_key: str | None = None,
     ):
         """
         Initialize a StrategyJob.
@@ -26,16 +24,12 @@ class StrategyJob:
             config: Strategy job configuration.
             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.
-                If provided, will be passed to ClientManager and strategy.
         """
         self.strategy = strategy
         self.config = config
 
         self.job_id = strategy.name or "unknown"
-        self.clients = ClientManager(
-            clients=clients, skip_auth=skip_auth, api_key=api_key
-        )
+        self.clients = ClientManager(clients=clients, skip_auth=skip_auth)
 
     def _setup_strategy(self):
         """Setup the strategy instance"""
@@ -44,23 +38,6 @@ class StrategyJob:
 
         self.strategy.log = self.log
 
-    def _is_using_api_key(self) -> bool:
-        """Check if API key authentication is being used."""
-        if self.clients._api_key:
-            return True
-
-        if self.clients.auth:
-            try:
-                creds = self.clients.auth._load_config_credentials()
-                if creds.get("api_key"):
-                    return True
-                if os.getenv("WAYFINDER_API_KEY"):
-                    return True
-            except Exception:
-                pass
-
-        return False
-
     async def setup(self):
         """
         Initialize the strategy job and strategy.
@@ -69,38 +46,13 @@ class StrategyJob:
         """
         self._setup_strategy()
 
-        # Ensure auth token is set for API calls
+        # Ensure API key is set for API calls
+        # All clients inherit from WayfinderClient and have _ensure_api_key()
         if not self.clients._skip_auth:
-            is_api_key_auth = self._is_using_api_key()
-
-            if is_api_key_auth:
-                logger.debug("Using API key authentication")
-                if self.clients.auth:
-                    await self.clients.auth._ensure_bearer_token()
-            else:
-                # Try to ensure bearer token is set, authenticate if needed
-                try:
-                    if self.clients.auth:
-                        await self.clients.auth._ensure_bearer_token()
-                except (PermissionError, Exception) as e:
-                    if not isinstance(e, PermissionError):
-                        logger.warning(
-                            f"Authentication failed: {e}, trying OAuth fallback"
-                        )
-                    username = self.config.user.username
-                    password = self.config.user.password
-                    refresh_token = self.config.user.refresh_token
-                    if refresh_token or (username and password):
-                        await self.clients.authenticate(
-                            username=username,
-                            password=password,
-                            refresh_token=refresh_token,
-                        )
-                    else:
-                        raise ValueError(
-                            "Authentication required: provide api_key parameter for service account auth, "
-                            "or username+password/refresh_token in config.json for personal access"
-                        ) from e
+            # Ensure API key on any client (they all share the same method)
+            token_client = self.clients.token
+            if token_client:
+                token_client._ensure_api_key()
 
         existing_cfg = dict(getattr(self.strategy, "config", {}) or {})
         strategy_cfg = dict(self.config.strategy_config or {})

wayfinder_paths/core/services/local_evm_txn.py

@@ -155,13 +155,13 @@ class LocalEvmTxn(EvmTxn):
             gas_price = await self._get_gas_price(w3)
 
             transaction["gasPrice"] = int(gas_price * SUGGESTED_GAS_PRICE_MULTIPLIER)
-        elif chain_id == 999:
-            big_block_gas_price = await w3.hype.big_block_gas_price()
+        # elif chain_id == 999:
+        #     big_block_gas_price = await w3.hype.big_block_gas_price()
 
-            transaction["maxFeePerGas"] = int(
-                big_block_gas_price * SUGGESTED_PRIORITY_FEE_MULTIPLIER
-            )
-            transaction["maxPriorityFeePerGas"] = 0
+        #     transaction["maxFeePerGas"] = int(
+        #         big_block_gas_price * SUGGESTED_PRIORITY_FEE_MULTIPLIER
+        #     )
+        #     transaction["maxPriorityFeePerGas"] = 0
         else:
             base_fee = await self._get_base_fee(w3)
             priority_fee = await self._get_priority_fee(w3)