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

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -15,14 +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.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 = {
@@ -64,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
@@ -109,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)
@@ -197,7 +166,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     async def unlend(
         self,
@@ -221,7 +190,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Public API - Borrowing Operations                                   #
@@ -251,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(
@@ -273,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,
@@ -284,19 +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:
-                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()
+                ).call(block_identifier="pending")
 
                 # Borrow balance should have increased by approximately the amount
                 # Allow for some interest accrual
@@ -317,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
 
@@ -370,7 +336,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[repay_amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Public API - Collateral Management                                  #
@@ -396,21 +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:
-                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()
+                ).call(block_identifier="pending")
 
                 if not is_member:
                     from loguru import logger
@@ -423,13 +388,38 @@ 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
 
+    async def is_market_entered(
+        self,
+        *,
+        mtoken: str,
+        account: str | None = None,
+    ) -> tuple[bool, bool | str]:
+        """Check whether an account has entered a given market (as collateral / borrowing market)."""
+        if self.simulation:
+            return True, True
+
+        try:
+            acct = self._checksum(account) if account else self._strategy_address()
+            mtoken = self._checksum(mtoken)
+
+            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)
+
     async def remove_collateral(
         self,
         *,
@@ -446,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                                                #
@@ -481,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
 
@@ -489,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 {}
 
@@ -559,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)
@@ -702,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
@@ -717,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:
@@ -758,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:
@@ -848,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}"
@@ -906,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:
@@ -950,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)
 
@@ -1063,7 +1069,7 @@ class MoonwellAdapter(BaseAdapter):
             from_address=strategy,
             value=amount,
         )
-        return await self._execute(tx)
+        return await self._send_tx(tx)
 
     # ------------------------------------------------------------------ #
     # Helpers                                                             #
@@ -1072,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,
         *,
@@ -1083,90 +1096,42 @@ 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
+        # Small delay after approval to ensure state is propagated on providers/chains
+        # where we don't wait for additional confirmations by default.
         if result[0]:
-            await asyncio.sleep(1.0)
+            confirmations = 0
+            if isinstance(result[1], dict):
+                try:
+                    confirmations = int(result[1].get("confirmations") or 0)
+                except (TypeError, ValueError):
+                    confirmations = 0
+            if confirmations == 0:
+                await asyncio.sleep(1.0)
 
         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,
         *,
@@ -1178,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")
+        async with web3_from_chain_id(self.chain_id) as web3:
+            contract = web3.eth.contract(address=target, abi=abi)
 
-        web3 = self.web3.get_web3(self.chain_id)
-        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."""