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

wayfinder_paths/core/strategies/opa_loop.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from loguru import logger
+
+
+@dataclass
+class OPAConfig:
+    max_iterations_per_tick: int = 4
+    max_steps_per_iteration: int = 5
+    max_total_steps_per_tick: int = 15
+
+
+@dataclass
+class PlanStep[TOp: Enum]:
+    op: TOp
+    priority: int
+    key: str
+    params: dict[str, Any] = field(default_factory=dict)
+    reason: str = ""
+
+    def __repr__(self) -> str:
+        return f"PlanStep({self.op.name}, priority={self.priority}, key={self.key!r})"
+
+
+@dataclass
+class Plan[TOp: Enum]:
+    steps: list[PlanStep[TOp]] = field(default_factory=list)
+    desired_state: dict[str, Any] = field(default_factory=dict)
+
+    def __bool__(self) -> bool:
+        return bool(self.steps)
+
+    def __len__(self) -> int:
+        return len(self.steps)
+
+
+class OPALoopMixin[TInventory, TOp: Enum](ABC):
+    @property
+    @abstractmethod
+    def opa_config(self) -> OPAConfig: ...
+
+    @abstractmethod
+    async def observe(self) -> TInventory: ...
+
+    @abstractmethod
+    def plan(self, inventory: TInventory) -> Plan[TOp]: ...
+
+    @abstractmethod
+    async def execute_step(
+        self, step: PlanStep[TOp], inventory: TInventory
+    ) -> tuple[bool, str]: ...
+
+    @abstractmethod
+    def get_inventory_changing_ops(self) -> set[TOp]: ...
+
+    async def on_loop_start(self) -> tuple[bool, str] | None:
+        return None
+
+    async def on_step_executed(
+        self, step: PlanStep[TOp], success: bool, message: str
+    ) -> None:
+        return None
+
+    def should_stop_early(
+        self, inventory: TInventory, iteration: int
+    ) -> tuple[bool, str] | None:
+        return None
+
+    async def on_loop_end(
+        self, success: bool, messages: list[str], total_steps: int
+    ) -> None:
+        return None
+
+    async def run_opa_loop(self) -> tuple[bool, str, bool]:
+        loop_logger = logger.bind(loop="opa")
+
+        setup_result = await self.on_loop_start()
+        if setup_result is not None:
+            return (*setup_result, False)
+
+        total_steps = 0
+        messages: list[str] = []
+        rotated = False
+        config = self.opa_config
+
+        try:
+            for iteration in range(config.max_iterations_per_tick):
+                loop_logger.debug(
+                    f"OPA iteration {iteration + 1}/{config.max_iterations_per_tick}"
+                )
+
+                # OBSERVE
+                try:
+                    inventory = await self.observe()
+                except Exception as e:
+                    loop_logger.error(f"Observe failed: {e}")
+                    return (False, f"Failed to observe: {e}", rotated)
+
+                stop_result = self.should_stop_early(inventory, iteration)
+                if stop_result is not None:
+                    await self.on_loop_end(stop_result[0], messages, total_steps)
+                    return (*stop_result, rotated)
+
+                # PLAN
+                try:
+                    plan = self.plan(inventory)
+                except Exception as e:
+                    loop_logger.error(f"Plan failed: {e}")
+                    return (False, f"Failed to plan: {e}", rotated)
+
+                if not plan.steps:
+                    loop_logger.debug("Plan is empty, nothing to do")
+                    break
+
+                loop_logger.debug(f"Plan has {len(plan.steps)} steps")
+
+                # ACT - execute steps up to limit
+                steps_this_iteration = 0
+                for step in plan.steps[: config.max_steps_per_iteration]:
+                    if total_steps >= config.max_total_steps_per_tick:
+                        loop_logger.warning(
+                            f"Hit max total steps ({config.max_total_steps_per_tick})"
+                        )
+                        break
+
+                    loop_logger.info(f"Executing step: {step.op.name} ({step.reason})")
+
+                    try:
+                        success, msg = await self.execute_step(step, inventory)
+                    except Exception as e:
+                        success = False
+                        msg = f"Step {step.op.name} raised exception: {e}"
+                        loop_logger.error(msg)
+
+                    await self.on_step_executed(step, success, msg)
+                    messages.append(f"{step.op.name}: {msg}")
+                    total_steps += 1
+                    steps_this_iteration += 1
+
+                    if step.params.get("is_rotation"):
+                        rotated = True
+
+                    # Re-observe after inventory-changing ops (failed steps likely didn't change anything)
+                    if success and step.op in self.get_inventory_changing_ops():
+                        loop_logger.debug(
+                            f"Step {step.op.name} changes inventory, re-observing"
+                        )
+                        break
+
+                if steps_this_iteration == 0:
+                    break
+
+        except Exception as e:
+            loop_logger.error(f"OPA loop failed: {e}")
+            await self.on_loop_end(False, messages, total_steps)
+            return (False, f"OPA loop error: {e}", rotated)
+
+        final_message = "; ".join(messages) if messages else "No action needed"
+        loop_logger.info(f"OPA loop complete: {total_steps} steps executed")
+
+        await self.on_loop_end(True, messages, total_steps)
+        return (True, final_message, rotated)

wayfinder_paths/core/utils/evm_helpers.py

@@ -4,25 +4,15 @@ from typing import Any
 
 from loguru import logger
 
-from wayfinder_paths.core.constants.base import CHAIN_CODE_TO_ID
+from wayfinder_paths.core.constants.chains import CHAIN_CODE_TO_ID
 
 
-def chain_code_to_chain_id(chain_code: str | None) -> int | None:
-    if not chain_code:
-        return None
-    return CHAIN_CODE_TO_ID.get(chain_code.lower())
-
-
-def resolve_chain_id(token_info: dict[str, Any], logger_instance=None) -> int | None:
-    log = logger_instance or logger
+def resolve_chain_id(token_info: dict[str, Any]) -> int | None:
     chain_meta = token_info.get("chain") or {}
     chain_id = chain_meta.get("id")
-    try:
-        if chain_id is not None:
-            return int(chain_id)
-    except (ValueError, TypeError):
-        log.debug("Invalid chain_id in token_info.chain: %s", chain_id)
-    return chain_code_to_chain_id(chain_meta.get("code"))
+    if chain_id is not None:
+        return int(chain_id)
+    return CHAIN_CODE_TO_ID.get(chain_meta.get("code").lower())
 
 
 def resolve_rpc_url(

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/tokens.py

@@ -1,6 +1,10 @@
+from collections.abc import Callable
+from typing import Any
+
 from web3 import AsyncWeb3
 
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
+from wayfinder_paths.core.utils.transaction import send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 NATIVE_TOKEN_ADDRESSES: set = {
@@ -102,3 +106,27 @@ async def build_send_transaction(
                 "data": data,
                 "chainId": chain_id,
             }
+
+
+async def ensure_allowance(
+    *,
+    token_address: str,
+    owner: str,
+    spender: str,
+    amount: int,
+    chain_id: int,
+    signing_callback: Callable,
+    approval_amount: int | None = None,
+) -> tuple[bool, Any]:
+    allowance = await get_token_allowance(token_address, chain_id, owner, spender)
+    if allowance >= amount:
+        return True, {}
+    approve_tx = await build_approve_transaction(
+        from_address=owner,
+        chain_id=chain_id,
+        token_address=token_address,
+        spender_address=spender,
+        amount=approval_amount if approval_amount is not None else amount,
+    )
+    txn_hash = await send_transaction(approve_tx, signing_callback)
+    return True, txn_hash

wayfinder_paths/core/utils/transaction.py

@@ -1,20 +1,25 @@
 import asyncio
 from collections.abc import Callable
+from typing import Any
 
+from eth_account import Account
 from loguru import logger
 from web3 import AsyncWeb3
 
+from wayfinder_paths.core.constants.base import (
+    SUGGESTED_GAS_PRICE_MULTIPLIER,
+    SUGGESTED_PRIORITY_FEE_MULTIPLIER,
+)
+from wayfinder_paths.core.constants.chains import (
+    CHAIN_ID_HYPEREVM,
+    PRE_EIP_1559_CHAIN_IDS,
+)
 from wayfinder_paths.core.utils.web3 import (
     get_transaction_chain_id,
     web3_from_chain_id,
     web3s_from_chain_id,
 )
 
-PRE_EIP_1559_CHAIN_IDS: set = {56, 42161}
-
-SUGGESTED_PRIORITY_FEE_MULTIPLIER = 1.5
-SUGGESTED_GAS_PRICE_MULTIPLIER = 1.5
-
 
 def _get_transaction_from_address(transaction: dict) -> str:
     if "from" not in transaction:
@@ -71,7 +76,7 @@ async def gas_price_transaction(
             gas_price = max(gas_prices)
 
             transaction["gasPrice"] = int(gas_price * gas_price_multiplier)
-        elif chain_id == 999:
+        elif chain_id == CHAIN_ID_HYPEREVM:
             # HyperEVM big blocks fetch base gas price from a different RPC method. Priority fee = 0 is # grandfathered in from Django, not sure what's right here.
             big_block_gas_prices = await asyncio.gather(
                 *[web3.hype.big_block_gas_price() for web3 in web3s]
@@ -111,7 +116,7 @@ async def gas_limit_transaction(transaction: dict):
 
     async def _estimate_gas(web3: AsyncWeb3, transaction: dict) -> int:
         try:
-            return await web3.eth.estimate_gas(transaction, block_identifier="pending")
+            return await web3.eth.estimate_gas(transaction, block_identifier="latest")
         except Exception as e:
             logger.info(
                 f"Failed to estimate gas using {web3.provider.endpoint_uri}. Error: {e}"
@@ -174,7 +179,10 @@ async def wait_for_transaction_receipt(
 async def send_transaction(
     transaction: dict, sign_callback: Callable, wait_for_receipt=True
 ) -> str:
-    logger.info(f"Broadcasting transaction {transaction.get('to', 'unknown')[:10]}...")
+    if sign_callback is None:
+        raise ValueError("sign_callback must be provided to send transaction")
+
+    logger.info(f"Broadcasting transaction {transaction}...")
     chain_id = get_transaction_chain_id(transaction)
     transaction = await gas_limit_transaction(transaction)
     transaction = await nonce_transaction(transaction)
@@ -187,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

@@ -5,8 +5,10 @@ from web3.middleware import ExtraDataToPOAMiddleware
 from web3.module import Module
 
 from wayfinder_paths.core.config import get_rpc_urls
-
-POA_MIDDLEWARE_CHAIN_IDS: set = {56, 137, 43114}
+from wayfinder_paths.core.constants.chains import (
+    CHAIN_ID_HYPEREVM,
+    POA_MIDDLEWARE_CHAIN_IDS,
+)
 
 
 class HyperModule(Module):
@@ -24,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
 
 
@@ -31,7 +36,7 @@ def _get_web3(rpc: str, chain_id: int) -> AsyncWeb3:
     web3 = AsyncWeb3(AsyncHTTPProvider(rpc))
     if chain_id in POA_MIDDLEWARE_CHAIN_IDS:
         web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-    if chain_id == 999:
+    if chain_id == CHAIN_ID_HYPEREVM:
         web3.attach_modules({"hype": (HyperModule)})
     return web3
 

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.
+"""