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

wayfinder_paths/adapters/moonwell_adapter/test_adapter.py

@@ -12,22 +12,17 @@ from wayfinder_paths.adapters.moonwell_adapter.adapter import (
 
 
 class TestMoonwellAdapter:
-    """Test cases for MoonwellAdapter"""
-
     @pytest.fixture
     def adapter(self):
-        """Create a MoonwellAdapter instance with mocked services"""
         config = {
             "strategy_wallet": {"address": "0x1234567890123456789012345678901234567890"}
         }
-        return MoonwellAdapter(config=config, simulation=True)
+        return MoonwellAdapter(config=config)
 
     def test_adapter_type(self, adapter):
-        """Test adapter has correct adapter_type"""
         assert adapter.adapter_type == "MOONWELL"
 
     def test_default_addresses(self, adapter):
-        """Test default Moonwell addresses are set correctly"""
         assert (
             adapter.comptroller_address.lower()
             == MOONWELL_DEFAULTS["comptroller"].lower()
@@ -42,16 +37,13 @@ class TestMoonwellAdapter:
         assert adapter.well_token.lower() == MOONWELL_DEFAULTS["well_token"].lower()
 
     def test_chain_id(self, adapter):
-        """Test default chain ID is Base"""
         assert adapter.chain_id == BASE_CHAIN_ID
 
     def test_chain_name(self, adapter):
-        """Test chain name is base"""
         assert adapter.chain_name == "base"
 
     @pytest.mark.asyncio
     async def test_health_check(self, adapter):
-        """Test adapter health check"""
         health = await adapter.health_check()
         assert isinstance(health, dict)
         assert health.get("status") in {"healthy", "unhealthy", "error"}
@@ -59,21 +51,28 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_connect(self, adapter):
-        """Test adapter connection"""
         ok = await adapter.connect()
         assert isinstance(ok, bool)
         assert ok is True
 
     @pytest.mark.asyncio
-    async def test_lend_simulation(self, adapter):
-        """Test lend operation in simulation mode"""
-        with patch.object(
-            adapter, "_encode_call", new_callable=AsyncMock
-        ) as mock_encode:
+    async def test_lend(self, adapter):
+        mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
+        with (
+            patch.object(
+                adapter, "_ensure_allowance", new_callable=AsyncMock
+            ) as mock_allowance,
+            patch.object(
+                adapter, "_encode_call", new_callable=AsyncMock
+            ) as mock_encode,
+            patch.object(adapter, "_send_tx", 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)
 
             success, result = await adapter.lend(
                 mtoken=MOONWELL_DEFAULTS["m_usdc"],
@@ -82,11 +81,10 @@ class TestMoonwellAdapter:
             )
 
             assert success
-            assert "simulation" in result
+            assert result == mock_tx_hash
 
     @pytest.mark.asyncio
     async def test_lend_invalid_amount(self, adapter):
-        """Test lend with invalid amount"""
         success, result = await adapter.lend(
             mtoken=MOONWELL_DEFAULTS["m_usdc"],
             underlying_token=MOONWELL_DEFAULTS["usdc"],
@@ -97,8 +95,7 @@ class TestMoonwellAdapter:
         assert "positive" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_unlend_simulation(self, adapter):
-        """Test unlend operation in simulation mode"""
+    async def test_unlend(self, adapter):
         # Mock contract encoding
         mock_contract = MagicMock()
         mock_contract.functions.redeem = MagicMock(
@@ -113,21 +110,26 @@ class TestMoonwellAdapter:
         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,
+        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,
         ):
+            mock_send.return_value = (True, mock_tx_hash)
             success, result = await adapter.unlend(
                 mtoken=MOONWELL_DEFAULTS["m_usdc"],
                 amount=10**8,
             )
 
         assert success
-        assert "simulation" in result
+        assert result == mock_tx_hash
 
     @pytest.mark.asyncio
     async def test_unlend_invalid_amount(self, adapter):
-        """Test unlend with invalid amount"""
         success, result = await adapter.unlend(
             mtoken=MOONWELL_DEFAULTS["m_usdc"],
             amount=-1,
@@ -137,12 +139,11 @@ class TestMoonwellAdapter:
         assert "positive" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_borrow_simulation(self, adapter):
-        """Test borrow operation in simulation mode"""
+    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():
+        async def mock_borrow_balance_call(**kwargs):
             result = borrow_balance_calls[0]
             # Next call returns increased balance
             borrow_balance_calls[0] = 10**6
@@ -155,7 +156,7 @@ class TestMoonwellAdapter:
         )
         mock_mtoken.functions.borrow = MagicMock(
             return_value=MagicMock(
-                call=AsyncMock(return_value=0),  # 0 = success
+                call=AsyncMock(return_value=0),
                 _encode_transaction_data=MagicMock(return_value="0x1234"),
                 build_transaction=AsyncMock(return_value={"data": "0x1234"}),
             )
@@ -168,28 +169,42 @@ class TestMoonwellAdapter:
         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,
+        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,
         ):
+            mock_send.return_value = (True, mock_tx_hash)
             success, result = await adapter.borrow(
                 mtoken=MOONWELL_DEFAULTS["m_usdc"],
                 amount=10**6,
             )
 
         assert success
-        assert "simulation" in result
+        assert result == mock_tx_hash
 
     @pytest.mark.asyncio
-    async def test_repay_simulation(self, adapter):
-        """Test repay operation in simulation mode"""
-        with patch.object(
-            adapter, "_encode_call", new_callable=AsyncMock
-        ) as mock_encode:
+    async def test_repay(self, adapter):
+        mock_tx_hash = {"tx_hash": "0xabc123", "status": "success"}
+        with (
+            patch.object(
+                adapter, "_ensure_allowance", new_callable=AsyncMock
+            ) as mock_allowance,
+            patch.object(
+                adapter, "_encode_call", new_callable=AsyncMock
+            ) as mock_encode,
+            patch.object(adapter, "_send_tx", 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)
 
             success, result = await adapter.repay(
                 mtoken=MOONWELL_DEFAULTS["m_usdc"],
@@ -198,11 +213,10 @@ class TestMoonwellAdapter:
             )
 
             assert success
-            assert "simulation" in result
+            assert result == mock_tx_hash
 
     @pytest.mark.asyncio
-    async def test_set_collateral_simulation(self, adapter):
-        """Test set collateral operation in simulation mode"""
+    async def test_set_collateral(self, adapter):
         # Mock comptroller contract for verification
         mock_comptroller = MagicMock()
         mock_comptroller.functions.checkMembership = MagicMock(
@@ -222,20 +236,25 @@ class TestMoonwellAdapter:
         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,
+        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,
         ):
+            mock_send.return_value = (True, mock_tx_hash)
             success, result = await adapter.set_collateral(
                 mtoken=MOONWELL_DEFAULTS["m_wsteth"],
             )
 
             assert success is True
-            assert "simulation" in result
+            assert result == mock_tx_hash
 
     @pytest.mark.asyncio
-    async def test_claim_rewards_simulation(self, adapter):
-        """Test claim rewards operation in simulation mode"""
+    async def test_claim_rewards(self, adapter):
         # Mock contract for getting outstanding rewards
         mock_reward_contract = MagicMock()
         mock_reward_contract.functions.getOutstandingRewardsForUser = MagicMock(
@@ -265,7 +284,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_get_pos_success(self, adapter):
-        """Test get position data"""
         underlying_addr = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
 
         # Mock mtoken contract calls
@@ -317,7 +335,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_get_collateral_factor_success(self, adapter):
-        """Test get collateral factor"""
         # Clear cache to ensure fresh test
         adapter._cf_cache.clear()
 
@@ -348,7 +365,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     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(
             return_value=MagicMock(call=AsyncMock(return_value=(False, 0)))
@@ -373,7 +389,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     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()
 
@@ -411,24 +426,22 @@ class TestMoonwellAdapter:
             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
+            assert call_count == 1
 
             # 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
+            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
+            assert call_count == 2
 
     @pytest.mark.asyncio
     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
@@ -436,12 +449,10 @@ class TestMoonwellAdapter:
         # Clear cache to ensure fresh test
         adapter._cf_cache.clear()
 
-        # Save original TTL
         original_ttl = adapter_module.CF_CACHE_TTL
 
         try:
-            # Set a very short TTL for testing
-            adapter_module.CF_CACHE_TTL = 0.1  # 100ms
+            adapter_module.CF_CACHE_TTL = 0.1
 
             call_count = 0
 
@@ -478,7 +489,6 @@ class TestMoonwellAdapter:
                 # 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
 
@@ -488,7 +498,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_get_apy_supply(self, adapter):
-        """Test get supply APY"""
         rate_per_second = int(1.5e9)
 
         # Mock mtoken contract
@@ -534,7 +543,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_get_apy_borrow(self, adapter):
-        """Test get borrow APY"""
         rate_per_second = int(2e9)
 
         # Mock mtoken contract
@@ -580,14 +588,9 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_get_borrowable_amount_success(self, adapter):
-        """Test get borrowable amount"""
         mock_contract = MagicMock()
         mock_contract.functions.getAccountLiquidity = MagicMock(
-            return_value=MagicMock(
-                call=AsyncMock(
-                    return_value=(0, 10**18, 0)
-                )  # error, liquidity, shortfall
-            )
+            return_value=MagicMock(call=AsyncMock(return_value=(0, 10**18, 0)))
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
@@ -607,12 +610,9 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     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(
-            return_value=MagicMock(
-                call=AsyncMock(return_value=(0, 0, 10**16))  # has shortfall
-            )
+            return_value=MagicMock(call=AsyncMock(return_value=(0, 0, 10**16)))
         )
         mock_web3 = MagicMock()
         mock_web3.eth.contract = MagicMock(return_value=mock_contract)
@@ -631,8 +631,7 @@ class TestMoonwellAdapter:
         assert "shortfall" in result.lower()
 
     @pytest.mark.asyncio
-    async def test_wrap_eth_simulation(self, adapter):
-        """Test wrap ETH operation in simulation mode"""
+    async def test_wrap_eth(self, adapter):
         mock_contract = MagicMock()
         mock_contract.functions.deposit = MagicMock(
             return_value=MagicMock(
@@ -646,29 +645,32 @@ class TestMoonwellAdapter:
         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,
+        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,
         ):
+            mock_send.return_value = (True, mock_tx_hash)
             success, result = await adapter.wrap_eth(amount=10**18)
 
         assert success
-        assert "simulation" in result
+        assert result == mock_tx_hash
 
     def test_strategy_address_missing(self):
-        """Test error when strategy wallet is missing"""
-        adapter = MoonwellAdapter(config={}, simulation=True)
+        adapter = MoonwellAdapter(config={})
 
         with pytest.raises(ValueError, match="strategy_wallet"):
             adapter._strategy_address()
 
     def test_checksum_missing_address(self, adapter):
-        """Test error when address is missing"""
         with pytest.raises(ValueError, match="Missing required"):
             adapter._checksum(None)
 
     def test_config_override(self):
-        """Test config can override default addresses"""
         custom_comptroller = "0x1111111111111111111111111111111111111111"
         custom_well = "0x2222222222222222222222222222222222222222"
         config = {
@@ -682,7 +684,7 @@ class TestMoonwellAdapter:
             },
         }
 
-        adapter = MoonwellAdapter(config=config, simulation=True)
+        adapter = MoonwellAdapter(config=config)
 
         assert adapter.comptroller_address.lower() == custom_comptroller.lower()
         assert adapter.well_token.lower() == custom_well.lower()
@@ -690,7 +692,6 @@ class TestMoonwellAdapter:
 
     @pytest.mark.asyncio
     async def test_max_withdrawable_mtoken_zero_balance(self, adapter):
-        """Test max withdrawable when balance is zero"""
         # Mock contracts
         mock_mtoken = MagicMock()
         mock_mtoken.functions.balanceOf = MagicMock(

wayfinder_paths/adapters/pool_adapter/README.md

@@ -1,37 +1,30 @@
 # Pool Adapter
 
-A Wayfinder adapter that provides high-level operations for DeFi pool data and analytics. This adapter wraps the `PoolClient` to offer strategy-friendly methods for discovering, analyzing, and filtering yield opportunities.
+Adapter for DeFi pool data and yield analytics.
 
-## Capabilities
+- **Type**: `POOL`
+- **Module**: `wayfinder_paths.adapters.pool_adapter.adapter.PoolAdapter`
 
-- `pool.read`: Read pool information and metadata
-- `pool.analytics`: Get comprehensive pool analytics
-- `pool.discovery`: Find and search pools
-- `llama.data`: Access Llama protocol data
-- `pool.reports`: Get pool reports and analytics
+## Overview
 
-## Configuration
-
-The adapter uses the PoolClient which automatically handles authentication and API configuration through the Wayfinder settings. No additional configuration is required.
-
-The PoolClient will automatically:
-
-- Use the WAYFINDER_API_URL from settings
-- Handle authentication via config.json
-- Manage token refresh and retry logic
+The PoolAdapter provides:
+- Pool information and metadata
+- Yield analytics via DeFi Llama integration
+- Pool discovery and filtering
 
 ## Usage
 
-### Initialize the Adapter
-
 ```python
 from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
 
-# No configuration needed - uses PoolClient with automatic settings
 adapter = PoolAdapter()
 ```
 
-### Get Pools by IDs
+## Methods
+
+### get_pools_by_ids
+
+Fetch pool information by pool IDs.
 
 ```python
 success, data = await adapter.get_pools_by_ids(
@@ -39,51 +32,37 @@ success, data = await adapter.get_pools_by_ids(
 )
 if success:
     pools = data.get("pools", [])
-    print(f"Found {len(pools)} pools")
-else:
-    print(f"Error: {data}")
 ```
 
-### Get pools (all or filtered)
+### get_pools
 
-Pass at least `chain_id` when fetching all pools (e.g. `chain_id=8453` for Base):
+Fetch pools with optional filtering.
 
 ```python
-success, data = await adapter.get_pools(chain_id=8453)
+success, data = await adapter.get_pools(
+    chain_id=8453,      # Filter by chain (e.g., Base)
+    project="lido",     # Optional: filter by project
+)
 if success:
     matches = data.get("matches", [])
-    for match in matches:
-        if match.get("stablecoin"):
-            print(f"Pool {match.get('id')} - APY: {match.get('apy')}%")
-else:
-    print(f"Error: {data}")
 ```
 
-Optional: `project="lido"` to filter by project.
-
-## API Endpoints
+## Response Format
 
-The adapter uses the Wayfinder API:
+Pool data includes:
+- `id` - Pool identifier
+- `apy` - Current APY
+- `tvl` - Total value locked
+- `chain` - Chain information
+- `project` - Protocol name
+- `stablecoin` - Whether pool is stablecoin-based
 
-- `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
-
-All methods return a tuple of `(success: bool, data: Any)` where:
+## Dependencies
 
-- `success` is `True` if the operation succeeded
-- `data` contains the response data on success or error message on failure
+- `PoolClient` - Low-level API client
 
 ## Testing
 
-Run the adapter tests:
-
 ```bash
-pytest wayfinder_paths/adapters/pool_adapter/test_adapter.py -v
+poetry run pytest wayfinder_paths/adapters/pool_adapter/ -v
 ```
-
-## Dependencies
-
-- `PoolClient` - Low-level API client for pool operations
-- `BaseAdapter` - Base adapter class with common functionality

wayfinder_paths/adapters/pool_adapter/__init__.py

@@ -1,7 +1,3 @@
-"""
-Pool Adapter Package
-"""
-
 from .adapter import PoolAdapter
 
 __all__ = ["PoolAdapter"]

wayfinder_paths/adapters/pool_adapter/adapter.py

@@ -9,16 +9,6 @@ from wayfinder_paths.core.clients.PoolClient import (
 
 
 class PoolAdapter(BaseAdapter):
-    """
-    Pool adapter for DeFi pool data and analytics operations.
-
-    Provides high-level operations for:
-    - Fetching pool information and metadata
-    - Getting pool analytics and reports
-    - Accessing Llama protocol data
-    - Pool discovery and filtering
-    """
-
     adapter_type: str = "POOL"
 
     def __init__(
@@ -32,15 +22,6 @@ class PoolAdapter(BaseAdapter):
     async def get_pools_by_ids(
         self, pool_ids: list[str]
     ) -> tuple[bool, PoolList | str]:
-        """
-        Get pool information by pool IDs.
-
-        Args:
-            pool_ids: List of pool identifiers
-
-        Returns:
-            Tuple of (success, data) where data is pool information or error message
-        """
         try:
             data = await self.pool_client.get_pools_by_ids(pool_ids=pool_ids)
             return (True, data)

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -6,24 +6,19 @@ from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
 
 
 class TestPoolAdapter:
-    """Test cases for PoolAdapter"""
-
     @pytest.fixture
     def mock_pool_client(self):
-        """Mock PoolClient for testing"""
         mock_client = AsyncMock()
         return mock_client
 
     @pytest.fixture
     def adapter(self, mock_pool_client):
-        """Create a PoolAdapter instance with mocked client for testing"""
         adapter = PoolAdapter()
         adapter.pool_client = mock_pool_client
         return adapter
 
     @pytest.mark.asyncio
     async def test_get_pools_by_ids_success(self, adapter, mock_pool_client):
-        """Test successful pool retrieval by IDs"""
         mock_response = {
             "pools": [
                 {
@@ -49,7 +44,6 @@ class TestPoolAdapter:
 
     @pytest.mark.asyncio
     async def test_get_pools_success(self, adapter, mock_pool_client):
-        """Test successful Llama matches retrieval"""
         # Mock response
         mock_response = {
             "matches": [
@@ -71,7 +65,6 @@ class TestPoolAdapter:
 
     @pytest.mark.asyncio
     async def test_get_pools_by_ids_failure(self, adapter, mock_pool_client):
-        """Test pool retrieval failure"""
         mock_pool_client.get_pools_by_ids = AsyncMock(
             side_effect=Exception("API Error")
         )
@@ -82,5 +75,4 @@ class TestPoolAdapter:
         assert "API Error" in data
 
     def test_adapter_type(self, adapter):
-        """Test adapter has adapter_type"""
         assert adapter.adapter_type == "POOL"