wayfinder-paths 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/adapters/moonwell_adapter/test_adapter.py

@@ -1,4 +1,5 @@
-from unittest.mock import AsyncMock, MagicMock
+from contextlib import asynccontextmanager
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -14,27 +15,12 @@ class TestMoonwellAdapter:
     """Test cases for MoonwellAdapter"""
 
     @pytest.fixture
-    def mock_web3_service(self):
-        """Mock Web3Service for testing"""
-        mock_service = MagicMock()
-        mock_service.token_transactions = MagicMock()
-        mock_service.evm_transactions = MagicMock()
-
-        # Mock get_web3 to return a mock web3 instance
-        mock_web3 = MagicMock()
-        mock_service.get_web3 = MagicMock(return_value=mock_web3)
-
-        return mock_service
-
-    @pytest.fixture
-    def adapter(self, mock_web3_service):
+    def adapter(self):
         """Create a MoonwellAdapter instance with mocked services"""
         config = {
             "strategy_wallet": {"address": "0x1234567890123456789012345678901234567890"}
         }
-        return MoonwellAdapter(
-            config=config, web3_service=mock_web3_service, simulation=True
-        )
+        return MoonwellAdapter(config=config, simulation=True)
 
     def test_adapter_type(self, adapter):
         """Test adapter has correct adapter_type"""
@@ -79,32 +65,24 @@ class TestMoonwellAdapter:
         assert ok is True
 
     @pytest.mark.asyncio
-    async def test_lend_simulation(self, adapter, mock_web3_service):
+    async def test_lend_simulation(self, adapter):
         """Test lend operation in simulation mode"""
-        # Mock the allowance check
-        mock_web3_service.token_transactions.read_erc20_allowance = AsyncMock(
-            return_value={"allowance": 10**18}
-        )
-
-        # Mock contract encoding
-        mock_contract = MagicMock()
-        mock_contract.functions.mint = MagicMock(
-            return_value=MagicMock(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
+        with patch.object(
+            adapter, "_encode_call", new_callable=AsyncMock
+        ) as mock_encode:
+            mock_encode.return_value = {
+                "data": "0x1234",
+                "to": MOONWELL_DEFAULTS["m_usdc"],
+            }
+
+            success, result = await adapter.lend(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                underlying_token=MOONWELL_DEFAULTS["usdc"],
+                amount=10**6,
             )
-        )
-        mock_web3 = MagicMock()
-        mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
-
-        success, result = await adapter.lend(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
-            underlying_token=MOONWELL_DEFAULTS["usdc"],
-            amount=10**6,
-        )
 
-        assert success is True
-        assert "simulation" in result
+            assert success
+            assert "simulation" in result
 
     @pytest.mark.asyncio
     async def test_lend_invalid_amount(self, adapter):
@@ -119,7 +97,7 @@ class TestMoonwellAdapter:
         assert "positive" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_unlend_simulation(self, adapter, mock_web3_service):
+    async def test_unlend_simulation(self, adapter):
         """Test unlend operation in simulation mode"""
         # Mock contract encoding
         mock_contract = MagicMock()
@@ -130,14 +108,21 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.unlend(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
-            amount=10**8,
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.unlend(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                amount=10**8,
+            )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
@@ -152,78 +137,104 @@ class TestMoonwellAdapter:
         assert "positive" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_borrow_simulation(self, adapter, mock_web3_service):
+    async def test_borrow_simulation(self, adapter):
         """Test borrow operation in simulation mode"""
-        # Mock contract encoding
-        mock_contract = MagicMock()
-        mock_contract.functions.borrow = MagicMock(
+        # Track calls to return different values (0 before, 10**6 after)
+        borrow_balance_calls = [0]
+
+        async def mock_borrow_balance_call():
+            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(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
+                call=AsyncMock(return_value=0),  # 0 = success
+                _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_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
+        mock_web3.eth.contract = MagicMock(return_value=mock_mtoken)
 
-        success, result = await adapter.borrow(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
-            amount=10**6,
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.borrow(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                amount=10**6,
+            )
 
-        assert success is True
+        assert success
         assert "simulation" in result
 
     @pytest.mark.asyncio
-    async def test_repay_simulation(self, adapter, mock_web3_service):
+    async def test_repay_simulation(self, adapter):
         """Test repay operation in simulation mode"""
-        # Mock the allowance check
-        mock_web3_service.token_transactions.read_erc20_allowance = AsyncMock(
-            return_value={"allowance": 10**18}
-        )
-
-        # Mock contract encoding
-        mock_contract = MagicMock()
-        mock_contract.functions.repayBorrow = MagicMock(
-            return_value=MagicMock(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
+        with patch.object(
+            adapter, "_encode_call", new_callable=AsyncMock
+        ) as mock_encode:
+            mock_encode.return_value = {
+                "data": "0x1234",
+                "to": MOONWELL_DEFAULTS["m_usdc"],
+            }
+
+            success, result = await adapter.repay(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                underlying_token=MOONWELL_DEFAULTS["usdc"],
+                amount=10**6,
             )
-        )
-        mock_web3 = MagicMock()
-        mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
-
-        success, result = await adapter.repay(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"],
-            underlying_token=MOONWELL_DEFAULTS["usdc"],
-            amount=10**6,
-        )
 
-        assert success is True
-        assert "simulation" in result
+            assert success
+            assert "simulation" in result
 
     @pytest.mark.asyncio
-    async def test_set_collateral_simulation(self, adapter, mock_web3_service):
+    async def test_set_collateral_simulation(self, adapter):
         """Test set collateral operation in simulation mode"""
-        # Mock contract encoding
-        mock_contract = MagicMock()
-        mock_contract.functions.enterMarkets = MagicMock(
+        # 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(
-                build_transaction=AsyncMock(return_value={"data": "0x1234"})
+                _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_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.set_collateral(
-            mtoken=MOONWELL_DEFAULTS["m_wsteth"],
-        )
+        mock_web3 = MagicMock()
+        mock_web3.eth.contract = MagicMock(return_value=mock_comptroller)
+
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.set_collateral(
+                mtoken=MOONWELL_DEFAULTS["m_wsteth"],
+            )
 
-        assert success is True
-        assert "simulation" in result
+            assert success is True
+            assert "simulation" in result
 
     @pytest.mark.asyncio
-    async def test_claim_rewards_simulation(self, adapter, mock_web3_service):
+    async def test_claim_rewards_simulation(self, adapter):
         """Test claim rewards operation in simulation mode"""
         # Mock contract for getting outstanding rewards
         mock_reward_contract = MagicMock()
@@ -246,15 +257,14 @@ class TestMoonwellAdapter:
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(side_effect=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
         success, result = await adapter.claim_rewards()
 
-        assert success is True
+        assert success
         assert isinstance(result, dict)
 
     @pytest.mark.asyncio
-    async def test_get_pos_success(self, adapter, mock_web3_service):
+    async def test_get_pos_success(self, adapter):
         """Test get position data"""
         underlying_addr = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
 
@@ -286,11 +296,18 @@ class TestMoonwellAdapter:
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(side_effect=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_pos(mtoken=MOONWELL_DEFAULTS["m_usdc"])
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            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
@@ -299,8 +316,11 @@ class TestMoonwellAdapter:
         assert result["borrow_balance"] == 10**6
 
     @pytest.mark.asyncio
-    async def test_get_collateral_factor_success(self, adapter, mock_web3_service):
+    async def test_get_collateral_factor_success(self, adapter):
         """Test get collateral factor"""
+        # Clear cache to ensure fresh test
+        adapter._cf_cache.clear()
+
         # Mock contract calls - returns (isListed, collateralFactorMantissa)
         mock_contract = MagicMock()
         mock_contract.functions.markets = MagicMock(
@@ -310,17 +330,24 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_collateral_factor(
-            mtoken=MOONWELL_DEFAULTS["m_wsteth"]
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_collateral_factor(
+                mtoken=MOONWELL_DEFAULTS["m_wsteth"]
+            )
 
-        assert success is True
+        assert success
         assert result == 0.75
 
     @pytest.mark.asyncio
-    async def test_get_collateral_factor_not_listed(self, adapter, mock_web3_service):
+    async def test_get_collateral_factor_not_listed(self, adapter):
         """Test get collateral factor for unlisted market"""
         mock_contract = MagicMock()
         mock_contract.functions.markets = MagicMock(
@@ -328,21 +355,31 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_collateral_factor(
-            mtoken="0x0000000000000000000000000000000000000001"
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_collateral_factor(
+                mtoken="0x0000000000000000000000000000000000000001"
+            )
 
         assert success is False
         assert "not listed" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_get_collateral_factor_caching(self, adapter, mock_web3_service):
+    async def test_get_collateral_factor_caching(self, adapter):
         """Test that collateral factor is cached and subsequent calls don't hit RPC"""
+        # Clear cache to ensure fresh test
+        adapter._cf_cache.clear()
+
         call_count = 0
 
-        async def mock_markets_call():
+        async def mock_markets_call(**kwargs):
             nonlocal call_count
             call_count += 1
             return (True, int(0.80 * MANTISSA))
@@ -353,42 +390,52 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
-
-        mtoken = MOONWELL_DEFAULTS["m_wsteth"]
 
-        # First call should hit RPC
-        success1, result1 = await adapter.get_collateral_factor(mtoken=mtoken)
-        assert success1 is True
-        assert result1 == 0.80
-        assert call_count == 1
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
 
-        # Second call should use cache (no additional RPC call)
-        success2, result2 = await adapter.get_collateral_factor(mtoken=mtoken)
-        assert success2 is True
-        assert result2 == 0.80
-        assert call_count == 1  # Still 1, cache was used
+        mtoken = MOONWELL_DEFAULTS["m_wsteth"]
 
-        # Third call for same mtoken should still use cache
-        success3, result3 = await adapter.get_collateral_factor(mtoken=mtoken)
-        assert success3 is True
-        assert result3 == 0.80
-        assert call_count == 1  # Still 1
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            # First call should hit RPC
+            success1, result1 = await adapter.get_collateral_factor(mtoken=mtoken)
+            assert success1 is True
+            assert result1 == 0.80
+            assert call_count == 1
 
-        # Call for different mtoken should hit RPC
-        success4, result4 = await adapter.get_collateral_factor(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"]
-        )
-        assert success4 is True
-        assert call_count == 2  # Incremented for new mtoken
+            # Second call should use cache (no additional RPC call)
+            success2, result2 = await adapter.get_collateral_factor(mtoken=mtoken)
+            assert success2 is True
+            assert result2 == 0.80
+            assert call_count == 1  # Still 1, cache was used
+
+            # Third call for same mtoken should still use cache
+            success3, result3 = await adapter.get_collateral_factor(mtoken=mtoken)
+            assert success3 is True
+            assert result3 == 0.80
+            assert call_count == 1  # Still 1
+
+            # Call for different mtoken should hit RPC
+            success4, result4 = await adapter.get_collateral_factor(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"]
+            )
+            assert success4 is True
+            assert call_count == 2  # Incremented for new mtoken
 
     @pytest.mark.asyncio
-    async def test_get_collateral_factor_cache_expiry(self, adapter, mock_web3_service):
+    async def test_get_collateral_factor_cache_expiry(self, adapter):
         """Test that collateral factor cache expires after TTL"""
         import time
 
         from wayfinder_paths.adapters.moonwell_adapter import adapter as adapter_module
 
+        # Clear cache to ensure fresh test
+        adapter._cf_cache.clear()
+
         # Save original TTL
         original_ttl = adapter_module.CF_CACHE_TTL
 
@@ -398,7 +445,7 @@ class TestMoonwellAdapter:
 
             call_count = 0
 
-            async def mock_markets_call():
+            async def mock_markets_call(**kwargs):
                 nonlocal call_count
                 call_count += 1
                 return (True, int(0.75 * MANTISSA))
@@ -409,31 +456,38 @@ class TestMoonwellAdapter:
             )
             mock_web3 = MagicMock()
             mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-            mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
+
+            @asynccontextmanager
+            async def mock_web3_ctx(_chain_id):
+                yield mock_web3
 
             mtoken = MOONWELL_DEFAULTS["m_wsteth"]
 
-            # First call
-            await adapter.get_collateral_factor(mtoken=mtoken)
-            assert call_count == 1
+            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
+                # 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)
+                # Wait for cache to expire
+                time.sleep(0.15)
 
-            # Call after expiry should hit RPC again
-            await adapter.get_collateral_factor(mtoken=mtoken)
-            assert call_count == 2
+                # Call after expiry should hit RPC again
+                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, mock_web3_service):
+    async def test_get_apy_supply(self, adapter):
         """Test get supply APY"""
         rate_per_second = int(1.5e9)
 
@@ -459,18 +513,27 @@ class TestMoonwellAdapter:
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(side_effect=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_apy(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"], apy_type="supply", include_rewards=False
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_apy(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                apy_type="supply",
+                include_rewards=False,
+            )
 
-        assert success is True
+        assert success
         assert isinstance(result, float)
         assert result >= 0
 
     @pytest.mark.asyncio
-    async def test_get_apy_borrow(self, adapter, mock_web3_service):
+    async def test_get_apy_borrow(self, adapter):
         """Test get borrow APY"""
         rate_per_second = int(2e9)
 
@@ -496,18 +559,27 @@ class TestMoonwellAdapter:
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(side_effect=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_apy(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"], apy_type="borrow", include_rewards=False
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_apy(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"],
+                apy_type="borrow",
+                include_rewards=False,
+            )
 
-        assert success is True
+        assert success
         assert isinstance(result, float)
         assert result >= 0
 
     @pytest.mark.asyncio
-    async def test_get_borrowable_amount_success(self, adapter, mock_web3_service):
+    async def test_get_borrowable_amount_success(self, adapter):
         """Test get borrowable amount"""
         mock_contract = MagicMock()
         mock_contract.functions.getAccountLiquidity = MagicMock(
@@ -519,15 +591,22 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_borrowable_amount()
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_borrowable_amount()
 
-        assert success is True
+        assert success
         assert result == 10**18
 
     @pytest.mark.asyncio
-    async def test_get_borrowable_amount_shortfall(self, adapter, mock_web3_service):
+    async def test_get_borrowable_amount_shortfall(self, adapter):
         """Test get borrowable amount when account has shortfall"""
         mock_contract = MagicMock()
         mock_contract.functions.getAccountLiquidity = MagicMock(
@@ -537,15 +616,22 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.get_borrowable_amount()
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.get_borrowable_amount()
 
         assert success is False
         assert "shortfall" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_wrap_eth_simulation(self, adapter, mock_web3_service):
+    async def test_wrap_eth_simulation(self, adapter):
         """Test wrap ETH operation in simulation mode"""
         mock_contract = MagicMock()
         mock_contract.functions.deposit = MagicMock(
@@ -555,11 +641,18 @@ class TestMoonwellAdapter:
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.wrap_eth(amount=10**18)
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
 
-        assert success is True
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.wrap_eth(amount=10**18)
+
+        assert success
         assert "simulation" in result
 
     def test_strategy_address_missing(self):
@@ -574,7 +667,7 @@ class TestMoonwellAdapter:
         with pytest.raises(ValueError, match="Missing required"):
             adapter._checksum(None)
 
-    def test_config_override(self, mock_web3_service):
+    def test_config_override(self):
         """Test config can override default addresses"""
         custom_comptroller = "0x1111111111111111111111111111111111111111"
         custom_well = "0x2222222222222222222222222222222222222222"
@@ -589,18 +682,14 @@ class TestMoonwellAdapter:
             },
         }
 
-        adapter = MoonwellAdapter(
-            config=config, web3_service=mock_web3_service, simulation=True
-        )
+        adapter = MoonwellAdapter(config=config, simulation=True)
 
         assert adapter.comptroller_address.lower() == custom_comptroller.lower()
         assert adapter.well_token.lower() == custom_well.lower()
         assert adapter.chain_id == 1
 
     @pytest.mark.asyncio
-    async def test_max_withdrawable_mtoken_zero_balance(
-        self, adapter, mock_web3_service
-    ):
+    async def test_max_withdrawable_mtoken_zero_balance(self, adapter):
         """Test max withdrawable when balance is zero"""
         # Mock contracts
         mock_mtoken = MagicMock()
@@ -624,12 +713,19 @@ class TestMoonwellAdapter:
 
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_mtoken)
-        mock_web3_service.get_web3 = MagicMock(return_value=mock_web3)
 
-        success, result = await adapter.max_withdrawable_mtoken(
-            mtoken=MOONWELL_DEFAULTS["m_usdc"]
-        )
+        @asynccontextmanager
+        async def mock_web3_ctx(_chain_id):
+            yield mock_web3
+
+        with patch(
+            "wayfinder_paths.adapters.moonwell_adapter.adapter.web3_from_chain_id",
+            mock_web3_ctx,
+        ):
+            success, result = await adapter.max_withdrawable_mtoken(
+                mtoken=MOONWELL_DEFAULTS["m_usdc"]
+            )
 
-        assert success is True
+        assert success
         assert result["cTokens_raw"] == 0
         assert result["underlying_raw"] == 0