wayfinder-paths 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -206,15 +206,6 @@ class StablecoinYieldStrategy(Strategy):
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
-            self.register_adapters(
-                [
-                    balance,
-                    token_adapter,
-                    ledger_adapter,
-                    pool_adapter,
-                    brap_adapter,
-                ]
-            )
             self.balance_adapter = balance
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
@@ -504,7 +495,6 @@ class StablecoinYieldStrategy(Strategy):
             == self.current_pool.get("chain").get("id")
             else None
         )
-        # Refresh all tracked balances from blockchain
         await self._refresh_tracked_balances()
         logger.info(
             f"Refreshed balances for {len(self.tracked_balances)} tracked tokens"
@@ -573,7 +563,6 @@ class StablecoinYieldStrategy(Strategy):
 
     async def _infer_active_pool_from_tracked_tokens(self):
         try:
-            # Refresh balances for tracked tokens
             await self._refresh_tracked_balances()
 
             usdc_token_id = self.usdc_token_info.get("token_id")
@@ -582,7 +571,6 @@ class StablecoinYieldStrategy(Strategy):
             best_token_id = None
             best_balance_wei = 0
 
-            # Find the non-gas, non-USDC token with the largest balance
             for token_id, balance_wei in self.tracked_balances.items():
                 if balance_wei <= 0:
                     continue
@@ -591,7 +579,6 @@ class StablecoinYieldStrategy(Strategy):
                 if token_id == usdc_token_id:
                     continue
 
-                # Prefer tokens with larger balances
                 if balance_wei > best_balance_wei:
                     best_token_id = token_id
                     best_balance_wei = balance_wei
@@ -792,7 +779,6 @@ class StablecoinYieldStrategy(Strategy):
                         f"Need at least {required_gas} {gas_symbol} on Base for gas. You have: {total_gas}",
                     )
 
-            # Transfer main token if provided
             if main_token_amount > 0:
                 self.current_pool_balance = int(
                     main_token_amount * (10 ** self.current_pool.get("decimals"))
@@ -800,7 +786,6 @@ class StablecoinYieldStrategy(Strategy):
                 self.DEPOSIT_USDC = main_token_amount
                 logger.info(f"Set deposit amount to {main_token_amount} USDC")
 
-                # Transfer USDC from main to strategy wallet
                 logger.info("Initiating USDC transfer from main to strategy wallet")
                 (
                     success,
@@ -978,7 +963,6 @@ class StablecoinYieldStrategy(Strategy):
 
         transferred_items = []
 
-        # Transfer USDC to main wallet
         usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
             token_id="usd-coin-base",
             wallet_address=strategy_address,
@@ -1001,7 +985,6 @@ class StablecoinYieldStrategy(Strategy):
                 else:
                     logger.warning(f"USDC transfer failed: {msg}")
 
-        # Transfer ETH (minus reserve for tx fees) to main wallet
         eth_ok, eth_raw = await self.balance_adapter.get_balance(
             token_id="ethereum-base",
             wallet_address=strategy_address,
@@ -1223,7 +1206,6 @@ class StablecoinYieldStrategy(Strategy):
             pass
 
     async def _sweep_wallet(self, target_token):
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         target_token_id = target_token.get("token_id")
@@ -1231,17 +1213,13 @@ class StablecoinYieldStrategy(Strategy):
         target_address = target_token.get("address", "").lower()
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
 
-        # Swap all non-target, non-gas tokens to the target
         for token_id, balance_wei in list(self.tracked_balances.items()):
-            # Skip if no balance
             if balance_wei <= 0:
                 continue
 
-            # Skip gas token
             if token_id == gas_token_id:
                 continue
 
-            # Skip if it's already the target token
             if token_id == target_token_id:
                 continue
 
@@ -1281,9 +1259,7 @@ class StablecoinYieldStrategy(Strategy):
                 logger.error(f"Error sweeping {token_id}: {e}")
                 continue
 
-        # Track the target token
         self._track_token(target_token_id)
-        # Refresh target token balance
         try:
             success, target_balance = await self.balance_adapter.get_balance(
                 token_id=target_token_id,
@@ -1368,18 +1344,15 @@ class StablecoinYieldStrategy(Strategy):
         )
 
     async def _get_non_gas_balances(self) -> list[dict[str, Any]]:
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
         results = []
 
         for token_id, balance_wei in self.tracked_balances.items():
-            # Skip gas token
             if token_id == gas_token_id:
                 continue
 
-            # Skip zero balances
             if balance_wei <= 0:
                 continue
 
@@ -1551,7 +1524,6 @@ class StablecoinYieldStrategy(Strategy):
         )
 
         if not self.DEPOSIT_USDC:
-            # No deposits recorded - report minimal status
             status_payload = {
                 "info": "No recorded strategy deposits.",
                 "idle_usd": 0.0,
@@ -1631,7 +1603,6 @@ class StablecoinYieldStrategy(Strategy):
         return [f"({wallet_id}) && (({approve_enso}) || ({swap_enso})) "]
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         usdc_token_id = self.usdc_token_info.get("token_id")
@@ -1641,12 +1612,10 @@ class StablecoinYieldStrategy(Strategy):
         available_usdc_wei = self.tracked_balances.get(usdc_token_id, 0)
         available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
 
-        # Liquidate non-USDC, non-gas, non-current-pool tokens first
         for token_id, balance_wei in list(self.tracked_balances.items()):
             if available_usdc_usd >= usd_value:
                 break
 
-            # Skip USDC, gas, and current pool
             if token_id == usdc_token_id:
                 continue
             if token_id == gas_token_id:
@@ -1654,7 +1623,6 @@ class StablecoinYieldStrategy(Strategy):
             if self.current_pool and token_id == self.current_pool.get("token_id"):
                 continue
 
-            # Skip zero balances
             if balance_wei <= 0:
                 continue
 
@@ -1706,7 +1674,6 @@ class StablecoinYieldStrategy(Strategy):
             available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
             self._update_balance(usdc_token_id, available_usdc_wei)
 
-        # If still not enough, liquidate from current pool
         if (
             available_usdc_usd < usd_value
             and self.current_pool
@@ -1741,7 +1708,6 @@ class StablecoinYieldStrategy(Strategy):
                 except Exception as e:
                     logger.error(f"Error swapping pool to USDC: {e}")
 
-                # Refresh USDC balance again
                 success, usdc_wei = await self.balance_adapter.get_balance(
                     token_id=usdc_token_id,
                     wallet_address=self._get_strategy_wallet_address(),

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
@@ -395,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)

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