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

wayfinder_paths/adapters/ledger_adapter/test_adapter.py

@@ -1,4 +1,4 @@
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
 import pytest
 
@@ -17,11 +17,9 @@ class TestLedgerAdapter:
     @pytest.fixture
     def adapter(self, mock_ledger_client):
         """Create a LedgerAdapter instance with mocked client for testing"""
-        with patch(
-            "adapters.ledger_adapter.adapter.LedgerClient",
-            return_value=mock_ledger_client,
-        ):
-            return LedgerAdapter()
+        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):
@@ -161,12 +159,15 @@ class TestLedgerAdapter:
 
         # Test
         operation_data = SWAP(
+            adapter="TestAdapter",
             from_token_id="0xA0b86a33E6441c8C06DdD4D4c4c4c4c4c4c4c4c4c",
             to_token_id="0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
             from_amount="1000000000000000000",
             to_amount="995000000000000000",
             from_amount_usd=1000.0,
             to_amount_usd=995.0,
+            transaction_hash="0x123abc",
+            transaction_chain_id=8453,
         )
 
         success, data = await adapter.record_operation(

wayfinder_paths/adapters/pool_adapter/README.md

@@ -15,6 +15,7 @@ A Wayfinder adapter that provides high-level operations for DeFi pool data and a
 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
@@ -44,17 +45,6 @@ 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
@@ -90,22 +80,6 @@ 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
@@ -168,7 +142,7 @@ if success:
     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}")
@@ -189,6 +163,7 @@ The adapter uses the following Wayfinder API endpoints:
 ## 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
 

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.
@@ -227,56 +208,3 @@ class PoolAdapter(BaseAdapter):
         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": {},
@@ -117,27 +96,5 @@
         "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

@@ -1,4 +1,4 @@
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
 import pytest
 
@@ -17,11 +17,9 @@ class TestPoolAdapter:
     @pytest.fixture
     def adapter(self, mock_pool_client):
         """Create a PoolAdapter instance with mocked client for testing"""
-        with patch(
-            "adapters.pool_adapter.adapter.PoolClient",
-            return_value=mock_pool_client,
-        ):
-            return PoolAdapter()
+        adapter = PoolAdapter()
+        adapter.pool_client = mock_pool_client
+        return adapter
 
     @pytest.mark.asyncio
     async def test_get_pools_by_ids_success(self, adapter, mock_pool_client):
@@ -49,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"""
@@ -161,35 +140,6 @@ class TestPoolAdapter:
         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"""

wayfinder_paths/adapters/token_adapter/test_adapter.py

@@ -43,31 +43,21 @@ class TestTokenAdapter:
             success, data = await adapter.get_token("0x1234...")
 
             assert success is False
-            assert "No token found for address" in data
+            assert "No token found for" in data
 
     @pytest.mark.asyncio
-    async def test_get_token_flexible_success(self, adapter):
-        """Test flexible token retrieval with both address and token_id"""
+    async def test_get_token_by_token_id(self, adapter):
+        """Test token retrieval with token_id"""
         mock_token_data = {"address": "0x1234...", "symbol": "TEST"}
 
         with patch.object(
             adapter.token_client, "get_token_details", return_value=mock_token_data
         ):
-            success, data = await adapter.get_token(
-                address="0x1234...", token_id="token-123"
-            )
+            success, data = await adapter.get_token("token-123")
 
             assert success is True
             assert data == mock_token_data
 
-    @pytest.mark.asyncio
-    async def test_get_token_no_parameters(self, adapter):
-        """Test get_token with no parameters raises error"""
-        success, data = await adapter.get_token()
-
-        assert success is False
-        assert "Either address or token_id must be provided" in data
-
     def test_adapter_type(self, adapter):
         """Test adapter has adapter_type"""
         assert adapter.adapter_type == "TOKEN"

wayfinder_paths/core/adapters/models.py

@@ -5,7 +5,13 @@ from typing import Annotated, Any, Literal
 from pydantic import BaseModel, Field
 
 
-class SWAP(BaseModel):
+class OperationBase(BaseModel):
+    adapter: str
+    transaction_hash: str | None
+    transaction_chain_id: int | None
+
+
+class SWAP(OperationBase):
     """Swap operation."""
 
     type: Literal["SWAP"] = "SWAP"
@@ -15,18 +21,17 @@ class SWAP(BaseModel):
     to_amount: str
     from_amount_usd: float
     to_amount_usd: float
-    transaction_hash: str | None = None
     transaction_status: str | None = None
     transaction_receipt: dict[str, Any] | None = None
 
 
-class LEND(BaseModel):
+class LEND(OperationBase):
     type: Literal["LEND"] = "LEND"
     contract: str
     amount: int
 
 
-class UNLEND(BaseModel):
+class UNLEND(OperationBase):
     type: Literal["UNLEND"] = "UNLEND"
     contract: str
     amount: int

wayfinder_paths/core/analytics/__init__.py

@@ -0,0 +1,11 @@
+"""Reusable, strategy-agnostic analytics helpers."""
+
+from .bootstrap import block_bootstrap_paths
+from .stats import percentile, rolling_min_sum, z_from_conf
+
+__all__ = [
+    "block_bootstrap_paths",
+    "percentile",
+    "rolling_min_sum",
+    "z_from_conf",
+]

wayfinder_paths/core/analytics/bootstrap.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import random
+from collections.abc import Sequence
+
+
+def block_bootstrap_paths(
+    *series: Sequence[float],
+    block_hours: int,
+    sims: int,
+    rng: random.Random,
+) -> list[tuple[list[float], ...]]:
+    """
+    Block-bootstrap aligned series together.
+
+    Samples contiguous blocks from the same indices across every series so their
+    time alignment is preserved (useful for resampling correlated paths).
+
+    Args:
+        *series: One or more equal-frequency series (funding, closes, highs, ...)
+        block_hours: Block length for sampling (clamped to [1, base_len])
+        sims: Number of bootstrap paths to return
+        rng: Random generator
+
+    Returns:
+        List of tuples, each containing resampled series lists (truncated to the
+        shared base length).
+    """
+    if sims <= 0 or not series:
+        return []
+
+    base_len = min(len(s) for s in series)
+    if base_len <= 1:
+        return []
+
+    block_hours = max(1, min(int(block_hours), base_len))
+    max_start = max(0, base_len - block_hours)
+
+    if max_start == 0:
+        # Series are shorter than a full block; just return copies.
+        out: list[tuple[list[float], ...]] = []
+        for _ in range(sims):
+            out.append(tuple(list(s[:base_len]) for s in series))
+        return out
+
+    bootstrap_paths: list[tuple[list[float], ...]] = []
+    for _ in range(sims):
+        sampled: list[list[float]] = [[] for _ in series]
+        while len(sampled[0]) < base_len:
+            start = rng.randint(0, max_start)
+            end = start + block_hours
+            for i, s in enumerate(series):
+                sampled[i].extend(s[start:end])
+
+        bootstrap_paths.append(tuple(x[:base_len] for x in sampled))
+
+    return bootstrap_paths

wayfinder_paths/core/analytics/stats.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from statistics import NormalDist
+
+
+def z_from_conf(confidence: float) -> float:
+    """Return the two-sided z-score for a confidence level (e.g. 0.975)."""
+    return NormalDist().inv_cdf((1 + float(confidence)) / 2)
+
+
+def rolling_min_sum(arr: Sequence[float], window: int) -> float:
+    """Return the minimum rolling window sum over `arr`."""
+    values = list(arr)
+    if window <= 0:
+        return 0.0
+    if len(values) < window:
+        return float(sum(values))
+
+    current_sum = sum(values[:window])
+    min_sum = current_sum
+    for i in range(window, len(values)):
+        current_sum = current_sum - values[i - window] + values[i]
+        min_sum = min(min_sum, current_sum)
+    return float(min_sum)
+
+
+def percentile(sorted_values: Sequence[float], pct: float) -> float:
+    """
+    Inclusive percentile on a pre-sorted list.
+
+    Mirrors a simple linear interpolation between closest ranks.
+    """
+    values = list(sorted_values)
+    if not values:
+        return float("nan")
+    if len(values) == 1:
+        return float(values[0])
+
+    pct = min(max(float(pct), 0.0), 1.0)
+    idx = (len(values) - 1) * pct
+    lower = math.floor(idx)
+    upper = math.ceil(idx)
+    if lower == upper:
+        return float(values[lower])
+    weight = idx - lower
+    return float(values[lower] + weight * (values[upper] - values[lower]))

wayfinder_paths/core/analytics/test_analytics.py

@@ -0,0 +1,170 @@
+"""Tests for core analytics modules (bootstrap, stats)."""
+
+import math
+import random
+
+from wayfinder_paths.core.analytics.bootstrap import block_bootstrap_paths
+from wayfinder_paths.core.analytics.stats import (
+    percentile,
+    rolling_min_sum,
+    z_from_conf,
+)
+
+
+class TestBlockBootstrapPaths:
+    """Tests for block_bootstrap_paths function."""
+
+    def test_returns_empty_when_sims_zero(self):
+        """Should return empty list when sims=0."""
+        result = block_bootstrap_paths(
+            [1.0, 2.0, 3.0], block_hours=2, sims=0, rng=random.Random(42)
+        )
+        assert result == []
+
+    def test_returns_empty_when_series_empty(self):
+        """Should return empty list when no series provided."""
+        result = block_bootstrap_paths(block_hours=2, sims=10, rng=random.Random(42))
+        assert result == []
+
+    def test_returns_empty_when_base_len_one(self):
+        """Should return empty list when series has only one element."""
+        result = block_bootstrap_paths(
+            [1.0], block_hours=2, sims=10, rng=random.Random(42)
+        )
+        assert result == []
+
+    def test_single_series(self):
+        """Should bootstrap a single series correctly."""
+        series = [1.0, 2.0, 3.0, 4.0, 5.0]
+        result = block_bootstrap_paths(
+            series, block_hours=2, sims=5, rng=random.Random(42)
+        )
+
+        assert len(result) == 5
+        for path in result:
+            assert len(path) == 1  # One series
+            assert len(path[0]) == 5  # Same length as original
+
+    def test_multiple_aligned_series(self):
+        """Should bootstrap multiple series with aligned indices."""
+        series_a = [1.0, 2.0, 3.0, 4.0, 5.0]
+        series_b = [10.0, 20.0, 30.0, 40.0, 50.0]
+        result = block_bootstrap_paths(
+            series_a, series_b, block_hours=2, sims=3, rng=random.Random(42)
+        )
+
+        assert len(result) == 3
+        for path in result:
+            assert len(path) == 2  # Two series
+            assert len(path[0]) == 5
+            assert len(path[1]) == 5
+
+    def test_preserves_length(self):
+        """Bootstrapped paths should have same length as input."""
+        series = list(range(100))
+        series_float = [float(x) for x in series]
+        result = block_bootstrap_paths(
+            series_float, block_hours=24, sims=10, rng=random.Random(42)
+        )
+
+        for path in result:
+            assert len(path[0]) == 100
+
+    def test_block_clamping(self):
+        """Block hours should be clamped to valid range."""
+        series = [1.0, 2.0, 3.0]
+
+        # Block larger than series - should still work
+        result = block_bootstrap_paths(
+            series, block_hours=100, sims=2, rng=random.Random(42)
+        )
+        assert len(result) == 2
+
+        # Block of zero - should clamp to 1
+        result = block_bootstrap_paths(
+            series, block_hours=0, sims=2, rng=random.Random(42)
+        )
+        assert len(result) == 2
+
+
+class TestZFromConf:
+    """Tests for z_from_conf function."""
+
+    def test_95_confidence(self):
+        """95% confidence should give z ≈ 1.96."""
+        z = z_from_conf(0.95)
+        assert 1.95 < z < 1.97
+
+    def test_99_confidence(self):
+        """99% confidence should give z ≈ 2.576."""
+        z = z_from_conf(0.99)
+        assert 2.57 < z < 2.58
+
+    def test_90_confidence(self):
+        """90% confidence should give z ≈ 1.645."""
+        z = z_from_conf(0.90)
+        assert 1.64 < z < 1.66
+
+
+class TestRollingMinSum:
+    """Tests for rolling_min_sum function."""
+
+    def test_basic(self):
+        """Basic rolling min sum calculation."""
+        arr = [1, -2, 3, -4, 5]
+        result = rolling_min_sum(arr, 2)
+        # Windows: [1,-2]=-1, [-2,3]=1, [3,-4]=-1, [-4,5]=1
+        assert result == -1
+
+    def test_window_larger_than_arr(self):
+        """Window larger than array returns sum of array."""
+        arr = [1.0, 2.0, 3.0]
+        result = rolling_min_sum(arr, 10)
+        assert result == 6.0
+
+    def test_window_zero(self):
+        """Window of zero returns 0."""
+        arr = [1.0, 2.0, 3.0]
+        result = rolling_min_sum(arr, 0)
+        assert result == 0.0
+
+    def test_all_negative(self):
+        """All negative values."""
+        arr = [-1.0, -2.0, -3.0, -4.0]
+        result = rolling_min_sum(arr, 2)
+        # Windows: [-1,-2]=-3, [-2,-3]=-5, [-3,-4]=-7
+        assert result == -7.0
+
+
+class TestPercentile:
+    """Tests for percentile function."""
+
+    def test_empty_returns_nan(self):
+        """Empty list returns nan."""
+        result = percentile([], 0.5)
+        assert math.isnan(result)
+
+    def test_single_value(self):
+        """Single value returns that value regardless of percentile."""
+        assert percentile([42.0], 0.0) == 42.0
+        assert percentile([42.0], 0.5) == 42.0
+        assert percentile([42.0], 1.0) == 42.0
+
+    def test_median(self):
+        """50th percentile (median) calculation."""
+        sorted_values = [1.0, 2.0, 3.0, 4.0, 5.0]
+        result = percentile(sorted_values, 0.5)
+        assert result == 3.0
+
+    def test_interpolation(self):
+        """Percentile with interpolation."""
+        sorted_values = [0.0, 10.0]
+        # 25th percentile should interpolate to 2.5
+        result = percentile(sorted_values, 0.25)
+        assert result == 2.5
+
+    def test_bounds_clamped(self):
+        """Percentile values outside [0,1] are clamped."""
+        sorted_values = [1.0, 2.0, 3.0]
+        assert percentile(sorted_values, -1.0) == 1.0  # Clamped to 0
+        assert percentile(sorted_values, 2.0) == 3.0  # Clamped to 1

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]