wayfinder-paths 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -69,77 +69,6 @@ class TestPoolAdapter:
         assert success is True
         assert data == mock_response
 
-    @pytest.mark.asyncio
-    async def test_find_high_yield_pools_success(self, adapter, mock_pool_client):
-        """Test successful high yield pool discovery"""
-        mock_llama_response = {
-            "matches": [
-                {
-                    "pool_id": "pool-123",
-                    "llama_apy_pct": 5.2,
-                    "llama_tvl_usd": 1000000,
-                    "llama_stablecoin": True,
-                    "network": "base",
-                },
-                {
-                    "pool_id": "pool-456",
-                    "llama_apy_pct": 2.0,
-                    "llama_tvl_usd": 500000,
-                    "llama_stablecoin": True,
-                    "network": "ethereum",
-                },
-                {
-                    "pool_id": "pool-789",
-                    "llama_apy_pct": 6.0,
-                    "llama_tvl_usd": 2000000,
-                    "llama_stablecoin": False,
-                    "network": "base",
-                },
-            ]
-        }
-        mock_pool_client.get_llama_matches = AsyncMock(return_value=mock_llama_response)
-
-        success, data = await adapter.find_high_yield_pools(
-            min_apy=0.03, min_tvl=500000, stablecoin_only=True, network_codes=["base"]
-        )
-
-        assert success is True
-        assert len(data["pools"]) == 1  # Only pool-123 meets criteria
-        assert (
-            data["pools"][0].get("pool_id") == "pool-123"
-            or data["pools"][0].get("id") == "pool-123"
-        )
-        assert data["total_found"] == 1
-        assert data["filters_applied"]["min_apy"] == 0.03
-        assert data["filters_applied"]["stablecoin_only"] is True
-
-    @pytest.mark.asyncio
-    async def test_get_pool_analytics_success(self, adapter, mock_pool_client):
-        """Test successful pool analytics generation"""
-        mock_pool_data = {
-            "pools": [
-                {"id": "pool-123", "name": "USDC/USDT Pool", "symbol": "USDC-USDT"}
-            ]
-        }
-        mock_pool_client.get_pools_by_ids = AsyncMock(return_value=mock_pool_data)
-
-        mock_llama_data = {
-            "pool-123": {
-                "llama_apy_pct": 5.2,
-                "llama_combined_apy_pct": 5.2,
-                "llama_tvl_usd": 1000000,
-            }
-        }
-        mock_pool_client.get_llama_reports = AsyncMock(return_value=mock_llama_data)
-
-        success, data = await adapter.get_pool_analytics(["pool-123"])
-
-        assert success is True
-        assert len(data["analytics"]) == 1
-        assert data["analytics"][0]["pool"]["id"] == "pool-123"
-        assert round(data["analytics"][0]["combined_apy"], 6) == round(0.052, 6)
-        assert data["analytics"][0]["tvl_usd"] == 1000000
-
     @pytest.mark.asyncio
     async def test_get_pools_by_ids_failure(self, adapter, mock_pool_client):
         """Test pool retrieval failure"""
@@ -152,21 +81,6 @@ class TestPoolAdapter:
         assert success is False
         assert "API Error" in data
 
-    @pytest.mark.asyncio
-    async def test_find_high_yield_pools_no_matches(self, adapter, mock_pool_client):
-        """Test high yield pool discovery with no matches"""
-        mock_llama_response = {"matches": []}
-        mock_pool_client.get_llama_matches.return_value = mock_llama_response
-
-        success, data = await adapter.find_high_yield_pools(
-            min_apy=0.10,
-            min_tvl=10000000,
-        )
-
-        assert success is True
-        assert len(data["pools"]) == 0
-        assert data["total_found"] == 0
-
     def test_adapter_type(self, adapter):
         """Test adapter has adapter_type"""
         assert adapter.adapter_type == "POOL"

wayfinder_paths/adapters/token_adapter/README.md

@@ -12,7 +12,7 @@ The adapter uses the TokenClient which automatically handles authentication and
 
 The TokenClient will automatically:
 - Use the WAYFINDER_API_URL from settings
-- Handle authentication via environment variables or config.json
+- Handle authentication via config.json
 - Manage token refresh and retry logic
 
 ## Usage

wayfinder_paths/core/clients/AuthClient.py

@@ -1,4 +1,3 @@
-import os
 from typing import Any
 
 from loguru import logger
@@ -30,8 +29,6 @@ class AuthClient(WayfinderClient):
             creds = self._load_config_credentials()
             if creds.get("api_key"):
                 return True
-            if os.getenv("WAYFINDER_API_KEY"):
-                return True
         except Exception:
             pass
 

wayfinder_paths/core/clients/ClientManager.py

@@ -15,14 +15,10 @@ from wayfinder_paths.core.clients.protocols import (
     HyperlendClientProtocol,
     LedgerClientProtocol,
     PoolClientProtocol,
-    SimulationClientProtocol,
     TokenClientProtocol,
-    TransactionClientProtocol,
     WalletClientProtocol,
 )
-from wayfinder_paths.core.clients.SimulationClient import SimulationClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.TransactionClient import TransactionClient
 from wayfinder_paths.core.clients.WalletClient import WalletClient
 
 
@@ -32,7 +28,7 @@ class ClientManager:
 
     Args:
         clients: Optional dict of pre-instantiated clients to inject directly.
-            Keys: 'token', 'hyperlend', 'ledger', 'wallet', 'transaction', 'pool', 'brap', 'simulation'.
+            Keys: 'token', 'hyperlend', 'ledger', 'wallet', 'transaction', 'pool', 'brap'.
             If not provided, defaults to HTTP-based clients.
         skip_auth: If True, skips authentication (for SDK usage).
     """
@@ -59,12 +55,10 @@ class ClientManager:
         self._auth_client: AuthClient | None = None
         self._token_client: TokenClientProtocol | None = None
         self._wallet_client: WalletClientProtocol | None = None
-        self._transaction_client: TransactionClientProtocol | None = None
         self._ledger_client: LedgerClientProtocol | None = None
         self._pool_client: PoolClientProtocol | None = None
         self._hyperlend_client: HyperlendClientProtocol | None = None
         self._brap_client: BRAPClientProtocol | None = None
-        self._simulation_client: SimulationClientProtocol | None = None
 
     def _get_or_create_client(
         self,
@@ -109,13 +103,6 @@ class ClientManager:
         """Get or create token client"""
         return self._get_or_create_client("_token_client", "token", TokenClient)
 
-    @property
-    def transaction(self) -> TransactionClientProtocol:
-        """Get or create transaction client"""
-        return self._get_or_create_client(
-            "_transaction_client", "transaction", TransactionClient
-        )
-
     @property
     def ledger(self) -> LedgerClientProtocol:
         """Get or create ledger client"""
@@ -143,13 +130,6 @@ class ClientManager:
         """Get or create BRAP client"""
         return self._get_or_create_client("_brap_client", "brap", BRAPClient)
 
-    @property
-    def simulation(self) -> SimulationClientProtocol:
-        """Get or create simulation client"""
-        return self._get_or_create_client(
-            "_simulation_client", "simulation", SimulationClient
-        )
-
     async def authenticate(
         self,
         username: str | None = None,
@@ -206,5 +186,4 @@ class ClientManager:
             "wallet": self._wallet_client,
             "hyperlend": self._hyperlend_client,
             "brap": self._brap_client,
-            "simulation": self._simulation_client,
         }

wayfinder_paths/core/clients/WalletClient.py

@@ -33,14 +33,6 @@ class PoolBalance(TypedDict):
     usd_value: NotRequired[float | None]
 
 
-class EnrichedBalances(TypedDict):
-    """Enriched token balances response structure"""
-
-    wallet_address: Required[str]
-    balances: Required[list[TokenBalance]]
-    total_usd_value: NotRequired[float | None]
-
-
 class WalletClient(WayfinderClient):
     def __init__(self, api_key: str | None = None):
         super().__init__(api_key=api_key)

wayfinder_paths/core/clients/WayfinderClient.py

@@ -121,17 +121,17 @@ class WayfinderClient:
 
     async def _ensure_bearer_token(self) -> bool:
         """
-        Ensure Authorization header is set. Priority: existing header > constructor api_key > config.json api_key > env api_key > config.json tokens > env tokens > username/password.
+        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.
         """
         if self.headers.get("Authorization"):
             return True
 
-        # Check for API key: constructor > config.json > environment
+        # 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")
+            api_key = creds.get("api_key")
 
         if api_key:
             api_key = api_key.strip() if isinstance(api_key, str) else api_key
@@ -142,12 +142,7 @@ class WayfinderClient:
 
         # Fall back to OAuth token-based auth
         creds = self._load_config_credentials()
-        access = os.getenv("WAYFINDER_ACCESS_TOKEN")
-        refresh = creds.get("refresh_token") or os.getenv("WAYFINDER_REFRESH_TOKEN")
-
-        if access:
-            self.set_tokens(access, refresh)
-            return True
+        refresh = creds.get("refresh_token")
 
         if refresh:
             self._refresh_token = refresh
@@ -155,8 +150,8 @@ class WayfinderClient:
             if refreshed:
                 return True
 
-        username = creds.get("username") or os.getenv("WAYFINDER_USERNAME")
-        password = creds.get("password") or os.getenv("WAYFINDER_PASSWORD")
+        username = creds.get("username")
+        password = creds.get("password")
 
         if username and password:
             try:
@@ -178,7 +173,7 @@ class WayfinderClient:
                 pass
 
         raise PermissionError(
-            "Not authenticated: provide api_key (via constructor, config.json, or WAYFINDER_API_KEY env var) for service account auth, "
+            "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"
         )
 
@@ -201,11 +196,11 @@ class WayfinderClient:
         # Ensure API key or bearer token 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, config, or env
+            # 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")
+                api_key = creds.get("api_key")
 
             if api_key:
                 api_key = api_key.strip() if isinstance(api_key, str) else api_key

wayfinder_paths/core/clients/__init__.py

@@ -13,14 +13,10 @@ from wayfinder_paths.core.clients.protocols import (
     HyperlendClientProtocol,
     LedgerClientProtocol,
     PoolClientProtocol,
-    SimulationClientProtocol,
     TokenClientProtocol,
-    TransactionClientProtocol,
     WalletClientProtocol,
 )
-from wayfinder_paths.core.clients.SimulationClient import SimulationClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.TransactionClient import TransactionClient
 from wayfinder_paths.core.clients.WalletClient import WalletClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 
@@ -30,19 +26,15 @@ __all__ = [
     "AuthClient",
     "TokenClient",
     "WalletClient",
-    "TransactionClient",
     "LedgerClient",
     "PoolClient",
     "BRAPClient",
-    "SimulationClient",
     "HyperlendClient",
     # Protocols for SDK usage
     "TokenClientProtocol",
     "HyperlendClientProtocol",
     "LedgerClientProtocol",
     "WalletClientProtocol",
-    "TransactionClientProtocol",
     "PoolClientProtocol",
     "BRAPClientProtocol",
-    "SimulationClientProtocol",
 ]

wayfinder_paths/core/clients/protocols.py

@@ -28,12 +28,10 @@ if TYPE_CHECKING:
         LlamaReport,
         PoolList,
     )
-    from wayfinder_paths.core.clients.SimulationClient import SimulationResult
     from wayfinder_paths.core.clients.TokenClient import (
         GasToken,
         TokenDetails,
     )
-    from wayfinder_paths.core.clients.TransactionClient import TransactionPayload
     from wayfinder_paths.core.clients.WalletClient import (
         PoolBalance,
         TokenBalance,
@@ -186,21 +184,6 @@ class WalletClientProtocol(Protocol):
         ...
 
 
-class TransactionClientProtocol(Protocol):
-    """Protocol for transaction operations"""
-
-    async def build_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: float,
-        chain_id: int,
-    ) -> TransactionPayload:
-        """Build a send transaction payload for EVM tokens/native transfers"""
-        ...
-
-
 class PoolClientProtocol(Protocol):
     """Protocol for pool-related read operations"""
 
@@ -242,49 +225,6 @@ class BRAPClientProtocol(Protocol):
         ...
 
 
-class SimulationClientProtocol(Protocol):
-    """Protocol for blockchain transaction simulations"""
-
-    async def simulate_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """Simulate sending native ETH or ERC20 tokens"""
-        ...
-
-    async def simulate_approve(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-        clear_approval_first: bool = False,
-    ) -> SimulationResult:
-        """Simulate ERC20 token approval"""
-        ...
-
-    async def simulate_swap(
-        self,
-        from_token_address: str,
-        to_token_address: str,
-        from_chain_id: int,
-        to_chain_id: int,
-        amount: str,
-        from_address: str,
-        slippage: float,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """Simulate token swap operation"""
-        ...
-
-
 class HyperliquidExecutorProtocol(Protocol):
     """Protocol for Hyperliquid order execution operations."""
 

wayfinder_paths/core/config.py

@@ -4,7 +4,6 @@ Separates user-provided configuration from system configuration
 """
 
 import json
-import os
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -72,12 +71,8 @@ class SystemConfig:
     These are values managed by the Wayfinder system
     """
 
-    # API endpoints (populated from environment or defaults)
-    api_base_url: str = field(
-        default_factory=lambda: os.getenv(
-            "WAYFINDER_API_URL", "https://api.wayfinder.ai"
-        )
-    )
+    # API endpoints (populated from config.json or defaults)
+    api_base_url: str = field(default="https://api.wayfinder.ai")
 
     # Job configuration
     job_id: str | None = None
@@ -102,10 +97,7 @@ class SystemConfig:
     def from_dict(cls, data: dict[str, Any]) -> "SystemConfig":
         """Create SystemConfig from dictionary"""
         return cls(
-            api_base_url=data.get(
-                "api_base_url",
-                os.getenv("WAYFINDER_API_URL", "https://api.wayfinder.ai"),
-            ),
+            api_base_url=data.get("api_base_url", "https://api.wayfinder.ai"),
             job_id=data.get("job_id"),
             job_type=data.get("job_type", "strategy"),
             update_interval=data.get("update_interval", 60),
@@ -113,10 +105,8 @@ class SystemConfig:
             retry_delay=data.get("retry_delay", 5),
             log_path=data.get("log_path"),
             data_path=data.get("data_path"),
-            wallets_path=data.get(
-                "wallets_path", os.getenv("WALLETS_PATH", "wallets.json")
-            ),
-            wallet_id=data.get("wallet_id") or os.getenv("WALLET_ID"),
+            wallets_path=data.get("wallets_path", "wallets.json"),
+            wallet_id=data.get("wallet_id"),
         )
 
     def to_dict(self) -> dict[str, Any]:
@@ -386,36 +376,6 @@ class StrategyJobConfig:
         return config
 
 
-def load_config_from_env() -> StrategyJobConfig:
-    """
-    Load configuration from environment variables
-    This is the simplest way for users to provide configuration
-    """
-    user_config = UserConfig(
-        username=os.getenv("WAYFINDER_USERNAME"),
-        password=os.getenv("WAYFINDER_PASSWORD"),
-        refresh_token=os.getenv("WAYFINDER_REFRESH_TOKEN"),
-        main_wallet_address=os.getenv("MAIN_WALLET_ADDRESS"),
-        strategy_wallet_address=os.getenv("STRATEGY_WALLET_ADDRESS"),
-        default_slippage=float(os.getenv("DEFAULT_SLIPPAGE", "0.005")),
-        gas_multiplier=float(os.getenv("GAS_MULTIPLIER", "1.2")),
-    )
-
-    system_config = SystemConfig(
-        api_base_url=os.getenv("WAYFINDER_API_URL", "https://api.wayfinder.ai"),
-        job_id=os.getenv("JOB_ID"),
-        update_interval=int(os.getenv("UPDATE_INTERVAL", "60")),
-        max_retries=int(os.getenv("MAX_RETRIES", "3")),
-        retry_delay=int(os.getenv("RETRY_DELAY", "5")),
-        wallets_path=os.getenv("WALLETS_PATH", "wallets.json"),
-        wallet_id=os.getenv("WALLET_ID"),
-    )
-
-    # No auto-population - wallets must be explicitly set in environment or matched by label
-
-    return StrategyJobConfig(user=user_config, system=system_config)
-
-
 # --- Internal helpers -------------------------------------------------------
 
 

wayfinder_paths/core/engine/StrategyJob.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from typing import Any
 
 from loguru import logger
@@ -54,8 +53,6 @@ class StrategyJob:
                 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
 

wayfinder_paths/core/services/base.py

@@ -50,55 +50,6 @@ class EvmTxn(ABC):
     transaction confirmations.
     """
 
-    @abstractmethod
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address.
-
-        Args:
-            address: Address to query balance for
-            token_address: ERC20 token address, or None for native token
-            chain_id: Chain ID
-
-        Returns:
-            Tuple of (success, balance_integer_or_error_message)
-        """
-        pass
-
-    @abstractmethod
-    async def approve_token(
-        self,
-        token_address: str,
-        spender: str,
-        amount: int,
-        from_address: str,
-        chain_id: int,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-    ) -> tuple[bool, Any]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-
-        Args:
-            token_address: ERC20 token contract address
-            spender: Address being approved to spend tokens
-            amount: Amount to approve (in token units, not human-readable)
-            from_address: Address approving the tokens
-            chain_id: Chain ID
-            wait_for_receipt: Whether to wait for the transaction receipt
-            timeout: Receipt timeout in seconds
-
-        Returns:
-            Tuple of (success, transaction_result_dict_or_error_message)
-            Transaction result should include 'tx_hash' and optionally 'receipt'
-        """
-        pass
-
     @abstractmethod
     async def broadcast_transaction(
         self,

wayfinder_paths/core/services/local_evm_txn.py

@@ -4,18 +4,13 @@ from typing import Any
 from eth_account import Account
 from eth_utils import to_checksum_address
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3, Web3
+from web3 import AsyncHTTPProvider, AsyncWeb3
 
 from wayfinder_paths.core.constants import (
     DEFAULT_GAS_ESTIMATE_FALLBACK,
     ONE_GWEI,
-    ZERO_ADDRESS,
 )
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.constants.erc20_abi import (
-    ERC20_APPROVAL_ABI,
-    ERC20_MINIMAL_ABI,
-)
 from wayfinder_paths.core.services.base import EvmTxn
 from wayfinder_paths.core.utils.evm_helpers import (
     resolve_private_key_for_from_address,
@@ -79,10 +74,10 @@ class NonceManager:
 
 class LocalEvmTxn(EvmTxn):
     """
-    Local wallet provider using private keys stored in config or environment variables.
+    Local wallet provider using private keys stored in config.json or wallets.json.
 
     This provider implements the current default behavior:
-    - Resolves private keys from config or environment
+    - Resolves private keys from config.json or wallets.json
     - Signs transactions using eth_account
     - Broadcasts transactions via RPC
     """
@@ -107,80 +102,6 @@ class LocalEvmTxn(EvmTxn):
         rpc_url = self._resolve_rpc_url(chain_id)
         return AsyncWeb3(AsyncHTTPProvider(rpc_url))
 
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address (native or ERC20 token).
-        """
-        w3 = self.get_web3(chain_id)
-        try:
-            checksum_addr = to_checksum_address(address)
-
-            if not token_address or token_address.lower() == ZERO_ADDRESS:
-                balance = await w3.eth.get_balance(checksum_addr)
-                return (True, int(balance))
-
-            token_checksum = to_checksum_address(token_address)
-            contract = w3.eth.contract(address=token_checksum, abi=ERC20_MINIMAL_ABI)
-            balance = await contract.functions.balanceOf(checksum_addr).call()
-            return (True, int(balance))
-
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"Failed to get balance: {exc}")
-            return (False, f"Balance query failed: {exc}")
-        finally:
-            await self._close_web3(w3)
-
-    async def approve_token(
-        self,
-        token_address: str,
-        spender: str,
-        amount: int,
-        from_address: str,
-        chain_id: int,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-    ) -> tuple[bool, Any]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-        """
-        try:
-            token_checksum = to_checksum_address(token_address)
-            spender_checksum = to_checksum_address(spender)
-            from_checksum = to_checksum_address(from_address)
-            amount_int = int(amount)
-
-            w3_sync = Web3()
-            contract = w3_sync.eth.contract(
-                address=token_checksum, abi=ERC20_APPROVAL_ABI
-            )
-            transaction_data = contract.encodeABI(
-                fn_name="approve",
-                args=[spender_checksum, amount_int],
-            )
-
-            approve_txn = {
-                "from": from_checksum,
-                "chainId": int(chain_id),
-                "to": token_checksum,
-                "data": transaction_data,
-                "value": 0,
-                "gas": ERC20_APPROVAL_GAS_LIMIT,
-            }
-
-            return await self.broadcast_transaction(
-                approve_txn,
-                wait_for_receipt=wait_for_receipt,
-                timeout=timeout,
-            )
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"ERC20 approval failed: {exc}")
-            return (False, f"ERC20 approval failed: {exc}")
-
     async def broadcast_transaction(
         self,
         transaction: dict[str, Any],