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

wayfinder_paths/__init__.py

@@ -2,6 +2,7 @@ __version__ = "0.1.0"
 
 from wayfinder_paths.core import (
     BaseAdapter,
+    LiquidationResult,
     StatusDict,
     StatusTuple,
     Strategy,
@@ -10,6 +11,7 @@ from wayfinder_paths.core import (
 __all__ = [
     "__version__",
     "BaseAdapter",
+    "LiquidationResult",
     "Strategy",
     "StatusDict",
     "StatusTuple",

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -11,10 +11,8 @@ from wayfinder_paths.core.adapters.models import SWAP
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.LedgerClient import TransactionRecord
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants.contracts import TOKENS_REQUIRING_APPROVAL_RESET
 from wayfinder_paths.core.utils.tokens import (
-    build_approve_transaction,
-    get_token_allowance,
+    ensure_allowance,
     is_native_token,
 )
 from wayfinder_paths.core.utils.transaction import send_transaction
@@ -48,45 +46,6 @@ class BRAPAdapter(BaseAdapter):
             return max(matching, key=lambda q: int(q.get("output_amount", 0) or 0))
         return None
 
-    async def _handle_token_approval(
-        self,
-        *,
-        chain_id: int,
-        token_address: str,
-        owner_address: str,
-        spender_address: str,
-        amount: int,
-    ) -> None:
-        token_checksum = Web3.to_checksum_address(token_address)
-        owner_checksum = Web3.to_checksum_address(owner_address)
-        spender_checksum = Web3.to_checksum_address(spender_address)
-
-        if (chain_id, token_checksum) in TOKENS_REQUIRING_APPROVAL_RESET:
-            allowance = await get_token_allowance(
-                token_checksum,
-                chain_id,
-                owner_checksum,
-                spender_checksum,
-            )
-            if allowance > 0:
-                clear_tx = await build_approve_transaction(
-                    from_address=owner_checksum,
-                    chain_id=chain_id,
-                    token_address=token_checksum,
-                    spender_address=spender_checksum,
-                    amount=0,
-                )
-                await send_transaction(clear_tx, self.strategy_wallet_signing_callback)
-
-        approve_tx = await build_approve_transaction(
-            from_address=owner_checksum,
-            chain_id=chain_id,
-            token_address=token_checksum,
-            spender_address=spender_checksum,
-            amount=int(amount),
-        )
-        await send_transaction(approve_tx, self.strategy_wallet_signing_callback)
-
     async def _record_swap_operation(
         self,
         from_token: dict[str, Any],
@@ -227,12 +186,13 @@ class BRAPAdapter(BaseAdapter):
             and approve_amount
             and not is_native_token(token_address)
         ):
-            await self._handle_token_approval(
-                chain_id=chain_id,
-                token_address=from_token.get("address"),
-                owner_address=from_address,
-                spender_address=spender,
+            await ensure_allowance(
+                token_address=token_address,
+                owner=from_address,
+                spender=spender,
                 amount=int(approve_amount),
+                chain_id=chain_id,
+                signing_callback=self.strategy_wallet_signing_callback,
             )
 
         txn_hash = await send_transaction(

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -49,9 +49,6 @@ class HyperlendAdapter(BaseAdapter):
         strategy_addr = strategy_wallet.get("address")
 
         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,
@@ -167,12 +164,12 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
-            token_addr = self.wrapped_native
+            token_addr = HYPEREVM_WHYPE
             transaction = await self._encode_call(
-                target=self.gateway_address,
+                target=HYPERLEND_WRAPPED_TOKEN_GATEWAY,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="depositETH",
-                args=[self.pool_address, strategy, 0],
+                args=[HYPERLEND_POOL, strategy, 0],
                 from_address=strategy,
                 chain_id=chain_id,
                 value=qty,
@@ -182,7 +179,7 @@ class HyperlendAdapter(BaseAdapter):
             approved = await ensure_allowance(
                 token_address=token_addr,
                 owner=strategy,
-                spender=self.pool_address,
+                spender=HYPERLEND_POOL,
                 amount=qty,
                 chain_id=chain_id,
                 signing_callback=self.strategy_wallet_signing_callback,
@@ -190,7 +187,7 @@ class HyperlendAdapter(BaseAdapter):
             if not approved[0]:
                 return approved
             transaction = await self._encode_call(
-                target=self.pool_address,
+                target=HYPERLEND_POOL,
                 abi=POOL_ABI,
                 fn_name="supply",
                 args=[token_addr, qty, strategy, 0],
@@ -230,19 +227,19 @@ class HyperlendAdapter(BaseAdapter):
         chain_id = int(chain_id)
 
         if native:
-            token_addr = self.wrapped_native
+            token_addr = HYPEREVM_WHYPE
             transaction = await self._encode_call(
-                target=self.gateway_address,
+                target=HYPERLEND_WRAPPED_TOKEN_GATEWAY,
                 abi=WRAPPED_TOKEN_GATEWAY_ABI,
                 fn_name="withdrawETH",
-                args=[self.pool_address, qty, strategy],
+                args=[HYPERLEND_POOL, qty, strategy],
                 from_address=strategy,
                 chain_id=chain_id,
             )
         else:
             token_addr = to_checksum_address(underlying_token)
             transaction = await self._encode_call(
-                target=self.pool_address,
+                target=HYPERLEND_POOL,
                 abi=POOL_ABI,
                 fn_name="withdraw",
                 args=[token_addr, qty, strategy],
@@ -317,7 +314,7 @@ class HyperlendAdapter(BaseAdapter):
         operation_data = model(
             adapter=self.adapter_type,
             token_address=token_address,
-            pool_address=self.pool_address,
+            pool_address=HYPERLEND_POOL,
             amount=str(amount),
             amount_usd=amount_usd or 0,
             transaction_hash=txn_hash,
@@ -356,21 +353,3 @@ class HyperlendAdapter(BaseAdapter):
             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/hyperliquid_adapter/adapter.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import time
 from decimal import ROUND_DOWN, Decimal, getcontext
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from aiocache import Cache
 from eth_utils import to_checksum_address
@@ -21,11 +21,7 @@ from wayfinder_paths.core.constants.hyperliquid import (
 from wayfinder_paths.core.constants.hyperliquid import (
     HYPERLIQUID_BRIDGE_ADDRESS as _HYPERLIQUID_BRIDGE_ADDRESS,
 )
-
-if TYPE_CHECKING:
-    from wayfinder_paths.core.clients.protocols import (
-        HyperliquidExecutorProtocol as HyperliquidExecutor,
-    )
+from wayfinder_paths.core.types import HyperliquidSignCallback
 
 # Re-export Bridge2 constants for backwards compatibility.
 HYPERLIQUID_BRIDGE_ADDRESS = _HYPERLIQUID_BRIDGE_ADDRESS
@@ -35,11 +31,20 @@ try:
     from hyperliquid.info import Info
     from hyperliquid.utils import constants
 
+    from wayfinder_paths.adapters.hyperliquid_adapter.exchange import Exchange
+    from wayfinder_paths.adapters.hyperliquid_adapter.local_signer import (
+        create_local_signer,
+    )
+    from wayfinder_paths.adapters.hyperliquid_adapter.util import Util
+
     HYPERLIQUID_AVAILABLE = True
 except ImportError:
     HYPERLIQUID_AVAILABLE = False
     Info = None
     constants = None
+    Exchange = None
+    Util = None
+    create_local_signer = None
 
 
 class HyperliquidAdapter(BaseAdapter):
@@ -62,7 +67,7 @@ class HyperliquidAdapter(BaseAdapter):
         config: dict[str, Any] | None = None,
         *,
         simulation: bool = False,
-        executor: HyperliquidExecutor | None = None,
+        sign_callback: HyperliquidSignCallback | None = None,
     ) -> None:
         super().__init__("hyperliquid_adapter", config)
 
@@ -74,11 +79,36 @@ class HyperliquidAdapter(BaseAdapter):
 
         self.simulation = simulation
         self._cache = Cache(Cache.MEMORY)
-        self._executor = executor
 
         # Initialize Hyperliquid Info client
         self.info = Info(constants.MAINNET_API_URL, skip_ws=True)
 
+        # Initialize Util
+        self.util = Util(self.info)
+
+        # Initialize Exchange with appropriate signing type
+        self._exchange: Exchange | None = None
+        if not self.simulation:
+            if sign_callback is None:
+                # Local signing: create local signer from config
+                if not config:
+                    raise ValueError(
+                        "Config required for local signing (no sign_callback provided)"
+                    )
+                sign_callback = create_local_signer(config)
+                signing_type = "local"
+            else:
+                # Remote signing: use provided callback (EIP-712)
+                signing_type = "eip712"
+
+            # Instantiate Exchange
+            self._exchange = Exchange(
+                info=self.info,
+                util=self.util,
+                sign_callback=sign_callback,
+                signing_type=signing_type,
+            )
+
         # Cache asset mappings after first fetch
         self._asset_to_sz_decimals: dict[int, int] | None = None
         self._coin_to_asset: dict[str, int] | None = None
@@ -533,13 +563,18 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
+        if not self._exchange:
             raise NotImplementedError(
-                "No Hyperliquid executor configured. "
-                "Inject a HyperliquidExecutor implementation (e.g., LocalHyperliquidExecutor)."
+                "No Hyperliquid exchange configured. "
+                "Provide a sign_callback or config with private key."
             )
 
-        result = await self._executor.place_market_order(
+        # Convert builder to BuilderInfo
+        from hyperliquid.utils.types import BuilderInfo
+
+        builder_info = BuilderInfo(b=builder.get("b"), f=builder.get("f"))
+
+        result = await self._exchange.place_market_order(
             asset_id=asset_id,
             is_buy=is_buy,
             slippage=slippage,
@@ -547,7 +582,7 @@ class HyperliquidAdapter(BaseAdapter):
             address=address,
             reduce_only=reduce_only,
             cloid=cloid,
-            builder=builder,
+            builder=builder_info,
         )
 
         # Check both the API status and the order statuses for errors
@@ -575,15 +610,12 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError(
-                "No Hyperliquid executor configured. "
-                "Inject a HyperliquidExecutor implementation (e.g., LocalHyperliquidExecutor)."
-            )
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.cancel_order(
+        result = await self._exchange.cancel_order(
             asset_id=asset_id,
-            order_id=int(order_id) if isinstance(order_id, str) else order_id,
+            order_id=str(order_id) if isinstance(order_id, int) else order_id,
             address=address,
         )
 
@@ -596,26 +628,52 @@ class HyperliquidAdapter(BaseAdapter):
         cloid: str,
         address: str,
     ) -> tuple[bool, dict[str, Any]]:
+        """
+        Cancel order by client order ID (CLOID).
+
+        Note: The Exchange class uses cancel_order with order_id.
+        For cloid-based cancellation, we'd need to first fetch the order_id from open orders.
+        """
         if self.simulation:
             logger.info(
                 f"[SIMULATION] cancel_order_by_cloid: asset={asset_id}, cloid={cloid}"
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError(
-                "No Hyperliquid executor configured. "
-                "Inject a HyperliquidExecutor implementation (e.g., LocalHyperliquidExecutor)."
-            )
+        # Find order_id from open orders
+        success, orders = await self.get_frontend_open_orders(address)
+        if not success:
+            return False, {
+                "status": "err",
+                "response": {"type": "error", "data": "Could not fetch open orders"},
+            }
 
-        result = await self._executor.cancel_order_by_cloid(
-            asset_id=asset_id,
-            cloid=cloid,
-            address=address,
-        )
+        # Find matching order by cloid
+        matching_order = None
+        for order in orders:
+            if order.get("cloid") == cloid:
+                matching_order = order
+                break
 
-        success = result.get("status") == "ok"
-        return success, result
+        if not matching_order:
+            return False, {
+                "status": "err",
+                "response": {
+                    "type": "error",
+                    "data": f"Order with cloid {cloid} not found",
+                },
+            }
+
+        order_id = matching_order.get("oid")
+        if not order_id:
+            return False, {
+                "status": "err",
+                "response": {"type": "error", "data": "Order missing oid"},
+            }
+
+        return await self.cancel_order(
+            asset_id=asset_id, order_id=order_id, address=address
+        )
 
     async def spot_transfer(
         self,
@@ -638,13 +696,15 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.spot_transfer(
-            amount=float(amount),
+        # Arbitrum chain ID
+        result = await self._exchange.spot_transfer(
+            signature_chain_id=42161,
             destination=str(destination),
             token=str(token),
+            amount=str(amount),
             address=address,
         )
 
@@ -760,11 +820,11 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.update_leverage(
-            asset_id=asset_id,
+        result = await self._exchange.update_leverage(
+            asset=asset_id,
             leverage=leverage,
             is_cross=is_cross,
             address=address,
@@ -782,12 +842,13 @@ class HyperliquidAdapter(BaseAdapter):
             self.logger.info(f"[SIMULATION] transfer_spot_to_perp: {amount} USDC")
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.transfer_spot_to_perp(
+        result = await self._exchange.usd_class_transfer(
             amount=amount,
             address=address,
+            to_perp=True,
         )
 
         success = result.get("status") == "ok"
@@ -802,12 +863,13 @@ class HyperliquidAdapter(BaseAdapter):
             self.logger.info(f"[SIMULATION] transfer_perp_to_spot: {amount} USDC")
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.transfer_perp_to_spot(
+        result = await self._exchange.usd_class_transfer(
             amount=amount,
             address=address,
+            to_perp=False,
         )
 
         success = result.get("status") == "ok"
@@ -828,15 +890,17 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.place_stop_loss(
+        result = await self._exchange.place_trigger_order(
             asset_id=asset_id,
             is_buy=is_buy,
             trigger_price=trigger_price,
             size=size,
             address=address,
+            tpsl="sl",
+            is_market=True,
         )
 
         success = result.get("status") == "ok"
@@ -951,10 +1015,10 @@ class HyperliquidAdapter(BaseAdapter):
             self.logger.info(f"[SIMULATION] withdraw: {amount} USDC")
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.withdraw(
+        result = await self._exchange.withdraw(
             amount=amount,
             address=address,
         )
@@ -1004,10 +1068,10 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
 
-        result = await self._executor.approve_builder_fee(
+        result = await self._exchange.approve_builder_fee(
             builder=builder,
             max_fee_rate=max_fee_rate,
             address=address,
@@ -1094,17 +1158,21 @@ class HyperliquidAdapter(BaseAdapter):
             )
             return True, {"simulation": True, "status": "ok"}
 
-        if not self._executor:
-            raise NotImplementedError("No Hyperliquid executor configured.")
+        if not self._exchange:
+            raise NotImplementedError("No Hyperliquid exchange configured.")
+
+        # Convert builder to BuilderInfo
+        from hyperliquid.utils.types import BuilderInfo
+
+        builder_info = BuilderInfo(b=builder.get("b"), f=builder.get("f"))
 
-        result = await self._executor.place_limit_order(
+        result = await self._exchange.place_limit_order(
             asset_id=asset_id,
             is_buy=is_buy,
             price=price,
             size=size,
             address=address,
-            reduce_only=reduce_only,
-            builder=builder,
+            builder=builder_info,
         )
 
         success = result.get("status") == "ok"