wayfinder-paths 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

wayfinder_paths/strategies/stablecoin_yield_strategy/test_strategy.py

@@ -1,36 +1,17 @@
-import sys
 from pathlib import Path
 from unittest.mock import AsyncMock
 
-# Ensure wayfinder-paths is on path for tests.test_utils import
-# This is a workaround until conftest loading order is resolved
-_wayfinder_path_dir = Path(__file__).parent.parent.parent.resolve()
-_wayfinder_path_str = str(_wayfinder_path_dir)
-if _wayfinder_path_str not in sys.path:
-    sys.path.insert(0, _wayfinder_path_str)
-elif sys.path.index(_wayfinder_path_str) > 0:
-    # Move to front to take precedence
-    sys.path.remove(_wayfinder_path_str)
-    sys.path.insert(0, _wayfinder_path_str)
-
-import pytest  # noqa: E402
-
-try:
-    from tests.test_utils import get_canonical_examples, load_strategy_examples
-except ImportError:
-    # Fallback if path setup didn't work
-    import importlib.util
-
-    test_utils_path = Path(_wayfinder_path_dir) / "tests" / "test_utils.py"
-    spec = importlib.util.spec_from_file_location("tests.test_utils", test_utils_path)
-    test_utils = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(test_utils)
-    get_canonical_examples = test_utils.get_canonical_examples
-    load_strategy_examples = test_utils.load_strategy_examples
-
-from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (  # noqa: E402
+import pytest
+
+from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (
     StablecoinYieldStrategy,
 )
+from wayfinder_paths.tests.test_utils import (
+    get_canonical_examples,
+    load_strategy_examples,
+)
+
+_StablecoinYieldStrategy = StablecoinYieldStrategy
 
 
 @pytest.fixture
@@ -47,17 +28,14 @@ def strategy():
     )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
-        usdc_balance_mock = AsyncMock(return_value=(True, 60000000))
-        gas_balance_mock = AsyncMock(return_value=(True, 2000000000000000))
 
-        def get_balance_side_effect(query, wallet_address, **kwargs):
-            token_id = (
-                query if isinstance(query, str) else (query or {}).get("token_id")
-            )
+        def get_balance_side_effect(
+            *, wallet_address, token_id=None, token_address=None, chain_id=None
+        ):
             if token_id == "usd-coin-base" or token_id == "usd-coin":
-                return usdc_balance_mock.return_value
+                return (True, 60000000)
             elif token_id == "ethereum-base" or token_id == "ethereum":
-                return gas_balance_mock.return_value
+                return (True, 2000000000000000)
             return (True, 1000000000)
 
         s.balance_adapter.get_balance = AsyncMock(side_effect=get_balance_side_effect)
@@ -111,10 +89,10 @@ def strategy():
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
         s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
-            return_value=(True, "Transfer successful (simulated)")
+            return_value=(True, "0xtxhash_transfer")
         )
         s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
-            return_value=(True, "Transfer successful (simulated)")
+            return_value=(True, "0xtxhash_transfer")
         )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
@@ -154,46 +132,36 @@ def strategy():
 
     if hasattr(s, "brap_adapter") and s.brap_adapter:
 
-        def get_swap_quote_side_effect(*args, **kwargs):
+        def best_quote_side_effect(*args, **kwargs):
             to_token_address = kwargs.get("to_token_address", "")
             if to_token_address == "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913":
-                return (
-                    True,
-                    {
-                        "quotes": {
-                            "best_quote": {
-                                "output_amount": "99900000",
-                            }
-                        }
-                    },
-                )
+                return (True, {"output_amount": "99900000"})
             return (
                 True,
                 {
-                    "quotes": {
-                        "best_quote": {
-                            "output_amount": "105000000",
-                            "input_amount": "50000000000000",
-                            "toAmount": "105000000",
-                            "estimatedGas": "1000000000",
-                            "fromAmount": "100000000",
-                            "fromToken": {"symbol": "USDC"},
-                            "toToken": {"symbol": "POOL"},
-                        }
-                    }
+                    "output_amount": "105000000",
+                    "input_amount": "50000000000000",
+                    "toAmount": "105000000",
+                    "estimatedGas": "1000000000",
+                    "fromAmount": "100000000",
+                    "fromToken": {"symbol": "USDC"},
+                    "toToken": {"symbol": "POOL"},
                 },
             )
 
-        s.brap_adapter.get_swap_quote = AsyncMock(
-            side_effect=get_swap_quote_side_effect
-        )
+        s.brap_adapter.best_quote = AsyncMock(side_effect=best_quote_side_effect)
 
     if (
         hasattr(s, "brap_adapter")
         and s.brap_adapter
         and hasattr(s.brap_adapter, "swap_from_quote")
     ):
-        s.brap_adapter.swap_from_quote = AsyncMock(return_value=None)
+        s.brap_adapter.swap_from_quote = AsyncMock(
+            return_value=(
+                True,
+                {"tx_hash": "0xmockhash", "from_amount": "100", "to_amount": "99"},
+            )
+        )
 
     s.DEPOSIT_USDC = 0
     s.usdc_token_info = {
@@ -408,13 +376,9 @@ async def test_deposit_tracks_usdc(strategy):
 
 @pytest.mark.asyncio
 async def test_sweep_wallet_uses_tracked_tokens(strategy):
-    from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (
-        StablecoinYieldStrategy,
-    )
-
     # Restore the real _sweep_wallet method (fixture mocks it as a no-op)
-    strategy._sweep_wallet = StablecoinYieldStrategy._sweep_wallet.__get__(
-        strategy, StablecoinYieldStrategy
+    strategy._sweep_wallet = _StablecoinYieldStrategy._sweep_wallet.__get__(
+        strategy, _StablecoinYieldStrategy
     )
 
     strategy._track_token("token-1", 1000000)
@@ -426,8 +390,9 @@ async def test_sweep_wallet_uses_tracked_tokens(strategy):
     assert "token-2" in strategy.tracked_token_ids
 
     # Mock balance adapter to return fresh balances
-    async def get_balance_mock(query, **kwargs):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    def get_balance_mock(
+        *, wallet_address, token_id=None, token_address=None, chain_id=None
+    ):
         balance = strategy.tracked_balances.get(token_id, 0)
         return (True, int(balance) if balance else 0)
 
@@ -468,8 +433,9 @@ async def test_get_non_gas_balances_uses_tracked_state(strategy):
     strategy._track_token(pool_token_id, 50000000000000000000)
 
     # Mock refresh
-    def _get_balance_effect(query, **kwargs):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    def _get_balance_effect(
+        *, wallet_address, token_id=None, token_address=None, chain_id=None
+    ):
         return (True, strategy.tracked_balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(side_effect=_get_balance_effect)
@@ -488,8 +454,9 @@ async def test_partial_liquidate_uses_tracked_tokens(strategy):
     strategy._track_token("test-pool-base", 100000000000000000000)
 
     # Mock balance and token adapters
-    def _get_balance_effect_partial(query, **kwargs):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    def _get_balance_effect_partial(
+        *, wallet_address, token_id=None, token_address=None, chain_id=None
+    ):
         return (True, strategy.tracked_balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(

wayfinder_paths/tests/test_mcp_quote_swap.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.quotes import quote_swap
+
+
+@pytest.mark.asyncio
+async def test_quote_swap_returns_compact_best_quote_by_default():
+    fake_wallet = {"address": "0x000000000000000000000000000000000000dEaD"}
+
+    class FakeTokenClient:
+        async def get_gas_token(self, chain_code: str):
+            assert chain_code == "arbitrum"
+            return {
+                "token_id": "ethereum-arbitrum",
+                "asset_id": "ethereum",
+                "symbol": "ETH",
+                "decimals": 18,
+                "chain_id": 42161,
+                "address": "0x0000000000000000000000000000000000000000",
+            }
+
+        async def get_token_details(self, query: str):
+            assert query == "usd-coin-arbitrum"
+            return {
+                "token_id": "usd-coin-arbitrum",
+                "asset_id": "usd-coin",
+                "symbol": "USDC",
+                "decimals": 6,
+                "chain_id": 42161,
+                "address": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+            }
+
+    class FakeBRAPClient:
+        async def get_quote(self, **kwargs):  # noqa: ANN003
+            assert kwargs["from_chain_id"] == 42161
+            assert kwargs["to_chain_id"] == 42161
+            assert kwargs["slippage"] == pytest.approx(0.005)
+
+            calldata = "0x" + ("ab" * 4096)
+            return {
+                "quotes": {
+                    "quote_count": 3,
+                    "best_quote": {
+                        "provider": "brap_best",
+                        "input_amount": kwargs["amount1"],
+                        "output_amount": "1234567",
+                        "input_amount_usd": 5.0,
+                        "output_amount_usd": 4.99,
+                        "gas_estimate": 210000,
+                        "fee_estimate": {"total_usd": 0.01},
+                        "native_input": True,
+                        "native_output": False,
+                        "calldata": calldata,
+                        "wrap_transaction": None,
+                        "unwrap_transaction": None,
+                    },
+                    "all_quotes": [
+                        {"provider": "brap_best"},
+                        {"provider": "brap_alt"},
+                        {"provider": "brap_alt"},
+                    ],
+                }
+            }
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.find_wallet_by_label",
+            return_value=fake_wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.TokenClient",
+            return_value=FakeTokenClient(),
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.BRAPClient", return_value=FakeBRAPClient()
+        ),
+    ):
+        out = await quote_swap(
+            wallet_label="main",
+            from_token="ethereum-arbitrum",
+            to_token="usd-coin-arbitrum",
+            amount="0.0017",
+            slippage_bps=50,
+        )
+
+    assert out["ok"] is True
+    res = out["result"]
+    assert "raw" not in res["quote"]
+
+    best = res["quote"]["best_quote"]
+    assert best["provider"] == "brap_best"
+    assert best["output_amount"] == "1234567"
+    assert best["calldata_len"] > 0
+    assert "calldata" not in best
+    assert res["quote"]["quote_count"] == 3
+    assert res["quote"]["providers"] == ["brap_best", "brap_alt"]
+
+
+@pytest.mark.asyncio
+async def test_quote_swap_can_include_calldata_when_requested():
+    fake_wallet = {"address": "0x000000000000000000000000000000000000dEaD"}
+    token_client = AsyncMock()
+    token_client.get_gas_token = AsyncMock(
+        return_value={
+            "token_id": "ethereum-arbitrum",
+            "asset_id": "ethereum",
+            "symbol": "ETH",
+            "decimals": 18,
+            "chain_id": 42161,
+            "address": "0x0000000000000000000000000000000000000000",
+        }
+    )
+    token_client.get_token_details = AsyncMock(
+        return_value={
+            "token_id": "usd-coin-arbitrum",
+            "asset_id": "usd-coin",
+            "symbol": "USDC",
+            "decimals": 6,
+            "chain_id": 42161,
+            "address": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        }
+    )
+
+    calldata = "0x" + ("cd" * 1024)
+    brap_client = AsyncMock()
+    brap_client.get_quote = AsyncMock(
+        return_value={
+            "quotes": {
+                "quote_count": 1,
+                "best_quote": {
+                    "provider": "brap_best",
+                    "output_amount": "1",
+                    "calldata": calldata,
+                },
+                "all_quotes": [{"provider": "brap_best"}],
+            }
+        }
+    )
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.find_wallet_by_label",
+            return_value=fake_wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.TokenClient", return_value=token_client
+        ),
+        patch("wayfinder_paths.mcp.tools.quotes.BRAPClient", return_value=brap_client),
+    ):
+        out = await quote_swap(
+            wallet_label="main",
+            from_token="ethereum-arbitrum",
+            to_token="usd-coin-arbitrum",
+            amount="0.0017",
+            slippage_bps=50,
+            include_calldata=True,
+        )
+
+    assert out["ok"] is True
+    best = out["result"]["quote"]["best_quote"]
+    assert best["calldata"] == calldata

wayfinder_paths/tests/test_test_coverage.py

@@ -1,3 +1,4 @@
+import json
 from pathlib import Path
 
 import pytest
@@ -105,7 +106,6 @@ def test_strategy_tests_use_examples_json():
         if not test_file.exists():
             continue
 
-        # Read the test file content
         try:
             content = test_file.read_text()
 
@@ -162,8 +162,6 @@ def test_strategy_examples_have_smoke():
     if not strategies_dir.exists():
         pytest.skip("Strategies directory not found")
 
-    import json
-
     missing_smoke = []
 
     # Find all strategy directories
@@ -174,7 +172,6 @@ def test_strategy_examples_have_smoke():
         strategy_py = strategy_dir / "strategy.py"
         examples_json = strategy_dir / "examples.json"
 
-        # Only check strategies that exist
         if not strategy_py.exists():
             continue