wayfinder-paths 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -1,10 +1,3 @@
-"""
-Moonwell Adapter for lending, borrowing, and collateral management on Moonwell protocol.
-
-This adapter provides functionality for interacting with Moonwell on Base chain,
-including supplying/withdrawing collateral, borrowing/repaying, and claiming rewards.
-"""
-
 from __future__ import annotations
 
 import asyncio
@@ -59,37 +52,31 @@ CF_CACHE_TTL = 3600
 
 # Default retry settings for rate-limited RPCs
 DEFAULT_MAX_RETRIES = 5
-DEFAULT_BASE_DELAY = 3.0  # seconds
+DEFAULT_BASE_DELAY = 3.0
 
 
 def _is_rate_limit_error(error: Exception | str) -> bool:
-    """Check if an error is a rate limit (429) error."""
     error_str = str(error)
     return "429" in error_str or "Too Many Requests" in error_str
 
 
 def _timestamp_rate_to_apy(rate: float) -> float:
-    """Convert a per-second rate to APY."""
     return (1 + rate) ** SECONDS_PER_YEAR - 1
 
 
 class MoonwellAdapter(BaseAdapter):
-    """Moonwell adapter for lending/borrowing operations on Base chain."""
-
     adapter_type = "MOONWELL"
 
     def __init__(
         self,
         config: dict[str, Any] | 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.simulation = simulation
         self.token_client = token_client
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
 
@@ -139,7 +126,6 @@ class MoonwellAdapter(BaseAdapter):
         underlying_token: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Supply tokens to Moonwell by minting mTokens."""
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -174,7 +160,6 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Withdraw tokens from Moonwell by redeeming mTokens."""
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -202,13 +187,6 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Borrow tokens from Moonwell.
-
-        Note: Moonwell/Compound borrow() returns an error code, not a boolean.
-        Even if the transaction succeeds (status=1), the borrow may have failed
-        if the return value is non-zero. We verify success by checking that
-        the borrow balance actually increased.
-        """
         from loguru import logger
 
         strategy = self._strategy_address()
@@ -218,7 +196,6 @@ class MoonwellAdapter(BaseAdapter):
 
         mtoken = self._checksum(mtoken)
 
-        # Get borrow balance before the transaction for verification
         borrow_before = 0
         try:
             async with web3_from_chain_id(self.chain_id) as web3:
@@ -266,7 +243,7 @@ class MoonwellAdapter(BaseAdapter):
 
                 # Borrow balance should have increased by approximately the amount
                 # Allow for some interest accrual
-                expected_increase = amount * 0.99  # Allow 1% tolerance for interest
+                expected_increase = amount * 0.99
                 actual_increase = borrow_after - borrow_before
 
                 if actual_increase < expected_increase:
@@ -299,14 +276,6 @@ class MoonwellAdapter(BaseAdapter):
         amount: int,
         repay_full: bool = False,
     ) -> tuple[bool, Any]:
-        """Repay borrowed tokens to Moonwell.
-
-        Args:
-            mtoken: The mToken address
-            underlying_token: The underlying token address (e.g., WETH)
-            amount: Amount to repay (used for approval if repay_full=True)
-            repay_full: If True, uses type(uint256).max to repay exact debt
-        """
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -347,11 +316,6 @@ class MoonwellAdapter(BaseAdapter):
         *,
         mtoken: str,
     ) -> tuple[bool, Any]:
-        """Enable a market as collateral (enter market).
-
-        Note: enterMarkets returns an array of error codes. We verify success
-        by checking if the account has actually entered the market.
-        """
         strategy = self._strategy_address()
         mtoken = self._checksum(mtoken)
 
@@ -401,10 +365,6 @@ class MoonwellAdapter(BaseAdapter):
         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)
@@ -425,7 +385,6 @@ class MoonwellAdapter(BaseAdapter):
         *,
         mtoken: str,
     ) -> tuple[bool, Any]:
-        """Disable a market as collateral (exit market)."""
         strategy = self._strategy_address()
         mtoken = self._checksum(mtoken)
 
@@ -447,21 +406,18 @@ class MoonwellAdapter(BaseAdapter):
         *,
         min_rewards_usd: float = 0.0,
     ) -> tuple[bool, dict[str, int] | str]:
-        """Claim WELL rewards from Moonwell. Skips if below min_rewards_usd threshold."""
         strategy = self._strategy_address()
 
-        # Get outstanding rewards first
         rewards = await self._get_outstanding_rewards(strategy)
 
         # Skip if no rewards to claim
         if not rewards:
             return True, {}
 
-        # Check minimum threshold if token_client available
         if min_rewards_usd > 0 and self.token_client:
             total_usd = await self._calculate_rewards_usd(rewards)
             if total_usd < min_rewards_usd:
-                return True, {}  # Skip claiming, below threshold
+                return True, {}
 
         # Claim via comptroller (like reference implementation)
         tx = await self._encode_call(
@@ -478,14 +434,12 @@ class MoonwellAdapter(BaseAdapter):
         return True, rewards
 
     async def _get_outstanding_rewards(self, account: str) -> dict[str, int]:
-        """Get outstanding rewards for an account across all markets."""
         try:
             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(block_identifier="pending")
@@ -507,7 +461,6 @@ class MoonwellAdapter(BaseAdapter):
             return {}
 
     async def _calculate_rewards_usd(self, rewards: dict[str, int]) -> float:
-        """Calculate total USD value of rewards."""
         if not self.token_client:
             return 0.0
 
@@ -536,20 +489,6 @@ class MoonwellAdapter(BaseAdapter):
         max_retries: int = 3,
         block_identifier: int | str | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
-        """Get position data (balances, rewards) for an account in a market.
-
-        Args:
-            mtoken: The mToken address
-            account: Account to query (defaults to strategy wallet)
-            include_usd: Whether to include USD values
-            max_retries: Number of retry attempts
-            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/"pending": current head (default)
-
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
         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"
@@ -566,7 +505,6 @@ class MoonwellAdapter(BaseAdapter):
                         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
@@ -585,12 +523,12 @@ class MoonwellAdapter(BaseAdapter):
                             mtoken, account
                         ).call(block_identifier=block_id)
                     )
-                break  # Success, exit retry loop
+                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)  # 2, 4, 8 seconds
+                        wait_time = 2 ** (attempt + 1)
                         await asyncio.sleep(wait_time)
                         continue
                 return False, last_error
@@ -599,10 +537,8 @@ class MoonwellAdapter(BaseAdapter):
             return False, last_error
 
         try:
-            # Process rewards
             reward_balances = self._process_rewards(rewards)
 
-            # Build balances dict
             mtoken_key = f"{self.chain_name}_{mtoken}"
             underlying_key = f"{self.chain_name}_{underlying}"
 
@@ -621,7 +557,6 @@ class MoonwellAdapter(BaseAdapter):
                 "underlying_token": underlying,
             }
 
-            # Calculate USD values if requested and token_client available
             if include_usd and self.token_client:
                 usd_balances = await self._calculate_usd_balances(
                     balances, underlying_key, exch
@@ -633,7 +568,6 @@ class MoonwellAdapter(BaseAdapter):
             return False, str(exc)
 
     def _process_rewards(self, rewards: list) -> dict[str, int]:
-        """Process rewards tuple into dict mapping token keys to amounts."""
         result: dict[str, int] = {}
         for reward_info in rewards:
             if len(reward_info) >= 2:
@@ -647,11 +581,9 @@ class MoonwellAdapter(BaseAdapter):
     async def _calculate_usd_balances(
         self, balances: dict[str, int], underlying_key: str, _exchange_rate: int
     ) -> dict[str, float | None]:
-        """Calculate USD values for balances."""
         if not self.token_client:
             return {}
 
-        # Fetch token data for all tokens
         tokens = set(balances.keys()) | {underlying_key}
         token_data: dict[str, dict | None] = {}
         for token_key in tokens:
@@ -662,7 +594,6 @@ class MoonwellAdapter(BaseAdapter):
             except Exception:
                 token_data[token_key] = None
 
-        # Calculate USD values
         usd_balances: dict[str, float | None] = {}
         for token_key, bal in balances.items():
             data = token_data.get(token_key)
@@ -684,14 +615,8 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, float | str]:
-        """Get the collateral factor for a market as decimal (e.g., 0.75 for 75%).
-
-        Uses a 1-hour cache since collateral factors rarely change (governance controlled).
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
         mtoken = self._checksum(mtoken)
 
-        # Check cache first
         now = time.time()
         if mtoken in self._cf_cache:
             cached_value, cached_time = self._cf_cache[mtoken]
@@ -715,7 +640,6 @@ class MoonwellAdapter(BaseAdapter):
                     if not is_listed:
                         return False, f"Market {mtoken} is not listed"
 
-                    # Convert from mantissa to decimal
                     collateral_factor = collateral_factor_mantissa / MANTISSA
 
                     # Cache the result
@@ -740,10 +664,6 @@ class MoonwellAdapter(BaseAdapter):
         include_rewards: bool = True,
         max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, float | str]:
-        """Get supply or borrow APY for a market, optionally including WELL rewards.
-
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
         mtoken = self._checksum(mtoken)
 
         last_error = ""
@@ -756,7 +676,6 @@ class MoonwellAdapter(BaseAdapter):
                         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(
                             block_identifier="pending"
@@ -786,11 +705,9 @@ class MoonwellAdapter(BaseAdapter):
                             )
                         )
 
-                    # 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
@@ -815,7 +732,6 @@ class MoonwellAdapter(BaseAdapter):
         total_value: int,
         apy_type: str,
     ) -> float:
-        """Calculate WELL rewards APR for a market."""
         if not self.token_client:
             return 0.0
 
@@ -830,12 +746,11 @@ class MoonwellAdapter(BaseAdapter):
             if not well_config:
                 return 0.0
 
-            # Get emission rate (supply or borrow)
             # Config format: (mToken, rewardToken, owner, emissionCap, supplyEmissionsPerSec, borrowEmissionsPerSec, ...)
             if apy_type == "supply":
-                well_rate = well_config[4]  # supplyEmissionsPerSec
+                well_rate = well_config[4]
             else:
-                well_rate = well_config[5]  # borrowEmissionsPerSec
+                well_rate = well_config[5]
                 # Borrow rewards are shown as negative in some implementations
                 if well_rate < 0:
                     well_rate = -well_rate
@@ -843,14 +758,12 @@ class MoonwellAdapter(BaseAdapter):
             if well_rate == 0:
                 return 0.0
 
-            # Get underlying token for decimals
             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}"
             underlying_key = f"{self.chain_name}_{underlying_addr}"
 
@@ -876,7 +789,6 @@ class MoonwellAdapter(BaseAdapter):
             if not well_price or not underlying_price:
                 return 0.0
 
-            # Calculate total value in USD
             total_value_usd = (
                 total_value / (10**underlying_decimals)
             ) * underlying_price
@@ -884,7 +796,6 @@ class MoonwellAdapter(BaseAdapter):
             if total_value_usd == 0:
                 return 0.0
 
-            # Calculate rewards APR
             # rewards_apr = well_price * emissions_per_second * seconds_per_year / total_value_usd
             rewards_apr = (
                 well_price * (well_rate / MANTISSA) * SECONDS_PER_YEAR / total_value_usd
@@ -900,10 +811,6 @@ class MoonwellAdapter(BaseAdapter):
         account: str | None = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
     ) -> tuple[bool, int | str]:
-        """Get the maximum borrowable amount for an account (USD with 18 decimals).
-
-        Includes retry logic with exponential backoff for rate-limited RPCs.
-        """
         account = self._checksum(account) if account else self._strategy_address()
 
         last_error = ""
@@ -914,7 +821,6 @@ class MoonwellAdapter(BaseAdapter):
                         address=self.comptroller_address, abi=COMPTROLLER_ABI
                     )
 
-                    # getAccountLiquidity returns (error, liquidity, shortfall)
                     (
                         error,
                         liquidity,
@@ -946,7 +852,6 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         account: str | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
-        """Calculate max mTokens withdrawable without liquidation using binary search."""
         mtoken = self._checksum(mtoken)
         account = self._checksum(account) if account else self._strategy_address()
 
@@ -957,7 +862,6 @@ class MoonwellAdapter(BaseAdapter):
                 )
                 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"
@@ -988,8 +892,7 @@ class MoonwellAdapter(BaseAdapter):
                         "underlying_decimals": None,
                     }
 
-                # Get underlying decimals
-                u_dec = 18  # Default
+                u_dec = 18
                 if self.token_client:
                     try:
                         u_key = f"{self.chain_name}_{u_addr}"
@@ -1013,7 +916,7 @@ class MoonwellAdapter(BaseAdapter):
                     if err != 0:
                         return False, f"Comptroller error {err}"
                     if short == 0:
-                        lo = mid  # Safe, try more
+                        lo = mid
                     else:
                         hi = mid - 1
 
@@ -1055,7 +958,6 @@ class MoonwellAdapter(BaseAdapter):
         *,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Wrap ETH to WETH."""
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -1079,9 +981,6 @@ class MoonwellAdapter(BaseAdapter):
     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
 
@@ -1093,14 +992,6 @@ class MoonwellAdapter(BaseAdapter):
         spender: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """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 self.simulation:
-            return True, {}  # Skip allowance check in simulation
-
         allowance = await get_token_allowance(
             token_address, self.chain_id, owner, spender
         )
@@ -1142,7 +1033,6 @@ class MoonwellAdapter(BaseAdapter):
         from_address: str,
         value: int = 0,
     ) -> dict[str, Any]:
-        """Encode a contract call without touching the network."""
         async with web3_from_chain_id(self.chain_id) as web3:
             contract = web3.eth.contract(address=target, abi=abi)
 
@@ -1164,7 +1054,6 @@ class MoonwellAdapter(BaseAdapter):
             return tx
 
     def _strategy_address(self) -> str:
-        """Get the strategy wallet address."""
         addr = None
         if isinstance(self.strategy_wallet, dict):
             addr = self.strategy_wallet.get("address") or (
@@ -1179,7 +1068,6 @@ class MoonwellAdapter(BaseAdapter):
         return to_checksum_address(addr)
 
     def _checksum(self, address: str | None) -> str:
-        """Convert address to checksum format."""
         if not address:
             raise ValueError("Missing required contract address in Moonwell config")
         return to_checksum_address(address)