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

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -12,23 +12,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,32 +35,30 @@ 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 {}
+        adapter_cfg = config.get("hyperlend_adapter") 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"]
+        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 = self._checksum(
-            adapter_cfg.get("wrapped_token_gateway")
-            or HYPERLEND_DEFAULTS["wrapped_token_gateway"]
+        self.gateway_address = to_checksum_address(
+            adapter_cfg.get("wrapped_token_gateway") or HYPERLEND_WRAPPED_TOKEN_GATEWAY
         )
-        self.wrapped_native = self._checksum(
-            adapter_cfg.get("wrapped_native_underlying")
-            or HYPERLEND_DEFAULTS["wrapped_native_underlying"]
+        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
         )
 
-    # ------------------------------------------------------------------ #
-    # Public API                                                         #
-    # ------------------------------------------------------------------ #
-
     async def get_stable_markets(
         self,
         *,
@@ -131,14 +125,14 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         native: bool = False,
     ) -> 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(
+            transcation = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="depositETH",
@@ -148,17 +142,18 @@ class HyperlendAdapter(BaseAdapter):
                 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(
+            transcation = await self._encode_call(
                 target=self.pool_address,
                 abi=POOL_ABI,
                 fn_name="supply",
@@ -166,7 +161,10 @@ class HyperlendAdapter(BaseAdapter):
                 from_address=strategy,
                 chain_id=chain_id,
             )
-        return await self._send_tx(tx)
+        txn_hash = await send_transaction(
+            transcation, self.strategy_wallet_signing_callback
+        )
+        return True, txn_hash
 
     async def unlend(
         self,
@@ -176,14 +174,14 @@ class HyperlendAdapter(BaseAdapter):
         chain_id: int,
         native: bool = False,
     ) -> 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(
+            transaction = await self._encode_call(
                 target=self.gateway_address,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="withdrawETH",
@@ -192,8 +190,8 @@ class HyperlendAdapter(BaseAdapter):
                 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 +199,10 @@ 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,
-            chain_id=chain_id,
-            token_address=token_address,
-            spender_address=spender,
-            amount=amount,
+        txn_hash = await send_transaction(
+            transaction, self.strategy_wallet_signing_callback
         )
-        return await self._send_tx(approve_tx)
+        return True, txn_hash
 
     async def _encode_call(
         self,
@@ -254,35 +226,16 @@ 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
-
-    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"
-            )
-        return to_checksum_address(addr)
+            return transaction
 
     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
-
-    def _checksum(self, address: str | None) -> str:
-        if not address:
-            raise ValueError("Missing required contract address in HyperLend config")
-        return to_checksum_address(address)
+        return to_checksum_address(underlying_token)

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

wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -5,17 +5,18 @@ import time
 from typing import TYPE_CHECKING, Any
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.constants.contracts import (
+    ARBITRUM_USDC,
+    HYPERLIQUID_BRIDGE,
+)
 
 if TYPE_CHECKING:
     from wayfinder_paths.core.clients.protocols import (
         HyperliquidExecutorProtocol as HyperliquidExecutor,
     )
 
-# Hyperliquid L1 bridge address on Arbitrum - send USDC here to deposit
-HYPERLIQUID_BRIDGE_ADDRESS = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7"
-
-# USDC contract on Arbitrum
-ARBITRUM_USDC_ADDRESS = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+HYPERLIQUID_BRIDGE_ADDRESS = HYPERLIQUID_BRIDGE
+ARBITRUM_USDC_ADDRESS = ARBITRUM_USDC
 
 try:
     from hyperliquid.info import Info

wayfinder_paths/adapters/ledger_adapter/README.md

@@ -46,7 +46,10 @@ success, data = await adapter.get_strategy_net_deposit(
     wallet_address="0x..."
 )
 if success:
-    net_deposit = data.get("net_deposit", 0)
+    net_deposit = float(data) if data is not None else 0
+    print(f"Net deposit: {net_deposit} USDC")
+else:
+    print(f"Error: {data}")
 ```
 
 ### record_deposit

wayfinder_paths/adapters/ledger_adapter/adapter.py

@@ -4,7 +4,6 @@ from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.adapters.models import Operation
 from wayfinder_paths.core.clients.LedgerClient import (
     LedgerClient,
-    NetDeposit,
     StrategyTransactionList,
     TransactionRecord,
 )
@@ -36,7 +35,7 @@ class LedgerAdapter(BaseAdapter):
 
     async def get_strategy_net_deposit(
         self, wallet_address: str
-    ) -> tuple[bool, NetDeposit | str]:
+    ) -> tuple[bool, float | str]:
         try:
             data = await self.ledger_client.get_strategy_net_deposit(
                 wallet_address=wallet_address
@@ -116,9 +115,10 @@ class LedgerAdapter(BaseAdapter):
         strategy_name: str | None = None,
     ) -> tuple[bool, TransactionRecord | str]:
         try:
+            op_dict = operation_data.model_dump(mode="json")
             result = await self.ledger_client.add_strategy_operation(
                 wallet_address=wallet_address,
-                operation_data=operation_data,
+                operation_data=op_dict,
                 usd_value=usd_value,
                 strategy_name=strategy_name,
             )