wayfinder-paths 0.1.7__py3-none-any.whl

wayfinder_paths/adapters/ledger_adapter/test_adapter.py

@@ -0,0 +1,205 @@
+from unittest.mock import AsyncMock
+
+import pytest
+
+from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
+
+
+class TestLedgerAdapter:
+    """Test cases for LedgerAdapter"""
+
+    @pytest.fixture
+    def mock_ledger_client(self):
+        """Mock LedgerClient for testing"""
+        mock_client = AsyncMock()
+        return mock_client
+
+    @pytest.fixture
+    def adapter(self, mock_ledger_client):
+        """Create a LedgerAdapter instance with mocked client for testing"""
+        adapter = LedgerAdapter()
+        adapter.ledger_client = mock_ledger_client
+        return adapter
+
+    @pytest.mark.asyncio
+    async def test_get_strategy_transactions_success(self, adapter, mock_ledger_client):
+        """Test successful strategy transaction retrieval"""
+        mock_response = {
+            "transactions": [
+                {
+                    "id": "tx_123",
+                    "operation": "DEPOSIT",
+                    "amount": "1000000000000000000",
+                    "usd_value": "1000.00",
+                }
+            ],
+            "total": 1,
+        }
+        mock_ledger_client.get_strategy_transactions = AsyncMock(
+            return_value=mock_response
+        )
+
+        success, data = await adapter.get_strategy_transactions(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            limit=10,
+            offset=0,
+        )
+
+        assert success is True
+        assert data == mock_response
+        mock_ledger_client.get_strategy_transactions.assert_called_once_with(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            limit=10,
+            offset=0,
+        )
+
+    @pytest.mark.asyncio
+    async def test_get_strategy_transactions_failure(self, adapter, mock_ledger_client):
+        """Test strategy transaction retrieval failure"""
+        mock_ledger_client.get_strategy_transactions = AsyncMock(
+            side_effect=Exception("API Error")
+        )
+
+        success, data = await adapter.get_strategy_transactions(
+            wallet_address="0x1234567890123456789012345678901234567890"
+        )
+
+        assert success is False
+        assert "API Error" in data
+
+    @pytest.mark.asyncio
+    async def test_get_strategy_net_deposit_success(self, adapter, mock_ledger_client):
+        """Test successful strategy net deposit retrieval"""
+        mock_response = {
+            "net_deposit": "1000.00",
+            "total_deposits": "1500.00",
+            "total_withdrawals": "500.00",
+        }
+        mock_ledger_client.get_strategy_net_deposit = AsyncMock(
+            return_value=mock_response
+        )
+
+        # Test
+        success, data = await adapter.get_strategy_net_deposit(
+            wallet_address="0x1234567890123456789012345678901234567890"
+        )
+
+        assert success is True
+        assert data == mock_response
+        mock_ledger_client.get_strategy_net_deposit.assert_called_once_with(
+            wallet_address="0x1234567890123456789012345678901234567890"
+        )
+
+    @pytest.mark.asyncio
+    async def test_record_deposit_success(self, adapter, mock_ledger_client):
+        """Test successful deposit recording"""
+        mock_response = {
+            "transaction_id": "tx_456",
+            "status": "recorded",
+            "timestamp": "2024-01-15T10:30:00Z",
+        }
+        mock_ledger_client.add_strategy_deposit.return_value = mock_response
+
+        # Test
+        success, data = await adapter.record_deposit(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            chain_id=8453,
+            token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+            token_amount="1000000000000000000",
+            usd_value="1000.00",
+            strategy_name="TestStrategy",
+        )
+
+        assert success is True
+        assert data == mock_response
+        mock_ledger_client.add_strategy_deposit.assert_called_once_with(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            chain_id=8453,
+            token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+            token_amount="1000000000000000000",
+            usd_value="1000.00",
+            data=None,
+            strategy_name="TestStrategy",
+        )
+
+    @pytest.mark.asyncio
+    async def test_record_withdrawal_success(self, adapter, mock_ledger_client):
+        """Test successful withdrawal recording"""
+        mock_response = {
+            "transaction_id": "tx_789",
+            "status": "recorded",
+            "timestamp": "2024-01-15T11:00:00Z",
+        }
+        mock_ledger_client.add_strategy_withdraw.return_value = mock_response
+
+        # Test
+        success, data = await adapter.record_withdrawal(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            chain_id=8453,
+            token_address="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+            token_amount="500000000000000000",
+            usd_value="500.00",
+            strategy_name="TestStrategy",
+        )
+
+        assert success is True
+        assert data == mock_response
+
+    @pytest.mark.asyncio
+    async def test_record_operation_success(self, adapter, mock_ledger_client):
+        """Test successful operation recording"""
+        from wayfinder_paths.core.adapters.models import SWAP
+
+        mock_response = {
+            "operation_id": "op_123",
+            "status": "recorded",
+            "timestamp": "2024-01-15T10:45:00Z",
+        }
+        mock_ledger_client.add_strategy_operation.return_value = mock_response
+
+        # Test
+        operation_data = SWAP(
+            from_token_id="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
+            to_token_id="0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
+            from_amount="1000000000000000000",
+            to_amount="995000000000000000",
+            from_amount_usd=1000.0,
+            to_amount_usd=995.0,
+        )
+
+        success, data = await adapter.record_operation(
+            wallet_address="0x1234567890123456789012345678901234567890",
+            operation_data=operation_data,
+            usd_value="1000.00",
+            strategy_name="TestStrategy",
+        )
+
+        assert success is True
+        assert data == mock_response
+
+    @pytest.mark.asyncio
+    async def test_get_transaction_summary_success(self, adapter, mock_ledger_client):
+        """Test successful transaction summary generation"""
+        mock_transactions = {
+            "transactions": [
+                {"operation": "DEPOSIT", "amount": "1000000000000000000"},
+                {"operation": "WITHDRAW", "amount": "500000000000000000"},
+                {"operation": "SWAP", "amount": "200000000000000000"},
+            ]
+        }
+        mock_ledger_client.get_strategy_transactions.return_value = mock_transactions
+
+        # Test
+        success, data = await adapter.get_transaction_summary(
+            wallet_address="0x1234567890123456789012345678901234567890", limit=10
+        )
+
+        assert success is True
+        assert data["total_transactions"] == 3
+        assert data["operations"]["deposits"] == 1
+        assert data["operations"]["withdrawals"] == 1
+        assert data["operations"]["operations"] == 1
+
+    def test_adapter_type(self, adapter):
+        """Test adapter has adapter_type"""
+        assert adapter.adapter_type == "LEDGER"

wayfinder_paths/adapters/pool_adapter/README.md

@@ -0,0 +1,206 @@
+# Pool Adapter
+
+A Wayfinder adapter that provides high-level operations for DeFi pool data and analytics. This adapter wraps the `PoolClient` to offer strategy-friendly methods for discovering, analyzing, and filtering yield opportunities.
+
+## Capabilities
+
+- `pool.read`: Read pool information and metadata
+- `pool.analytics`: Get comprehensive pool analytics
+- `pool.discovery`: Find and search pools
+- `llama.data`: Access Llama protocol data
+- `pool.reports`: Get pool reports and analytics
+
+## Configuration
+
+The adapter uses the PoolClient which automatically handles authentication and API configuration through the Wayfinder settings. No additional configuration is required.
+
+The PoolClient will automatically:
+- Use the WAYFINDER_API_URL from settings
+- Handle authentication via environment variables or config.json
+- Manage token refresh and retry logic
+
+## Usage
+
+### Initialize the Adapter
+
+```python
+from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
+
+# No configuration needed - uses PoolClient with automatic settings
+adapter = PoolAdapter()
+```
+
+### Get Pools by IDs
+
+```python
+success, data = await adapter.get_pools_by_ids(
+    pool_ids=["pool-123", "pool-456"],
+    merge_external=True
+)
+if success:
+    pools = data.get("pools", [])
+    print(f"Found {len(pools)} pools")
+else:
+    print(f"Error: {data}")
+```
+
+### Get All Pools
+
+```python
+success, data = await adapter.get_all_pools(merge_external=False)
+if success:
+    pools = data.get("pools", [])
+    print(f"Total pools available: {len(pools)}")
+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}")
+```
+
+### Search Pools
+
+```python
+success, data = await adapter.search_pools(
+    query="USDC",
+    limit=10
+)
+if success:
+    pools = data.get("pools", [])
+    print(f"Found {len(pools)} pools matching 'USDC'")
+    for pool in pools:
+        print(f"Pool: {pool.get('name')} - {pool.get('symbol')}")
+else:
+    print(f"Error: {data}")
+```
+
+### Get Llama Matches
+
+```python
+success, data = await adapter.get_llama_matches()
+if success:
+    matches = data.get("matches", [])
+    print(f"Found {len(matches)} Llama matches")
+    for match in matches:
+        if match.get("llama_stablecoin"):
+            print(f"Stablecoin pool: {match.get('id')} - APY: {match.get('llama_apy_pct')}%")
+else:
+    print(f"Error: {data}")
+```
+
+### Get Llama Reports
+
+```python
+success, data = await adapter.get_llama_reports(
+    identifiers=["pool-123", "usd-coin-base", "base_0x1234..."]
+)
+if success:
+    reports = data
+    for identifier, report in reports.items():
+        print(f"Report for {identifier}: APY {report.get('llama_apy_pct', 0)}%")
+else:
+    print(f"Error: {data}")
+```
+
+## 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:
+
+- `GET /api/v1/public/pools/?pool_ids=X` - Get pools by IDs
+- `GET /api/v1/public/pools/` - Get all pools
+- `GET /api/v1/public/pools/llama/matches/` - Get Llama matches
+- `GET /api/v1/public/pools/llama/reports/` - Get Llama reports
+
+## Error Handling
+
+All methods return a tuple of `(success: bool, data: Any)` where:
+- `success` is `True` if the operation succeeded
+- `data` contains the response data on success or error message on failure
+
+## Testing
+
+Run the adapter tests:
+
+```bash
+pytest wayfinder_paths/adapters/pool_adapter/test_adapter.py -v
+```
+
+## Dependencies
+
+- `PoolClient` - Low-level API client for pool operations
+- `BaseAdapter` - Base adapter class with common functionality

wayfinder_paths/adapters/pool_adapter/__init__.py

@@ -0,0 +1,7 @@
+"""
+Pool Adapter Package
+"""
+
+from .adapter import PoolAdapter
+
+__all__ = ["PoolAdapter"]

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -0,0 +1,282 @@
+from typing import Any
+
+from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.clients.PoolClient import (
+    LlamaMatch,
+    LlamaReport,
+    PoolClient,
+    PoolList,
+)
+
+
+class PoolAdapter(BaseAdapter):
+    """
+    Pool adapter for DeFi pool data and analytics operations.
+
+    Provides high-level operations for:
+    - Fetching pool information and metadata
+    - Getting pool analytics and reports
+    - Accessing Llama protocol data
+    - Pool discovery and filtering
+    """
+
+    adapter_type: str = "POOL"
+
+    def __init__(
+        self,
+        config: dict[str, Any] | None = None,
+        pool_client: PoolClient | None = None,
+    ):
+        super().__init__("pool_adapter", config)
+        self.pool_client = pool_client or PoolClient()
+
+    async def get_pools_by_ids(
+        self, pool_ids: list[str], merge_external: bool | None = None
+    ) -> tuple[bool, PoolList | str]:
+        """
+        Get pool information by pool IDs.
+
+        Args:
+            pool_ids: List of pool identifiers
+            merge_external: Whether to merge external data
+
+        Returns:
+            Tuple of (success, data) where data is pool information or error message
+        """
+        try:
+            pool_ids_str = ",".join(pool_ids)
+            data = await self.pool_client.get_pools_by_ids(
+                pool_ids=pool_ids_str, merge_external=merge_external
+            )
+            return (True, data)
+        except Exception as e:
+            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.
+
+        Returns:
+            Tuple of (success, data) where data is Llama matches or error message
+        """
+        try:
+            data = await self.pool_client.get_llama_matches()
+            return (True, data)
+        except Exception as e:
+            self.logger.error(f"Error fetching Llama matches: {e}")
+            return (False, str(e))
+
+    async def get_llama_reports(
+        self, identifiers: list[str]
+    ) -> tuple[bool, dict[str, LlamaReport] | str]:
+        """
+        Get Llama reports for specific identifiers.
+
+        Args:
+            identifiers: List of identifiers (token IDs, addresses, pool IDs)
+
+        Returns:
+            Tuple of (success, data) where data is Llama reports or error message
+        """
+        try:
+            identifiers_str = ",".join(identifiers)
+            data = await self.pool_client.get_llama_reports(identifiers=identifiers_str)
+            return (True, data)
+        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))