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

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -1,63 +1,35 @@
 from __future__ import annotations
 
 import asyncio
-import time
 from typing import Any, Literal
 
+from aiocache import Cache
 from eth_utils import to_checksum_address
+from eth_utils.abi import collapse_if_tuple
 
+from wayfinder_paths.adapters.multicall_adapter.adapter import MulticallAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.TokenClient import TokenClient
+from wayfinder_paths.core.constants.base import MANTISSA, MAX_UINT256, SECONDS_PER_YEAR
+from wayfinder_paths.core.constants.chains import CHAIN_ID_BASE
+from wayfinder_paths.core.constants.contracts import (
+    BASE_WETH,
+    MOONWELL_COMPTROLLER,
+    MOONWELL_M_USDC,
+    MOONWELL_REWARD_DISTRIBUTOR,
+    MOONWELL_WELL_TOKEN,
+)
 from wayfinder_paths.core.constants.moonwell_abi import (
     COMPTROLLER_ABI,
     MTOKEN_ABI,
     REWARD_DISTRIBUTOR_ABI,
     WETH_ABI,
 )
-from wayfinder_paths.core.utils.tokens import (
-    build_approve_transaction,
-    get_token_allowance,
-)
-from wayfinder_paths.core.utils.transaction import send_transaction
+from wayfinder_paths.core.utils.tokens import ensure_allowance
+from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
-# Moonwell Base chain addresses
-MOONWELL_DEFAULTS = {
-    # mToken addresses
-    "m_usdc": "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22",
-    "m_weth": "0x628ff693426583D9a7FB391E54366292F509D457",
-    "m_wsteth": "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b",
-    # Underlying token addresses
-    "usdc": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    "weth": "0x4200000000000000000000000000000000000006",
-    "wsteth": "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
-    # Protocol addresses
-    "reward_distributor": "0xe9005b078701e2a0948d2eac43010d35870ad9d2",
-    "comptroller": "0xfbb21d0380bee3312b33c4353c8936a0f13ef26c",
-    # WELL token address on Base
-    "well_token": "0xA88594D404727625A9437C3f886C7643872296AE",
-}
-
-# Base chain ID
-BASE_CHAIN_ID = 8453
-
-# Mantissa for collateral factor calculations (1e18)
-MANTISSA = 10**18
-
-# Seconds per year for APY calculations
-SECONDS_PER_YEAR = 365 * 24 * 60 * 60
-
-# Collateral factor cache TTL (1 hour - rarely changes, governance controlled)
-CF_CACHE_TTL = 3600
-
-# Default retry settings for rate-limited RPCs
-DEFAULT_MAX_RETRIES = 5
-DEFAULT_BASE_DELAY = 3.0
-
-
-def _is_rate_limit_error(error: Exception | str) -> bool:
-    error_str = str(error)
-    return "429" in error_str or "Too Many Requests" in error_str
+CHAIN_NAME = "base"
 
 
 def _timestamp_rate_to_apy(rate: float) -> float:
@@ -67,6 +39,69 @@ def _timestamp_rate_to_apy(rate: float) -> float:
 class MoonwellAdapter(BaseAdapter):
     adapter_type = "MOONWELL"
 
+    # ---------------------------
+    # Multicall decoding helpers
+    # ---------------------------
+
+    @staticmethod
+    def _chunks(seq: list[Any], n: int) -> list[list[Any]]:
+        return [seq[i : i + n] for i in range(0, len(seq), n)]
+
+    @staticmethod
+    def _fn_abi(
+        contract: Any, fn_name: str, *, inputs_len: int | None = None
+    ) -> dict[str, Any]:
+        for item in contract.abi or []:
+            if item.get("type") != "function":
+                continue
+            if item.get("name") != fn_name:
+                continue
+            if inputs_len is not None and len(item.get("inputs") or []) != inputs_len:
+                continue
+            return item
+        raise ValueError(f"Function ABI not found: {fn_name} (inputs_len={inputs_len})")
+
+    @staticmethod
+    def _decode(web3: Any, fn_abi: dict[str, Any], data: bytes) -> tuple[Any, ...]:
+        output_types = [
+            collapse_if_tuple(o)
+            for o in (fn_abi.get("outputs") or [])
+            if isinstance(o, dict)
+        ]
+        if not output_types:
+            return ()
+        return tuple(web3.codec.decode(output_types, data))
+
+    async def _multicall_chunked(
+        self,
+        *,
+        multicall: MulticallAdapter,
+        calls: list[Any],
+        chunk_size: int,
+    ) -> list[bytes]:
+        """
+        Execute multicall in chunks.
+
+        If a chunk reverts, fall back to executing calls one-by-one so we can salvage
+        partial results (returning b"" for failed calls).
+        """
+        out: list[bytes] = []
+        for chunk in self._chunks(calls, max(1, int(chunk_size))):
+            if not chunk:
+                continue
+            try:
+                res = await multicall.aggregate(chunk)
+                out.extend(list(res.return_data))
+                continue
+            except Exception:  # noqa: BLE001 - fall back to individual calls
+                for call in chunk:
+                    try:
+                        r = await multicall.aggregate([call])
+                        out.append(r.return_data[0] if r.return_data else b"")
+                    except Exception:  # noqa: BLE001
+                        out.append(b"")
+        return out
+
     def __init__(
         self,
         config: dict[str, Any] | None = None,
@@ -75,49 +110,20 @@ class MoonwellAdapter(BaseAdapter):
     ) -> None:
         super().__init__("moonwell_adapter", config)
         cfg = config or {}
-        adapter_cfg = cfg.get("moonwell_adapter") or {}
 
         self.token_client = token_client
         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)
-        self.chain_name = "base"
+        # Chain configuration (Base-only for now)
+        self.chain_id = CHAIN_ID_BASE
+        self.chain_name = CHAIN_NAME
+        self.comptroller_address = MOONWELL_COMPTROLLER
+        self.reward_distributor_address = MOONWELL_REWARD_DISTRIBUTOR
+        self.m_usdc = MOONWELL_M_USDC  # Sample mtoken for ABI extraction
 
-        # Protocol addresses (with config overrides)
-        self.comptroller_address = self._checksum(
-            adapter_cfg.get("comptroller") or MOONWELL_DEFAULTS["comptroller"]
-        )
-        self.reward_distributor_address = self._checksum(
-            adapter_cfg.get("reward_distributor")
-            or MOONWELL_DEFAULTS["reward_distributor"]
-        )
-        self.well_token = self._checksum(
-            adapter_cfg.get("well_token") or MOONWELL_DEFAULTS["well_token"]
-        )
-
-        # Token addresses
-        self.m_usdc = self._checksum(
-            adapter_cfg.get("m_usdc") or MOONWELL_DEFAULTS["m_usdc"]
-        )
-        self.m_weth = self._checksum(
-            adapter_cfg.get("m_weth") or MOONWELL_DEFAULTS["m_weth"]
-        )
-        self.m_wsteth = self._checksum(
-            adapter_cfg.get("m_wsteth") or MOONWELL_DEFAULTS["m_wsteth"]
-        )
-        self.usdc = self._checksum(adapter_cfg.get("usdc") or MOONWELL_DEFAULTS["usdc"])
-        self.weth = self._checksum(adapter_cfg.get("weth") or MOONWELL_DEFAULTS["weth"])
-        self.wsteth = self._checksum(
-            adapter_cfg.get("wsteth") or MOONWELL_DEFAULTS["wsteth"]
-        )
-
-        # Collateral factor cache: mtoken -> (value, timestamp)
-        self._cf_cache: dict[str, tuple[float, float]] = {}
-
-    # ------------------------------------------------------------------ #
-    # Public API - Lending Operations                                     #
-    # ------------------------------------------------------------------ #
+        strategy_wallet = cfg.get("strategy_wallet") or {}
+        self.strategy_wallet_address = to_checksum_address(strategy_wallet["address"])
+        self._cache = Cache(Cache.MEMORY)
 
     async def lend(
         self,
@@ -126,33 +132,38 @@ class MoonwellAdapter(BaseAdapter):
         underlying_token: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         amount = int(amount)
         if amount <= 0:
             return False, "amount must be positive"
 
-        mtoken = self._checksum(mtoken)
-        underlying_token = self._checksum(underlying_token)
+        mtoken = to_checksum_address(mtoken)
+        underlying_token = to_checksum_address(underlying_token)
 
-        # Approve mToken to spend underlying tokens
-        approved = await self._ensure_allowance(
+        approved = await ensure_allowance(
             token_address=underlying_token,
             owner=strategy,
             spender=mtoken,
             amount=amount,
+            chain_id=CHAIN_ID_BASE,
+            signing_callback=self.strategy_wallet_signing_callback,
+            approval_amount=MAX_UINT256,
         )
         if not approved[0]:
             return approved
 
-        # Mint mTokens (supply underlying)
-        tx = await self._encode_call(
+        transaction = await encode_call(
             target=mtoken,
             abi=MTOKEN_ABI,
             fn_name="mint",
             args=[amount],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        return await self._send_tx(tx)
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
+        )
+        return (True, txn_hash)
 
     async def unlend(
         self,
@@ -160,26 +171,25 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         amount = int(amount)
         if amount <= 0:
             return False, "amount must be positive"
 
-        mtoken = self._checksum(mtoken)
+        mtoken = to_checksum_address(mtoken)
 
-        # Redeem mTokens for underlying
-        tx = await self._encode_call(
+        transaction = await encode_call(
             target=mtoken,
             abi=MTOKEN_ABI,
             fn_name="redeem",
             args=[amount],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Borrowing Operations                                   #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
+        )
+        return (True, txn_hash)
 
     async def borrow(
         self,
@@ -187,86 +197,25 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        from loguru import logger
-
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         amount = int(amount)
         if amount <= 0:
             return False, "amount must be positive"
 
-        mtoken = self._checksum(mtoken)
+        mtoken = to_checksum_address(mtoken)
 
-        borrow_before = 0
-        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(block_identifier="pending")
-
-                # Simulate borrow to check for errors before submitting
-                try:
-                    borrow_return = await mtoken_contract.functions.borrow(amount).call(
-                        {"from": strategy}, block_identifier="pending"
-                    )
-                    if borrow_return != 0:
-                        logger.warning(
-                            f"Borrow simulation returned error code {borrow_return}. "
-                            "Codes: 3=COMPTROLLER_REJECTION, 9=INVALID_ACCOUNT_PAIR, "
-                            "14=INSUFFICIENT_LIQUIDITY"
-                        )
-                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}")
-
-        tx = await self._encode_call(
+        transaction = await encode_call(
             target=mtoken,
             abi=MTOKEN_ABI,
             fn_name="borrow",
             args=[amount],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        result = await self._send_tx(tx)
-
-        if not result[0]:
-            return result
-
-        # Verify the borrow actually succeeded by checking balance increased
-        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="pending")
-
-                # Borrow balance should have increased by approximately the amount
-                # Allow for some interest accrual
-                expected_increase = amount * 0.99
-                actual_increase = borrow_after - borrow_before
-
-                if actual_increase < expected_increase:
-                    from loguru import logger
-
-                    logger.error(
-                        f"Borrow verification failed: balance only increased by "
-                        f"{actual_increase} (expected ~{amount}). "
-                        f"Moonwell likely returned an error code. "
-                        f"Before: {borrow_before}, After: {borrow_after}"
-                    )
-                    return (
-                        False,
-                        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
-
-            logger.warning(f"Could not verify borrow balance: {e}")
-            # Continue with the original result if verification fails
-
-        return result
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
+        )
+        return (True, txn_hash)
 
     async def repay(
         self,
@@ -276,75 +225,73 @@ class MoonwellAdapter(BaseAdapter):
         amount: int,
         repay_full: bool = False,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         amount = int(amount)
         if amount <= 0:
             return False, "amount must be positive"
 
-        mtoken = self._checksum(mtoken)
-        underlying_token = self._checksum(underlying_token)
+        mtoken = to_checksum_address(mtoken)
+        underlying_token = to_checksum_address(underlying_token)
 
-        # 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(
+        approved = await ensure_allowance(
             token_address=underlying_token,
             owner=strategy,
             spender=mtoken,
             amount=amount,
+            chain_id=CHAIN_ID_BASE,
+            signing_callback=self.strategy_wallet_signing_callback,
+            approval_amount=MAX_UINT256,
         )
         if not approved[0]:
             return approved
 
-        # Use max uint256 for full repayment to avoid balance calculation issues
-        repay_amount = self.MAX_UINT256 if repay_full else amount
+        # max uint256 avoids balance calculation race conditions
+        repay_amount = MAX_UINT256 if repay_full else amount
 
-        tx = await self._encode_call(
+        transaction = await encode_call(
             target=mtoken,
             abi=MTOKEN_ABI,
             fn_name="repayBorrow",
             args=[repay_amount],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Collateral Management                                  #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
+        )
+        return (True, txn_hash)
 
     async def set_collateral(
         self,
         *,
         mtoken: str,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
-        mtoken = self._checksum(mtoken)
+        strategy = self.strategy_wallet_address
+        mtoken = to_checksum_address(mtoken)
 
-        tx = await self._encode_call(
-            target=self.comptroller_address,
+        transaction = await encode_call(
+            target=MOONWELL_COMPTROLLER,
             abi=COMPTROLLER_ABI,
             fn_name="enterMarkets",
             args=[[mtoken]],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
+        )
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
         )
-        result = await self._send_tx(tx)
-
-        if not result[0]:
-            return result
 
-        # Verify the market was actually entered
         try:
-            async with web3_from_chain_id(self.chain_id) as web3:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
                 comptroller = web3.eth.contract(
-                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                    address=MOONWELL_COMPTROLLER, abi=COMPTROLLER_ABI
                 )
                 is_member = await comptroller.functions.checkMembership(
                     strategy, mtoken
                 ).call(block_identifier="pending")
 
                 if not is_member:
-                    from loguru import logger
-
-                    logger.error(
+                    self.logger.error(
                         f"set_collateral verification failed: account {strategy} "
                         f"is not a member of market {mtoken} after enterMarkets call"
                     )
@@ -353,11 +300,9 @@ class MoonwellAdapter(BaseAdapter):
                         f"enterMarkets succeeded but account is not a member of market {mtoken}",
                     )
         except Exception as e:
-            from loguru import logger
+            self.logger.warning(f"Could not verify market membership: {e}")
 
-            logger.warning(f"Could not verify market membership: {e}")
-
-        return result
+        return (True, txn_hash)
 
     async def is_market_entered(
         self,
@@ -366,16 +311,20 @@ class MoonwellAdapter(BaseAdapter):
         account: str | None = None,
     ) -> tuple[bool, bool | str]:
         try:
-            acct = self._checksum(account) if account else self._strategy_address()
-            mtoken = self._checksum(mtoken)
+            acct = (
+                to_checksum_address(account)
+                if account
+                else self.strategy_wallet_address
+            )
+            mtoken = to_checksum_address(mtoken)
 
-            async with web3_from_chain_id(self.chain_id) as web3:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
                 comptroller = web3.eth.contract(
-                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                    address=MOONWELL_COMPTROLLER, abi=COMPTROLLER_ABI
                 )
                 is_member = await comptroller.functions.checkMembership(
                     acct, mtoken
-                ).call()
+                ).call(block_identifier="pending")
                 return True, bool(is_member)
         except Exception as exc:
             return False, str(exc)
@@ -385,32 +334,31 @@ class MoonwellAdapter(BaseAdapter):
         *,
         mtoken: str,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
-        mtoken = self._checksum(mtoken)
+        strategy = self.strategy_wallet_address
+        mtoken = to_checksum_address(mtoken)
 
-        tx = await self._encode_call(
-            target=self.comptroller_address,
+        transaction = await encode_call(
+            target=MOONWELL_COMPTROLLER,
             abi=COMPTROLLER_ABI,
             fn_name="exitMarket",
             args=[mtoken],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Rewards                                                #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
+        )
+        return (True, txn_hash)
 
     async def claim_rewards(
         self,
         *,
         min_rewards_usd: float = 0.0,
     ) -> tuple[bool, dict[str, int] | str]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
 
         rewards = await self._get_outstanding_rewards(strategy)
 
-        # Skip if no rewards to claim
         if not rewards:
             return True, {}
 
@@ -419,25 +367,22 @@ class MoonwellAdapter(BaseAdapter):
             if total_usd < min_rewards_usd:
                 return True, {}
 
-        # Claim via comptroller (like reference implementation)
-        tx = await self._encode_call(
-            target=self.comptroller_address,
+        transaction = await encode_call(
+            target=MOONWELL_COMPTROLLER,
             abi=COMPTROLLER_ABI,
             fn_name="claimReward",
             args=[strategy],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
         )
-        result = await self._send_tx(tx)
-        if not result[0]:
-            return result
-
+        await send_transaction(transaction, self.strategy_wallet_signing_callback)
         return True, rewards
 
     async def _get_outstanding_rewards(self, account: str) -> dict[str, int]:
         try:
-            async with web3_from_chain_id(self.chain_id) as web3:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
                 contract = web3.eth.contract(
-                    address=self.reward_distributor_address, abi=REWARD_DISTRIBUTOR_ABI
+                    address=MOONWELL_REWARD_DISTRIBUTOR, abi=REWARD_DISTRIBUTOR_ABI
                 )
 
                 all_rewards = await contract.functions.getOutstandingRewardsForUser(
@@ -446,15 +391,12 @@ class MoonwellAdapter(BaseAdapter):
 
                 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:
+                        for reward_info in mtoken_data[1]:
                             if len(reward_info) >= 2:
-                                token_addr = reward_info[0]
-                                total_reward = reward_info[1]
+                                token_addr, total_reward, *_ = reward_info
                                 if total_reward > 0:
-                                    key = f"{self.chain_name}_{token_addr}"
+                                    key = f"{CHAIN_NAME}_{token_addr}"
                                     rewards[key] = rewards.get(key, 0) + total_reward
                 return rewards
         except Exception:
@@ -466,81 +408,384 @@ class MoonwellAdapter(BaseAdapter):
 
         total_usd = 0.0
         for token_key, amount in rewards.items():
-            try:
-                token_data = await self.token_client.get_token_details(token_key)
-                if token_data:
-                    price = token_data.get("price_usd") or token_data.get("price", 0)
-                    decimals = token_data.get("decimals", 18)
-                    total_usd += (amount / (10**decimals)) * price
-            except Exception:
-                pass
+            token_data = await self.token_client.get_token_details(token_key)
+            if token_data:
+                price = token_data.get("price_usd") or token_data.get("price", 0)
+                decimals = token_data.get("decimals", 18)
+                total_usd += (amount / (10**decimals)) * price
         return total_usd
 
     # ------------------------------------------------------------------ #
     # Public API - Position & Market Data                                 #
     # ------------------------------------------------------------------ #
 
-    async def get_pos(
+    async def get_full_user_state(
         self,
         *,
-        mtoken: str,
         account: str | None = None,
+        include_rewards: bool = True,
         include_usd: bool = False,
-        max_retries: int = 3,
-        block_identifier: int | str | None = None,
+        include_apy: bool = False,
+        include_zero_positions: bool = False,
+        multicall_chunk_size: int = 240,
+        block_identifier: int | str | None = None,  # multicall ignores block id
     ) -> tuple[bool, dict[str, Any] | str]:
-        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 "pending"
+        """
+        Full Moonwell state snapshot using Multicall3.aggregate.
+
+        This minimizes RPC roundtrips by batching:
+          - Comptroller: getAllMarkets(), getAssetsIn(account), getAccountLiquidity(account)
+          - RewardDistributor (optional): getOutstandingRewardsForUser(account)
+          - Per market: balanceOf, exchangeRateStored, borrowBalanceStored, underlying,
+            decimals, comptroller.markets
+        """
+        _ = block_identifier  # reserved for future per-call block pinning
+        acct = to_checksum_address(account) if account else self.strategy_wallet_address
 
-        bal = exch = borrow = underlying = rewards = None
-        last_error = ""
+        try:
+            async with web3_from_chain_id(self.chain_id) as web3:
+                multicall = MulticallAdapter(chain_id=self.chain_id, web3=web3)
 
-        for attempt in range(max_retries):
-            try:
-                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,
-                    )
+                comptroller = web3.eth.contract(
+                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                )
+                rewards_contract = web3.eth.contract(
+                    address=self.reward_distributor_address,
+                    abi=REWARD_DISTRIBUTOR_ABI,
+                )
 
-                    # (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
+                # --- Stage 1: global reads (batched)
+                calls_stage1: list[Any] = [
+                    multicall.build_call(
+                        self.comptroller_address,
+                        comptroller.encode_abi("getAllMarkets", args=[]),
+                    ),
+                    multicall.build_call(
+                        self.comptroller_address,
+                        comptroller.encode_abi("getAssetsIn", args=[acct]),
+                    ),
+                    multicall.build_call(
+                        self.comptroller_address,
+                        comptroller.encode_abi("getAccountLiquidity", args=[acct]),
+                    ),
+                ]
+                if include_rewards:
+                    calls_stage1.append(
+                        multicall.build_call(
+                            self.reward_distributor_address,
+                            rewards_contract.encode_abi(
+                                "getOutstandingRewardsForUser", args=[acct]
+                            ),
+                        )
                     )
-                    rewards = (
-                        await rewards_contract.functions.getOutstandingRewardsForUser(
-                            mtoken, account
-                        ).call(block_identifier=block_id)
+
+                ret1 = await self._multicall_chunked(
+                    multicall=multicall,
+                    calls=calls_stage1,
+                    chunk_size=multicall_chunk_size,
+                )
+
+                # decode stage1
+                abi_all = self._fn_abi(comptroller, "getAllMarkets", inputs_len=0)
+                abi_assets = self._fn_abi(comptroller, "getAssetsIn", inputs_len=1)
+                abi_liq = self._fn_abi(comptroller, "getAccountLiquidity", inputs_len=1)
+
+                all_markets = (
+                    self._decode(web3, abi_all, ret1[0] or b"")[0]
+                    if ret1 and ret1[0]
+                    else []
+                )
+                assets_in = (
+                    self._decode(web3, abi_assets, ret1[1] or b"")[0]
+                    if len(ret1) > 1 and ret1[1]
+                    else []
+                )
+                liq_tuple = (
+                    self._decode(web3, abi_liq, ret1[2] or b"")
+                    if len(ret1) > 2 and ret1[2]
+                    else (0, 0, 0)
+                )
+                error, liquidity, shortfall = (
+                    int(liq_tuple[0]),
+                    int(liq_tuple[1]),
+                    int(liq_tuple[2]),
+                )
+
+                entered = {str(a).lower() for a in (assets_in or [])}
+
+                rewards: dict[str, int] = {}
+                if include_rewards:
+                    raw_rewards = ret1[3] if len(ret1) > 3 else b""
+                    if raw_rewards:
+                        abi_rewards = self._fn_abi(
+                            rewards_contract,
+                            "getOutstandingRewardsForUser",
+                            inputs_len=1,
+                        )
+                        decoded = self._decode(web3, abi_rewards, raw_rewards)
+                        try:
+                            all_rewards = decoded[0]
+                            for mtoken_data in all_rewards:
+                                if len(mtoken_data) < 2:
+                                    continue
+                                token_rewards = mtoken_data[1] or []
+                                for reward_info in token_rewards:
+                                    if len(reward_info) < 2:
+                                        continue
+                                    token_addr = reward_info[0]
+                                    total_reward = int(reward_info[1])
+                                    if total_reward <= 0:
+                                        continue
+                                    key = f"{self.chain_name}_{token_addr}"
+                                    rewards[key] = rewards.get(key, 0) + total_reward
+                        except Exception:  # noqa: BLE001
+                            rewards = await self._get_outstanding_rewards(acct)
+                    else:
+                        rewards = await self._get_outstanding_rewards(acct)
+
+                # --- Stage 2: per-market reads (batched)
+                market_calls: list[Any] = []
+                market_meta: list[str] = []
+
+                for m in all_markets or []:
+                    mtoken = to_checksum_address(str(m))
+                    mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                    market_meta.append(mtoken)
+
+                    market_calls.extend(
+                        [
+                            multicall.build_call(
+                                mtoken,
+                                mtoken_contract.encode_abi("balanceOf", args=[acct]),
+                            ),
+                            multicall.build_call(
+                                mtoken,
+                                mtoken_contract.encode_abi(
+                                    "exchangeRateStored", args=[]
+                                ),
+                            ),
+                            multicall.build_call(
+                                mtoken,
+                                mtoken_contract.encode_abi(
+                                    "borrowBalanceStored", args=[acct]
+                                ),
+                            ),
+                            multicall.build_call(
+                                mtoken,
+                                mtoken_contract.encode_abi("underlying", args=[]),
+                            ),
+                            multicall.build_call(
+                                mtoken,
+                                mtoken_contract.encode_abi("decimals", args=[]),
+                            ),
+                            multicall.build_call(
+                                self.comptroller_address,
+                                comptroller.encode_abi("markets", args=[mtoken]),
+                            ),
+                        ]
                     )
-                break
-            except Exception as exc:
-                last_error = str(exc)
-                if "429" in last_error or "Too Many Requests" in last_error:
-                    if attempt < max_retries - 1:
-                        wait_time = 2 ** (attempt + 1)
-                        await asyncio.sleep(wait_time)
+
+                ret2 = await self._multicall_chunked(
+                    multicall=multicall,
+                    calls=market_calls,
+                    chunk_size=multicall_chunk_size,
+                )
+
+                sample_mtoken = web3.eth.contract(address=self.m_usdc, abi=MTOKEN_ABI)
+                abi_bal = self._fn_abi(sample_mtoken, "balanceOf", inputs_len=1)
+                abi_exch = self._fn_abi(
+                    sample_mtoken, "exchangeRateStored", inputs_len=0
+                )
+                abi_borrow = self._fn_abi(
+                    sample_mtoken, "borrowBalanceStored", inputs_len=1
+                )
+                abi_under = self._fn_abi(sample_mtoken, "underlying", inputs_len=0)
+                abi_dec = self._fn_abi(sample_mtoken, "decimals", inputs_len=0)
+                abi_mkts = self._fn_abi(comptroller, "markets", inputs_len=1)
+
+                positions: list[dict[str, Any]] = []
+
+                stride = 6
+                for i, mtoken in enumerate(market_meta):
+                    base = i * stride
+                    if base + (stride - 1) >= len(ret2):
+                        break
+
+                    try:
+                        bal_c = (
+                            int(self._decode(web3, abi_bal, ret2[base + 0])[0])
+                            if ret2[base + 0]
+                            else 0
+                        )
+                        exch = (
+                            int(self._decode(web3, abi_exch, ret2[base + 1])[0])
+                            if ret2[base + 1]
+                            else 0
+                        )
+                        borrow = (
+                            int(self._decode(web3, abi_borrow, ret2[base + 2])[0])
+                            if ret2[base + 2]
+                            else 0
+                        )
+                        underlying = (
+                            to_checksum_address(
+                                str(self._decode(web3, abi_under, ret2[base + 3])[0])
+                            )
+                            if ret2[base + 3]
+                            else None
+                        )
+                        mdec = (
+                            int(self._decode(web3, abi_dec, ret2[base + 4])[0])
+                            if ret2[base + 4]
+                            else 18
+                        )
+                        mkts = (
+                            self._decode(web3, abi_mkts, ret2[base + 5])
+                            if ret2[base + 5]
+                            else (False, 0)
+                        )
+                        is_listed = bool(mkts[0])
+                        collateral_factor = float(int(mkts[1])) / MANTISSA
+                    except Exception:  # noqa: BLE001 - skip malformed markets
                         continue
-                return False, last_error
-        else:
-            # All retries exhausted
-            return False, last_error
+
+                    supplied_underlying = (bal_c * exch) // MANTISSA if exch else 0
+
+                    has_supply = bal_c > 0
+                    has_borrow = borrow > 0
+                    if not include_zero_positions and not (has_supply or has_borrow):
+                        continue
+
+                    row: dict[str, Any] = {
+                        "mtoken": mtoken,
+                        "underlying": underlying,
+                        "enteredAsCollateral": mtoken.lower() in entered,
+                        "isListed": is_listed,
+                        "collateralFactor": collateral_factor,
+                        "mTokenDecimals": int(mdec),
+                        "mTokenBalance": int(bal_c),
+                        "exchangeRate": int(exch),
+                        "suppliedUnderlying": int(supplied_underlying),
+                        "borrowedUnderlying": int(borrow),
+                    }
+
+                    if include_apy:
+                        try:
+                            ok_s, apy_s = await self.get_apy(
+                                mtoken=mtoken,
+                                apy_type="supply",
+                                include_rewards=True,
+                            )
+                            row["apySupply"] = apy_s if ok_s else None
+                        except Exception:  # noqa: BLE001
+                            row["apySupply"] = None
+
+                        try:
+                            ok_b, apy_b = await self.get_apy(
+                                mtoken=mtoken,
+                                apy_type="borrow",
+                                include_rewards=True,
+                            )
+                            row["apyBorrow"] = apy_b if ok_b else None
+                        except Exception:  # noqa: BLE001
+                            row["apyBorrow"] = None
+
+                    positions.append(row)
+
+                out: dict[str, Any] = {
+                    "protocol": "moonwell",
+                    "chainId": int(self.chain_id),
+                    "account": acct,
+                    "accountLiquidity": {
+                        "error": error,
+                        "liquidity": int(liquidity),
+                        "shortfall": int(shortfall),
+                    },
+                    "positions": positions,
+                    "rewards": rewards,
+                }
+
+                if include_usd and self.token_client:
+                    total_supplied_usd = 0.0
+                    total_borrowed_usd = 0.0
+
+                    for r in positions:
+                        u = r.get("underlying")
+                        if not u:
+                            continue
+                        key = f"{self.chain_name}_{u}"
+                        td = await self.token_client.get_token_details(key)
+                        if not td:
+                            continue
+                        price = td.get("price_usd") or td.get("price")
+                        dec = int(td.get("decimals", 18))
+                        if price is None:
+                            continue
+                        total_supplied_usd += (
+                            r["suppliedUnderlying"] / (10**dec)
+                        ) * float(price)
+                        total_borrowed_usd += (
+                            r["borrowedUnderlying"] / (10**dec)
+                        ) * float(price)
+
+                    out["totalsUsd"] = {
+                        "supplied": total_supplied_usd,
+                        "borrowed": total_borrowed_usd,
+                        "net": total_supplied_usd - total_borrowed_usd,
+                    }
+                    if include_rewards and rewards:
+                        out["rewardsUsd"] = await self._calculate_rewards_usd(rewards)
+
+                return True, out
+
+        except Exception as exc:  # noqa: BLE001
+            return False, str(exc)
+
+    async def get_pos(
+        self,
+        *,
+        mtoken: str,
+        account: str | None = None,
+        include_usd: bool = False,
+        block_identifier: int | str | None = None,
+    ) -> tuple[bool, dict[str, Any] | str]:
+        mtoken = to_checksum_address(mtoken)
+        account = (
+            to_checksum_address(account) if account else self.strategy_wallet_address
+        )
+        block_id = block_identifier if block_identifier is not None else "pending"
+
+        try:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                rewards_contract = web3.eth.contract(
+                    address=MOONWELL_REWARD_DISTRIBUTOR,
+                    abi=REWARD_DISTRIBUTOR_ABI,
+                )
+
+                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)
+        except Exception as exc:
+            return False, str(exc)
 
         try:
             reward_balances = self._process_rewards(rewards)
 
-            mtoken_key = f"{self.chain_name}_{mtoken}"
-            underlying_key = f"{self.chain_name}_{underlying}"
+            mtoken_key = f"{CHAIN_NAME}_{mtoken}"
+            underlying_key = f"{CHAIN_NAME}_{underlying}"
 
             balances: dict[str, int] = {mtoken_key: bal}
             balances.update(reward_balances)
@@ -559,7 +804,7 @@ class MoonwellAdapter(BaseAdapter):
 
             if include_usd and self.token_client:
                 usd_balances = await self._calculate_usd_balances(
-                    balances, underlying_key, exch
+                    balances, underlying_key
                 )
                 result["usd_balances"] = usd_balances
 
@@ -571,39 +816,31 @@ class MoonwellAdapter(BaseAdapter):
         result: dict[str, int] = {}
         for reward_info in rewards:
             if len(reward_info) >= 2:
-                token_addr = reward_info[0]
-                total_reward = reward_info[1]
+                token_addr, total_reward, *_ = reward_info
                 if total_reward > 0:
-                    key = f"{self.chain_name}_{token_addr}"
+                    key = f"{CHAIN_NAME}_{token_addr}"
                     result[key] = total_reward
         return result
 
     async def _calculate_usd_balances(
-        self, balances: dict[str, int], underlying_key: str, _exchange_rate: int
+        self, balances: dict[str, int], underlying_key: str
     ) -> dict[str, float | None]:
         if not self.token_client:
             return {}
 
-        tokens = set(balances.keys()) | {underlying_key}
-        token_data: dict[str, dict | None] = {}
-        for token_key in tokens:
-            try:
-                token_data[token_key] = await self.token_client.get_token_details(
-                    token_key
-                )
-            except Exception:
-                token_data[token_key] = None
+        tokens = list(set(balances.keys()) | {underlying_key})
+        token_details = await asyncio.gather(
+            *[self.token_client.get_token_details(key) for key in tokens]
+        )
+        token_data = dict(zip(tokens, token_details, strict=True))
 
         usd_balances: dict[str, float | None] = {}
         for token_key, bal in balances.items():
             data = token_data.get(token_key)
-            if data:
-                price = data.get("price_usd") or data.get("price")
-                if price is not None:
-                    decimals = data.get("decimals", 18)
-                    usd_balances[token_key] = (bal / (10**decimals)) * price
-                else:
-                    usd_balances[token_key] = None
+            if data and (price := data.get("price_usd") or data.get("price")):
+                usd_balances[token_key] = (
+                    bal / (10 ** data.get("decimals", 18))
+                ) * price
             else:
                 usd_balances[token_key] = None
 
@@ -613,48 +850,34 @@ class MoonwellAdapter(BaseAdapter):
         self,
         *,
         mtoken: str,
-        max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, float | str]:
-        mtoken = self._checksum(mtoken)
-
-        now = time.time()
-        if mtoken in self._cf_cache:
-            cached_value, cached_time = self._cf_cache[mtoken]
-            if now - cached_time < CF_CACHE_TTL:
-                return True, cached_value
-
-        last_error = ""
-        for attempt in range(max_retries):
-            try:
-                async with web3_from_chain_id(self.chain_id) as web3:
-                    contract = web3.eth.contract(
-                        address=self.comptroller_address, abi=COMPTROLLER_ABI
-                    )
+        mtoken = to_checksum_address(mtoken)
 
-                    # markets() returns (isListed, collateralFactorMantissa)
-                    result = await contract.functions.markets(mtoken).call(
-                        block_identifier="pending"
-                    )
-                    is_listed, collateral_factor_mantissa = result
+        cache_key = f"cf_{mtoken}"
+        if cached := await self._cache.get(cache_key):
+            return True, cached
 
-                    if not is_listed:
-                        return False, f"Market {mtoken} is not listed"
+        try:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
+                contract = web3.eth.contract(
+                    address=MOONWELL_COMPTROLLER, abi=COMPTROLLER_ABI
+                )
 
-                    collateral_factor = collateral_factor_mantissa / MANTISSA
+                # markets() returns (isListed, collateralFactorMantissa)
+                result = await contract.functions.markets(mtoken).call(
+                    block_identifier="pending"
+                )
+                is_listed, collateral_factor_mantissa = result
 
-                    # Cache the result
-                    self._cf_cache[mtoken] = (collateral_factor, now)
+                if not is_listed:
+                    return False, f"Market {mtoken} is not listed"
 
-                    return True, collateral_factor
-            except Exception as exc:
-                last_error = str(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, last_error
+                collateral_factor = collateral_factor_mantissa / MANTISSA
+                await self._cache.set(cache_key, collateral_factor, ttl=3600)
 
-        return False, last_error
+                return True, collateral_factor
+        except Exception as exc:
+            return False, str(exc)
 
     async def get_apy(
         self,
@@ -662,68 +885,53 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         apy_type: Literal["supply", "borrow"] = "supply",
         include_rewards: bool = True,
-        max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, float | str]:
-        mtoken = self._checksum(mtoken)
+        mtoken = to_checksum_address(mtoken)
 
-        last_error = ""
-        for attempt in range(max_retries):
-            try:
-                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,
-                    )
+        try:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                reward_distributor = web3.eth.contract(
+                    address=MOONWELL_REWARD_DISTRIBUTOR,
+                    abi=REWARD_DISTRIBUTOR_ABI,
+                )
 
-                    if apy_type == "supply":
-                        rate_per_timestamp = await mtoken_contract.functions.supplyRatePerTimestamp().call(
+                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(
+                    )
+                    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"
-                            )
-                        )
-
-                    rate = rate_per_timestamp / MANTISSA
-                    apy = _timestamp_rate_to_apy(rate)
+                    )
+                    mkt_config = await reward_distributor.functions.getAllMarketConfigs(
+                        mtoken
+                    ).call(block_identifier="pending")
+                    total_value = await mtoken_contract.functions.totalBorrows().call(
+                        block_identifier="pending"
+                    )
 
-                    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
+                apy = _timestamp_rate_to_apy(rate_per_timestamp / MANTISSA)
 
-                    return True, apy
-            except Exception as exc:
-                last_error = str(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, last_error
+                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 False, last_error
+                return True, apy
+        except Exception as exc:
+            return False, str(exc)
 
     async def _calculate_rewards_apr(
         self,
@@ -736,10 +944,12 @@ class MoonwellAdapter(BaseAdapter):
             return 0.0
 
         try:
-            # Find WELL token config
             well_config = None
             for config in mkt_config:
-                if len(config) >= 6 and config[1].lower() == self.well_token.lower():
+                if (
+                    len(config) >= 6
+                    and config[1].lower() == MOONWELL_WELL_TOKEN.lower()
+                ):
                     well_config = config
                     break
 
@@ -758,18 +968,17 @@ class MoonwellAdapter(BaseAdapter):
             if well_rate == 0:
                 return 0.0
 
-            async with web3_from_chain_id(self.chain_id) as web3:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
                 mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
                 underlying_addr = await mtoken_contract.functions.underlying().call(
                     block_identifier="pending"
                 )
 
-            well_key = f"{self.chain_name}_{self.well_token}"
-            underlying_key = f"{self.chain_name}_{underlying_addr}"
-
             well_data, underlying_data = await asyncio.gather(
-                self.token_client.get_token_details(well_key),
-                self.token_client.get_token_details(underlying_key),
+                self.token_client.get_token_details(
+                    f"{CHAIN_NAME}_{MOONWELL_WELL_TOKEN}"
+                ),
+                self.token_client.get_token_details(f"{CHAIN_NAME}_{underlying_addr}"),
             )
 
             well_price = (
@@ -809,42 +1018,34 @@ class MoonwellAdapter(BaseAdapter):
         self,
         *,
         account: str | None = None,
-        max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, int | str]:
-        account = self._checksum(account) if account else self._strategy_address()
-
-        last_error = ""
-        for attempt in range(max_retries):
-            try:
-                async with web3_from_chain_id(self.chain_id) as web3:
-                    contract = web3.eth.contract(
-                        address=self.comptroller_address, abi=COMPTROLLER_ABI
-                    )
+        account = (
+            to_checksum_address(account) if account else self.strategy_wallet_address
+        )
 
-                    (
-                        error,
-                        liquidity,
-                        shortfall,
-                    ) = await contract.functions.getAccountLiquidity(account).call(
-                        block_identifier="pending"
-                    )
+        try:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
+                contract = web3.eth.contract(
+                    address=MOONWELL_COMPTROLLER, abi=COMPTROLLER_ABI
+                )
 
-                    if error != 0:
-                        return False, f"Comptroller error: {error}"
+                (
+                    error,
+                    liquidity,
+                    shortfall,
+                ) = await contract.functions.getAccountLiquidity(account).call(
+                    block_identifier="pending"
+                )
 
-                    if shortfall > 0:
-                        return False, f"Account has shortfall: {shortfall}"
+                if error != 0:
+                    return False, f"Comptroller error: {error}"
 
-                    return True, liquidity
-            except Exception as exc:
-                last_error = str(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, last_error
+                if shortfall > 0:
+                    return False, f"Account has shortfall: {shortfall}"
 
-        return False, last_error
+                return True, liquidity
+        except Exception as exc:
+            return False, str(exc)
 
     async def max_withdrawable_mtoken(
         self,
@@ -852,13 +1053,15 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         account: str | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
-        mtoken = self._checksum(mtoken)
-        account = self._checksum(account) if account else self._strategy_address()
+        mtoken = to_checksum_address(mtoken)
+        account = (
+            to_checksum_address(account) if account else self.strategy_wallet_address
+        )
 
         try:
-            async with web3_from_chain_id(self.chain_id) as web3:
+            async with web3_from_chain_id(CHAIN_ID_BASE) as web3:
                 comptroller = web3.eth.contract(
-                    address=self.comptroller_address, abi=COMPTROLLER_ABI
+                    address=MOONWELL_COMPTROLLER, abi=COMPTROLLER_ABI
                 )
                 mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
 
@@ -894,13 +1097,11 @@ class MoonwellAdapter(BaseAdapter):
 
                 u_dec = 18
                 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
+                    u_data = await self.token_client.get_token_details(
+                        f"{CHAIN_NAME}_{u_addr}"
+                    )
+                    if u_data:
+                        u_dec = u_data.get("decimals", 18)
 
                 # Binary search: largest cTokens you can redeem without shortfall
                 lo, hi = 0, int(bal_raw)
@@ -949,125 +1150,26 @@ class MoonwellAdapter(BaseAdapter):
         except Exception as exc:
             return False, str(exc)
 
-    # ------------------------------------------------------------------ #
-    # Public API - ETH Wrapping                                           #
-    # ------------------------------------------------------------------ #
-
     async def wrap_eth(
         self,
         *,
         amount: int,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         amount = int(amount)
         if amount <= 0:
             return False, "amount must be positive"
 
-        tx = await self._encode_call(
-            target=self.weth,
+        transaction = await encode_call(
+            target=BASE_WETH,
             abi=WETH_ABI,
             fn_name="deposit",
             args=[],
             from_address=strategy,
+            chain_id=CHAIN_ID_BASE,
             value=amount,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Helpers                                                             #
-    # ------------------------------------------------------------------ #
-
-    # Max uint256 for unlimited approvals
-    MAX_UINT256 = 2**256 - 1
-
-    async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
-        return True, txn_hash
-
-    async def _ensure_allowance(
-        self,
-        *,
-        token_address: str,
-        owner: str,
-        spender: str,
-        amount: int,
-    ) -> tuple[bool, Any]:
-        allowance = await get_token_allowance(
-            token_address, self.chain_id, owner, spender
-        )
-        if allowance >= amount:
-            return True, {}
-
-        # Approve for max uint256 to avoid precision/timing issues
-        approve_tx = await build_approve_transaction(
-            from_address=owner,
-            chain_id=self.chain_id,
-            token_address=token_address,
-            spender_address=spender,
-            amount=self.MAX_UINT256,
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
         )
-
-        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.
-        if result[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 _encode_call(
-        self,
-        *,
-        target: str,
-        abi: list[dict[str, Any]],
-        fn_name: str,
-        args: list[Any],
-        from_address: str,
-        value: int = 0,
-    ) -> dict[str, Any]:
-        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
-
-    def _strategy_address(self) -> str:
-        addr = None
-        if isinstance(self.strategy_wallet, dict):
-            addr = self.strategy_wallet.get("address") or (
-                (self.strategy_wallet.get("evm") or {}).get("address")
-            )
-        elif isinstance(self.strategy_wallet, str):
-            addr = self.strategy_wallet
-        if not addr:
-            raise ValueError(
-                "strategy_wallet address is required for Moonwell operations"
-            )
-        return to_checksum_address(addr)
-
-    def _checksum(self, address: str | None) -> str:
-        if not address:
-            raise ValueError("Missing required contract address in Moonwell config")
-        return to_checksum_address(address)
+        return (True, txn_hash)