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

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -8,49 +8,43 @@ 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 MANTISSA, MAX_UINT256, SECONDS_PER_YEAR
+from wayfinder_paths.core.constants.chains import CHAIN_ID_BASE
+from wayfinder_paths.core.constants.contracts import (
+    BASE_USDC,
+    BASE_WETH,
+    BASE_WSTETH,
+    MOONWELL_COMPTROLLER,
+    MOONWELL_M_USDC,
+    MOONWELL_M_WETH,
+    MOONWELL_M_WSTETH,
+    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.tokens import ensure_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 = {
-    # 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",
+    "m_usdc": MOONWELL_M_USDC,
+    "m_weth": MOONWELL_M_WETH,
+    "m_wsteth": MOONWELL_M_WSTETH,
+    "usdc": BASE_USDC,
+    "weth": BASE_WETH,
+    "wsteth": BASE_WSTETH,
+    "reward_distributor": MOONWELL_REWARD_DISTRIBUTOR,
+    "comptroller": MOONWELL_COMPTROLLER,
+    "well_token": MOONWELL_WELL_TOKEN,
 }
 
-# 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)
+BASE_CHAIN_ID = CHAIN_ID_BASE
 CF_CACHE_TTL = 3600
-
-# Default retry settings for rate-limited RPCs
 DEFAULT_MAX_RETRIES = 5
 DEFAULT_BASE_DELAY = 3.0
 
@@ -80,45 +74,49 @@ class MoonwellAdapter(BaseAdapter):
         self.token_client = token_client
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
 
-        self.strategy_wallet = cfg.get("strategy_wallet") or {}
+        strategy_wallet = cfg.get("strategy_wallet") or {}
+        strategy_addr = strategy_wallet.get("address")
+        if not strategy_addr:
+            raise ValueError("strategy_wallet.address is required")
+        self.strategy_wallet_address = to_checksum_address(strategy_addr)
         self.chain_id = adapter_cfg.get("chain_id", BASE_CHAIN_ID)
         self.chain_name = "base"
 
         # Protocol addresses (with config overrides)
-        self.comptroller_address = self._checksum(
+        self.comptroller_address = to_checksum_address(
             adapter_cfg.get("comptroller") or MOONWELL_DEFAULTS["comptroller"]
         )
-        self.reward_distributor_address = self._checksum(
+        self.reward_distributor_address = to_checksum_address(
             adapter_cfg.get("reward_distributor")
             or MOONWELL_DEFAULTS["reward_distributor"]
         )
-        self.well_token = self._checksum(
+        self.well_token = to_checksum_address(
             adapter_cfg.get("well_token") or MOONWELL_DEFAULTS["well_token"]
         )
 
         # Token addresses
-        self.m_usdc = self._checksum(
+        self.m_usdc = to_checksum_address(
             adapter_cfg.get("m_usdc") or MOONWELL_DEFAULTS["m_usdc"]
         )
-        self.m_weth = self._checksum(
+        self.m_weth = to_checksum_address(
             adapter_cfg.get("m_weth") or MOONWELL_DEFAULTS["m_weth"]
         )
-        self.m_wsteth = self._checksum(
+        self.m_wsteth = to_checksum_address(
             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(
+        self.usdc = to_checksum_address(
+            adapter_cfg.get("usdc") or MOONWELL_DEFAULTS["usdc"]
+        )
+        self.weth = to_checksum_address(
+            adapter_cfg.get("weth") or MOONWELL_DEFAULTS["weth"]
+        )
+        self.wsteth = to_checksum_address(
             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                                     #
-    # ------------------------------------------------------------------ #
-
     async def lend(
         self,
         *,
@@ -126,20 +124,23 @@ 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=self.chain_id,
+            signing_callback=self.strategy_wallet_signing_callback,
+            approval_amount=MAX_UINT256,
         )
         if not approved[0]:
             return approved
@@ -152,7 +153,8 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._send_tx(tx)
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
+        return (True, txn_hash)
 
     async def unlend(
         self,
@@ -160,12 +162,12 @@ 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(
@@ -175,11 +177,8 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Borrowing Operations                                   #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
+        return (True, txn_hash)
 
     async def borrow(
         self,
@@ -187,14 +186,12 @@ 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:
@@ -211,15 +208,15 @@ class MoonwellAdapter(BaseAdapter):
                         {"from": strategy}, block_identifier="pending"
                     )
                     if borrow_return != 0:
-                        logger.warning(
+                        self.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}")
+                    self.logger.debug(f"Borrow simulation failed: {call_err}")
         except Exception as e:
-            logger.warning(f"Failed to get pre-borrow balance: {e}")
+            self.logger.warning(f"Failed to get pre-borrow balance: {e}")
 
         tx = await self._encode_call(
             target=mtoken,
@@ -228,10 +225,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        result = await self._send_tx(tx)
-
-        if not result[0]:
-            return result
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
 
         # Verify the borrow actually succeeded by checking balance increased
         try:
@@ -247,9 +241,7 @@ class MoonwellAdapter(BaseAdapter):
                 actual_increase = borrow_after - borrow_before
 
                 if actual_increase < expected_increase:
-                    from loguru import logger
-
-                    logger.error(
+                    self.logger.error(
                         f"Borrow verification failed: balance only increased by "
                         f"{actual_increase} (expected ~{amount}). "
                         f"Moonwell likely returned an error code. "
@@ -261,12 +253,9 @@ class MoonwellAdapter(BaseAdapter):
                         f"Before: {borrow_before}, After: {borrow_after}, Expected: +{amount}",
                     )
         except Exception as e:
-            from loguru import logger
+            self.logger.warning(f"Could not verify borrow balance: {e}")
 
-            logger.warning(f"Could not verify borrow balance: {e}")
-            # Continue with the original result if verification fails
-
-        return result
+        return (True, txn_hash)
 
     async def repay(
         self,
@@ -276,27 +265,30 @@ 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=self.chain_id,
+            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
+        repay_amount = MAX_UINT256 if repay_full else amount
 
         tx = await self._encode_call(
             target=mtoken,
@@ -305,19 +297,16 @@ class MoonwellAdapter(BaseAdapter):
             args=[repay_amount],
             from_address=strategy,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Collateral Management                                  #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(tx, 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,
@@ -326,10 +315,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[[mtoken]],
             from_address=strategy,
         )
-        result = await self._send_tx(tx)
-
-        if not result[0]:
-            return result
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
 
         # Verify the market was actually entered
         try:
@@ -342,9 +328,7 @@ class MoonwellAdapter(BaseAdapter):
                 ).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 +337,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,8 +348,12 @@ 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:
                 comptroller = web3.eth.contract(
@@ -375,7 +361,7 @@ class MoonwellAdapter(BaseAdapter):
                 )
                 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,8 +371,8 @@ 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,
@@ -395,18 +381,15 @@ class MoonwellAdapter(BaseAdapter):
             args=[mtoken],
             from_address=strategy,
         )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Public API - Rewards                                                #
-    # ------------------------------------------------------------------ #
+        txn_hash = await send_transaction(tx, 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)
 
@@ -427,10 +410,7 @@ class MoonwellAdapter(BaseAdapter):
             args=[strategy],
             from_address=strategy,
         )
-        result = await self._send_tx(tx)
-        if not result[0]:
-            return result
-
+        await send_transaction(tx, self.strategy_wallet_signing_callback)
         return True, rewards
 
     async def _get_outstanding_rewards(self, account: str) -> dict[str, int]:
@@ -476,10 +456,6 @@ class MoonwellAdapter(BaseAdapter):
                 pass
         return total_usd
 
-    # ------------------------------------------------------------------ #
-    # Public API - Position & Market Data                                 #
-    # ------------------------------------------------------------------ #
-
     async def get_pos(
         self,
         *,
@@ -489,8 +465,10 @@ class MoonwellAdapter(BaseAdapter):
         max_retries: int = 3,
         block_identifier: int | 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
+        )
         block_id = block_identifier if block_identifier is not None else "pending"
 
         bal = exch = borrow = underlying = rewards = None
@@ -615,7 +593,7 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, float | str]:
-        mtoken = self._checksum(mtoken)
+        mtoken = to_checksum_address(mtoken)
 
         now = time.time()
         if mtoken in self._cf_cache:
@@ -664,7 +642,7 @@ class MoonwellAdapter(BaseAdapter):
         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):
@@ -811,7 +789,9 @@ class MoonwellAdapter(BaseAdapter):
         account: str | None = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, int | str]:
-        account = self._checksum(account) if account else self._strategy_address()
+        account = (
+            to_checksum_address(account) if account else self.strategy_wallet_address
+        )
 
         last_error = ""
         for attempt in range(max_retries):
@@ -852,8 +832,10 @@ 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:
@@ -949,16 +931,12 @@ 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"
@@ -971,57 +949,8 @@ class MoonwellAdapter(BaseAdapter):
             from_address=strategy,
             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,
-        )
-
-        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
+        return (True, txn_hash)
 
     async def _encode_call(
         self,
@@ -1052,22 +981,3 @@ class MoonwellAdapter(BaseAdapter):
                 "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)