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

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -53,25 +53,6 @@ class PoolAdapter(BaseAdapter):
             self.logger.error(f"Error fetching pools by IDs: {e}")
             return (False, str(e))
 
-    async def get_all_pools(
-        self, merge_external: bool | None = None
-    ) -> tuple[bool, PoolList | str]:
-        """
-        Get all available pools.
-
-        Args:
-            merge_external: Whether to merge external data
-
-        Returns:
-            Tuple of (success, data) where data is all pools or error message
-        """
-        try:
-            data = await self.pool_client.get_all_pools(merge_external=merge_external)
-            return (True, data)
-        except Exception as e:
-            self.logger.error(f"Error fetching all pools: {e}")
-            return (False, str(e))
-
     async def get_llama_matches(self) -> tuple[bool, dict[str, LlamaMatch] | str]:
         """
         Get Llama protocol matches for pools.
@@ -105,178 +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))
-
-    async def search_pools(self, query: str, limit: int = 10) -> tuple[bool, Any]:
-        """
-        Search pools by name, symbol, or other criteria.
-
-        Args:
-            query: Search query string
-            limit: Maximum number of results
-
-        Returns:
-            Tuple of (success, data) where data is search results or error message
-        """
-        try:
-            success, all_pools_data = await self.get_all_pools()
-            if not success:
-                return (False, f"Failed to fetch pools: {all_pools_data}")
-
-            pools = all_pools_data.get("pools", [])
-            query_lower = query.lower()
-
-            # Simple text search
-            matching_pools = []
-            for pool in pools:
-                name = pool.get("name", "").lower()
-                symbol = pool.get("symbol", "").lower()
-                description = pool.get("description", "").lower()
-
-                if (
-                    query_lower in name
-                    or query_lower in symbol
-                    or query_lower in description
-                ):
-                    matching_pools.append(pool)
-
-            # Sort by relevance (exact matches first)
-            matching_pools.sort(
-                key=lambda x: (
-                    query_lower not in x.get("name", "").lower(),
-                    query_lower not in x.get("symbol", "").lower(),
-                )
-            )
-
-            return (
-                True,
-                {
-                    "pools": matching_pools[:limit],
-                    "total_found": len(matching_pools),
-                    "query": query,
-                },
-            )
-        except Exception as e:
-            self.logger.error(f"Error searching pools: {e}")
-            return (False, str(e))

wayfinder_paths/adapters/pool_adapter/examples.json

@@ -21,27 +21,6 @@
       }
     }
   },
-  "get_all_pools": {
-    "description": "Get all available pools",
-    "input": {
-      "merge_external": false
-    },
-    "output": {
-      "success": true,
-      "data": {
-        "pools": [
-          {
-            "id": "pool-123",
-            "name": "USDC/USDT Pool",
-            "symbol": "USDC-USDT",
-            "apy": 0.05,
-            "tvl": 1000000
-          }
-        ],
-        "total": 1
-      }
-    }
-  },
   "get_llama_matches": {
     "description": "Get Llama protocol matches for pools",
     "input": {},
@@ -60,84 +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
-      }
-    }
-  },
-  "search_pools": {
-    "description": "Search pools by name, symbol, or other criteria",
-    "input": {
-      "query": "USDC",
-      "limit": 5
-    },
-    "output": {
-      "success": true,
-      "data": {
-        "pools": [
-          {
-            "id": "pool-123",
-            "name": "USDC/USDT Pool",
-            "symbol": "USDC-USDT",
-            "description": "Stablecoin pool on Base"
-          }
-        ],
-        "total_found": 1,
-        "query": "USDC"
-      }
-    }
   }
 }

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -47,25 +47,6 @@ class TestPoolAdapter:
             pool_ids="pool-123,pool-456", merge_external=True
         )
 
-    @pytest.mark.asyncio
-    async def test_get_all_pools_success(self, adapter, mock_pool_client):
-        """Test successful retrieval of all pools"""
-        # Mock response
-        mock_response = {
-            "pools": [
-                {"id": "pool-123", "name": "Pool 1"},
-                {"id": "pool-456", "name": "Pool 2"},
-            ],
-            "total": 2,
-        }
-        mock_pool_client.get_all_pools = AsyncMock(return_value=mock_response)
-
-        success, data = await adapter.get_all_pools(merge_external=False)
-
-        assert success is True
-        assert data == mock_response
-        mock_pool_client.get_all_pools.assert_called_once_with(merge_external=False)
-
     @pytest.mark.asyncio
     async def test_get_llama_matches_success(self, adapter, mock_pool_client):
         """Test successful Llama matches retrieval"""
@@ -88,106 +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_search_pools_success(self, adapter, mock_pool_client):
-        """Test successful pool search"""
-        mock_all_pools = {
-            "pools": [
-                {
-                    "id": "pool-123",
-                    "name": "USDC/USDT Pool",
-                    "symbol": "USDC-USDT",
-                    "description": "Stablecoin pool on Base",
-                },
-                {
-                    "id": "pool-456",
-                    "name": "ETH/WETH Pool",
-                    "symbol": "ETH-WETH",
-                    "description": "Ethereum pool",
-                },
-            ]
-        }
-        mock_pool_client.get_all_pools = AsyncMock(return_value=mock_all_pools)
-
-        success, data = await adapter.search_pools("USDC", limit=5)
-
-        assert success is True
-        assert len(data["pools"]) == 1
-        assert data["pools"][0]["id"] == "pool-123"
-        assert data["total_found"] == 1
-        assert data["query"] == "USDC"
-
     @pytest.mark.asyncio
     async def test_get_pools_by_ids_failure(self, adapter, mock_pool_client):
         """Test pool retrieval failure"""
@@ -200,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/BRAPClient.py

@@ -27,6 +27,7 @@ class BRAPQuote(TypedDict):
     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]

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/PoolClient.py

@@ -85,22 +85,6 @@ class PoolClient(WayfinderClient):
         data = response.json()
         return data.get("data", data)
 
-    async def get_all_pools(self, *, merge_external: bool | None = None) -> PoolList:
-        """
-        Fetch all pools.
-
-        Example:
-        GET /api/v1/public/pools/?merge_external=false
-        """
-        url = f"{self.api_base_url}/public/pools/"
-        params: dict[str, Any] = {}
-        if merge_external is not None:
-            params["merge_external"] = "true" if merge_external else "false"
-        response = await self._request("GET", url, params=params, headers={})
-        response.raise_for_status()
-        data = response.json()
-        return data.get("data", data)
-
     async def get_llama_matches(self) -> dict[str, LlamaMatch]:
         """
         Fetch Llama matches for pools.

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