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

wayfinder_paths/adapters/moonwell_adapter/manifest.yaml

@@ -0,0 +1,14 @@
+schema_version: "0.1"
+entrypoint: "adapters.moonwell_adapter.adapter.MoonwellAdapter"
+capabilities:
+  - "lending.lend"
+  - "lending.unlend"
+  - "lending.borrow"
+  - "lending.repay"
+  - "collateral.set"
+  - "collateral.remove"
+  - "rewards.claim"
+  - "position.read"
+  - "market.apy"
+  - "market.collateral_factor"
+dependencies: []

wayfinder_paths/adapters/moonwell_adapter/test_adapter.py

@@ -2,13 +2,22 @@ from contextlib import asynccontextmanager
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
+from web3 import Web3
 
 from wayfinder_paths.adapters.moonwell_adapter.adapter import (
-    BASE_CHAIN_ID,
+    CHAIN_NAME,
     MANTISSA,
-    MOONWELL_DEFAULTS,
     MoonwellAdapter,
 )
+from wayfinder_paths.core.constants.contracts import (
+    BASE_USDC,
+    BASE_WETH,
+    MOONWELL_M_USDC,
+    MOONWELL_M_WETH,
+    MOONWELL_M_WSTETH,
+    MOONWELL_REWARD_DISTRIBUTOR,
+    MOONWELL_WELL_TOKEN,
+)
 
 
 class TestMoonwellAdapter:
@@ -22,61 +31,98 @@ class TestMoonwellAdapter:
     def test_adapter_type(self, adapter):
         assert adapter.adapter_type == "MOONWELL"
 
-    def test_default_addresses(self, adapter):
-        assert (
-            adapter.comptroller_address.lower()
-            == MOONWELL_DEFAULTS["comptroller"].lower()
-        )
-        assert (
-            adapter.reward_distributor_address.lower()
-            == MOONWELL_DEFAULTS["reward_distributor"].lower()
-        )
-        assert adapter.m_usdc.lower() == MOONWELL_DEFAULTS["m_usdc"].lower()
-        assert adapter.m_weth.lower() == MOONWELL_DEFAULTS["m_weth"].lower()
-        assert adapter.m_wsteth.lower() == MOONWELL_DEFAULTS["m_wsteth"].lower()
-        assert adapter.well_token.lower() == MOONWELL_DEFAULTS["well_token"].lower()
+    def test_chain_name(self):
+        assert CHAIN_NAME == "base"
 
-    def test_chain_id(self, adapter):
-        assert adapter.chain_id == BASE_CHAIN_ID
+    @pytest.mark.asyncio
+    async def test_get_full_user_state_basic(self, adapter):
+        w3 = Web3()
 
-    def test_chain_name(self, adapter):
-        assert adapter.chain_name == "base"
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield w3
+
+        m1 = MOONWELL_M_USDC
+        m2 = MOONWELL_M_WETH
+
+        rewards = w3.codec.encode(
+            ["(address,(address,uint256,uint256,uint256)[])[]"],
+            [[(m1, [(MOONWELL_WELL_TOKEN, 123, 0, 0)])]],
+        )
+
+        stage1 = [
+            w3.codec.encode(["address[]"], [[m1, m2]]),
+            w3.codec.encode(["address[]"], [[m1]]),
+            w3.codec.encode(["uint256", "uint256", "uint256"], [0, 123, 0]),
+            rewards,
+        ]
+
+        stage2 = [
+            # m1
+            w3.codec.encode(["uint256"], [100]),
+            w3.codec.encode(["uint256"], [2 * MANTISSA]),
+            w3.codec.encode(["uint256"], [50]),
+            w3.codec.encode(["address"], [BASE_USDC]),
+            w3.codec.encode(["uint8"], [8]),
+            w3.codec.encode(["bool", "uint256"], [True, int(0.5 * MANTISSA)]),
+            # m2 (all zeros, should be filtered out)
+            w3.codec.encode(["uint256"], [0]),
+            w3.codec.encode(["uint256"], [0]),
+            w3.codec.encode(["uint256"], [0]),
+            w3.codec.encode(["address"], [BASE_WETH]),
+            w3.codec.encode(["uint8"], [8]),
+            w3.codec.encode(["bool", "uint256"], [True, int(0.5 * MANTISSA)]),
+        ]
 
-    @pytest.mark.asyncio
-    async def test_health_check(self, adapter):
-        health = await adapter.health_check()
-        assert isinstance(health, dict)
-        assert health.get("status") in {"healthy", "unhealthy", "error"}
-        assert health.get("adapter") == "MOONWELL"
+        with (
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+                mock_web3_ctx,
+            ),
+            patch.object(
+                adapter, "_multicall_chunked", new_callable=AsyncMock
+            ) as mock_multicall,
+        ):
+            mock_multicall.side_effect = [stage1, stage2]
+            ok, state = await adapter.get_full_user_state(
+                include_rewards=True,
+                include_usd=False,
+                include_apy=False,
+            )
 
-    @pytest.mark.asyncio
-    async def test_connect(self, adapter):
-        ok = await adapter.connect()
-        assert isinstance(ok, bool)
         assert ok is True
+        assert state["protocol"] == "moonwell"
+        assert state["chainId"] == adapter.chain_id
+        assert state["accountLiquidity"]["liquidity"] == 123
+        assert len(state["positions"]) == 1
+        assert state["positions"][0]["enteredAsCollateral"] is True
+        assert state["positions"][0]["suppliedUnderlying"] == 200
+        assert state["rewards"][f"base_{MOONWELL_WELL_TOKEN.lower()}"] == 123
 
     @pytest.mark.asyncio
     async def test_lend(self, adapter):
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
         with (
-            patch.object(
-                adapter, "_ensure_allowance", new_callable=AsyncMock
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.ensure_allowance",
+                new_callable=AsyncMock,
             ) as mock_allowance,
-            patch.object(
-                adapter, "_encode_call", new_callable=AsyncMock
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
             ) as mock_encode,
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
         ):
             mock_allowance.return_value = (True, {})
-            mock_encode.return_value = {
-                "data": "0x1234",
-                "to": MOONWELL_DEFAULTS["m_usdc"],
-            }
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": MOONWELL_M_USDC}
+            mock_send.return_value = mock_tx_hash
 
             success, result = await adapter.lend(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
-                underlying_token=MOONWELL_DEFAULTS["usdc"],
+                mtoken=MOONWELL_M_USDC,
+                underlying_token=BASE_USDC,
                 amount=10**6,
             )
 
@@ -86,8 +132,8 @@ class TestMoonwellAdapter:
     @pytest.mark.asyncio
     async def test_lend_invalid_amount(self, adapter):
         success, result = await adapter.lend(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
-            underlying_token=MOONWELL_DEFAULTS["usdc"],
+            mtoken=MOONWELL_M_USDC,
+            underlying_token=BASE_USDC,
             amount=0,
         )
 
@@ -96,32 +142,22 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_unlend(self, adapter):
-        # Mock contract encoding
-        mock_contract = MagicMock()
-        mock_contract.functions.redeem = MagicMock(
-            return_value=MagicMock(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
-            )
-        )
-        mock_web3 = MagicMock()
-        mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-
-        @asynccontextmanager
-        async def mock_web3_ctx(_chain_id):
-            yield mock_web3
-
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
 
         with (
             patch(
-                "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
-                mock_web3_ctx,
-            ),
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
+            ) as mock_encode,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
         ):
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": MOONWELL_M_USDC}
+            mock_send.return_value = mock_tx_hash
             success, result = await adapter.unlend(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                mtoken=MOONWELL_M_USDC,
                 amount=10**8,
             )
 
@@ -131,7 +167,7 @@ class TestMoonwellAdapter:
     @pytest.mark.asyncio
     async def test_unlend_invalid_amount(self, adapter):
         success, result = await adapter.unlend(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
+            mtoken=MOONWELL_M_USDC,
             amount=-1,
         )
 
@@ -140,47 +176,22 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_borrow(self, adapter):
-        # Track calls to return different values (0 before, 10**6 after)
-        borrow_balance_calls = [0]
-
-        async def mock_borrow_balance_call(**kwargs):
-            result = borrow_balance_calls[0]
-            # Next call returns increased balance
-            borrow_balance_calls[0] = 10**6
-            return result
-
-        # Mock mtoken contract for pre-check and verification
-        mock_mtoken = MagicMock()
-        mock_mtoken.functions.borrowBalanceStored = MagicMock(
-            return_value=MagicMock(call=mock_borrow_balance_call)
-        )
-        mock_mtoken.functions.borrow = MagicMock(
-            return_value=MagicMock(
-                call=AsyncMock(return_value=0),
-                _encode_transaction_data=MagicMock(return_value="0x1234"),
-                build_transaction=AsyncMock(return_value={"data": "0x1234"}),
-            )
-        )
-
-        mock_web3 = MagicMock()
-        mock_web3.eth.contract = MagicMock(return_value=mock_mtoken)
-
-        @asynccontextmanager
-        async def mock_web3_ctx(_chain_id):
-            yield mock_web3
-
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
 
         with (
             patch(
-                "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
-                mock_web3_ctx,
-            ),
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
+            ) as mock_encode,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
         ):
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": MOONWELL_M_USDC}
+            mock_send.return_value = mock_tx_hash
             success, result = await adapter.borrow(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                mtoken=MOONWELL_M_USDC,
                 amount=10**6,
             )
 
@@ -191,24 +202,26 @@ class TestMoonwellAdapter:
     async def test_repay(self, adapter):
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
         with (
-            patch.object(
-                adapter, "_ensure_allowance", new_callable=AsyncMock
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.ensure_allowance",
+                new_callable=AsyncMock,
             ) as mock_allowance,
-            patch.object(
-                adapter, "_encode_call", new_callable=AsyncMock
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
             ) as mock_encode,
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
         ):
             mock_allowance.return_value = (True, {})
-            mock_encode.return_value = {
-                "data": "0x1234",
-                "to": MOONWELL_DEFAULTS["m_usdc"],
-            }
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": MOONWELL_M_USDC}
+            mock_send.return_value = mock_tx_hash
 
             success, result = await adapter.repay(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
-                underlying_token=MOONWELL_DEFAULTS["usdc"],
+                mtoken=MOONWELL_M_USDC,
+                underlying_token=BASE_USDC,
                 amount=10**6,
             )
 
@@ -217,17 +230,10 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_set_collateral(self, adapter):
-        # Mock comptroller contract for verification
         mock_comptroller = MagicMock()
         mock_comptroller.functions.checkMembership = MagicMock(
             return_value=MagicMock(call=AsyncMock(return_value=True))
         )
-        mock_comptroller.functions.enterMarkets = MagicMock(
-            return_value=MagicMock(
-                _encode_transaction_data=MagicMock(return_value="0x1234"),
-                build_transaction=AsyncMock(return_value={"data": "0x1234"}),
-            )
-        )
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_comptroller)
@@ -239,15 +245,23 @@ class TestMoonwellAdapter:
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
 
         with (
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
+            ) as mock_encode,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
             patch(
                 "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
                 mock_web3_ctx,
             ),
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
         ):
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": MOONWELL_M_WSTETH}
+            mock_send.return_value = mock_tx_hash
             success, result = await adapter.set_collateral(
-                mtoken=MOONWELL_DEFAULTS["m_wsteth"],
+                mtoken=MOONWELL_M_WSTETH,
             )
 
             assert success is True
@@ -270,7 +284,7 @@ class TestMoonwellAdapter:
         )
 
         def mock_contract(address, abi):
-            if address.lower() == adapter.reward_distributor_address.lower():
+            if address.lower() == MOONWELL_REWARD_DISTRIBUTOR.lower():
                 return mock_reward_contract
             return mock_comptroller
 
@@ -308,7 +322,7 @@ class TestMoonwellAdapter:
         )
 
         def mock_contract(address, abi):
-            if address.lower() == adapter.reward_distributor_address.lower():
+            if address.lower() == MOONWELL_REWARD_DISTRIBUTOR.lower():
                 return mock_reward
             return mock_mtoken
 
@@ -323,7 +337,7 @@ class TestMoonwellAdapter:
             "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
             mock_web3_ctx,
         ):
-            success, result = await adapter.get_pos(mtoken=MOONWELL_DEFAULTS["m_usdc"])
+            success, result = await adapter.get_pos(mtoken=MOONWELL_M_USDC)
 
         assert success
         assert "mtoken_balance" in result
@@ -336,7 +350,7 @@ class TestMoonwellAdapter:
     @pytest.mark.asyncio
     async def test_get_collateral_factor_success(self, adapter):
         # Clear cache to ensure fresh test
-        adapter._cf_cache.clear()
+        await adapter._cache.clear()
 
         # Mock contract calls - returns (isListed, collateralFactorMantissa)
         mock_contract = MagicMock()
@@ -357,7 +371,7 @@ class TestMoonwellAdapter:
             mock_web3_ctx,
         ):
             success, result = await adapter.get_collateral_factor(
-                mtoken=MOONWELL_DEFAULTS["m_wsteth"]
+                mtoken=MOONWELL_M_WSTETH
             )
 
         assert success
@@ -390,7 +404,7 @@ class TestMoonwellAdapter:
     @pytest.mark.asyncio
     async def test_get_collateral_factor_caching(self, adapter):
         # Clear cache to ensure fresh test
-        adapter._cf_cache.clear()
+        await adapter._cache.clear()
 
         call_count = 0
 
@@ -410,7 +424,7 @@ class TestMoonwellAdapter:
         async def mock_web3_ctx(_chain_id):
             yield mock_web3
 
-        mtoken = MOONWELL_DEFAULTS["m_wsteth"]
+        mtoken = MOONWELL_M_WSTETH
 
         with patch(
             "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
@@ -435,67 +449,11 @@ class TestMoonwellAdapter:
             assert call_count == 1
 
             success4, result4 = await adapter.get_collateral_factor(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"]
+                mtoken=MOONWELL_M_USDC
             )
             assert success4 is True
             assert call_count == 2
 
-    @pytest.mark.asyncio
-    async def test_get_collateral_factor_cache_expiry(self, adapter):
-        import time
-
-        from wayfinder_paths.adapters.moonwell_adapter import adapter as adapter_module
-
-        # Clear cache to ensure fresh test
-        adapter._cf_cache.clear()
-
-        original_ttl = adapter_module.CF_CACHE_TTL
-
-        try:
-            adapter_module.CF_CACHE_TTL = 0.1
-
-            call_count = 0
-
-            async def mock_markets_call(**kwargs):
-                nonlocal call_count
-                call_count += 1
-                return (True, int(0.75 * MANTISSA))
-
-            mock_contract = MagicMock()
-            mock_contract.functions.markets = MagicMock(
-                return_value=MagicMock(call=mock_markets_call)
-            )
-            mock_web3 = MagicMock()
-            mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-
-            @asynccontextmanager
-            async def mock_web3_ctx(_chain_id):
-                yield mock_web3
-
-            mtoken = MOONWELL_DEFAULTS["m_wsteth"]
-
-            with patch(
-                "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
-                mock_web3_ctx,
-            ):
-                # First call
-                await adapter.get_collateral_factor(mtoken=mtoken)
-                assert call_count == 1
-
-                # Immediate second call should use cache
-                await adapter.get_collateral_factor(mtoken=mtoken)
-                assert call_count == 1
-
-                # Wait for cache to expire
-                time.sleep(0.15)
-
-                await adapter.get_collateral_factor(mtoken=mtoken)
-                assert call_count == 2
-
-        finally:
-            # Restore original TTL
-            adapter_module.CF_CACHE_TTL = original_ttl
-
     @pytest.mark.asyncio
     async def test_get_apy_supply(self, adapter):
         rate_per_second = int(1.5e9)
@@ -516,7 +474,7 @@ class TestMoonwellAdapter:
         )
 
         def mock_contract(address, abi):
-            if address.lower() == adapter.reward_distributor_address.lower():
+            if address.lower() == MOONWELL_REWARD_DISTRIBUTOR.lower():
                 return mock_reward
             return mock_mtoken
 
@@ -532,7 +490,7 @@ class TestMoonwellAdapter:
             mock_web3_ctx,
         ):
             success, result = await adapter.get_apy(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                mtoken=MOONWELL_M_USDC,
                 apy_type="supply",
                 include_rewards=False,
             )
@@ -561,7 +519,7 @@ class TestMoonwellAdapter:
         )
 
         def mock_contract(address, abi):
-            if address.lower() == adapter.reward_distributor_address.lower():
+            if address.lower() == MOONWELL_REWARD_DISTRIBUTOR.lower():
                 return mock_reward
             return mock_mtoken
 
@@ -577,7 +535,7 @@ class TestMoonwellAdapter:
             mock_web3_ctx,
         ):
             success, result = await adapter.get_apy(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                mtoken=MOONWELL_M_USDC,
                 apy_type="borrow",
                 include_rewards=False,
             )
@@ -632,63 +590,28 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_wrap_eth(self, adapter):
-        mock_contract = MagicMock()
-        mock_contract.functions.deposit = MagicMock(
-            return_value=MagicMock(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
-            )
-        )
-        mock_web3 = MagicMock()
-        mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-
-        @asynccontextmanager
-        async def mock_web3_ctx(_chain_id):
-            yield mock_web3
-
         mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
 
         with (
             patch(
-                "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
-                mock_web3_ctx,
-            ),
-            patch.object(adapter, "_send_tx", new_callable=AsyncMock) as mock_send,
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.encode_call",
+                new_callable=AsyncMock,
+            ) as mock_encode,
+            patch(
+                "wayfinder_paths.adapters.moonwell_adapter.adapter.send_transaction",
+                new_callable=AsyncMock,
+            ) as mock_send,
         ):
-            mock_send.return_value = (True, mock_tx_hash)
+            mock_encode.return_value = {"data": "0x1234", "to": BASE_WETH}
+            mock_send.return_value = mock_tx_hash
             success, result = await adapter.wrap_eth(amount=10**18)
 
         assert success
         assert result == mock_tx_hash
 
     def test_strategy_address_missing(self):
-        adapter = MoonwellAdapter(config={})
-
-        with pytest.raises(ValueError, match="strategy_wallet"):
-            adapter._strategy_address()
-
-    def test_checksum_missing_address(self, adapter):
-        with pytest.raises(ValueError, match="Missing required"):
-            adapter._checksum(None)
-
-    def test_config_override(self):
-        custom_comptroller = "0x1111111111111111111111111111111111111111"
-        custom_well = "0x2222222222222222222222222222222222222222"
-        config = {
-            "strategy_wallet": {
-                "address": "0x1234567890123456789012345678901234567890"
-            },
-            "moonwell_adapter": {
-                "comptroller": custom_comptroller,
-                "well_token": custom_well,
-                "chain_id": 1,
-            },
-        }
-
-        adapter = MoonwellAdapter(config=config)
-
-        assert adapter.comptroller_address.lower() == custom_comptroller.lower()
-        assert adapter.well_token.lower() == custom_well.lower()
-        assert adapter.chain_id == 1
+        with pytest.raises(KeyError):
+            MoonwellAdapter(config={})
 
     @pytest.mark.asyncio
     async def test_max_withdrawable_mtoken_zero_balance(self, adapter):
@@ -707,9 +630,7 @@ class TestMoonwellAdapter:
             return_value=MagicMock(call=AsyncMock(return_value=8))
         )
         mock_mtoken.functions.underlying = MagicMock(
-            return_value=MagicMock(
-                call=AsyncMock(return_value=MOONWELL_DEFAULTS["usdc"])
-            )
+            return_value=MagicMock(call=AsyncMock(return_value=BASE_USDC))
         )
 
         mock_web3 = MagicMock()
@@ -724,7 +645,7 @@ class TestMoonwellAdapter:
             mock_web3_ctx,
         ):
             success, result = await adapter.max_withdrawable_mtoken(
-                mtoken=MOONWELL_DEFAULTS["m_usdc"]
+                mtoken=MOONWELL_M_USDC
             )
 
         assert success

wayfinder_paths/adapters/multicall_adapter/__init__.py

@@ -0,0 +1,7 @@
+"""
+Multicall Adapter
+"""
+
+from wayfinder_paths.adapters.multicall_adapter.adapter import MulticallAdapter
+
+__all__ = ["MulticallAdapter"]