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

wayfinder_paths/adapters/pool_adapter/README.md

@@ -17,7 +17,7 @@ The adapter uses the PoolClient which automatically handles authentication and A
 The PoolClient 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
@@ -45,41 +45,6 @@ else:
     print(f"Error: {data}")
 ```
 
-### Find High Yield Pools
-
-```python
-success, data = await adapter.find_high_yield_pools(
-    min_apy=0.03,  # 3% minimum APY
-    min_tvl=500000,  # $500k minimum TVL
-    stablecoin_only=True,
-    network_codes=["base", "ethereum"]
-)
-if success:
-    pools = data.get("pools", [])
-    print(f"Found {len(pools)} high-yield pools")
-    for pool in pools:
-        print(f"Pool: {pool.get('id')} - APY: {pool.get('llama_apy_pct')}%")
-else:
-    print(f"Error: {data}")
-```
-
-### Get Pool Analytics
-
-```python
-success, data = await adapter.get_pool_analytics(
-    pool_ids=["pool-123", "pool-456"]
-)
-if success:
-    analytics = data.get("analytics", [])
-    for pool_analytics in analytics:
-        pool = pool_analytics.get("pool", {})
-        combined_apy = pool_analytics.get("combined_apy", 0)
-        tvl_usd = pool_analytics.get("tvl_usd", 0)
-        print(f"Pool: {pool.get('name')} - APY: {combined_apy:.2%} - TVL: ${tvl_usd:,.0f}")
-else:
-    print(f"Error: {data}")
-```
-
 ### Get Llama Matches
 
 ```python
@@ -110,47 +75,6 @@ else:
 
 ## Advanced Usage
 
-### Filtering High Yield Pools
-
-The `find_high_yield_pools` method provides powerful filtering capabilities:
-
-```python
-# Find stablecoin pools with high yield on specific networks
-success, data = await adapter.find_high_yield_pools(
-    min_apy=0.05,  # 5% minimum APY
-    min_tvl=1000000,  # $1M minimum TVL
-    stablecoin_only=True,  # Only stablecoin pools
-    network_codes=["base", "arbitrum"]  # Specific networks
-)
-
-if success:
-    pools = data.get("pools", [])
-    # Pools are automatically sorted by APY (highest first)
-    best_pool = pools[0] if pools else None
-    if best_pool:
-        print(f"Best pool: {best_pool.get('id')} - APY: {best_pool.get('llama_apy_pct')}%")
-```
-
-### Comprehensive Pool Analysis
-
-```python
-# Get detailed analytics for specific pools
-success, data = await adapter.get_pool_analytics(["pool-123"])
-
-if success:
-    analytics = data.get("analytics", [])
-    for pool_analytics in analytics:
-        pool = pool_analytics.get("pool", {})
-        llama_data = pool_analytics.get("llama_data", {})
-
-        print(f"Pool: {pool.get('name')}")
-        print(f"  Combined APY: {pool_analytics.get('combined_apy', 0):.2%}")
-        print(f"  TVL: ${pool_analytics.get('tvl_usd', 0):,.0f}")
-        print(f"  Llama APY: {llama_data.get('llama_apy_pct', 0)}%")
-        print(f"  Stablecoin: {llama_data.get('llama_stablecoin', False)}")
-        print(f"  IL Risk: {llama_data.get('llama_il_risk', 'unknown')}")
-```
-
 ## API Endpoints
 
 The adapter uses the following Wayfinder API endpoints:

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -86,125 +86,3 @@ class PoolAdapter(BaseAdapter):
         except Exception as e:
             self.logger.error(f"Error fetching Llama reports: {e}")
             return (False, str(e))
-
-    async def find_high_yield_pools(
-        self,
-        min_apy: float = 0.01,
-        min_tvl: float = 1000000,
-        stablecoin_only: bool = True,
-        network_codes: list[str] | None = None,
-    ) -> tuple[bool, Any]:
-        """
-        Find high-yield pools based on criteria.
-
-        Args:
-            min_apy: Minimum APY threshold (as decimal, e.g., 0.01 for 1%)
-            min_tvl: Minimum TVL threshold in USD
-            stablecoin_only: Whether to filter for stablecoin pools only
-            network_codes: List of network codes to filter by
-
-        Returns:
-            Tuple of (success, data) where data is filtered pools or error message
-        """
-        try:
-            # Get Llama matches for yield data
-            success, llama_data = await self.get_llama_matches()
-            if not success:
-                return (False, f"Failed to fetch Llama data: {llama_data}")
-
-            matches = llama_data.get("matches", [])
-            filtered_pools = []
-
-            for pool in matches:
-                # Apply filters
-                if stablecoin_only and not pool.get("llama_stablecoin", False):
-                    continue
-
-                if pool.get("llama_tvl_usd", 0) < min_tvl:
-                    continue
-
-                if (
-                    pool.get("llama_apy_pct", 0) < min_apy * 100
-                ):  # Convert to percentage
-                    continue
-
-                if network_codes and pool.get("network", "").lower() not in [
-                    nc.lower() for nc in network_codes
-                ]:
-                    continue
-
-                filtered_pools.append(pool)
-
-            # Sort by APY descending
-            filtered_pools.sort(key=lambda x: x.get("llama_apy_pct", 0), reverse=True)
-
-            return (
-                True,
-                {
-                    "pools": filtered_pools,
-                    "total_found": len(filtered_pools),
-                    "filters_applied": {
-                        "min_apy": min_apy,
-                        "min_tvl": min_tvl,
-                        "stablecoin_only": stablecoin_only,
-                        "network_codes": network_codes,
-                    },
-                },
-            )
-        except Exception as e:
-            self.logger.error(f"Error finding high yield pools: {e}")
-            return (False, str(e))
-
-    async def get_pool_analytics(self, pool_ids: list[str]) -> tuple[bool, Any]:
-        """
-        Get comprehensive analytics for specific pools.
-
-        Args:
-            pool_ids: List of pool identifiers
-
-        Returns:
-            Tuple of (success, data) where data is pool analytics or error message
-        """
-        try:
-            # Get pool data
-            success, pool_data = await self.get_pools_by_ids(pool_ids)
-            if not success:
-                return (False, f"Failed to fetch pool data: {pool_data}")
-
-            # Get Llama reports
-            success, llama_data = await self.get_llama_reports(pool_ids)
-            if not success:
-                self.logger.warning(f"Failed to fetch Llama data: {llama_data}")
-                llama_data = {}
-
-            pools = pool_data.get("pools", [])
-            llama_reports = llama_data
-
-            # Combine data
-            analytics = []
-            for pool in pools:
-                pool_id = pool.get("id")
-                llama_report = llama_reports.get(pool_id.lower()) if pool_id else None
-
-                analytics.append(
-                    {
-                        "pool": pool,
-                        "llama_data": llama_report,
-                        "combined_apy": (
-                            llama_report.get("llama_combined_apy_pct", 0) / 100
-                            if llama_report
-                            and llama_report.get("llama_combined_apy_pct") is not None
-                            else pool.get("apy", 0)
-                        ),
-                        "tvl_usd": (
-                            llama_report.get("llama_tvl_usd", 0)
-                            if llama_report and llama_report.get("llama_tvl_usd")
-                            else pool.get("tvl", 0)
-                        ),
-                    }
-                )
-
-            return (True, {"analytics": analytics, "total_pools": len(analytics)})
-        except Exception as e:
-            self.logger.error(f"Error getting pool analytics: {e}")
-            return (False, str(e))

wayfinder_paths/adapters/pool_adapter/examples.json

@@ -39,62 +39,5 @@
         ]
       }
     }
-  },
-  "find_high_yield_pools": {
-    "description": "Find high-yield pools based on criteria",
-    "input": {
-      "min_apy": 0.03,
-      "min_tvl": 500000,
-      "stablecoin_only": true,
-      "network_codes": ["base", "ethereum"]
-    },
-    "output": {
-      "success": true,
-      "data": {
-        "pools": [
-          {
-            "id": "pool-123",
-            "llama_apy_pct": 5.2,
-            "llama_tvl_usd": 1000000,
-            "llama_stablecoin": true,
-            "network": "base"
-          }
-        ],
-        "total_found": 1,
-        "filters_applied": {
-          "min_apy": 0.03,
-          "min_tvl": 500000,
-          "stablecoin_only": true,
-          "network_codes": ["base", "ethereum"]
-        }
-      }
-    }
-  },
-  "get_pool_analytics": {
-    "description": "Get comprehensive analytics for specific pools",
-    "input": {
-      "pool_ids": ["pool-123"]
-    },
-    "output": {
-      "success": true,
-      "data": {
-        "analytics": [
-          {
-            "pool": {
-              "id": "pool-123",
-              "name": "USDC/USDT Pool",
-              "symbol": "USDC-USDT"
-            },
-            "llama_data": {
-              "llama_apy_pct": 5.2,
-              "llama_tvl_usd": 1000000
-            },
-            "combined_apy": 0.052,
-            "tvl_usd": 1000000
-          }
-        ],
-        "total_pools": 1
-      }
-    }
   }
 }

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/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,13 +121,13 @@ 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()
@@ -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,7 +196,7 @@ 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()

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