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

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -15,7 +15,7 @@ from wayfinder_paths.core.clients.BRAPClient import (
 from wayfinder_paths.core.clients.LedgerClient import TransactionRecord
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.constants import DEFAULT_SLIPPAGE, ZERO_ADDRESS
-from wayfinder_paths.core.utils.erc20_service import (
+from wayfinder_paths.core.utils.tokens import (
     build_approve_transaction,
     get_token_allowance,
 )
@@ -29,26 +29,14 @@ _NEEDS_CLEAR_APPROVAL = {
 
 
 class BRAPAdapter(BaseAdapter):
-    """
-    BRAP (Bridge/Router/Adapter Protocol) adapter for cross-chain swaps and quotes.
-
-    Provides high-level operations for:
-    - Getting swap quotes across chains
-    - Executing cross-chain transactions
-    - Route optimization and fee calculation
-    - Bridge operations
-    """
-
     adapter_type: str = "BRAP"
 
     def __init__(
         self,
         config: dict[str, Any] | None = None,
-        simulation: bool = False,
         strategy_wallet_signing_callback=None,
     ):
         super().__init__("brap_adapter", config)
-        self.simulation = simulation
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.brap_client = BRAPClient()
         self.token_client = TokenClient()
@@ -67,23 +55,6 @@ class BRAPAdapter(BaseAdapter):
         slippage: float | None = None,
         wayfinder_fee: float | None = None,
     ) -> tuple[bool, BRAPQuoteResponse | str]:
-        """
-        Get a quote for a cross-chain swap operation.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            from_address: Source wallet address
-            to_address: Destination wallet address
-            amount: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-            wayfinder_fee: Wayfinder fee (optional)
-
-        Returns:
-            Tuple of (success, data) where data is quote response or error message
-        """
         try:
             data = await self.brap_client.get_quote(
                 from_token=from_token_address,
@@ -111,25 +82,6 @@ class BRAPAdapter(BaseAdapter):
         wayfinder_fee: float | None = None,
         preferred_providers: list[str] | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
-        """
-        Get the best available quote for a swap operation.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            from_address: Source wallet address
-            to_address: Destination wallet address
-            amount: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-            wayfinder_fee: Wayfinder fee (optional)
-            preferred_providers: List of provider names in order of preference (optional).
-                                 If provided, selects first matching provider instead of "best".
-
-        Returns:
-            Tuple of (success, data) where data is best quote or error message
-        """
         try:
             data = await self.brap_client.get_quote(
                 from_token=from_token_address,
@@ -177,20 +129,9 @@ class BRAPAdapter(BaseAdapter):
         quotes: list[dict[str, Any]],
         preferred_providers: list[str],
     ) -> dict[str, Any] | None:
-        """
-        Select a quote from the list based on provider preference order.
-
-        Args:
-            quotes: List of quote objects from BRAP API
-            preferred_providers: List of provider names in order of preference (case-insensitive)
-
-        Returns:
-            The first matching quote, or None if no preferred provider found
-        """
         # Normalize preferred providers to lowercase for case-insensitive matching
         preferred_lower = [p.lower() for p in preferred_providers]
 
-        # Build a map of provider name -> quotes
         provider_quotes: dict[str, list[dict[str, Any]]] = {}
         for quote in quotes:
             # Provider name might be in different fields depending on BRAP response structure
@@ -209,7 +150,6 @@ class BRAPAdapter(BaseAdapter):
         # Select first matching provider in preference order
         for pref in preferred_lower:
             if pref in provider_quotes:
-                # Return the quote with highest output for this provider
                 provider_list = provider_quotes[pref]
                 best_for_provider = max(
                     provider_list, key=lambda q: int(q.get("output_amount", 0) or 0)
@@ -233,22 +173,7 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float | None = None,
     ) -> tuple[bool, Any]:
-        """
-        Calculate fees for a swap operation.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            amount: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-
-        Returns:
-            Tuple of (success, data) where data is fee breakdown or error message
-        """
         try:
-            # Get quote to extract fee information
             success, quote_data = await self.get_swap_quote(
                 from_token_address=from_token_address,
                 to_token_address=to_token_address,
@@ -268,7 +193,6 @@ class BRAPAdapter(BaseAdapter):
             if not best_quote:
                 return (False, "No quote available for fee calculation")
 
-            # Extract fee information
             fee_estimate = best_quote.get("fee_estimate", {})
             fees = {
                 "input_amount": best_quote.get("input_amount", 0),
@@ -295,20 +219,6 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float | None = None,
     ) -> tuple[bool, Any]:
-        """
-        Compare multiple routes for a swap operation.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            amount: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-
-        Returns:
-            Tuple of (success, data) where data is route comparison or error message
-        """
         try:
             data = await self.brap_client.get_quote(
                 from_token=from_token_address,
@@ -379,19 +289,6 @@ class BRAPAdapter(BaseAdapter):
         strategy_name: str | None = None,
         preferred_providers: list[str] | None = None,
     ) -> tuple[bool, Any]:
-        """
-        Execute a swap by looking up token metadata via token IDs.
-
-        Args:
-            from_token_id: Source token ID
-            to_token_id: Destination token ID
-            from_address: Wallet address
-            amount: Amount to swap (in smallest units)
-            slippage: Maximum slippage tolerance
-            strategy_name: Strategy name for ledger recording
-            preferred_providers: List of provider names in order of preference (e.g., ["enso", "aerodrome"]).
-                                 If provided, selects first matching provider instead of "best".
-        """
         from_token = await self.token_client.get_token_details(from_token_id)
         if not from_token:
             return (False, f"From token not found: {from_token_id}")
@@ -429,9 +326,6 @@ class BRAPAdapter(BaseAdapter):
         quote: dict[str, Any],
         strategy_name: str | None = None,
     ) -> tuple[bool, Any]:
-        """
-        Execute a swap using a previously retrieved BRAP quote.
-        """
         chain = from_token.get("chain") or {}
         chain_id = self._chain_id(chain)
 
@@ -556,20 +450,6 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float | None = None,
     ) -> tuple[bool, Any]:
-        """
-        Get a quote for a bridge operation (same as swap for BRAP).
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            amount: Amount to bridge (in smallest units)
-            slippage: Maximum slippage tolerance (optional)
-
-        Returns:
-            Tuple of (success, data) where data is bridge quote or error message
-        """
         # For BRAP, bridge operations are the same as swap operations
         return await self.get_swap_quote(
             from_token_address=from_token_address,
@@ -585,17 +465,6 @@ class BRAPAdapter(BaseAdapter):
     async def estimate_gas_cost(
         self, from_chain_id: int, to_chain_id: int, operation_type: str = "swap"
     ) -> tuple[bool, Any]:
-        """
-        Estimate gas costs for a cross-chain operation.
-
-        Args:
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            operation_type: Type of operation ("swap", "bridge")
-
-        Returns:
-            Tuple of (success, data) where data is gas cost estimate or error message
-        """
         try:
             # This is a simplified estimation - in practice, you'd want to
             # query actual gas prices from the chains
@@ -643,19 +512,6 @@ class BRAPAdapter(BaseAdapter):
         to_chain_id: int,
         amount: str,
     ) -> tuple[bool, Any]:
-        """
-        Validate swap parameters before executing.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            amount: Amount to swap (in smallest units)
-
-        Returns:
-            Tuple of (success, data) where data is validation result or error message
-        """
         try:
             validation_errors = []
 
@@ -752,9 +608,6 @@ class BRAPAdapter(BaseAdapter):
         return await self._send_tx(approve_tx)
 
     async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        """Send transaction with simulation check."""
-        if self.simulation:
-            return True, {"simulation": tx}
         txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
         return True, txn_hash
 

wayfinder_paths/adapters/brap_adapter/test_adapter.py

@@ -6,24 +6,19 @@ from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 
 
 class TestBRAPAdapter:
-    """Test cases for BRAPAdapter"""
-
     @pytest.fixture
     def mock_brap_client(self):
-        """Mock BRAPClient for testing"""
         mock_client = AsyncMock()
         return mock_client
 
     @pytest.fixture
     def adapter(self, mock_brap_client):
-        """Create a BRAPAdapter instance with mocked client for testing"""
         adapter = BRAPAdapter()
         adapter.brap_client = mock_brap_client
         return adapter
 
     @pytest.mark.asyncio
     async def test_get_swap_quote_success(self, adapter, mock_brap_client):
-        """Test successful swap quote retrieval"""
         mock_response = {
             "quotes": [
                 {
@@ -80,7 +75,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_get_best_quote_success(self, adapter, mock_brap_client):
-        """Test successful best quote retrieval"""
         mock_response = {
             "quotes": [],
             "best_quote": {
@@ -115,7 +109,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_get_best_quote_no_quotes(self, adapter, mock_brap_client):
-        """Test best quote retrieval when no quotes available"""
         mock_response = {"quotes": [], "best_quote": None}
         mock_brap_client.get_quote = AsyncMock(return_value=mock_response)
 
@@ -134,7 +127,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_calculate_swap_fees_success(self, adapter, mock_brap_client):
-        """Test successful swap fee calculation"""
         mock_quote_response = {
             "quotes": [],
             "best_quote": {
@@ -175,7 +167,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_compare_routes_success(self, adapter, mock_brap_client):
-        """Test successful route comparison"""
         mock_response = {
             "quotes": [
                 {
@@ -233,7 +224,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_estimate_gas_cost_success(self, adapter):
-        """Test successful gas cost estimation"""
         success, data = await adapter.estimate_gas_cost(
             from_chain_id=8453, to_chain_id=1, operation_type="swap"
         )
@@ -247,7 +237,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_validate_swap_parameters_success(self, adapter, mock_brap_client):
-        """Test successful swap parameter validation"""
         mock_quote_response = {
             "quotes": [],
             "best_quote": {
@@ -279,7 +268,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_validate_swap_parameters_invalid_address(self, adapter):
-        """Test swap parameter validation with invalid address"""
         success, data = await adapter.validate_swap_parameters(
             from_token_address="invalid_address",
             to_token_address="0xB1c97a44F7552d9Dd5e5e5e5e5e5e5e5e5e5e5e5e5e",
@@ -294,7 +282,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_validate_swap_parameters_invalid_amount(self, adapter):
-        """Test swap parameter validation with invalid amount"""
         success, data = await adapter.validate_swap_parameters(
             from_token_address="0x" + "a" * 40,
             to_token_address="0x" + "b" * 40,
@@ -309,7 +296,6 @@ class TestBRAPAdapter:
 
     @pytest.mark.asyncio
     async def test_get_swap_quote_failure(self, adapter, mock_brap_client):
-        """Test swap quote retrieval failure"""
         mock_brap_client.get_quote = AsyncMock(side_effect=Exception("API Error"))
 
         success, data = await adapter.get_swap_quote(
@@ -326,5 +312,4 @@ class TestBRAPAdapter:
         assert "API Error" in data
 
     def test_adapter_type(self, adapter):
-        """Test adapter has adapter_type"""
         assert adapter.adapter_type == "BRAP"

wayfinder_paths/adapters/hyperlend_adapter/__init__.py

@@ -1,7 +1,3 @@
-"""
-Hyperlend Adapter
-"""
-
 from wayfinder_paths.adapters.hyperlend_adapter.adapter import HyperlendAdapter
 
 __all__ = ["HyperlendAdapter"]

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -16,7 +16,7 @@ from wayfinder_paths.core.constants.hyperlend_abi import (
     POOL_ABI,
     WRAPPED_TOKEN_GATEWAY_ABI,
 )
-from wayfinder_paths.core.utils.erc20_service import (
+from wayfinder_paths.core.utils.tokens import (
     build_approve_transaction,
     get_token_allowance,
 )
@@ -31,21 +31,17 @@ HYPERLEND_DEFAULTS = {
 
 
 class HyperlendAdapter(BaseAdapter):
-    """Thin HyperLend adapter that only builds tx data and lets the provider send it."""
-
     adapter_type = "HYPERLEND"
 
     def __init__(
         self,
         config: dict[str, Any],
-        simulation: bool = False,
         strategy_wallet_signing_callback=None,
     ) -> None:
         super().__init__("hyperlend_adapter", config)
         cfg = config or {}
         adapter_cfg = cfg.get("hyperlend_adapter") or {}
 
-        self.simulation = simulation
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.hyperlend_client = HyperlendClient()
 
@@ -212,9 +208,6 @@ class HyperlendAdapter(BaseAdapter):
     # ------------------------------------------------------------------ #
 
     async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        """Send transaction with simulation check."""
-        if self.simulation:
-            return True, {"simulation": tx}
         txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
         return True, txn_hash
 
@@ -250,8 +243,6 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         value: int = 0,
     ) -> dict[str, Any]:
-        """Encode calldata without touching network."""
-
         async with web3_from_chain_id(chain_id) as web3:
             contract = web3.eth.contract(address=target, abi=abi)
             try:

wayfinder_paths/adapters/hyperlend_adapter/test_adapter.py

@@ -6,17 +6,13 @@ from wayfinder_paths.adapters.hyperlend_adapter.adapter import HyperlendAdapter
 
 
 class TestHyperlendAdapter:
-    """Test cases for HyperlendAdapter"""
-
     @pytest.fixture
     def mock_hyperlend_client(self):
-        """Mock HyperlendClient for testing"""
         mock_client = AsyncMock()
         return mock_client
 
     @pytest.fixture
     def adapter(self, mock_hyperlend_client):
-        """Create a HyperlendAdapter instance with mocked client for testing"""
         adapter = HyperlendAdapter(
             config={},
         )
@@ -25,7 +21,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_stable_markets_success(self, adapter, mock_hyperlend_client):
-        """Test successful stable markets retrieval"""
         mock_response = {
             "markets": {
                 "0x1234...": {
@@ -69,7 +64,6 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_minimal_params(
         self, adapter, mock_hyperlend_client
     ):
-        """Test stable markets retrieval with only required chain_id"""
         mock_response = {
             "markets": {
                 "0x1234...": {
@@ -100,7 +94,6 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_partial_params(
         self, adapter, mock_hyperlend_client
     ):
-        """Test stable markets retrieval with partial optional parameters"""
         mock_response = {"markets": {}, "notes": []}
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
@@ -118,7 +111,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_stable_markets_failure(self, adapter, mock_hyperlend_client):
-        """Test stable markets retrieval failure"""
         mock_hyperlend_client.get_stable_markets = AsyncMock(
             side_effect=Exception("API Error: Connection timeout")
         )
@@ -130,7 +122,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_stable_markets_http_error(self, adapter, mock_hyperlend_client):
-        """Test stable markets retrieval with HTTP error"""
         mock_hyperlend_client.get_stable_markets = AsyncMock(
             side_effect=Exception("HTTP 404 Not Found")
         )
@@ -144,7 +135,6 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_empty_response(
         self, adapter, mock_hyperlend_client
     ):
-        """Test stable markets retrieval with empty response"""
         mock_response = {"markets": {}, "notes": []}
         mock_hyperlend_client.get_stable_markets = AsyncMock(return_value=mock_response)
 
@@ -155,12 +145,10 @@ class TestHyperlendAdapter:
         assert len(data.get("markets", {})) == 0
 
     def test_adapter_type(self, adapter):
-        """Test adapter has adapter_type"""
         assert adapter.adapter_type == "HYPERLEND"
 
     @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"}
@@ -168,7 +156,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_connect(self, adapter):
-        """Test adapter connection"""
         ok = await adapter.connect()
         assert isinstance(ok, bool)
         assert ok is True
@@ -177,7 +164,6 @@ class TestHyperlendAdapter:
     async def test_get_stable_markets_with_is_stable_symbol(
         self, adapter, mock_hyperlend_client
     ):
-        """Test stable markets retrieval with is_stable_symbol parameter (ignored by API)"""
         mock_response = {
             "markets": {
                 "0x1234...": {
@@ -206,7 +192,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_assets_view_success(self, adapter, mock_hyperlend_client):
-        """Test successful assets view retrieval"""
         mock_response = {
             "block_number": 12345,
             "user": "0x0c737cB5934afCb5B01965141F865F795B324080",
@@ -271,7 +256,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_assets_view_failure(self, adapter, mock_hyperlend_client):
-        """Test assets view retrieval failure"""
         mock_hyperlend_client.get_assets_view = AsyncMock(
             side_effect=Exception("API Error: Invalid address")
         )
@@ -285,7 +269,6 @@ class TestHyperlendAdapter:
 
     @pytest.mark.asyncio
     async def test_get_assets_view_empty_response(self, adapter, mock_hyperlend_client):
-        """Test assets view retrieval with empty response"""
         mock_response = {
             "block_number": 12345,
             "user": "0x0c737cB5934afCb5B01965141F865F795B324080",