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

wayfinder_paths/core/utils/test_transaction.py

@@ -0,0 +1,289 @@
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from web3 import AsyncWeb3
+
+from wayfinder_paths.core.constants import SUPPORTED_CHAINS
+from wayfinder_paths.core.utils.transaction import (
+    PRE_EIP_1559_CHAIN_IDS,
+    _get_transaction_from_address,
+    gas_limit_transaction,
+    gas_price_transaction,
+    nonce_transaction,
+)
+from wayfinder_paths.core.utils.web3 import get_transaction_chain_id
+
+RANDOM_USER_0 = "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"
+
+
+def for_every_chain_id(async_f):
+    return asyncio.gather(*[async_f(chain_id) for chain_id in SUPPORTED_CHAINS])
+
+
+class TestGetChainId:
+    def test_valid_chain_id(self):
+        transaction = {"chainId": 1}
+        result = get_transaction_chain_id(transaction)
+        assert result == 1
+
+    def test_chain_id_as_string(self):
+        transaction = {"chainId": "1"}
+        result = get_transaction_chain_id(transaction)
+        assert result == 1
+
+    def test_empty_transaction(self):
+        transaction = {}
+        with pytest.raises(ValueError, match="Transaction does not contain chainId"):
+            get_transaction_chain_id(transaction)
+
+
+class TestGetFromAddress:
+    def test_valid_checksum_address(self):
+        transaction = {"from": RANDOM_USER_0}
+        result = _get_transaction_from_address(transaction)
+        assert result == RANDOM_USER_0
+        assert AsyncWeb3.is_checksum_address(result)
+
+    def test_lowercase_address_converted_to_checksum(self):
+        lowercase_address = RANDOM_USER_0.lower()
+        transaction = {"from": lowercase_address}
+        result = _get_transaction_from_address(transaction)
+        assert AsyncWeb3.is_checksum_address(result)
+        assert result == RANDOM_USER_0
+
+    def test_empty_transaction(self):
+        transaction = {}
+        with pytest.raises(
+            ValueError, match="Transaction does not contain from address"
+        ):
+            _get_transaction_from_address(transaction)
+
+
+@pytest.mark.asyncio
+class TestNonceTransaction:
+    @pytest.fixture
+    def mock_web3(self):
+        web3 = MagicMock()
+        web3.eth = MagicMock()
+        web3.eth.get_transaction_count = AsyncMock()
+        return web3
+
+    async def test_noncing_on_mainnet(self):
+        transaction = {
+            "from": RANDOM_USER_0,
+            "chainId": 1,
+        }
+        result = await nonce_transaction(transaction)
+        assert result["nonce"] >= 0
+
+    async def test_noncing_on_all_chains(self):
+        async def test_noncing(chain_id):
+            transaction = {
+                "from": RANDOM_USER_0,
+                "chainId": chain_id,
+            }
+            result = await nonce_transaction(transaction)
+            assert "nonce" in result
+            assert result["nonce"] >= 0
+
+        await for_every_chain_id(test_noncing)
+
+    @patch("wayfinder_paths.core.utils.transaction.web3s_from_chain_id")
+    async def test_multiple_web3s_returns_max_nonce(self, mock_web3s_context):
+        mock_web3_1 = MagicMock()
+        mock_web3_1.eth = MagicMock()
+        mock_web3_1.eth.get_transaction_count = AsyncMock(return_value=5)
+        mock_web3_1.provider.disconnect = AsyncMock()
+
+        mock_web3_2 = MagicMock()
+        mock_web3_2.eth = MagicMock()
+        mock_web3_2.eth.get_transaction_count = AsyncMock(return_value=8)
+        mock_web3_2.provider.disconnect = AsyncMock()
+
+        mock_web3_3 = MagicMock()
+        mock_web3_3.eth = MagicMock()
+        mock_web3_3.eth.get_transaction_count = AsyncMock(return_value=6)
+        mock_web3_3.provider.disconnect = AsyncMock()
+
+        mock_web3s_context.return_value.__aenter__.return_value = [
+            mock_web3_1,
+            mock_web3_2,
+            mock_web3_3,
+        ]
+
+        transaction = {
+            "from": RANDOM_USER_0,
+            "chainId": 1,
+        }
+
+        result = await nonce_transaction(transaction)
+
+        assert result["nonce"] == 8
+        mock_web3_1.eth.get_transaction_count.assert_called_once()
+        mock_web3_2.eth.get_transaction_count.assert_called_once()
+        mock_web3_3.eth.get_transaction_count.assert_called_once()
+
+    @patch("wayfinder_paths.core.utils.transaction.web3s_from_chain_id")
+    async def test_preserves_all_existing_fields(self, mock_web3s_context, mock_web3):
+        mock_web3.eth.get_transaction_count.return_value = 5
+        mock_web3.provider.disconnect = AsyncMock()
+        mock_web3s_context.return_value.__aenter__.return_value = [mock_web3]
+
+        transaction = {
+            "from": RANDOM_USER_0,
+            "chainId": 1,
+            "to": RANDOM_USER_0,
+            "value": 100,
+            "gas": 21000,
+            "gasPrice": 1000000000,
+            "data": "0xabcd",
+        }
+
+        result = await nonce_transaction(transaction)
+
+        assert result["nonce"] == 5
+        assert result["from"] == transaction["from"]
+        assert result["chainId"] == transaction["chainId"]
+        assert result["to"] == transaction["to"]
+        assert result["value"] == transaction["value"]
+        assert result["gas"] == transaction["gas"]
+        assert result["gasPrice"] == transaction["gasPrice"]
+        assert result["data"] == transaction["data"]
+
+
+@pytest.mark.asyncio
+class TestGasPriceTransaction:
+    async def test_pricing_on_all_chains(self):
+        async def test_pricing(chain_id):
+            transaction = {
+                "chainId": chain_id,
+            }
+            result = await gas_price_transaction(transaction)
+            if chain_id in PRE_EIP_1559_CHAIN_IDS:
+                assert "maxFeePerGas" not in result
+                assert "maxPriorityFeePerGas" not in result
+                assert result["gasPrice"] > 0
+            elif chain_id == 999:
+                assert "gasPrice" not in result
+                assert result["maxFeePerGas"] > 0
+                assert result["maxPriorityFeePerGas"] == 0
+            else:
+                assert "gasPrice" not in result
+                assert result["maxFeePerGas"] > 0
+                assert result["maxPriorityFeePerGas"] > 0
+
+        await for_every_chain_id(test_pricing)
+
+    @patch("wayfinder_paths.core.utils.transaction.web3s_from_chain_id")
+    async def test_eip1559_with_custom_multiplier_and_max_aggregation(
+        self, mock_web3s_context
+    ):
+        # Mock multiple web3 instances with different base fees and priority fees
+        mock_block_1 = MagicMock()
+        mock_block_1.baseFeePerGas = 30_000_000_000
+        mock_fee_history_1 = MagicMock()
+        mock_fee_history_1.reward = [[2_000_000_000] for _ in range(10)]
+        mock_web3_1 = MagicMock()
+        mock_web3_1.eth = MagicMock()
+        mock_web3_1.eth.get_block = AsyncMock(return_value=mock_block_1)
+        mock_web3_1.eth.fee_history = AsyncMock(return_value=mock_fee_history_1)
+        mock_web3_1.provider.disconnect = AsyncMock()
+
+        mock_block_2 = MagicMock()
+        mock_block_2.baseFeePerGas = 35_000_000_000
+        mock_fee_history_2 = MagicMock()
+        mock_fee_history_2.reward = [[3_000_000_000] for _ in range(10)]
+        mock_web3_2 = MagicMock()
+        mock_web3_2.eth = MagicMock()
+        mock_web3_2.eth.get_block = AsyncMock(return_value=mock_block_2)
+        mock_web3_2.eth.fee_history = AsyncMock(return_value=mock_fee_history_2)
+        mock_web3_2.provider.disconnect = AsyncMock()
+
+        mock_block_3 = MagicMock()
+        mock_block_3.baseFeePerGas = 32_000_000_000
+        mock_fee_history_3 = MagicMock()
+        mock_fee_history_3.reward = [[2_500_000_000] for _ in range(10)]
+        mock_web3_3 = MagicMock()
+        mock_web3_3.eth = MagicMock()
+        mock_web3_3.eth.get_block = AsyncMock(return_value=mock_block_3)
+        mock_web3_3.eth.fee_history = AsyncMock(return_value=mock_fee_history_3)
+        mock_web3_3.provider.disconnect = AsyncMock()
+
+        mock_web3s_context.return_value.__aenter__.return_value = [
+            mock_web3_1,
+            mock_web3_2,
+            mock_web3_3,
+        ]
+
+        transaction = {"chainId": 1}
+        custom_priority_multiplier = 2.0
+
+        result = await gas_price_transaction(
+            transaction, priority_fee_multiplier=custom_priority_multiplier
+        )
+
+        # Should use max base fee (35 gwei) and max priority fee (3 gwei)
+        expected_max_priority_fee = int(3_000_000_000 * custom_priority_multiplier)
+        expected_max_fee = int(
+            35_000_000_000 * 2 + 3_000_000_000 * custom_priority_multiplier
+        )
+
+        assert result["maxPriorityFeePerGas"] == expected_max_priority_fee
+        assert result["maxFeePerGas"] == expected_max_fee
+        assert "gasPrice" not in result
+
+    @patch("wayfinder_paths.core.utils.transaction.web3s_from_chain_id")
+    async def test_non_eip1559_with_custom_multiplier_and_max_aggregation(
+        self, mock_web3s_context
+    ):
+        # Mock multiple web3 instances with different gas prices
+        # gas_price is an awaitable property, so we need to make it a coroutine
+        mock_web3_1 = MagicMock()
+        mock_web3_1.eth = MagicMock()
+        mock_web3_1.eth.gas_price = AsyncMock(return_value=5_000_000_000)()
+        mock_web3_1.provider.disconnect = AsyncMock()
+
+        mock_web3_2 = MagicMock()
+        mock_web3_2.eth = MagicMock()
+        mock_web3_2.eth.gas_price = AsyncMock(return_value=8_000_000_000)()
+        mock_web3_2.provider.disconnect = AsyncMock()
+
+        mock_web3_3 = MagicMock()
+        mock_web3_3.eth = MagicMock()
+        mock_web3_3.eth.gas_price = AsyncMock(return_value=6_000_000_000)()
+        mock_web3_3.provider.disconnect = AsyncMock()
+
+        mock_web3s_context.return_value.__aenter__.return_value = [
+            mock_web3_1,
+            mock_web3_2,
+            mock_web3_3,
+        ]
+
+        transaction = {"chainId": 56}
+        custom_gas_multiplier = 2.5
+
+        result = await gas_price_transaction(
+            transaction, gas_price_multiplier=custom_gas_multiplier
+        )
+
+        # Should use max gas price (8 gwei) * multiplier
+        expected_gas_price = int(8_000_000_000 * custom_gas_multiplier)
+
+        assert result["gasPrice"] == expected_gas_price
+        assert "maxFeePerGas" not in result
+        assert "maxPriorityFeePerGas" not in result
+
+
+@pytest.mark.asyncio
+class TestGasLimitTransaction:
+    async def test_gas_limit_on_all_chains(self):
+        async def test_gas_limit(chain_id):
+            transaction = {
+                "chainId": chain_id,
+            }
+            result = await gas_limit_transaction(transaction)
+            assert "gas" in result
+            assert result["gas"] > 0
+
+        await for_every_chain_id(test_gas_limit)

wayfinder_paths/core/utils/transaction.py

@@ -1,6 +1,8 @@
 import asyncio
 from collections.abc import Callable
+from typing import Any
 
+from eth_account import Account
 from loguru import logger
 from web3 import AsyncWeb3
 
@@ -180,7 +182,7 @@ async def send_transaction(
     if sign_callback is None:
         raise ValueError("sign_callback must be provided to send transaction")
 
-    logger.info(f"Broadcasting transaction {transaction.get('to', 'unknown')[:10]}...")
+    logger.info(f"Broadcasting transaction {transaction}...")
     chain_id = get_transaction_chain_id(transaction)
     transaction = await gas_limit_transaction(transaction)
     transaction = await nonce_transaction(transaction)
@@ -193,4 +195,45 @@ async def send_transaction(
     return txn_hash
 
 
+async def sign_and_send_transaction(
+    transaction: dict, private_key: str, wait_for_receipt: bool = True
+) -> str:
+    account = Account.from_key(private_key)
+
+    async def sign_callback(tx: dict) -> bytes:
+        signed = account.sign_transaction(tx)
+        return signed.raw_transaction
+
+    return await send_transaction(transaction, sign_callback, wait_for_receipt)
+
+
+async def encode_call(
+    *,
+    target: str,
+    abi: list[dict[str, Any]],
+    fn_name: str,
+    args: list[Any],
+    from_address: str,
+    chain_id: int,
+    value: int = 0,
+) -> dict[str, Any]:
+    async with web3_from_chain_id(chain_id) as web3:
+        contract = web3.eth.contract(address=target, abi=abi)
+        try:
+            tx_data = await getattr(contract.functions, fn_name)(
+                *args
+            ).build_transaction({"from": from_address})
+            data = tx_data["data"]
+        except ValueError as exc:
+            raise ValueError(f"Failed to encode {fn_name}: {exc}") from exc
+
+        return {
+            "chainId": int(chain_id),
+            "from": AsyncWeb3.to_checksum_address(from_address),
+            "to": AsyncWeb3.to_checksum_address(target),
+            "data": data,
+            "value": int(value),
+        }
+
+
 # TODO: HypeEVM Big Blocks: Setting and detecting

wayfinder_paths/core/utils/web3.py

@@ -26,6 +26,9 @@ def _get_rpcs_for_chain_id(chain_id: int) -> list:
     rpcs = get_rpc_urls().get(str(chain_id))
     if rpcs is None:
         raise ValueError(f"No RPCs configured for chain ID {chain_id}")
+    # Handle both string (single URL) and list (multiple URLs) formats
+    if isinstance(rpcs, str):
+        return [rpcs]
     return rpcs
 
 

wayfinder_paths/mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Wayfinder Paths MCP server package.
+
+This package is intentionally isolated from the core SDK so that importing
+`wayfinder_paths` does not require MCP dependencies.
+"""

wayfinder_paths/mcp/preview.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any
+
+from wayfinder_paths.core.constants.hyperliquid import (
+    ARBITRUM_USDC_TOKEN_ID,
+    HYPE_FEE_WALLET,
+    HYPERLIQUID_BRIDGE_ADDRESS,
+)
+from wayfinder_paths.mcp.utils import (
+    find_wallet_by_label,
+    normalize_address,
+    read_text_excerpt,
+    repo_root,
+)
+
+
+def build_execution_preview(tool_input: dict[str, Any]) -> dict[str, Any]:
+    req = tool_input.get("request") if isinstance(tool_input, dict) else None
+    if not isinstance(req, dict):
+        return {
+            "summary": "Execute request missing 'request' object.",
+            "recipient_mismatch": False,
+        }
+
+    kind = str(req.get("kind") or "").strip()
+    wallet_label = str(req.get("wallet_label") or "").strip()
+    w = find_wallet_by_label(wallet_label) if wallet_label else None
+    sender = normalize_address((w or {}).get("address")) if w else None
+
+    recipient = normalize_address(req.get("recipient"))
+    if kind == "swap":
+        recipient = recipient or sender
+        summary = (
+            "EXECUTE swap\n"
+            f"wallet_label: {wallet_label}\n"
+            f"from_token: {req.get('from_token')}\n"
+            f"to_token: {req.get('to_token')}\n"
+            f"amount: {req.get('amount')}\n"
+            f"slippage_bps: {req.get('slippage_bps')}\n"
+            f"sender: {sender or '(unknown)'}\n"
+            f"recipient: {recipient or '(unknown)'}"
+        )
+    elif kind == "hyperliquid_deposit":
+        recipient = normalize_address(HYPERLIQUID_BRIDGE_ADDRESS)
+        summary = (
+            "EXECUTE hyperliquid_deposit (Bridge2)\n"
+            f"wallet_label: {wallet_label}\n"
+            f"token: {ARBITRUM_USDC_TOKEN_ID}\n"
+            f"amount: {req.get('amount')}\n"
+            "chain_id: 42161\n"
+            f"sender: {sender or '(unknown)'}\n"
+            f"recipient: {recipient or '(missing)'}"
+        )
+    elif kind == "send":
+        summary = (
+            "EXECUTE send\n"
+            f"wallet_label: {wallet_label}\n"
+            f"token: {req.get('token')}\n"
+            f"amount: {req.get('amount')}\n"
+            f"chain_id: {req.get('chain_id')}\n"
+            f"sender: {sender or '(unknown)'}\n"
+            f"recipient: {recipient or '(missing)'}"
+        )
+    else:
+        summary = f"EXECUTE {kind or '(unknown kind)'}\nwallet_label: {wallet_label}"
+
+    mismatch = bool(sender and recipient and sender.lower() != recipient.lower())
+    if kind == "hyperliquid_deposit":
+        mismatch = False  # deposit recipient is fixed; mismatch is expected
+    return {"summary": summary, "recipient_mismatch": mismatch}
+
+
+def build_run_script_preview(tool_input: dict[str, Any]) -> dict[str, Any]:
+    ti = tool_input if isinstance(tool_input, dict) else {}
+    path_raw = ti.get("script_path") or ti.get("path")
+    args = ti.get("args") if isinstance(ti.get("args"), list) else []
+    dry_run = bool(ti.get("dry_run", True))
+
+    if not isinstance(path_raw, str) or not path_raw.strip():
+        return {"summary": "RUN_SCRIPT missing script_path."}
+
+    root = repo_root()
+    p = Path(path_raw)
+    if not p.is_absolute():
+        p = root / p
+    resolved = p.resolve(strict=False)
+
+    rel = str(resolved)
+    try:
+        rel = str(resolved.relative_to(root))
+    except Exception:
+        pass
+
+    sha = None
+    try:
+        if resolved.exists():
+            sha = hashlib.sha256(resolved.read_bytes()).hexdigest()
+    except Exception:
+        sha = None
+
+    excerpt = read_text_excerpt(resolved, max_chars=1200) if resolved.exists() else None
+
+    summary = (
+        "RUN_SCRIPT (executes local python)\n"
+        f"script_path: {rel}\n"
+        f"dry_run: {dry_run}\n"
+        f"args: {args or []}\n"
+        f"script_sha256: {(sha[:12] + '…') if sha else '(unavailable)'}"
+    )
+    if excerpt:
+        summary += "\n\n" + excerpt
+    else:
+        summary += "\n\n(no script contents available)"
+
+    return {"summary": summary}
+
+
+def build_hyperliquid_execute_preview(tool_input: dict[str, Any]) -> dict[str, Any]:
+    # hyperliquid_execute uses direct parameters, not a 'request' wrapper
+    req = tool_input if isinstance(tool_input, dict) else {}
+    if not req:
+        return {"summary": "HYPERLIQUID_EXECUTE missing parameters."}
+
+    action = str(req.get("action") or "").strip()
+    wallet_label = str(req.get("wallet_label") or "").strip()
+    w = find_wallet_by_label(wallet_label) if wallet_label else None
+    sender = normalize_address((w or {}).get("address")) if w else None
+
+    dry_run = req.get("dry_run")
+    coin = req.get("coin")
+    asset_id = req.get("asset_id")
+
+    header = "HYPERLIQUID_EXECUTE\n"
+    base = (
+        f"action: {action or '(missing)'}\n"
+        f"wallet_label: {wallet_label}\n"
+        f"address: {sender or '(unknown)'}\n"
+        f"dry_run: {dry_run}\n"
+        f"coin: {coin}\n"
+        f"asset_id: {asset_id}"
+    )
+
+    if action == "place_order":
+        details = (
+            "\n\nORDER\n"
+            f"order_type: {req.get('order_type')}\n"
+            f"is_buy: {req.get('is_buy')}\n"
+            f"size: {req.get('size')}\n"
+            f"usd_amount: {req.get('usd_amount')}\n"
+            f"usd_amount_kind: {req.get('usd_amount_kind')}\n"
+            f"price: {req.get('price')}\n"
+            f"slippage: {req.get('slippage')}\n"
+            f"reduce_only: {req.get('reduce_only')}\n"
+            f"cloid: {req.get('cloid')}\n"
+            f"leverage: {req.get('leverage')}\n"
+            f"is_cross: {req.get('is_cross')}\n"
+            f"builder_wallet: {HYPE_FEE_WALLET}\n"
+            f"builder_fee_tenths_bp: {req.get('builder_fee_tenths_bp') or '(from config/default)'}"
+        )
+        return {"summary": header + base + details}
+
+    if action == "cancel_order":
+        details = (
+            "\n\nCANCEL\n"
+            f"order_id: {req.get('order_id')}\n"
+            f"cancel_cloid: {req.get('cancel_cloid')}"
+        )
+        return {"summary": header + base + details}
+
+    if action == "update_leverage":
+        details = (
+            "\n\nLEVERAGE\n"
+            f"leverage: {req.get('leverage')}\n"
+            f"is_cross: {req.get('is_cross')}"
+        )
+        return {"summary": header + base + details}
+
+    if action == "withdraw":
+        details = f"\n\nWITHDRAW\namount_usdc: {req.get('amount_usdc')}"
+        return {"summary": header + base + details}
+
+    return {"summary": header + base}

wayfinder_paths/mcp/scripting.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+from eth_account import Account
+
+from wayfinder_paths.mcp.utils import find_wallet_by_label, load_config_json
+
+# Known signing callback parameter names used by adapters
+_SIGNING_CALLBACK_PARAMS = frozenset(
+    {
+        "strategy_wallet_signing_callback",
+        "sign_callback",
+        "signing_callback",
+    }
+)
+
+
+def _make_sign_callback(private_key: str):
+    account = Account.from_key(private_key)
+
+    async def sign_callback(transaction: dict) -> bytes:
+        signed = account.sign_transaction(transaction)
+        return signed.raw_transaction
+
+    return sign_callback
+
+
+def _detect_callback_params(adapter_class: type) -> set[str]:
+    try:
+        sig = inspect.signature(adapter_class.__init__)
+    except (ValueError, TypeError):
+        return set()
+
+    return {
+        name
+        for name in sig.parameters
+        if name in _SIGNING_CALLBACK_PARAMS or name.endswith("_signing_callback")
+    }
+
+
+def get_adapter[T](
+    adapter_class: type[T],
+    wallet_label: str | None = None,
+    *,
+    config_overrides: dict[str, Any] | None = None,
+    **kwargs: Any,
+) -> T:
+    config = load_config_json()
+
+    if config_overrides:
+        config = {**config, **config_overrides}
+
+    sign_callback = None
+    if wallet_label:
+        wallet = find_wallet_by_label(wallet_label)
+        if not wallet:
+            raise ValueError(
+                f"Wallet '{wallet_label}' not found in wallets.json. "
+                "Run 'just create-wallets' or check WALLETS_PATH."
+            )
+
+        private_key = wallet.get("private_key") or wallet.get("private_key_hex")
+        if not private_key:
+            raise ValueError(
+                f"Wallet '{wallet_label}' is missing private_key_hex. "
+                "Local signing requires a private key."
+            )
+
+        config["strategy_wallet"] = wallet
+        sign_callback = _make_sign_callback(private_key)
+
+    callback_params = _detect_callback_params(adapter_class)
+    adapter_kwargs: dict[str, Any] = {"config": config}
+
+    if sign_callback and callback_params:
+        for param_name in callback_params:
+            if param_name not in kwargs:
+                adapter_kwargs[param_name] = sign_callback
+
+    adapter_kwargs.update(kwargs)
+
+    return adapter_class(**adapter_kwargs)

wayfinder_paths/mcp/server.py

@@ -0,0 +1,52 @@
+"""Wayfinder Paths MCP server (FastMCP).
+
+Run locally (via Claude Code .mcp.json):
+  poetry run python -m wayfinder_paths.mcp.server
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from mcp.server.fastmcp import FastMCP
+
+from wayfinder_paths.mcp.tools.balances import balances
+from wayfinder_paths.mcp.tools.discovery import describe, discover
+from wayfinder_paths.mcp.tools.execute import execute
+from wayfinder_paths.mcp.tools.hyperliquid import hyperliquid, hyperliquid_execute
+from wayfinder_paths.mcp.tools.quotes import quote_swap
+from wayfinder_paths.mcp.tools.run_script import run_script
+from wayfinder_paths.mcp.tools.strategies import run_strategy
+from wayfinder_paths.mcp.tools.tokens import tokens
+from wayfinder_paths.mcp.tools.wallets import wallets
+
+mcp = FastMCP("wayfinder")
+
+mcp.tool()(discover)
+mcp.tool()(describe)
+mcp.tool()(wallets)
+mcp.tool()(tokens)
+mcp.tool()(balances)
+mcp.tool()(quote_swap)
+mcp.tool()(hyperliquid)
+mcp.tool()(hyperliquid_execute)
+mcp.tool()(run_strategy)
+mcp.tool()(run_script)
+mcp.tool()(execute)
+
+
+def main() -> None:
+    # FastMCP is sync, but our tools are async; the library handles that.
+    mcp.run()
+
+
+if __name__ == "__main__":
+    # Some environments complain if an event loop is already running.
+    # FastMCP handles stdio and tool execution; we just start it.
+    try:
+        main()
+    except RuntimeError as exc:
+        if "asyncio.run()" in str(exc) and asyncio.get_event_loop().is_running():
+            main()
+        else:
+            raise