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

wayfinder_paths/adapters/boros_adapter/utils.py

@@ -0,0 +1,85 @@
+"""Boros-specific utilities (tick math, parsing helpers, conversions)."""
+
+from __future__ import annotations
+
+import math
+from decimal import Decimal
+from typing import Any
+
+BOROS_TICK_BASE = 1.0001
+
+
+def tick_from_rate(
+    rate: float, tick_step: int, *, round_down: bool, base: float = BOROS_TICK_BASE
+) -> int:
+    """Convert APR rate to Boros limitTick."""
+    if tick_step <= 0:
+        tick_step = 1
+    ln_base = math.log(base)
+    if rate >= 0:
+        if rate == 0:
+            return 0
+        raw = math.log1p(rate) / (tick_step * ln_base)
+        return int(math.floor(raw) if round_down else math.ceil(raw))
+    # Negative rate
+    raw = math.log1p(-rate) / (tick_step * ln_base)
+    return -int(math.floor(raw) if round_down else math.ceil(raw))
+
+
+def rate_from_tick(tick: int, tick_step: int, base: float = BOROS_TICK_BASE) -> float:
+    """Convert Boros limitTick to APR rate."""
+    if tick_step <= 0:
+        tick_step = 1
+    p = base ** (abs(int(tick)) * int(tick_step))
+    r = p - 1
+    return r if tick >= 0 else -r
+
+
+def normalize_apr(value: Any) -> float | None:
+    """Normalize various APR encodings to decimal.
+
+    Handles: decimal (0.1115), percent (11.15), bps (1115), 1e18-scaled.
+    """
+    if value is None:
+        return None
+    try:
+        x = float(value)
+    except (TypeError, ValueError):
+        return None
+
+    if x == 0:
+        return None
+    # 1e18-scaled decimal
+    if x > 1e9:
+        return x / 1e18
+    # bps (1115 = 11.15%)
+    if x > 1000:
+        return x / 10_000.0
+    # percent (11.15 = 11.15%)
+    if x > 1:
+        return x / 100.0
+    # already decimal
+    return x
+
+
+def cash_wei_to_float(value_wei: Any) -> float:
+    """Convert Boros cash units (1e18) to float."""
+    if value_wei is None:
+        return 0.0
+    try:
+        return float(Decimal(str(value_wei)) / Decimal(1e18))
+    except Exception:
+        return 0.0
+
+
+def market_id_from_market_acc(market_acc: str) -> int | None:
+    """Parse a Boros `marketAcc` into a market_id (last 3 bytes)."""
+    if not market_acc or len(market_acc) < 8:
+        return None
+    try:
+        market_id = int(market_acc[-6:], 16)
+    except ValueError:
+        return None
+    if market_id == 0xFFFFFF:
+        return None
+    return market_id

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -61,7 +61,7 @@ class BRAPAdapter(BaseAdapter):
         owner_checksum = Web3.to_checksum_address(owner_address)
         spender_checksum = Web3.to_checksum_address(spender_address)
 
-        if (chain_id, token_checksum.lower()) in TOKENS_REQUIRING_APPROVAL_RESET:
+        if (chain_id, token_checksum) in TOKENS_REQUIRING_APPROVAL_RESET:
             allowance = await get_token_allowance(
                 token_checksum,
                 chain_id,

wayfinder_paths/adapters/brap_adapter/manifest.yaml

@@ -0,0 +1,9 @@
+schema_version: "0.1"
+entrypoint: "adapters.brap_adapter.adapter.BRAPAdapter"
+capabilities:
+  - "swap.quote"
+  - "swap.execute"
+  - "swap.compare_routes"
+  - "bridge.quote"
+  - "gas.estimate"
+dependencies: []

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Literal
 
 from eth_utils import to_checksum_address
 
+from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
+from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.adapters.models import LEND, UNLEND
 from wayfinder_paths.core.clients.HyperlendClient import (
     AssetsView,
     HyperlendClient,
@@ -36,28 +39,19 @@ class HyperlendAdapter(BaseAdapter):
     ) -> None:
         super().__init__("hyperlend_adapter", config)
         config = config or {}
-        adapter_cfg = config.get("hyperlend_adapter") or {}
 
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.hyperlend_client = HyperlendClient()
 
+        self.ledger_adapter = LedgerAdapter()
+        self.token_adapter = TokenAdapter()
         strategy_wallet = config.get("strategy_wallet") or {}
         strategy_addr = strategy_wallet.get("address")
-        if not strategy_addr:
-            raise ValueError("strategy_wallet.address is required")
+
         self.strategy_wallet_address = to_checksum_address(strategy_addr)
-        self.pool_address = to_checksum_address(
-            adapter_cfg.get("pool_address") or HYPERLEND_POOL
-        )
-        self.gateway_address = to_checksum_address(
-            adapter_cfg.get("wrapped_token_gateway") or HYPERLEND_WRAPPED_TOKEN_GATEWAY
-        )
-        self.wrapped_native = to_checksum_address(
-            adapter_cfg.get("wrapped_native_underlying") or HYPEREVM_WHYPE
-        )
-        self.gateway_deposit_takes_pool = adapter_cfg.get(
-            "gateway_deposit_takes_pool", True
-        )
+        self.pool_address = HYPERLEND_POOL
+        self.gateway_address = HYPERLEND_WRAPPED_TOKEN_GATEWAY
+        self.wrapped_native = HYPEREVM_WHYPE
 
     async def get_stable_markets(
         self,
@@ -89,6 +83,46 @@ class HyperlendAdapter(BaseAdapter):
         except Exception as exc:
             return False, str(exc)
 
+    async def get_full_user_state(
+        self,
+        *,
+        account: str,
+        include_zero_positions: bool = False,
+    ) -> tuple[bool, dict[str, Any] | str]:
+        """
+        Full Hyperlend user state.
+
+        Backed by the Wayfinder API `hyperlend/assets/` response which already includes
+        per-asset supply/borrow balances and account health factor.
+        """
+        ok, view = await self.get_assets_view(user_address=account)
+        if not ok:
+            return False, str(view)
+
+        assets = view.get("assets", []) if isinstance(view, dict) else []
+        if include_zero_positions:
+            positions = assets
+        else:
+            positions = [
+                a
+                for a in assets
+                if float(a.get("supply", 0) or 0) > 0
+                or float(a.get("variable_borrow", 0) or 0) > 0
+            ]
+
+        return (
+            True,
+            {
+                "protocol": "hyperlend",
+                "account": account,
+                "positions": positions,
+                "accountData": view.get("account_data")
+                if isinstance(view, dict)
+                else {},
+                "assetsView": view,
+            },
+        )
+
     async def get_market_entry(
         self,
         *,
@@ -124,6 +158,7 @@ class HyperlendAdapter(BaseAdapter):
         qty: int,
         chain_id: int,
         native: bool = False,
+        strategy_name: str | None = None,
     ) -> tuple[bool, Any]:
         strategy = self.strategy_wallet_address
         qty = int(qty)
@@ -132,11 +167,12 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
-            transcation = await self._encode_call(
+            token_addr = self.wrapped_native
+            transaction = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="depositETH",
-                args=[self._gateway_first_arg(underlying_token), strategy, 0],
+                args=[self.pool_address, strategy, 0],
                 from_address=strategy,
                 chain_id=chain_id,
                 value=qty,
@@ -153,7 +189,7 @@ class HyperlendAdapter(BaseAdapter):
             )
             if not approved[0]:
                 return approved
-            transcation = await self._encode_call(
+            transaction = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="supply",
@@ -161,10 +197,22 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
+
         txn_hash = await send_transaction(
-            transcation, self.strategy_wallet_signing_callback
+            transaction, self.strategy_wallet_signing_callback
         )
-        return True, txn_hash
+
+        await self._record_pool_op(
+            token_address=token_addr,
+            amount=qty,
+            chain_id=chain_id,
+            wallet_address=strategy,
+            txn_hash=txn_hash,
+            strategy_name=strategy_name,
+            op_type="lend",
+        )
+
+        return (True, txn_hash)
 
     async def unlend(
         self,
@@ -173,6 +221,7 @@ class HyperlendAdapter(BaseAdapter):
         qty: int,
         chain_id: int,
         native: bool = False,
+        strategy_name: str | None = None,
     ) -> tuple[bool, Any]:
         strategy = self.strategy_wallet_address
         qty = int(qty)
@@ -181,11 +230,12 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
+            token_addr = self.wrapped_native
             transaction = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="withdrawETH",
-                args=[self._gateway_first_arg(underlying_token), qty, strategy],
+                args=[self.pool_address, qty, strategy],
                 from_address=strategy,
                 chain_id=chain_id,
             )
@@ -199,9 +249,20 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
+
         txn_hash = await send_transaction(
             transaction, self.strategy_wallet_signing_callback
         )
+        await self._record_pool_op(
+            token_address=token_addr,
+            amount=qty,
+            chain_id=chain_id,
+            wallet_address=strategy,
+            txn_hash=txn_hash,
+            strategy_name=strategy_name,
+            op_type="unlend",
+        )
+
         return True, txn_hash
 
     async def _encode_call(
@@ -235,7 +296,81 @@ class HyperlendAdapter(BaseAdapter):
             }
             return transaction
 
-    def _gateway_first_arg(self, underlying_token: str) -> str:
-        if self.gateway_deposit_takes_pool:
-            return self.pool_address
-        return to_checksum_address(underlying_token)
+    async def _record_pool_op(
+        self,
+        token_address: str,
+        amount: int,
+        chain_id: int,
+        wallet_address: str,
+        txn_hash: str,
+        op_type: Literal["lend", "unlend"],
+        strategy_name: str | None = None,
+    ):
+        amount_usd = await self._calculate_amount_usd(
+            token_address=token_address,
+            amount=amount,
+            chain_id=chain_id,
+        )
+
+        model = {"lend": LEND, "unlend": UNLEND}[op_type]
+
+        operation_data = model(
+            adapter=self.adapter_type,
+            token_address=token_address,
+            pool_address=self.pool_address,
+            amount=str(amount),
+            amount_usd=amount_usd or 0,
+            transaction_hash=txn_hash,
+            transaction_chain_id=chain_id,
+        )
+
+        success, ledger_response = await self.ledger_adapter.record_operation(
+            wallet_address=wallet_address,
+            operation_data=operation_data,
+            usd_value=amount_usd or 0,
+            strategy_name=strategy_name,
+        )
+        if not success:
+            self.logger.warning("Ledger record failed", error=ledger_response)
+
+    async def _calculate_amount_usd(
+        self,
+        token_address: str,
+        amount: int,
+        chain_id: int,
+    ) -> float | None:
+        # Get token details with market data using the address as query
+        success, token_data = await self.token_adapter.get_token(
+            query=token_address,
+            chain_id=chain_id,
+        )
+        if not success or not token_data:
+            self.logger.warning(
+                f"Could not get token info for {token_address} on chain {chain_id}"
+            )
+            return None
+
+        # Get price data
+        decimals, current_price = (
+            token_data["decimals"],
+            token_data["current_price"],
+        )
+        return current_price * float(amount) / 10 ** int(decimals)
+
+    async def _ensure_allowance(
+        self,
+        *,
+        token_address: str,
+        owner: str,
+        spender: str,
+        amount: int,
+        chain_id: int,
+    ) -> tuple[bool, Any]:
+        return await ensure_allowance(
+            token_address=token_address,
+            owner=owner,
+            spender=spender,
+            amount=amount,
+            chain_id=chain_id,
+            signing_callback=self.strategy_wallet_signing_callback,
+        )

wayfinder_paths/adapters/hyperlend_adapter/manifest.yaml

@@ -0,0 +1,9 @@
+schema_version: "0.1"
+entrypoint: "adapters.hyperlend_adapter.adapter.HyperlendAdapter"
+capabilities:
+  - "market.stable_markets"
+  - "market.assets_view"
+  - "market.rate_history"
+  - "lending.lend"
+  - "lending.unlend"
+dependencies: []

wayfinder_paths/adapters/hyperlend_adapter/test_adapter.py

@@ -151,19 +151,6 @@ class TestHyperlendAdapter:
     def test_adapter_type(self, adapter):
         assert adapter.adapter_type == "HYPERLEND"
 
-    @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") == "HYPERLEND"
-
-    @pytest.mark.asyncio
-    async def test_connect(self, adapter):
-        ok = await adapter.connect()
-        assert isinstance(ok, bool)
-        assert ok is True
-
     @pytest.mark.asyncio
     async def test_get_stable_markets_with_is_stable_symbol(
         self, adapter, mock_hyperlend_client
@@ -271,6 +258,83 @@ class TestHyperlendAdapter:
         assert success is False
         assert "API Error: Invalid address" in data
 
+    @pytest.mark.asyncio
+    async def test_get_full_user_state_filters_zero_positions(
+        self, adapter, mock_hyperlend_client
+    ):
+        mock_response = {
+            "block_number": 12345,
+            "user": "0xabc",
+            "native_balance_wei": 0,
+            "native_balance": 0.0,
+            "assets": [
+                {
+                    "underlying": "0x1",
+                    "symbol": "USDC",
+                    "symbol_canonical": "usdc",
+                    "symbol_display": "USDC",
+                    "decimals": 6,
+                    "a_token": "0xa",
+                    "variable_debt_token": "0xd",
+                    "usage_as_collateral_enabled": True,
+                    "borrowing_enabled": True,
+                    "is_active": True,
+                    "is_frozen": False,
+                    "is_paused": False,
+                    "is_siloed_borrowing": False,
+                    "is_stablecoin": True,
+                    "underlying_wallet_balance": 0.0,
+                    "underlying_wallet_balance_wei": 0,
+                    "price_usd": 1.0,
+                    "supply": 0.0,
+                    "variable_borrow": 0.0,
+                    "supply_usd": 0.0,
+                    "variable_borrow_usd": 0.0,
+                    "supply_apr": 0.0,
+                    "supply_apy": 0.0,
+                    "variable_borrow_apr": 0.0,
+                    "variable_borrow_apy": 0.0,
+                },
+                {
+                    "underlying": "0x2",
+                    "symbol": "USDT",
+                    "symbol_canonical": "usdt",
+                    "symbol_display": "USDT",
+                    "decimals": 6,
+                    "a_token": "0xa2",
+                    "variable_debt_token": "0xd2",
+                    "usage_as_collateral_enabled": True,
+                    "borrowing_enabled": True,
+                    "is_active": True,
+                    "is_frozen": False,
+                    "is_paused": False,
+                    "is_siloed_borrowing": False,
+                    "is_stablecoin": True,
+                    "underlying_wallet_balance": 0.0,
+                    "underlying_wallet_balance_wei": 0,
+                    "price_usd": 1.0,
+                    "supply": 123.0,
+                    "variable_borrow": 0.0,
+                    "supply_usd": 123.0,
+                    "variable_borrow_usd": 0.0,
+                    "supply_apr": 0.05,
+                    "supply_apy": 0.05,
+                    "variable_borrow_apr": 0.07,
+                    "variable_borrow_apy": 0.07,
+                },
+            ],
+            "account_data": {"health_factor": 2.0},
+            "base_currency_info": {},
+        }
+        mock_hyperlend_client.get_assets_view = AsyncMock(return_value=mock_response)
+
+        ok, state = await adapter.get_full_user_state(account="0xabc")
+        assert ok is True
+        assert state["protocol"] == "hyperlend"
+        assert state["account"] == "0xabc"
+        assert len(state["positions"]) == 1
+        assert state["positions"][0]["symbol"] == "USDT"
+
     @pytest.mark.asyncio
     async def test_get_assets_view_empty_response(self, adapter, mock_hyperlend_client):
         mock_response = {

wayfinder_paths/adapters/hyperliquid_adapter/__init__.py

@@ -1,18 +1,11 @@
-from .adapter import (
-    ARBITRUM_USDC_ADDRESS,
-    HYPERLIQUID_BRIDGE_ADDRESS,
-    HyperliquidAdapter,
-)
-from .executor import HyperliquidExecutor, LocalHyperliquidExecutor
+from .adapter import HyperliquidAdapter
+from .executor import LocalHyperliquidExecutor
 from .paired_filler import FillConfig, FillConfirmCfg, PairedFiller
 
 __all__ = [
     "HyperliquidAdapter",
-    "HyperliquidExecutor",
     "LocalHyperliquidExecutor",
     "PairedFiller",
     "FillConfig",
     "FillConfirmCfg",
-    "HYPERLIQUID_BRIDGE_ADDRESS",
-    "ARBITRUM_USDC_ADDRESS",
 ]