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

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -15,15 +15,18 @@ from eth_utils import to_checksum_address
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.constants.moonwell_abi import (
     COMPTROLLER_ABI,
     MTOKEN_ABI,
     REWARD_DISTRIBUTOR_ABI,
     WETH_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
 
 # Moonwell Base chain addresses
 MOONWELL_DEFAULTS = {
@@ -58,11 +61,6 @@ CF_CACHE_TTL = 3600
 DEFAULT_MAX_RETRIES = 5
 DEFAULT_BASE_DELAY = 3.0  # seconds
 
-# Compound-style Failure(uint256,uint256,uint256) topic0
-FAILURE_EVENT_TOPIC0 = (
-    "0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0"
-)
-
 
 def _is_rate_limit_error(error: Exception | str) -> bool:
     """Check if an error is a rate limit (429) error."""
@@ -70,38 +68,6 @@ def _is_rate_limit_error(error: Exception | str) -> bool:
     return "429" in error_str or "Too Many Requests" in error_str
 
 
-async def _retry_with_backoff(
-    coro_factory,
-    max_retries: int = DEFAULT_MAX_RETRIES,
-    base_delay: float = DEFAULT_BASE_DELAY,
-):
-    """Retry an async operation with exponential backoff on rate limit errors.
-
-    Args:
-        coro_factory: A callable that returns a new coroutine each time.
-        max_retries: Maximum number of retry attempts.
-        base_delay: Base delay in seconds (doubles each retry).
-
-    Returns:
-        The result of the coroutine if successful.
-
-    Raises:
-        The last exception if all retries fail.
-    """
-    last_error = None
-    for attempt in range(max_retries):
-        try:
-            return await coro_factory()
-        except Exception as exc:
-            last_error = exc
-            if _is_rate_limit_error(exc) and attempt < max_retries - 1:
-                wait_time = base_delay * (2**attempt)
-                await asyncio.sleep(wait_time)
-                continue
-            raise
-    raise last_error
-
-
 def _timestamp_rate_to_apy(rate: float) -> float:
     """Convert a per-second rate to APY."""
     return (1 + rate) ** SECONDS_PER_YEAR - 1
@@ -115,20 +81,17 @@ class MoonwellAdapter(BaseAdapter):
     def __init__(
         self,
         config: dict[str, Any] | None = None,
-        web3_service: Web3Service | None = None,
         token_client: TokenClient | None = None,
         simulation: bool = False,
+        strategy_wallet_signing_callback=None,
     ) -> None:
         super().__init__("moonwell_adapter", config)
         cfg = config or {}
         adapter_cfg = cfg.get("moonwell_adapter") or {}
 
-        self.web3 = web3_service
         self.simulation = simulation
         self.token_client = token_client
-        self.token_txn_service = (
-            web3_service.token_transactions if web3_service else None
-        )
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
 
         self.strategy_wallet = cfg.get("strategy_wallet") or {}
         self.chain_id = adapter_cfg.get("chain_id", BASE_CHAIN_ID)
@@ -169,79 +132,6 @@ class MoonwellAdapter(BaseAdapter):
     # Public API - Lending Operations                                     #
     # ------------------------------------------------------------------ #
 
-    def _tx_pinned_block(self, result: Any) -> int | None:
-        if isinstance(result, dict):
-            return (
-                result.get("confirmed_block_number")
-                or result.get("block_number")
-                or (result.get("receipt", {}) or {}).get("blockNumber")
-            )
-        return None
-
-    def _as_bytes(self, value: Any) -> bytes | None:
-        if value is None:
-            return None
-        if isinstance(value, (bytes, bytearray)):
-            return bytes(value)
-        if hasattr(value, "hex"):
-            try:
-                hex_str = value.hex()
-                if isinstance(hex_str, str):
-                    if hex_str.startswith("0x"):
-                        return bytes.fromhex(hex_str[2:])
-                    return bytes.fromhex(hex_str)
-            except Exception:
-                return None
-        if isinstance(value, str):
-            v = value
-            if v.startswith("0x"):
-                v = v[2:]
-            try:
-                return bytes.fromhex(v)
-            except Exception:
-                return None
-        return None
-
-    def _failure_event_details(
-        self, result: Any, contract_address: str
-    ) -> dict[str, int] | None:
-        if not isinstance(result, dict):
-            return None
-
-        receipt = (
-            result.get("receipt") if isinstance(result.get("receipt"), dict) else {}
-        )
-        logs = receipt.get("logs") if isinstance(receipt, dict) else None
-        if not isinstance(logs, list):
-            return None
-
-        addr_l = str(contract_address or "").lower()
-        for log in logs:
-            if not isinstance(log, dict):
-                continue
-            if str(log.get("address") or "").lower() != addr_l:
-                continue
-            topics = log.get("topics") or []
-            if not topics:
-                continue
-            topic0_bytes = self._as_bytes(topics[0])
-            if not topic0_bytes:
-                continue
-            if topic0_bytes.hex() != FAILURE_EVENT_TOPIC0.lower().removeprefix("0x"):
-                continue
-
-            data_b = self._as_bytes(log.get("data"))
-            if not data_b or len(data_b) < 96:
-                return {"error": 0, "info": 0, "detail": 0}
-
-            return {
-                "error": int.from_bytes(data_b[0:32], "big"),
-                "info": int.from_bytes(data_b[32:64], "big"),
-                "detail": int.from_bytes(data_b[64:96], "big"),
-            }
-
-        return None
-
     async def lend(
         self,
         *,
@@ -249,11 +139,7 @@ class MoonwellAdapter(BaseAdapter):
         underlying_token: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Supply tokens to Moonwell by minting mTokens.
-
-        Note: mint() returns an error code and can emit Failure without reverting.
-        We verify success by checking that the mToken balance increased.
-        """
+        """Supply tokens to Moonwell by minting mTokens."""
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -262,17 +148,6 @@ class MoonwellAdapter(BaseAdapter):
         mtoken = self._checksum(mtoken)
         underlying_token = self._checksum(underlying_token)
 
-        mtoken_bal_before = None
-        if self.web3 and not self.simulation:
-            try:
-                web3 = self.web3.get_web3(self.chain_id)
-                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-                mtoken_bal_before = await mtoken_contract.functions.balanceOf(
-                    strategy
-                ).call()
-            except Exception:
-                mtoken_bal_before = None
-
         # Approve mToken to spend underlying tokens
         approved = await self._ensure_allowance(
             token_address=underlying_token,
@@ -291,41 +166,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        result = await self._execute(tx)
-
-        if not result[0] or not self.web3 or self.simulation:
-            return result
-
-        if isinstance(result[1], dict):
-            failure = self._failure_event_details(result[1], mtoken)
-            if failure is not None:
-                return (
-                    False,
-                    f"Mint failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
-                )
-
-        if mtoken_bal_before is None:
-            return result
-
-        try:
-            pinned_block = self._tx_pinned_block(result[1])
-            block_id = pinned_block if pinned_block is not None else "latest"
-
-            web3 = self.web3.get_web3(self.chain_id)
-            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-            mtoken_bal_after = await mtoken_contract.functions.balanceOf(strategy).call(
-                block_identifier=block_id
-            )
-            if int(mtoken_bal_after) <= int(mtoken_bal_before):
-                return (
-                    False,
-                    f"Mint verification failed: mToken balance did not increase (before={mtoken_bal_before}, after={mtoken_bal_after})",
-                )
-        except Exception:
-            # If verification fails due to RPC/ABI issues, keep original result.
-            return result
-
-        return result
+        return await self._send_tx(tx)
 
     async def unlend(
         self,
@@ -333,13 +174,7 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Withdraw tokens from Moonwell by redeeming mTokens.
-
-        Note: redeem() returns an error code and can emit Failure without reverting.
-        We verify success by checking that either:
-          - underlying wallet balance increased, or
-          - mToken wallet balance decreased.
-        """
+        """Withdraw tokens from Moonwell by redeeming mTokens."""
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -347,38 +182,6 @@ class MoonwellAdapter(BaseAdapter):
 
         mtoken = self._checksum(mtoken)
 
-        mtoken_bal_before = None
-        underlying_addr = None
-        underlying_bal_before = None
-
-        if self.web3 and not self.simulation:
-            try:
-                web3 = self.web3.get_web3(self.chain_id)
-                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-
-                # Snapshot balances for verification.
-                mtoken_bal_before = await mtoken_contract.functions.balanceOf(
-                    strategy
-                ).call()
-                try:
-                    underlying_addr = (
-                        await mtoken_contract.functions.underlying().call()
-                    )
-                except Exception:
-                    underlying_addr = None
-                if underlying_addr:
-                    underlying_contract = web3.eth.contract(
-                        address=to_checksum_address(underlying_addr),
-                        abi=ERC20_ABI,
-                    )
-                    underlying_bal_before = (
-                        await underlying_contract.functions.balanceOf(strategy).call()
-                    )
-            except Exception:
-                mtoken_bal_before = None
-                underlying_addr = None
-                underlying_bal_before = None
-
         # Redeem mTokens for underlying
         tx = await self._encode_call(
             target=mtoken,
@@ -387,60 +190,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        result = await self._execute(tx)
-
-        if not result[0] or not self.web3 or self.simulation:
-            return result
-
-        if isinstance(result[1], dict):
-            failure = self._failure_event_details(result[1], mtoken)
-            if failure is not None:
-                return (
-                    False,
-                    f"Redeem failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
-                )
-
-        if mtoken_bal_before is None:
-            return result
-
-        try:
-            pinned_block = self._tx_pinned_block(result[1])
-            block_id = pinned_block if pinned_block is not None else "latest"
-
-            web3 = self.web3.get_web3(self.chain_id)
-            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-            mtoken_bal_after = await mtoken_contract.functions.balanceOf(strategy).call(
-                block_identifier=block_id
-            )
-
-            underlying_bal_after = None
-            if underlying_addr:
-                underlying_contract = web3.eth.contract(
-                    address=to_checksum_address(underlying_addr),
-                    abi=ERC20_ABI,
-                )
-                underlying_bal_after = await underlying_contract.functions.balanceOf(
-                    strategy
-                ).call(block_identifier=block_id)
-
-            mtoken_decreased = int(mtoken_bal_after) < int(mtoken_bal_before)
-            underlying_increased = (
-                underlying_bal_before is not None
-                and underlying_bal_after is not None
-                and int(underlying_bal_after) > int(underlying_bal_before)
-            )
-
-            if not mtoken_decreased and not underlying_increased:
-                return (
-                    False,
-                    "Redeem verification failed: no observed balance change "
-                    f"(mtoken before={mtoken_bal_before}, after={mtoken_bal_after}; "
-                    f"underlying before={underlying_bal_before}, after={underlying_bal_after})",
-                )
-        except Exception:
-            return result
-
-        return result
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Public API - Borrowing Operations                                   #
@@ -470,19 +220,18 @@ class MoonwellAdapter(BaseAdapter):
 
         # Get borrow balance before the transaction for verification
         borrow_before = 0
-        if self.web3:
-            try:
-                web3 = self.web3.get_web3(self.chain_id)
+        try:
+            async with web3_from_chain_id(self.chain_id) as web3:
                 mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
 
                 borrow_before = await mtoken_contract.functions.borrowBalanceStored(
                     strategy
-                ).call()
+                ).call(block_identifier="pending")
 
                 # Simulate borrow to check for errors before submitting
                 try:
                     borrow_return = await mtoken_contract.functions.borrow(amount).call(
-                        {"from": strategy}
+                        {"from": strategy}, block_identifier="pending"
                     )
                     if borrow_return != 0:
                         logger.warning(
@@ -492,9 +241,8 @@ class MoonwellAdapter(BaseAdapter):
                         )
                 except Exception as call_err:
                     logger.debug(f"Borrow simulation failed: {call_err}")
-
-            except Exception as e:
-                logger.warning(f"Failed to get pre-borrow balance: {e}")
+        except Exception as e:
+            logger.warning(f"Failed to get pre-borrow balance: {e}")
 
         tx = await self._encode_call(
             target=mtoken,
@@ -503,28 +251,18 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        result = await self._execute(tx)
+        result = await self._send_tx(tx)
 
         if not result[0]:
             return result
 
         # Verify the borrow actually succeeded by checking balance increased
-        if self.web3:
-            try:
-                pinned_block = None
-                if isinstance(result[1], dict):
-                    pinned_block = (
-                        result[1].get("confirmed_block_number")
-                        or result[1].get("block_number")
-                        or (result[1].get("receipt", {}) or {}).get("blockNumber")
-                    )
-                block_id = pinned_block if pinned_block is not None else "latest"
-
-                web3 = self.web3.get_web3(self.chain_id)
+        try:
+            async with web3_from_chain_id(self.chain_id) as web3:
                 mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
                 borrow_after = await mtoken_contract.functions.borrowBalanceStored(
                     strategy
-                ).call(block_identifier=block_id)
+                ).call(block_identifier="pending")
 
                 # Borrow balance should have increased by approximately the amount
                 # Allow for some interest accrual
@@ -545,11 +283,11 @@ class MoonwellAdapter(BaseAdapter):
                         f"Borrow failed: balance did not increase as expected. "
                         f"Before: {borrow_before}, After: {borrow_after}, Expected: +{amount}",
                     )
-            except Exception as e:
-                from loguru import logger
+        except Exception as e:
+            from loguru import logger
 
-                logger.warning(f"Could not verify borrow balance: {e}")
-                # Continue with the original result if verification fails
+            logger.warning(f"Could not verify borrow balance: {e}")
+            # Continue with the original result if verification fails
 
         return result
 
@@ -577,17 +315,6 @@ class MoonwellAdapter(BaseAdapter):
         mtoken = self._checksum(mtoken)
         underlying_token = self._checksum(underlying_token)
 
-        borrow_before = None
-        if self.web3 and not self.simulation:
-            try:
-                web3 = self.web3.get_web3(self.chain_id)
-                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-                borrow_before = await mtoken_contract.functions.borrowBalanceStored(
-                    strategy
-                ).call()
-            except Exception:
-                borrow_before = None
-
         # Approve mToken to spend underlying tokens for repayment
         # When repay_full=True, approve the amount we have, Moonwell will use only what's needed
         approved = await self._ensure_allowance(
@@ -609,49 +336,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[repay_amount],
             from_address=strategy,
         )
-        result = await self._execute(tx)
-
-        if not result[0] or not self.web3 or self.simulation:
-            return result
-
-        if isinstance(result[1], dict):
-            failure = self._failure_event_details(result[1], mtoken)
-            if failure is not None:
-                return (
-                    False,
-                    f"Repay failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
-                )
-
-        if borrow_before is None or int(borrow_before) <= 0:
-            return result
-
-        try:
-            pinned_block = self._tx_pinned_block(result[1])
-            block_id = pinned_block if pinned_block is not None else "latest"
-
-            web3 = self.web3.get_web3(self.chain_id)
-            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-            borrow_after = await mtoken_contract.functions.borrowBalanceStored(
-                strategy
-            ).call(block_identifier=block_id)
-
-            if repay_full:
-                # Full repayment should clear the borrow balance (allow 1 wei dust).
-                if int(borrow_after) > 1:
-                    return (
-                        False,
-                        f"Repay verification failed: repay_full did not clear debt (before={borrow_before}, after={borrow_after})",
-                    )
-            else:
-                if int(borrow_after) >= int(borrow_before):
-                    return (
-                        False,
-                        f"Repay verification failed: borrow balance did not decrease (before={borrow_before}, after={borrow_after})",
-                    )
-        except Exception:
-            return result
-
-        return result
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Public API - Collateral Management                                  #
@@ -677,30 +362,20 @@ class MoonwellAdapter(BaseAdapter):
             args=[[mtoken]],
             from_address=strategy,
         )
-        result = await self._execute(tx)
+        result = await self._send_tx(tx)
 
         if not result[0]:
             return result
 
         # Verify the market was actually entered
-        if self.web3:
-            try:
-                pinned_block = None
-                if isinstance(result[1], dict):
-                    pinned_block = (
-                        result[1].get("confirmed_block_number")
-                        or result[1].get("block_number")
-                        or (result[1].get("receipt", {}) or {}).get("blockNumber")
-                    )
-                block_id = pinned_block if pinned_block is not None else "latest"
-
-                web3 = self.web3.get_web3(self.chain_id)
+        try:
+            async with web3_from_chain_id(self.chain_id) as web3:
                 comptroller = web3.eth.contract(
                     address=self.comptroller_address, abi=COMPTROLLER_ABI
                 )
                 is_member = await comptroller.functions.checkMembership(
                     strategy, mtoken
-                ).call(block_identifier=block_id)
+                ).call(block_identifier="pending")
 
                 if not is_member:
                     from loguru import logger
@@ -713,10 +388,10 @@ class MoonwellAdapter(BaseAdapter):
                         False,
                         f"enterMarkets succeeded but account is not a member of market {mtoken}",
                     )
-            except Exception as e:
-                from loguru import logger
+        except Exception as e:
+            from loguru import logger
 
-                logger.warning(f"Could not verify market membership: {e}")
+            logger.warning(f"Could not verify market membership: {e}")
 
         return result
 
@@ -729,19 +404,19 @@ class MoonwellAdapter(BaseAdapter):
         """Check whether an account has entered a given market (as collateral / borrowing market)."""
         if self.simulation:
             return True, True
-        if not self.web3:
-            return False, "web3 service not configured"
 
         try:
             acct = self._checksum(account) if account else self._strategy_address()
             mtoken = self._checksum(mtoken)
 
-            web3 = self.web3.get_web3(self.chain_id)
-            comptroller = web3.eth.contract(
-                address=self.comptroller_address, abi=COMPTROLLER_ABI
-            )
-            is_member = await comptroller.functions.checkMembership(acct, mtoken).call()
-            return True, bool(is_member)
+            async with web3_from_chain_id(self.chain_id) as web3:
+                comptroller = web3.eth.contract(
+                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                )
+                is_member = await comptroller.functions.checkMembership(
+                    acct, mtoken
+                ).call()
+                return True, bool(is_member)
         except Exception as exc:
             return False, str(exc)
 
@@ -761,7 +436,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[mtoken],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Public API - Rewards                                                #
@@ -796,7 +471,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[strategy],
             from_address=strategy,
         )
-        result = await self._execute(tx)
+        result = await self._send_tx(tx)
         if not result[0]:
             return result
 
@@ -804,33 +479,30 @@ class MoonwellAdapter(BaseAdapter):
 
     async def _get_outstanding_rewards(self, account: str) -> dict[str, int]:
         """Get outstanding rewards for an account across all markets."""
-        if not self.web3:
-            return {}
-
         try:
-            web3 = self.web3.get_web3(self.chain_id)
-            contract = web3.eth.contract(
-                address=self.reward_distributor_address, abi=REWARD_DISTRIBUTOR_ABI
-            )
+            async with web3_from_chain_id(self.chain_id) as web3:
+                contract = web3.eth.contract(
+                    address=self.reward_distributor_address, abi=REWARD_DISTRIBUTOR_ABI
+                )
 
-            # Call getOutstandingRewardsForUser(user)
-            all_rewards = await contract.functions.getOutstandingRewardsForUser(
-                account
-            ).call()
-
-            rewards: dict[str, int] = {}
-            for mtoken_data in all_rewards:
-                # mtoken_data is (mToken, [(rewardToken, totalReward, supplySide, borrowSide)])
-                if len(mtoken_data) >= 2:
-                    token_rewards = mtoken_data[1] if len(mtoken_data) > 1 else []
-                    for reward_info in token_rewards:
-                        if len(reward_info) >= 2:
-                            token_addr = reward_info[0]
-                            total_reward = reward_info[1]
-                            if total_reward > 0:
-                                key = f"{self.chain_name}_{token_addr}"
-                                rewards[key] = rewards.get(key, 0) + total_reward
-            return rewards
+                # Call getOutstandingRewardsForUser(user)
+                all_rewards = await contract.functions.getOutstandingRewardsForUser(
+                    account
+                ).call(block_identifier="pending")
+
+                rewards: dict[str, int] = {}
+                for mtoken_data in all_rewards:
+                    # mtoken_data is (mToken, [(rewardToken, totalReward, supplySide, borrowSide)])
+                    if len(mtoken_data) >= 2:
+                        token_rewards = mtoken_data[1] if len(mtoken_data) > 1 else []
+                        for reward_info in token_rewards:
+                            if len(reward_info) >= 2:
+                                token_addr = reward_info[0]
+                                total_reward = reward_info[1]
+                                if total_reward > 0:
+                                    key = f"{self.chain_name}_{token_addr}"
+                                    rewards[key] = rewards.get(key, 0) + total_reward
+                return rewards
         except Exception:
             return {}
 
@@ -874,45 +546,45 @@ class MoonwellAdapter(BaseAdapter):
             block_identifier: Block to query at. Can be:
                 - int: specific block number (for pinning to tx block)
                 - "safe": OP Stack safe block (data posted to L1)
-                - None/"latest": current head (default)
+                - None/"pending": current head (default)
 
         Includes retry logic with exponential backoff for rate-limited RPCs.
         """
-        if not self.web3:
-            return False, "web3 service not configured"
-
         mtoken = self._checksum(mtoken)
         account = self._checksum(account) if account else self._strategy_address()
-        block_id = block_identifier if block_identifier is not None else "latest"
+        block_id = block_identifier if block_identifier is not None else "pending"
 
         bal = exch = borrow = underlying = rewards = None
         last_error = ""
 
         for attempt in range(max_retries):
             try:
-                web3 = self.web3.get_web3(self.chain_id)
-                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-                rewards_contract = web3.eth.contract(
-                    address=self.reward_distributor_address, abi=REWARD_DISTRIBUTOR_ABI
-                )
+                async with web3_from_chain_id(self.chain_id) as web3:
+                    mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                    rewards_contract = web3.eth.contract(
+                        address=self.reward_distributor_address,
+                        abi=REWARD_DISTRIBUTOR_ABI,
+                    )
 
-                # Fetch data sequentially to avoid overwhelming rate-limited public RPCs
-                # (parallel fetch would make 5 simultaneous calls per position)
-                bal = await mtoken_contract.functions.balanceOf(account).call(
-                    block_identifier=block_id
-                )
-                exch = await mtoken_contract.functions.exchangeRateStored().call(
-                    block_identifier=block_id
-                )
-                borrow = await mtoken_contract.functions.borrowBalanceStored(
-                    account
-                ).call(block_identifier=block_id)
-                underlying = await mtoken_contract.functions.underlying().call(
-                    block_identifier=block_id
-                )
-                rewards = await rewards_contract.functions.getOutstandingRewardsForUser(
-                    mtoken, account
-                ).call(block_identifier=block_id)
+                    # Fetch data sequentially to avoid overwhelming rate-limited public RPCs
+                    # (parallel fetch would make 5 simultaneous calls per position)
+                    bal = await mtoken_contract.functions.balanceOf(account).call(
+                        block_identifier=block_id
+                    )
+                    exch = await mtoken_contract.functions.exchangeRateStored().call(
+                        block_identifier=block_id
+                    )
+                    borrow = await mtoken_contract.functions.borrowBalanceStored(
+                        account
+                    ).call(block_identifier=block_id)
+                    underlying = await mtoken_contract.functions.underlying().call(
+                        block_identifier=block_id
+                    )
+                    rewards = (
+                        await rewards_contract.functions.getOutstandingRewardsForUser(
+                            mtoken, account
+                        ).call(block_identifier=block_id)
+                    )
                 break  # Success, exit retry loop
             except Exception as exc:
                 last_error = str(exc)
@@ -1017,9 +689,6 @@ class MoonwellAdapter(BaseAdapter):
         Uses a 1-hour cache since collateral factors rarely change (governance controlled).
         Includes retry logic with exponential backoff for rate-limited RPCs.
         """
-        if not self.web3:
-            return False, "web3 service not configured"
-
         mtoken = self._checksum(mtoken)
 
         # Check cache first
@@ -1032,25 +701,27 @@ class MoonwellAdapter(BaseAdapter):
         last_error = ""
         for attempt in range(max_retries):
             try:
-                web3 = self.web3.get_web3(self.chain_id)
-                contract = web3.eth.contract(
-                    address=self.comptroller_address, abi=COMPTROLLER_ABI
-                )
+                async with web3_from_chain_id(self.chain_id) as web3:
+                    contract = web3.eth.contract(
+                        address=self.comptroller_address, abi=COMPTROLLER_ABI
+                    )
 
-                # markets() returns (isListed, collateralFactorMantissa)
-                result = await contract.functions.markets(mtoken).call()
-                is_listed, collateral_factor_mantissa = result
+                    # markets() returns (isListed, collateralFactorMantissa)
+                    result = await contract.functions.markets(mtoken).call(
+                        block_identifier="pending"
+                    )
+                    is_listed, collateral_factor_mantissa = result
 
-                if not is_listed:
-                    return False, f"Market {mtoken} is not listed"
+                    if not is_listed:
+                        return False, f"Market {mtoken} is not listed"
 
-                # Convert from mantissa to decimal
-                collateral_factor = collateral_factor_mantissa / MANTISSA
+                    # Convert from mantissa to decimal
+                    collateral_factor = collateral_factor_mantissa / MANTISSA
 
-                # Cache the result
-                self._cf_cache[mtoken] = (collateral_factor, now)
+                    # Cache the result
+                    self._cf_cache[mtoken] = (collateral_factor, now)
 
-                return True, collateral_factor
+                    return True, collateral_factor
             except Exception as exc:
                 last_error = str(exc)
                 if _is_rate_limit_error(exc) and attempt < max_retries - 1:
@@ -1073,50 +744,60 @@ class MoonwellAdapter(BaseAdapter):
 
         Includes retry logic with exponential backoff for rate-limited RPCs.
         """
-        if not self.web3:
-            return False, "web3 service not configured"
-
         mtoken = self._checksum(mtoken)
 
         last_error = ""
         for attempt in range(max_retries):
             try:
-                web3 = self.web3.get_web3(self.chain_id)
-                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-                reward_distributor = web3.eth.contract(
-                    address=self.reward_distributor_address, abi=REWARD_DISTRIBUTOR_ABI
-                )
-
-                # Get base rate (sequential to avoid rate limits)
-                if apy_type == "supply":
-                    rate_per_timestamp = (
-                        await mtoken_contract.functions.supplyRatePerTimestamp().call()
-                    )
-                    mkt_config = await reward_distributor.functions.getAllMarketConfigs(
-                        mtoken
-                    ).call()
-                    total_value = await mtoken_contract.functions.totalSupply().call()
-                else:
-                    rate_per_timestamp = (
-                        await mtoken_contract.functions.borrowRatePerTimestamp().call()
-                    )
-                    mkt_config = await reward_distributor.functions.getAllMarketConfigs(
-                        mtoken
-                    ).call()
-                    total_value = await mtoken_contract.functions.totalBorrows().call()
-
-                # Convert rate per second to APY
-                rate = rate_per_timestamp / MANTISSA
-                apy = _timestamp_rate_to_apy(rate)
-
-                # Add WELL rewards APY if requested and token_client available
-                if include_rewards and self.token_client and total_value > 0:
-                    rewards_apr = await self._calculate_rewards_apr(
-                        mtoken, mkt_config, total_value, apy_type
+                async with web3_from_chain_id(self.chain_id) as web3:
+                    mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                    reward_distributor = web3.eth.contract(
+                        address=self.reward_distributor_address,
+                        abi=REWARD_DISTRIBUTOR_ABI,
                     )
-                    apy += rewards_apr
 
-                return True, apy
+                    # Get base rate (sequential to avoid rate limits)
+                    if apy_type == "supply":
+                        rate_per_timestamp = await mtoken_contract.functions.supplyRatePerTimestamp().call(
+                            block_identifier="pending"
+                        )
+                        mkt_config = (
+                            await reward_distributor.functions.getAllMarketConfigs(
+                                mtoken
+                            ).call(block_identifier="pending")
+                        )
+                        total_value = (
+                            await mtoken_contract.functions.totalSupply().call(
+                                block_identifier="pending"
+                            )
+                        )
+                    else:
+                        rate_per_timestamp = await mtoken_contract.functions.borrowRatePerTimestamp().call(
+                            block_identifier="pending"
+                        )
+                        mkt_config = (
+                            await reward_distributor.functions.getAllMarketConfigs(
+                                mtoken
+                            ).call(block_identifier="pending")
+                        )
+                        total_value = (
+                            await mtoken_contract.functions.totalBorrows().call(
+                                block_identifier="pending"
+                            )
+                        )
+
+                    # Convert rate per second to APY
+                    rate = rate_per_timestamp / MANTISSA
+                    apy = _timestamp_rate_to_apy(rate)
+
+                    # Add WELL rewards APY if requested and token_client available
+                    if include_rewards and self.token_client and total_value > 0:
+                        rewards_apr = await self._calculate_rewards_apr(
+                            mtoken, mkt_config, total_value, apy_type
+                        )
+                        apy += rewards_apr
+
+                    return True, apy
             except Exception as exc:
                 last_error = str(exc)
                 if _is_rate_limit_error(exc) and attempt < max_retries - 1:
@@ -1163,9 +844,11 @@ class MoonwellAdapter(BaseAdapter):
                 return 0.0
 
             # Get underlying token for decimals
-            web3 = self.web3.get_web3(self.chain_id)
-            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-            underlying_addr = await mtoken_contract.functions.underlying().call()
+            async with web3_from_chain_id(self.chain_id) as web3:
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                underlying_addr = await mtoken_contract.functions.underlying().call(
+                    block_identifier="pending"
+                )
 
             # Get prices
             well_key = f"{self.chain_name}_{self.well_token}"
@@ -1221,33 +904,32 @@ class MoonwellAdapter(BaseAdapter):
 
         Includes retry logic with exponential backoff for rate-limited RPCs.
         """
-        if not self.web3:
-            return False, "web3 service not configured"
-
         account = self._checksum(account) if account else self._strategy_address()
 
         last_error = ""
         for attempt in range(max_retries):
             try:
-                web3 = self.web3.get_web3(self.chain_id)
-                contract = web3.eth.contract(
-                    address=self.comptroller_address, abi=COMPTROLLER_ABI
-                )
+                async with web3_from_chain_id(self.chain_id) as web3:
+                    contract = web3.eth.contract(
+                        address=self.comptroller_address, abi=COMPTROLLER_ABI
+                    )
 
-                # getAccountLiquidity returns (error, liquidity, shortfall)
-                (
-                    error,
-                    liquidity,
-                    shortfall,
-                ) = await contract.functions.getAccountLiquidity(account).call()
+                    # getAccountLiquidity returns (error, liquidity, shortfall)
+                    (
+                        error,
+                        liquidity,
+                        shortfall,
+                    ) = await contract.functions.getAccountLiquidity(account).call(
+                        block_identifier="pending"
+                    )
 
-                if error != 0:
-                    return False, f"Comptroller error: {error}"
+                    if error != 0:
+                        return False, f"Comptroller error: {error}"
 
-                if shortfall > 0:
-                    return False, f"Account has shortfall: {shortfall}"
+                    if shortfall > 0:
+                        return False, f"Account has shortfall: {shortfall}"
 
-                return True, liquidity
+                    return True, liquidity
             except Exception as exc:
                 last_error = str(exc)
                 if _is_rate_limit_error(exc) and attempt < max_retries - 1:
@@ -1265,93 +947,102 @@ class MoonwellAdapter(BaseAdapter):
         account: str | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
         """Calculate max mTokens withdrawable without liquidation using binary search."""
-        if not self.web3:
-            return False, "web3 service not configured"
-
         mtoken = self._checksum(mtoken)
         account = self._checksum(account) if account else self._strategy_address()
 
         try:
-            web3 = self.web3.get_web3(self.chain_id)
-            comptroller = web3.eth.contract(
-                address=self.comptroller_address, abi=COMPTROLLER_ABI
-            )
-            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
-
-            # Get all needed data in parallel
-            bal_raw, exch_raw, cash_raw, m_dec, u_addr = await asyncio.gather(
-                mtoken_contract.functions.balanceOf(account).call(),
-                mtoken_contract.functions.exchangeRateStored().call(),
-                mtoken_contract.functions.getCash().call(),
-                mtoken_contract.functions.decimals().call(),
-                mtoken_contract.functions.underlying().call(),
-            )
+            async with web3_from_chain_id(self.chain_id) as web3:
+                comptroller = web3.eth.contract(
+                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                )
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+
+                # Get all needed data in parallel
+                bal_raw, exch_raw, cash_raw, m_dec, u_addr = await asyncio.gather(
+                    mtoken_contract.functions.balanceOf(account).call(
+                        block_identifier="pending"
+                    ),
+                    mtoken_contract.functions.exchangeRateStored().call(
+                        block_identifier="pending"
+                    ),
+                    mtoken_contract.functions.getCash().call(
+                        block_identifier="pending"
+                    ),
+                    mtoken_contract.functions.decimals().call(
+                        block_identifier="pending"
+                    ),
+                    mtoken_contract.functions.underlying().call(
+                        block_identifier="pending"
+                    ),
+                )
+
+                if bal_raw == 0 or exch_raw == 0:
+                    return True, {
+                        "cTokens_raw": 0,
+                        "cTokens": 0.0,
+                        "underlying_raw": 0,
+                        "underlying": 0.0,
+                        "bounds_raw": {"collateral_cTokens": 0, "cash_cTokens": 0},
+                        "exchangeRate_raw": int(exch_raw),
+                        "mToken_decimals": int(m_dec),
+                        "underlying_decimals": None,
+                    }
+
+                # Get underlying decimals
+                u_dec = 18  # Default
+                if self.token_client:
+                    try:
+                        u_key = f"{self.chain_name}_{u_addr}"
+                        u_data = await self.token_client.get_token_details(u_key)
+                        if u_data:
+                            u_dec = u_data.get("decimals", 18)
+                    except Exception:
+                        pass
+
+                # Binary search: largest cTokens you can redeem without shortfall
+                lo, hi = 0, int(bal_raw)
+                while lo < hi:
+                    mid = (lo + hi + 1) // 2
+                    (
+                        err,
+                        _liq,
+                        short,
+                    ) = await comptroller.functions.getHypotheticalAccountLiquidity(
+                        account, mtoken, mid, 0
+                    ).call(block_identifier="pending")
+                    if err != 0:
+                        return False, f"Comptroller error {err}"
+                    if short == 0:
+                        lo = mid  # Safe, try more
+                    else:
+                        hi = mid - 1
+
+                c_by_collateral = lo
+
+                # Pool cash bound (convert underlying cash -> cToken capacity)
+                c_by_cash = (int(cash_raw) * MANTISSA) // int(exch_raw)
+
+                redeem_c_raw = min(c_by_collateral, int(c_by_cash))
+
+                # Final underlying you actually receive (mirror Solidity floor)
+                under_raw = (redeem_c_raw * int(exch_raw)) // MANTISSA
 
-            if bal_raw == 0 or exch_raw == 0:
                 return True, {
-                    "cTokens_raw": 0,
-                    "cTokens": 0.0,
-                    "underlying_raw": 0,
-                    "underlying": 0.0,
-                    "bounds_raw": {"collateral_cTokens": 0, "cash_cTokens": 0},
+                    "cTokens_raw": int(redeem_c_raw),
+                    "cTokens": redeem_c_raw / (10 ** int(m_dec)),
+                    "underlying_raw": int(under_raw),
+                    "underlying": under_raw / (10 ** int(u_dec)),
+                    "bounds_raw": {
+                        "collateral_cTokens": int(c_by_collateral),
+                        "cash_cTokens": int(c_by_cash),
+                    },
                     "exchangeRate_raw": int(exch_raw),
                     "mToken_decimals": int(m_dec),
-                    "underlying_decimals": None,
+                    "underlying_decimals": int(u_dec),
+                    "conversion_factor": redeem_c_raw / under_raw
+                    if under_raw > 0
+                    else 0,
                 }
-
-            # Get underlying decimals
-            u_dec = 18  # Default
-            if self.token_client:
-                try:
-                    u_key = f"{self.chain_name}_{u_addr}"
-                    u_data = await self.token_client.get_token_details(u_key)
-                    if u_data:
-                        u_dec = u_data.get("decimals", 18)
-                except Exception:
-                    pass
-
-            # Binary search: largest cTokens you can redeem without shortfall
-            lo, hi = 0, int(bal_raw)
-            while lo < hi:
-                mid = (lo + hi + 1) // 2
-                (
-                    err,
-                    _liq,
-                    short,
-                ) = await comptroller.functions.getHypotheticalAccountLiquidity(
-                    account, mtoken, mid, 0
-                ).call()
-                if err != 0:
-                    return False, f"Comptroller error {err}"
-                if short == 0:
-                    lo = mid  # Safe, try more
-                else:
-                    hi = mid - 1
-
-            c_by_collateral = lo
-
-            # Pool cash bound (convert underlying cash -> cToken capacity)
-            c_by_cash = (int(cash_raw) * MANTISSA) // int(exch_raw)
-
-            redeem_c_raw = min(c_by_collateral, int(c_by_cash))
-
-            # Final underlying you actually receive (mirror Solidity floor)
-            under_raw = (redeem_c_raw * int(exch_raw)) // MANTISSA
-
-            return True, {
-                "cTokens_raw": int(redeem_c_raw),
-                "cTokens": redeem_c_raw / (10 ** int(m_dec)),
-                "underlying_raw": int(under_raw),
-                "underlying": under_raw / (10 ** int(u_dec)),
-                "bounds_raw": {
-                    "collateral_cTokens": int(c_by_collateral),
-                    "cash_cTokens": int(c_by_cash),
-                },
-                "exchangeRate_raw": int(exch_raw),
-                "mToken_decimals": int(m_dec),
-                "underlying_decimals": int(u_dec),
-                "conversion_factor": redeem_c_raw / under_raw if under_raw > 0 else 0,
-            }
         except Exception as exc:
             return False, str(exc)
 
@@ -1378,7 +1069,7 @@ class MoonwellAdapter(BaseAdapter):
             from_address=strategy,
             value=amount,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Helpers                                                             #
@@ -1387,6 +1078,13 @@ class MoonwellAdapter(BaseAdapter):
     # Max uint256 for unlimited approvals
     MAX_UINT256 = 2**256 - 1
 
+    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,
         *,
@@ -1398,29 +1096,27 @@ class MoonwellAdapter(BaseAdapter):
         """Ensure token allowance is sufficient, approving if needed.
 
         Approves for max uint256 to avoid precision issues with exact amounts.
+        In simulation mode, skips the allowance check and assumes approval needed.
         """
-        if not self.token_txn_service:
-            return False, "token_txn_service not configured"
+        if self.simulation:
+            return True, {}  # Skip allowance check in simulation
 
-        chain = {"id": self.chain_id}
-        allowance = await self.token_txn_service.read_erc20_allowance(
-            chain, token_address, owner, spender
+        allowance = await get_token_allowance(
+            token_address, self.chain_id, owner, spender
         )
-        if allowance.get("allowance", 0) >= amount:
+        if allowance >= amount:
             return True, {}
 
         # Approve for max uint256 to avoid precision/timing issues
-        build_success, approve_tx = self.token_txn_service.build_erc20_approve(
+        approve_tx = await build_approve_transaction(
+            from_address=owner,
             chain_id=self.chain_id,
             token_address=token_address,
-            from_address=owner,
-            spender=spender,
+            spender_address=spender,
             amount=self.MAX_UINT256,
         )
-        if not build_success:
-            return False, approve_tx
 
-        result = await self._broadcast_transaction(approve_tx)
+        result = await self._send_tx(approve_tx)
 
         # Small delay after approval to ensure state is propagated on providers/chains
         # where we don't wait for additional confirmations by default.
@@ -1436,60 +1132,6 @@ class MoonwellAdapter(BaseAdapter):
 
         return result
 
-    async def _execute(
-        self, tx: dict[str, Any], max_retries: int = DEFAULT_MAX_RETRIES
-    ) -> tuple[bool, Any]:
-        """Execute a transaction (or return simulation data).
-
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
-        if self.simulation:
-            return True, {"simulation": tx}
-        if not self.web3:
-            return False, "web3 service not configured"
-
-        last_error = None
-        for attempt in range(max_retries):
-            try:
-                return await self.web3.broadcast_transaction(
-                    tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
-                )
-            except Exception as exc:
-                last_error = exc
-                if _is_rate_limit_error(exc) and attempt < max_retries - 1:
-                    wait_time = DEFAULT_BASE_DELAY * (2**attempt)
-                    await asyncio.sleep(wait_time)
-                    continue
-                return False, str(exc)
-
-        return False, str(last_error) if last_error else "Max retries exceeded"
-
-    async def _broadcast_transaction(
-        self, tx: dict[str, Any], max_retries: int = DEFAULT_MAX_RETRIES
-    ) -> tuple[bool, Any]:
-        """Broadcast a pre-built transaction.
-
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
-        if not self.web3:
-            return False, "web3 service not configured"
-
-        last_error = None
-        for attempt in range(max_retries):
-            try:
-                return await self.web3.evm_transactions.broadcast_transaction(
-                    tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
-                )
-            except Exception as exc:
-                last_error = exc
-                if _is_rate_limit_error(exc) and attempt < max_retries - 1:
-                    wait_time = DEFAULT_BASE_DELAY * (2**attempt)
-                    await asyncio.sleep(wait_time)
-                    continue
-                return False, str(exc)
-
-        return False, str(last_error) if last_error else "Max retries exceeded"
-
     async def _encode_call(
         self,
         *,
@@ -1501,28 +1143,25 @@ class MoonwellAdapter(BaseAdapter):
         value: int = 0,
     ) -> dict[str, Any]:
         """Encode a contract call without touching the network."""
-        if not self.web3:
-            raise ValueError("web3 service not configured")
-
-        web3 = self.web3.get_web3(self.chain_id)
-        contract = web3.eth.contract(address=target, abi=abi)
+        async with web3_from_chain_id(self.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
-
-        tx: dict[str, Any] = {
-            "chainId": int(self.chain_id),
-            "from": to_checksum_address(from_address),
-            "to": to_checksum_address(target),
-            "data": data,
-            "value": int(value),
-        }
-        return tx
+            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
+
+            tx: dict[str, Any] = {
+                "chainId": int(self.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:
         """Get the strategy wallet address."""