wayfinder-paths 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -12,12 +12,16 @@ from wayfinder_paths.core.clients.HyperlendClient import (
     MarketEntry,
     StableMarketsHeadroomResponse,
 )
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.hyperlend_abi import (
     POOL_ABI,
     WRAPPED_TOKEN_GATEWAY_ABI,
 )
-from wayfinder_paths.core.services.base import Web3Service
+from wayfinder_paths.core.utils.erc20_service import (
+    build_approve_transaction,
+    get_token_allowance,
+)
+from wayfinder_paths.core.utils.transaction import send_transaction
+from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 HYPERLEND_DEFAULTS = {
     "pool": "0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b",
@@ -34,15 +38,16 @@ class HyperlendAdapter(BaseAdapter):
     def __init__(
         self,
         config: dict[str, Any],
-        web3_service: Web3Service,
+        simulation: bool = False,
+        strategy_wallet_signing_callback=None,
     ) -> None:
         super().__init__("hyperlend_adapter", config)
         cfg = config or {}
         adapter_cfg = cfg.get("hyperlend_adapter") or {}
 
+        self.simulation = simulation
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.hyperlend_client = HyperlendClient()
-        self.web3 = web3_service
-        self.token_txn_service = web3_service.token_transactions
 
         self.strategy_wallet = cfg.get("strategy_wallet") or {}
         self.pool_address = self._checksum(
@@ -77,20 +82,6 @@ class HyperlendAdapter(BaseAdapter):
                 buffer_bps=buffer_bps,
                 min_buffer_tokens=min_buffer_tokens,
             )
-            # Strategies expect a dict with "markets" and "notes"; normalize if API returns a list
-            if isinstance(data, list):
-                markets: dict[str, Any] = {}
-                for i, item in enumerate(data):
-                    if isinstance(item, dict) and "address" in item:
-                        markets[item["address"]] = item
-                    elif isinstance(item, dict):
-                        markets[str(i)] = item
-                data = {"markets": markets, "notes": []}
-            elif isinstance(data, dict) and ("markets" not in data or "notes" not in data):
-                data = {
-                    "markets": data.get("markets", {}),
-                    "notes": data.get("notes", []),
-                }
             return True, data
         except Exception as exc:
             return False, str(exc)
@@ -179,7 +170,7 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     async def unlend(
         self,
@@ -214,12 +205,19 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Helpers                                                            #
     # ------------------------------------------------------------------ #
 
+    async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
+        """Send transaction with simulation check."""
+        if self.simulation:
+            return True, {"simulation": tx}
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
+        return True, txn_hash
+
     async def _ensure_allowance(
         self,
         *,
@@ -229,32 +227,17 @@ class HyperlendAdapter(BaseAdapter):
         amount: int,
         chain_id: int,
     ) -> tuple[bool, Any]:
-        chain = {"id": chain_id}
-        allowance = await self.token_txn_service.read_erc20_allowance(
-            chain, token_address, owner, spender
-        )
+        allowance = await get_token_allowance(token_address, chain_id, owner, spender)
         if allowance.get("allowance", 0) >= amount:
             return True, {}
-        build_success, approve_tx = self.token_txn_service.build_erc20_approve(
+        approve_tx = await build_approve_transaction(
+            from_address=owner,
             chain_id=chain_id,
             token_address=token_address,
-            from_address=owner,
             spender=spender,
             amount=amount,
         )
-        if not build_success:
-            return False, approve_tx
-        return await self._broadcast_transaction(approve_tx)
-
-    async def _execute(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        return await self.web3.broadcast_transaction(
-            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
-        )
-
-    async def _broadcast_transaction(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        return await self.web3.evm_transactions.broadcast_transaction(
-            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
-        )
+        return await self._send_tx(approve_tx)
 
     async def _encode_call(
         self,
@@ -268,23 +251,24 @@ class HyperlendAdapter(BaseAdapter):
         value: int = 0,
     ) -> dict[str, Any]:
         """Encode calldata without touching network."""
-        web3 = self.web3.get_web3(chain_id)
-        contract = web3.eth.contract(address=target, abi=abi)
-        try:
-            data = await getattr(contract.functions, fn_name)(*args).build_transaction(
-                {"from": from_address}
-            )["data"]
-        except ValueError as exc:
-            raise ValueError(f"Failed to encode {fn_name}: {exc}") from exc
 
-        tx: dict[str, Any] = {
-            "chainId": int(chain_id),
-            "from": to_checksum_address(from_address),
-            "to": to_checksum_address(target),
-            "data": data,
-            "value": int(value),
-        }
-        return tx
+        async with web3_from_chain_id(chain_id) as web3:
+            contract = web3.eth.contract(address=target, abi=abi)
+            try:
+                data = await getattr(contract.functions, fn_name)(
+                    *args
+                ).build_transaction({"from": from_address})["data"]
+            except ValueError as exc:
+                raise ValueError(f"Failed to encode {fn_name}: {exc}") from exc
+
+            tx: dict[str, Any] = {
+                "chainId": int(chain_id),
+                "from": to_checksum_address(from_address),
+                "to": to_checksum_address(target),
+                "data": data,
+                "value": int(value),
+            }
+            return tx
 
     def _strategy_address(self) -> str:
         addr = None

wayfinder_paths/adapters/hyperlend_adapter/test_adapter.py

@@ -1,4 +1,3 @@
-from types import SimpleNamespace
 from unittest.mock import AsyncMock
 
 import pytest
@@ -16,16 +15,10 @@ class TestHyperlendAdapter:
         return mock_client
 
     @pytest.fixture
-    def mock_web3_service(self):
-        """Minimal Web3Service stub for adapter construction."""
-        return SimpleNamespace(token_transactions=SimpleNamespace())
-
-    @pytest.fixture
-    def adapter(self, mock_hyperlend_client, mock_web3_service):
+    def adapter(self, mock_hyperlend_client):
         """Create a HyperlendAdapter instance with mocked client for testing"""
         adapter = HyperlendAdapter(
             config={},
-            web3_service=mock_web3_service,
         )
         adapter.hyperlend_client = mock_hyperlend_client
         return adapter

wayfinder_paths/adapters/moonwell_adapter/README.md

@@ -8,6 +8,7 @@ Adapter for interacting with the [Moonwell](https://moonwell.fi/) lending protoc
 ## Capabilities
 
 The adapter provides the following capabilities:
+
 - Lending: Supply and withdraw tokens
 - Borrowing: Borrow and repay tokens
 - Collateral management: Enable/disable markets as collateral
@@ -17,6 +18,7 @@ The adapter provides the following capabilities:
 ## Overview
 
 The MoonwellAdapter provides functionality for:
+
 - **Lending**: Supply tokens to earn yield
 - **Borrowing**: Borrow against collateral
 - **Collateral Management**: Enable/disable markets as collateral
@@ -25,10 +27,10 @@ The MoonwellAdapter provides functionality for:
 
 ## Supported Markets (Base Chain)
 
-| Token | mToken Address | Underlying Address |
-|-------|----------------|-------------------|
-| USDC | `0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
-| WETH | `0x628ff693426583D9a7FB391E54366292F509D457` | `0x4200000000000000000000000000000000000006` |
+| Token  | mToken Address                               | Underlying Address                           |
+| ------ | -------------------------------------------- | -------------------------------------------- |
+| USDC   | `0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22` | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
+| WETH   | `0x628ff693426583D9a7FB391E54366292F509D457` | `0x4200000000000000000000000000000000000006` |
 | wstETH | `0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b` | `0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452` |
 
 ## Protocol Addresses (Base Chain)
@@ -40,7 +42,6 @@ The MoonwellAdapter provides functionality for:
 ## Construction
 
 ```python
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.adapters.moonwell_adapter import MoonwellAdapter
 
 config = {
@@ -49,12 +50,9 @@ config = {
         "chain_id": 8453,  # Base chain (default)
     }
 }
-web3_service = DefaultWeb3Service(config)
-adapter = MoonwellAdapter(config=config, web3_service=web3_service)
+adapter = MoonwellAdapter(config=config)
 ```
 
-`web3_service` is required so the adapter can share the same wallet provider as the rest of the strategy.
-
 ## Usage
 
 ```python
@@ -102,45 +100,45 @@ await adapter.claim_rewards()
 
 ### Lending Operations
 
-| Method | Description |
-|--------|-------------|
-| `lend(mtoken, underlying_token, amount)` | Supply tokens to earn yield |
-| `unlend(mtoken, amount)` | Withdraw by redeeming mTokens |
+| Method                                   | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `lend(mtoken, underlying_token, amount)` | Supply tokens to earn yield   |
+| `unlend(mtoken, amount)`                 | Withdraw by redeeming mTokens |
 
 ### Borrowing Operations
 
-| Method | Description |
-|--------|-------------|
-| `borrow(mtoken, amount)` | Borrow underlying tokens |
-| `repay(mtoken, underlying_token, amount)` | Repay borrowed tokens |
+| Method                                    | Description              |
+| ----------------------------------------- | ------------------------ |
+| `borrow(mtoken, amount)`                  | Borrow underlying tokens |
+| `repay(mtoken, underlying_token, amount)` | Repay borrowed tokens    |
 
 ### Collateral Management
 
-| Method | Description |
-|--------|-------------|
-| `set_collateral(mtoken)` | Enable market as collateral (enterMarkets) |
-| `remove_collateral(mtoken)` | Disable market as collateral (exitMarket) |
+| Method                      | Description                                |
+| --------------------------- | ------------------------------------------ |
+| `set_collateral(mtoken)`    | Enable market as collateral (enterMarkets) |
+| `remove_collateral(mtoken)` | Disable market as collateral (exitMarket)  |
 
 ### Position & Market Data
 
-| Method | Description |
-|--------|-------------|
-| `get_pos(mtoken, account)` | Get position data (balances, debt, rewards) |
-| `get_collateral_factor(mtoken)` | Get collateral factor (LTV) |
-| `get_apy(mtoken, apy_type)` | Get supply or borrow APY |
-| `get_borrowable_amount(account)` | Get max borrowable in USD |
+| Method                                     | Description                                        |
+| ------------------------------------------ | -------------------------------------------------- |
+| `get_pos(mtoken, account)`                 | Get position data (balances, debt, rewards)        |
+| `get_collateral_factor(mtoken)`            | Get collateral factor (LTV)                        |
+| `get_apy(mtoken, apy_type)`                | Get supply or borrow APY                           |
+| `get_borrowable_amount(account)`           | Get max borrowable in USD                          |
 | `max_withdrawable_mtoken(mtoken, account)` | Calculate safe withdrawal amount via binary search |
 
 ### Rewards
 
-| Method | Description |
-|--------|-------------|
+| Method                           | Description                                   |
+| -------------------------------- | --------------------------------------------- |
 | `claim_rewards(min_rewards_usd)` | Claim WELL rewards (skips if below threshold) |
 
 ### Utilities
 
-| Method | Description |
-|--------|-------------|
+| Method             | Description      |
+| ------------------ | ---------------- |
 | `wrap_eth(amount)` | Wrap ETH to WETH |
 
 All methods return `(success: bool, payload: Any)` tuples. On failure the payload is an error string.