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

wayfinder_paths/adapters/moonwell_adapter/adapter.py

@@ -16,6 +16,7 @@ from eth_utils import to_checksum_address
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.constants.moonwell_abi import (
     COMPTROLLER_ABI,
     MTOKEN_ABI,
@@ -57,6 +58,11 @@ CF_CACHE_TTL = 3600
 DEFAULT_MAX_RETRIES = 5
 DEFAULT_BASE_DELAY = 3.0  # seconds
 
+# Compound-style Failure(uint256,uint256,uint256) topic0
+FAILURE_EVENT_TOPIC0 = (
+    "0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0"
+)
+
 
 def _is_rate_limit_error(error: Exception | str) -> bool:
     """Check if an error is a rate limit (429) error."""
@@ -163,6 +169,79 @@ class MoonwellAdapter(BaseAdapter):
     # Public API - Lending Operations                                     #
     # ------------------------------------------------------------------ #
 
+    def _tx_pinned_block(self, result: Any) -> int | None:
+        if isinstance(result, dict):
+            return (
+                result.get("confirmed_block_number")
+                or result.get("block_number")
+                or (result.get("receipt", {}) or {}).get("blockNumber")
+            )
+        return None
+
+    def _as_bytes(self, value: Any) -> bytes | None:
+        if value is None:
+            return None
+        if isinstance(value, (bytes, bytearray)):
+            return bytes(value)
+        if hasattr(value, "hex"):
+            try:
+                hex_str = value.hex()
+                if isinstance(hex_str, str):
+                    if hex_str.startswith("0x"):
+                        return bytes.fromhex(hex_str[2:])
+                    return bytes.fromhex(hex_str)
+            except Exception:
+                return None
+        if isinstance(value, str):
+            v = value
+            if v.startswith("0x"):
+                v = v[2:]
+            try:
+                return bytes.fromhex(v)
+            except Exception:
+                return None
+        return None
+
+    def _failure_event_details(
+        self, result: Any, contract_address: str
+    ) -> dict[str, int] | None:
+        if not isinstance(result, dict):
+            return None
+
+        receipt = (
+            result.get("receipt") if isinstance(result.get("receipt"), dict) else {}
+        )
+        logs = receipt.get("logs") if isinstance(receipt, dict) else None
+        if not isinstance(logs, list):
+            return None
+
+        addr_l = str(contract_address or "").lower()
+        for log in logs:
+            if not isinstance(log, dict):
+                continue
+            if str(log.get("address") or "").lower() != addr_l:
+                continue
+            topics = log.get("topics") or []
+            if not topics:
+                continue
+            topic0_bytes = self._as_bytes(topics[0])
+            if not topic0_bytes:
+                continue
+            if topic0_bytes.hex() != FAILURE_EVENT_TOPIC0.lower().removeprefix("0x"):
+                continue
+
+            data_b = self._as_bytes(log.get("data"))
+            if not data_b or len(data_b) < 96:
+                return {"error": 0, "info": 0, "detail": 0}
+
+            return {
+                "error": int.from_bytes(data_b[0:32], "big"),
+                "info": int.from_bytes(data_b[32:64], "big"),
+                "detail": int.from_bytes(data_b[64:96], "big"),
+            }
+
+        return None
+
     async def lend(
         self,
         *,
@@ -170,7 +249,11 @@ class MoonwellAdapter(BaseAdapter):
         underlying_token: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Supply tokens to Moonwell by minting mTokens."""
+        """Supply tokens to Moonwell by minting mTokens.
+
+        Note: mint() returns an error code and can emit Failure without reverting.
+        We verify success by checking that the mToken balance increased.
+        """
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -179,6 +262,17 @@ class MoonwellAdapter(BaseAdapter):
         mtoken = self._checksum(mtoken)
         underlying_token = self._checksum(underlying_token)
 
+        mtoken_bal_before = None
+        if self.web3 and not self.simulation:
+            try:
+                web3 = self.web3.get_web3(self.chain_id)
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                mtoken_bal_before = await mtoken_contract.functions.balanceOf(
+                    strategy
+                ).call()
+            except Exception:
+                mtoken_bal_before = None
+
         # Approve mToken to spend underlying tokens
         approved = await self._ensure_allowance(
             token_address=underlying_token,
@@ -197,7 +291,41 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        result = await self._execute(tx)
+
+        if not result[0] or not self.web3 or self.simulation:
+            return result
+
+        if isinstance(result[1], dict):
+            failure = self._failure_event_details(result[1], mtoken)
+            if failure is not None:
+                return (
+                    False,
+                    f"Mint failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
+                )
+
+        if mtoken_bal_before is None:
+            return result
+
+        try:
+            pinned_block = self._tx_pinned_block(result[1])
+            block_id = pinned_block if pinned_block is not None else "latest"
+
+            web3 = self.web3.get_web3(self.chain_id)
+            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+            mtoken_bal_after = await mtoken_contract.functions.balanceOf(strategy).call(
+                block_identifier=block_id
+            )
+            if int(mtoken_bal_after) <= int(mtoken_bal_before):
+                return (
+                    False,
+                    f"Mint verification failed: mToken balance did not increase (before={mtoken_bal_before}, after={mtoken_bal_after})",
+                )
+        except Exception:
+            # If verification fails due to RPC/ABI issues, keep original result.
+            return result
+
+        return result
 
     async def unlend(
         self,
@@ -205,7 +333,13 @@ class MoonwellAdapter(BaseAdapter):
         mtoken: str,
         amount: int,
     ) -> tuple[bool, Any]:
-        """Withdraw tokens from Moonwell by redeeming mTokens."""
+        """Withdraw tokens from Moonwell by redeeming mTokens.
+
+        Note: redeem() returns an error code and can emit Failure without reverting.
+        We verify success by checking that either:
+          - underlying wallet balance increased, or
+          - mToken wallet balance decreased.
+        """
         strategy = self._strategy_address()
         amount = int(amount)
         if amount <= 0:
@@ -213,6 +347,38 @@ class MoonwellAdapter(BaseAdapter):
 
         mtoken = self._checksum(mtoken)
 
+        mtoken_bal_before = None
+        underlying_addr = None
+        underlying_bal_before = None
+
+        if self.web3 and not self.simulation:
+            try:
+                web3 = self.web3.get_web3(self.chain_id)
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+
+                # Snapshot balances for verification.
+                mtoken_bal_before = await mtoken_contract.functions.balanceOf(
+                    strategy
+                ).call()
+                try:
+                    underlying_addr = (
+                        await mtoken_contract.functions.underlying().call()
+                    )
+                except Exception:
+                    underlying_addr = None
+                if underlying_addr:
+                    underlying_contract = web3.eth.contract(
+                        address=to_checksum_address(underlying_addr),
+                        abi=ERC20_ABI,
+                    )
+                    underlying_bal_before = (
+                        await underlying_contract.functions.balanceOf(strategy).call()
+                    )
+            except Exception:
+                mtoken_bal_before = None
+                underlying_addr = None
+                underlying_bal_before = None
+
         # Redeem mTokens for underlying
         tx = await self._encode_call(
             target=mtoken,
@@ -221,7 +387,60 @@ class MoonwellAdapter(BaseAdapter):
             args=[amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        result = await self._execute(tx)
+
+        if not result[0] or not self.web3 or self.simulation:
+            return result
+
+        if isinstance(result[1], dict):
+            failure = self._failure_event_details(result[1], mtoken)
+            if failure is not None:
+                return (
+                    False,
+                    f"Redeem failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
+                )
+
+        if mtoken_bal_before is None:
+            return result
+
+        try:
+            pinned_block = self._tx_pinned_block(result[1])
+            block_id = pinned_block if pinned_block is not None else "latest"
+
+            web3 = self.web3.get_web3(self.chain_id)
+            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+            mtoken_bal_after = await mtoken_contract.functions.balanceOf(strategy).call(
+                block_identifier=block_id
+            )
+
+            underlying_bal_after = None
+            if underlying_addr:
+                underlying_contract = web3.eth.contract(
+                    address=to_checksum_address(underlying_addr),
+                    abi=ERC20_ABI,
+                )
+                underlying_bal_after = await underlying_contract.functions.balanceOf(
+                    strategy
+                ).call(block_identifier=block_id)
+
+            mtoken_decreased = int(mtoken_bal_after) < int(mtoken_bal_before)
+            underlying_increased = (
+                underlying_bal_before is not None
+                and underlying_bal_after is not None
+                and int(underlying_bal_after) > int(underlying_bal_before)
+            )
+
+            if not mtoken_decreased and not underlying_increased:
+                return (
+                    False,
+                    "Redeem verification failed: no observed balance change "
+                    f"(mtoken before={mtoken_bal_before}, after={mtoken_bal_after}; "
+                    f"underlying before={underlying_bal_before}, after={underlying_bal_after})",
+                )
+        except Exception:
+            return result
+
+        return result
 
     # ------------------------------------------------------------------ #
     # Public API - Borrowing Operations                                   #
@@ -292,11 +511,20 @@ class MoonwellAdapter(BaseAdapter):
         # Verify the borrow actually succeeded by checking balance increased
         if self.web3:
             try:
+                pinned_block = None
+                if isinstance(result[1], dict):
+                    pinned_block = (
+                        result[1].get("confirmed_block_number")
+                        or result[1].get("block_number")
+                        or (result[1].get("receipt", {}) or {}).get("blockNumber")
+                    )
+                block_id = pinned_block if pinned_block is not None else "latest"
+
                 web3 = self.web3.get_web3(self.chain_id)
                 mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
                 borrow_after = await mtoken_contract.functions.borrowBalanceStored(
                     strategy
-                ).call()
+                ).call(block_identifier=block_id)
 
                 # Borrow balance should have increased by approximately the amount
                 # Allow for some interest accrual
@@ -349,6 +577,17 @@ class MoonwellAdapter(BaseAdapter):
         mtoken = self._checksum(mtoken)
         underlying_token = self._checksum(underlying_token)
 
+        borrow_before = None
+        if self.web3 and not self.simulation:
+            try:
+                web3 = self.web3.get_web3(self.chain_id)
+                mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+                borrow_before = await mtoken_contract.functions.borrowBalanceStored(
+                    strategy
+                ).call()
+            except Exception:
+                borrow_before = None
+
         # Approve mToken to spend underlying tokens for repayment
         # When repay_full=True, approve the amount we have, Moonwell will use only what's needed
         approved = await self._ensure_allowance(
@@ -370,7 +609,49 @@ class MoonwellAdapter(BaseAdapter):
             args=[repay_amount],
             from_address=strategy,
         )
-        return await self._execute(tx)
+        result = await self._execute(tx)
+
+        if not result[0] or not self.web3 or self.simulation:
+            return result
+
+        if isinstance(result[1], dict):
+            failure = self._failure_event_details(result[1], mtoken)
+            if failure is not None:
+                return (
+                    False,
+                    f"Repay failed (Failure event): error={failure['error']} info={failure['info']} detail={failure['detail']}",
+                )
+
+        if borrow_before is None or int(borrow_before) <= 0:
+            return result
+
+        try:
+            pinned_block = self._tx_pinned_block(result[1])
+            block_id = pinned_block if pinned_block is not None else "latest"
+
+            web3 = self.web3.get_web3(self.chain_id)
+            mtoken_contract = web3.eth.contract(address=mtoken, abi=MTOKEN_ABI)
+            borrow_after = await mtoken_contract.functions.borrowBalanceStored(
+                strategy
+            ).call(block_identifier=block_id)
+
+            if repay_full:
+                # Full repayment should clear the borrow balance (allow 1 wei dust).
+                if int(borrow_after) > 1:
+                    return (
+                        False,
+                        f"Repay verification failed: repay_full did not clear debt (before={borrow_before}, after={borrow_after})",
+                    )
+            else:
+                if int(borrow_after) >= int(borrow_before):
+                    return (
+                        False,
+                        f"Repay verification failed: borrow balance did not decrease (before={borrow_before}, after={borrow_after})",
+                    )
+        except Exception:
+            return result
+
+        return result
 
     # ------------------------------------------------------------------ #
     # Public API - Collateral Management                                  #
@@ -404,13 +685,22 @@ class MoonwellAdapter(BaseAdapter):
         # Verify the market was actually entered
         if self.web3:
             try:
+                pinned_block = None
+                if isinstance(result[1], dict):
+                    pinned_block = (
+                        result[1].get("confirmed_block_number")
+                        or result[1].get("block_number")
+                        or (result[1].get("receipt", {}) or {}).get("blockNumber")
+                    )
+                block_id = pinned_block if pinned_block is not None else "latest"
+
                 web3 = self.web3.get_web3(self.chain_id)
                 comptroller = web3.eth.contract(
                     address=self.comptroller_address, abi=COMPTROLLER_ABI
                 )
                 is_member = await comptroller.functions.checkMembership(
                     strategy, mtoken
-                ).call()
+                ).call(block_identifier=block_id)
 
                 if not is_member:
                     from loguru import logger
@@ -430,6 +720,31 @@ class MoonwellAdapter(BaseAdapter):
 
         return result
 
+    async def is_market_entered(
+        self,
+        *,
+        mtoken: str,
+        account: str | None = None,
+    ) -> tuple[bool, bool | str]:
+        """Check whether an account has entered a given market (as collateral / borrowing market)."""
+        if self.simulation:
+            return True, True
+        if not self.web3:
+            return False, "web3 service not configured"
+
+        try:
+            acct = self._checksum(account) if account else self._strategy_address()
+            mtoken = self._checksum(mtoken)
+
+            web3 = self.web3.get_web3(self.chain_id)
+            comptroller = web3.eth.contract(
+                address=self.comptroller_address, abi=COMPTROLLER_ABI
+            )
+            is_member = await comptroller.functions.checkMembership(acct, mtoken).call()
+            return True, bool(is_member)
+        except Exception as exc:
+            return False, str(exc)
+
     async def remove_collateral(
         self,
         *,
@@ -1107,9 +1422,17 @@ class MoonwellAdapter(BaseAdapter):
 
         result = await self._broadcast_transaction(approve_tx)
 
-        # Small delay after approval to ensure state is propagated
+        # Small delay after approval to ensure state is propagated on providers/chains
+        # where we don't wait for additional confirmations by default.
         if result[0]:
-            await asyncio.sleep(1.0)
+            confirmations = 0
+            if isinstance(result[1], dict):
+                try:
+                    confirmations = int(result[1].get("confirmations") or 0)
+                except (TypeError, ValueError):
+                    confirmations = 0
+            if confirmations == 0:
+                await asyncio.sleep(1.0)
 
         return result
 

wayfinder_paths/adapters/moonwell_adapter/test_adapter.py

@@ -103,7 +103,7 @@ class TestMoonwellAdapter:
             amount=10**6,
         )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -137,7 +137,7 @@ class TestMoonwellAdapter:
             amount=10**8,
         )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -170,7 +170,7 @@ class TestMoonwellAdapter:
             amount=10**6,
         )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -198,7 +198,7 @@ class TestMoonwellAdapter:
             amount=10**6,
         )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -219,7 +219,7 @@ class TestMoonwellAdapter:
             mtoken=MOONWELL_DEFAULTS["m_wsteth"],
         )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -250,7 +250,7 @@ class TestMoonwellAdapter:
 
         success, result = await adapter.claim_rewards()
 
-        assert success is True
+        assert success
         assert isinstance(result, dict)
 
     @pytest.mark.asyncio
@@ -290,7 +290,7 @@ class TestMoonwellAdapter:
 
         success, result = await adapter.get_pos(mtoken=MOONWELL_DEFAULTS["m_usdc"])
 
-        assert success is True
+        assert success
         assert "mtoken_balance" in result
         assert "underlying_balance" in result
         assert "borrow_balance" in result
@@ -316,7 +316,7 @@ class TestMoonwellAdapter:
             mtoken=MOONWELL_DEFAULTS["m_wsteth"]
         )
 
-        assert success is True
+        assert success
         assert result == 0.75
 
     @pytest.mark.asyncio
@@ -465,7 +465,7 @@ class TestMoonwellAdapter:
             mtoken=MOONWELL_DEFAULTS["m_usdc"], apy_type="supply", include_rewards=False
         )
 
-        assert success is True
+        assert success
         assert isinstance(result, float)
         assert result >= 0
 
@@ -502,7 +502,7 @@ class TestMoonwellAdapter:
             mtoken=MOONWELL_DEFAULTS["m_usdc"], apy_type="borrow", include_rewards=False
         )
 
-        assert success is True
+        assert success
         assert isinstance(result, float)
         assert result >= 0
 
@@ -523,7 +523,7 @@ class TestMoonwellAdapter:
 
         success, result = await adapter.get_borrowable_amount()
 
-        assert success is True
+        assert success
         assert result == 10**18
 
     @pytest.mark.asyncio
@@ -559,7 +559,7 @@ class TestMoonwellAdapter:
 
         success, result = await adapter.wrap_eth(amount=10**18)
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     def test_strategy_address_missing(self):
@@ -630,6 +630,6 @@ class TestMoonwellAdapter:
             mtoken=MOONWELL_DEFAULTS["m_usdc"]
         )
 
-        assert success is True
+        assert success
         assert result["cTokens_raw"] == 0
         assert result["underlying_raw"] == 0

wayfinder_paths/adapters/pool_adapter/README.md

@@ -44,30 +44,29 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Llama Matches
+### Get pools (all or filtered)
+
+Pass at least `chain_id` when fetching all pools (e.g. `chain_id=8453` for Base):
 
 ```python
-success, data = await adapter.get_pools()
+success, data = await adapter.get_pools(chain_id=8453)
 if success:
     matches = data.get("matches", [])
-    print(f"Found {len(matches)} Llama matches")
     for match in matches:
         if match.get("stablecoin"):
-            print(f"Stablecoin pool: {match.get('id')} - APY: {match.get('apy')}%")
+            print(f"Pool {match.get('id')} - APY: {match.get('apy')}%")
 else:
     print(f"Error: {data}")
 ```
 
-## Advanced Usage
+Optional: `project="lido"` to filter by project.
 
 ## API Endpoints
 
-The adapter uses the following Wayfinder API endpoints:
+The adapter uses the Wayfinder API:
 
-- `GET /api/v1/public/pools/?pool_ids=X` - Get pools by IDs
-- `GET /api/v1/public/pools/` - Get all pools
-- `GET /api/v1/public/pools/llama/matches/` - Get Llama matches
-- `GET /api/v1/public/pools/llama/reports/` - Get Llama reports
+- `GET /v1/blockchain/pools/?chain_id=1&project=lido` - List pools (filter by chain_id, optional project)
+- `POST /v1/blockchain/pools/` - Get pools by IDs (body: `{"pool_ids": ["id1", "id2"]}`)
 
 ## Error Handling
 

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -2,7 +2,7 @@ from typing import Any
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.PoolClient import (
-    LlamaMatch,
+    LlamaMatchesResponse,
     PoolClient,
     PoolList,
 )
@@ -48,16 +48,15 @@ class PoolAdapter(BaseAdapter):
             self.logger.error(f"Error fetching pools by IDs: {e}")
             return (False, str(e))
 
-    async def get_pools(self) -> tuple[bool, dict[str, LlamaMatch] | str]:
-        """
-        Get Llama protocol matches for pools.
-
-        Returns:
-            Tuple of (success, data) where data is Llama matches or error message
-        """
+    async def get_pools(
+        self,
+        *,
+        chain_id: int | None = None,
+        project: str | None = None,
+    ) -> tuple[bool, LlamaMatchesResponse | str]:
         try:
-            data = await self.pool_client.get_pools()
+            data = await self.pool_client.get_pools(chain_id=chain_id, project=project)
             return (True, data)
         except Exception as e:
-            self.logger.error(f"Error fetching Llama matches: {e}")
+            self.logger.error(f"Error fetching pools: {e}")
             return (False, str(e))

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -41,7 +41,7 @@ class TestPoolAdapter:
             pool_ids=["pool-123", "pool-456"]
         )
 
-        assert success is True
+        assert success
         assert data == mock_response
         mock_pool_client.get_pools_by_ids.assert_called_once_with(
             pool_ids=["pool-123", "pool-456"]
@@ -66,7 +66,7 @@ class TestPoolAdapter:
 
         success, data = await adapter.get_pools()
 
-        assert success is True
+        assert success
         assert data == mock_response
 
     @pytest.mark.asyncio

wayfinder_paths/adapters/token_adapter/README.md

@@ -63,23 +63,11 @@ else:
     print(f"Error: {data}")
 ```
 
-### Get Token (Flexible)
-
-```python
-# Try by address first, then by token_id
-success, data = await adapter.get_token(address="0x1234...", token_id="token-123")
-if success:
-    print(f"Token data: {data}")
-else:
-    print(f"Error: {data}")
-```
-
 ## API Endpoints
 
-The adapter uses the following existing public API endpoints:
+The adapter uses the following Wayfinder API endpoint:
 
-1. **Token Details** (by address): `GET /public/tokens/detail/?query={address}&get_chart=false`
-2. **Token by ID**: `GET /public/tokens/lookup/?token_id={token_id}`
+- `GET /api/v1/blockchain/tokens/detail/?query=...&market_data=...&chain_id=...`
 
 ## Error Handling