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

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,
@@ -12,23 +15,19 @@ from wayfinder_paths.core.clients.HyperlendClient import (
     MarketEntry,
     StableMarketsHeadroomResponse,
 )
+from wayfinder_paths.core.constants.contracts import (
+    HYPEREVM_WHYPE,
+    HYPERLEND_POOL,
+    HYPERLEND_WRAPPED_TOKEN_GATEWAY,
+)
 from wayfinder_paths.core.constants.hyperlend_abi import (
     POOL_ABI,
     WRAPPED_TOKEN_GATEWAY_ABI,
 )
-from wayfinder_paths.core.utils.tokens import (
-    build_approve_transaction,
-    get_token_allowance,
-)
+from wayfinder_paths.core.utils.tokens import ensure_allowance
 from wayfinder_paths.core.utils.transaction import send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
-HYPERLEND_DEFAULTS = {
-    "pool": "0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b",
-    "wrapped_token_gateway": "0x49558c794ea2aC8974C9F27886DDfAa951E99171",
-    "wrapped_native_underlying": "0x5555555555555555555555555555555555555555",
-}
-
 
 class HyperlendAdapter(BaseAdapter):
     adapter_type = "HYPERLEND"
@@ -39,31 +38,20 @@ class HyperlendAdapter(BaseAdapter):
         strategy_wallet_signing_callback=None,
     ) -> None:
         super().__init__("hyperlend_adapter", config)
-        cfg = config or {}
-        adapter_cfg = cfg.get("hyperlend_adapter") or {}
+        config = config or {}
 
         self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.hyperlend_client = HyperlendClient()
 
-        self.strategy_wallet = cfg.get("strategy_wallet") or {}
-        self.pool_address = self._checksum(
-            adapter_cfg.get("pool_address") or HYPERLEND_DEFAULTS["pool"]
-        )
-        self.gateway_address = self._checksum(
-            adapter_cfg.get("wrapped_token_gateway")
-            or HYPERLEND_DEFAULTS["wrapped_token_gateway"]
-        )
-        self.wrapped_native = self._checksum(
-            adapter_cfg.get("wrapped_native_underlying")
-            or HYPERLEND_DEFAULTS["wrapped_native_underlying"]
-        )
-        self.gateway_deposit_takes_pool = adapter_cfg.get(
-            "gateway_deposit_takes_pool", True
-        )
+        self.ledger_adapter = LedgerAdapter()
+        self.token_adapter = TokenAdapter()
+        strategy_wallet = config.get("strategy_wallet") or {}
+        strategy_addr = strategy_wallet.get("address")
 
-    # ------------------------------------------------------------------ #
-    # Public API                                                         #
-    # ------------------------------------------------------------------ #
+        self.strategy_wallet_address = to_checksum_address(strategy_addr)
+        self.pool_address = HYPERLEND_POOL
+        self.gateway_address = HYPERLEND_WRAPPED_TOKEN_GATEWAY
+        self.wrapped_native = HYPEREVM_WHYPE
 
     async def get_stable_markets(
         self,
@@ -95,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,
         *,
@@ -130,35 +158,38 @@ class HyperlendAdapter(BaseAdapter):
         qty: int,
         chain_id: int,
         native: bool = False,
+        strategy_name: str | None = None,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         qty = int(qty)
         if qty <= 0:
             return False, "qty must be positive"
         chain_id = int(chain_id)
 
         if native:
-            tx = 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,
             )
         else:
-            token_addr = self._checksum(underlying_token)
-            approved = await self._ensure_allowance(
+            token_addr = to_checksum_address(underlying_token)
+            approved = await ensure_allowance(
                 token_address=token_addr,
                 owner=strategy,
                 spender=self.pool_address,
                 amount=qty,
                 chain_id=chain_id,
+                signing_callback=self.strategy_wallet_signing_callback,
             )
             if not approved[0]:
                 return approved
-            tx = await self._encode_call(
+            transaction = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="supply",
@@ -166,7 +197,22 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
-        return await self._send_tx(tx)
+
+        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="lend",
+        )
+
+        return (True, txn_hash)
 
     async def unlend(
         self,
@@ -175,25 +221,27 @@ class HyperlendAdapter(BaseAdapter):
         qty: int,
         chain_id: int,
         native: bool = False,
+        strategy_name: str | None = None,
     ) -> tuple[bool, Any]:
-        strategy = self._strategy_address()
+        strategy = self.strategy_wallet_address
         qty = int(qty)
         if qty <= 0:
             return False, "qty must be positive"
         chain_id = int(chain_id)
 
         if native:
-            tx = 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="withdrawETH",
-                args=[self._gateway_first_arg(underlying_token), qty, strategy],
+                args=[self.pool_address, qty, strategy],
                 from_address=strategy,
                 chain_id=chain_id,
             )
         else:
-            token_addr = self._checksum(underlying_token)
-            tx = await self._encode_call(
+            token_addr = to_checksum_address(underlying_token)
+            transaction = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="withdraw",
@@ -201,36 +249,21 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
-        return await self._send_tx(tx)
-
-    # ------------------------------------------------------------------ #
-    # Helpers                                                            #
-    # ------------------------------------------------------------------ #
-
-    async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
-        return True, txn_hash
 
-    async def _ensure_allowance(
-        self,
-        *,
-        token_address: str,
-        owner: str,
-        spender: str,
-        amount: int,
-        chain_id: int,
-    ) -> tuple[bool, Any]:
-        allowance = await get_token_allowance(token_address, chain_id, owner, spender)
-        if allowance >= amount:
-            return True, {}
-        approve_tx = await build_approve_transaction(
-            from_address=owner,
+        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,
-            token_address=token_address,
-            spender_address=spender,
-            amount=amount,
+            wallet_address=strategy,
+            txn_hash=txn_hash,
+            strategy_name=strategy_name,
+            op_type="unlend",
         )
-        return await self._send_tx(approve_tx)
+
+        return True, txn_hash
 
     async def _encode_call(
         self,
@@ -254,35 +287,90 @@ class HyperlendAdapter(BaseAdapter):
             except ValueError as exc:
                 raise ValueError(f"Failed to encode {fn_name}: {exc}") from exc
 
-            tx: dict[str, Any] = {
+            transaction: dict[str, Any] = {
                 "chainId": int(chain_id),
                 "from": to_checksum_address(from_address),
                 "to": to_checksum_address(target),
                 "data": data,
                 "value": int(value),
             }
-            return tx
+            return transaction
 
-    def _strategy_address(self) -> str:
-        addr = None
-        if isinstance(self.strategy_wallet, dict):
-            addr = self.strategy_wallet.get("address") or (
-                (self.strategy_wallet.get("evm") or {}).get("address")
-            )
-        elif isinstance(self.strategy_wallet, str):
-            addr = self.strategy_wallet
-        if not addr:
-            raise ValueError(
-                "strategy_wallet address is required for HyperLend operations"
+    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 to_checksum_address(addr)
+            return None
 
-    def _gateway_first_arg(self, underlying_token: str) -> str:
-        if self.gateway_deposit_takes_pool:
-            return self.pool_address
-        return self._checksum(underlying_token) or self.wrapped_native
+        # Get price data
+        decimals, current_price = (
+            token_data["decimals"],
+            token_data["current_price"],
+        )
+        return current_price * float(amount) / 10 ** int(decimals)
 
-    def _checksum(self, address: str | None) -> str:
-        if not address:
-            raise ValueError("Missing required contract address in HyperLend config")
-        return to_checksum_address(address)
+    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

@@ -14,7 +14,11 @@ class TestHyperlendAdapter:
     @pytest.fixture
     def adapter(self, mock_hyperlend_client):
         adapter = HyperlendAdapter(
-            config={},
+            config={
+                "strategy_wallet": {
+                    "address": "0x1234567890123456789012345678901234567890"
+                }
+            },
         )
         adapter.hyperlend_client = mock_hyperlend_client
         return adapter
@@ -147,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
@@ -267,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",
 ]