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

wayfinder_paths/adapters/hyperliquid_adapter/exchange.py

@@ -0,0 +1,399 @@
+import json
+from decimal import Decimal
+from typing import Any, Literal
+
+from eth_account.messages import encode_typed_data
+from eth_utils import keccak
+from hyperliquid.api import API
+from hyperliquid.exchange import get_timestamp_ms
+from hyperliquid.info import Info
+from hyperliquid.utils.signing import (
+    BUILDER_FEE_SIGN_TYPES,
+    SPOT_TRANSFER_SIGN_TYPES,
+    USD_CLASS_TRANSFER_SIGN_TYPES,
+    USER_DEX_ABSTRACTION_SIGN_TYPES,
+    WITHDRAW_SIGN_TYPES,
+    OrderType,
+    OrderWire,
+    float_to_wire,
+    get_l1_action_payload,
+    order_type_to_wire,
+    order_wires_to_order_action,
+    user_signed_payload,
+)
+from hyperliquid.utils.types import BuilderInfo
+from loguru import logger
+from web3 import Web3
+
+from wayfinder_paths.adapters.hyperliquid_adapter.util import Util
+from wayfinder_paths.core.types import HyperliquidSignCallback
+
+ARBITRUM_CHAIN_ID = "0xa4b1"
+MAINNET = "Mainnet"
+USER_DECLINED_ERROR = {
+    "status": "err",
+    "error": "User declined transaction. Please try again..",
+}
+
+
+class Exchange:
+    def __init__(
+        self,
+        info: Info,
+        util: Util,
+        sign_callback: HyperliquidSignCallback,
+        signing_type: Literal["eip712", "local"],
+    ):
+        self.info = info
+        self.util = util
+        self.api = API()
+        self.sign_callback = sign_callback
+        self.signing_type = signing_type
+
+    def _create_hypecore_order_actions(
+        self,
+        asset_id: int,
+        is_buy: bool,
+        price: float,
+        size: float,
+        reduce_only: bool,
+        order_type: OrderType,
+        builder: BuilderInfo | None = None,
+        cloid: str | None = None,
+    ):
+        order: OrderWire = {
+            "a": asset_id,
+            "b": is_buy,
+            "p": float_to_wire(price),
+            "s": float_to_wire(size),
+            "r": reduce_only,
+            "t": order_type_to_wire(order_type),
+        }
+        if cloid is not None:
+            order["c"] = cloid
+        return order_wires_to_order_action([order], builder)
+
+    async def place_market_order(
+        self,
+        asset_id: int,
+        is_buy: bool,
+        slippage: float,
+        size: float,
+        address: str,
+        reduce_only: bool = False,
+        builder: BuilderInfo | None = None,
+        cloid: str | None = None,
+    ):
+        """Place a market order (IOC limit with slippage)."""
+        asset_name = self.info.asset_to_coin[asset_id]
+        mids = await self.info.all_dex_mid_prices()
+        midprice = float(mids[asset_name])
+
+        if slippage >= 1 or slippage < 0:
+            return {"error": f"slippage must be in [0, 1), got {slippage}"}
+
+        price = midprice * ((1 + slippage) if is_buy else (1 - slippage))
+        price = round(
+            float(f"{price:.5g}"),
+            self.util.get_price_decimals_for_hypecore_asset(asset_id),
+        )
+        order_actions = self._create_hypecore_order_actions(
+            asset_id,
+            is_buy,
+            price,
+            size,
+            reduce_only,
+            {"limit": {"tif": "Ioc"}},
+            builder,
+            cloid,
+        )
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def place_limit_order(
+        self,
+        asset_id: int,
+        is_buy: bool,
+        price: float,
+        size: float,
+        address: str,
+        builder: BuilderInfo | None = None,
+        cloid: str | None = None,
+    ):
+        """Place a limit order (GTC)."""
+        order_actions = self._create_hypecore_order_actions(
+            asset_id,
+            is_buy,
+            price,
+            size,
+            False,
+            {"limit": {"tif": "Gtc"}},
+            builder,
+            cloid,
+        )
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def place_trigger_order(
+        self,
+        asset_id: int,
+        is_buy: bool,
+        trigger_price: float,
+        size: float,
+        address: str,
+        tpsl: Literal["tp", "sl"],
+        is_market: bool = True,
+        limit_price: float | None = None,
+        builder: BuilderInfo | None = None,
+    ):
+        """Place a trigger order (TP or SL, market or limit, reduce only)."""
+        order_type = {
+            "trigger": {"triggerPx": trigger_price, "isMarket": is_market, "tpsl": tpsl}
+        }
+        price = trigger_price if is_market else (limit_price or trigger_price)
+        order_actions = self._create_hypecore_order_actions(
+            asset_id, is_buy, price, size, True, order_type, builder
+        )
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def cancel_order(self, asset_id: int, order_id: str, address: str):
+        """Cancel an open order."""
+        order_actions = {
+            "type": "cancel",
+            "cancels": [
+                {
+                    "a": asset_id,
+                    "o": order_id,
+                }
+            ],
+        }
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def update_leverage(
+        self, asset: int, leverage: int, is_cross: bool, address: str
+    ):
+        """Update leverage for an asset."""
+        order_actions = {
+            "type": "updateLeverage",
+            "asset": asset,
+            "isCross": is_cross,
+            "leverage": leverage,
+        }
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def update_isolated_margin(self, asset: int, delta_usdc: float, address: str):
+        """
+        Add/remove USDC margin on an existing ISOLATED position.
+        Works for both longs & shorts. Positive = add, negative = remove.
+        """
+        ntli = int(round(delta_usdc * 1_000_000))
+        order_actions = {
+            "type": "updateIsolatedMargin",
+            "asset": asset,
+            "isBuy": delta_usdc >= 0,
+            "ntli": ntli,
+        }
+        return await self.sign_and_broadcast_hypecore(order_actions, address)
+
+    async def withdraw(self, amount: float, address: str):
+        """Initiate a withdrawal request to Arbitrum."""
+        nonce = get_timestamp_ms()
+        action = {
+            "hyperliquidChain": MAINNET,
+            "signatureChainId": ARBITRUM_CHAIN_ID,
+            "destination": address,
+            "amount": str(amount),
+            "time": nonce,
+            "type": "withdraw3",
+        }
+        payload = self._get_hypecore_user_signature_payload(
+            "HyperliquidTransaction:Withdraw", WITHDRAW_SIGN_TYPES, action
+        )
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    async def spot_transfer(
+        self,
+        signature_chain_id: int,
+        destination: str,
+        token: str,
+        amount: str,
+        address: str,
+    ):
+        """Transfer spot assets to HyperEVM or another address."""
+        nonce = get_timestamp_ms()
+        action = {
+            "type": "spotSend",
+            "hyperliquidChain": MAINNET,
+            "signatureChainId": hex(signature_chain_id),
+            "destination": destination,
+            "token": token,
+            "amount": amount,
+            "time": nonce,
+        }
+        payload = self._get_hypecore_user_signature_payload(
+            "HyperliquidTransaction:SpotSend", SPOT_TRANSFER_SIGN_TYPES, action
+        )
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    async def usd_class_transfer(self, amount: float, address: str, to_perp: bool):
+        """Transfer USDC between spot and perp accounts."""
+        nonce = get_timestamp_ms()
+        action = {
+            "hyperliquidChain": MAINNET,
+            "signatureChainId": ARBITRUM_CHAIN_ID,
+            "amount": str(amount),
+            "toPerp": to_perp,
+            "nonce": nonce,
+            "type": "usdClassTransfer",
+        }
+        payload = self._get_hypecore_user_signature_payload(
+            "HyperliquidTransaction:UsdClassTransfer",
+            USD_CLASS_TRANSFER_SIGN_TYPES,
+            action,
+        )
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    async def set_dex_abstraction(self, address: str, enabled: bool):
+        """Enable or disable DEX abstraction for an address."""
+        nonce = get_timestamp_ms()
+        action = {
+            "hyperliquidChain": MAINNET,
+            "signatureChainId": ARBITRUM_CHAIN_ID,
+            "user": address.lower(),
+            "enabled": enabled,
+            "nonce": nonce,
+            "type": "userDexAbstraction",
+        }
+        payload = self._get_hypecore_user_signature_payload(
+            "HyperliquidTransaction:UserDexAbstraction",
+            USER_DEX_ABSTRACTION_SIGN_TYPES,
+            action,
+        )
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    async def approve_builder_fee(self, builder: str, max_fee_rate: str, address: str):
+        """Approve a builder fee for trading."""
+        nonce = get_timestamp_ms()
+        action = {
+            "hyperliquidChain": MAINNET,
+            "signatureChainId": ARBITRUM_CHAIN_ID,
+            "maxFeeRate": max_fee_rate,
+            "builder": builder,
+            "nonce": nonce,
+            "type": "approveBuilderFee",
+        }
+        payload = self._get_hypecore_user_signature_payload(
+            "HyperliquidTransaction:ApproveBuilderFee", BUILDER_FEE_SIGN_TYPES, action
+        )
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    def build_sign(self, raw_payload: dict) -> str:
+        """Build and format the signing payload based on signing_type."""
+        if self.signing_type == "eip712":
+            # Remote signing: Return JSON string of typed data
+            return json.dumps(
+                raw_payload,
+                default=lambda o: (
+                    "0x" + o.hex() if isinstance(o, (bytes, bytearray)) else o
+                ),
+                separators=(",", ":"),
+            )
+        # Local signing: Return keccak hash
+        encoded = encode_typed_data(full_message=raw_payload)
+        full_msg = b"\x19" + encoded.version + encoded.header + encoded.body
+        return f"0x{keccak(full_msg).hex()}"
+
+    async def sign(
+        self, payload: str, action: dict, address: str
+    ) -> dict[str, Any] | None:
+        """Sign the payload and return Hyperliquid-format signature."""
+        if self.signing_type == "eip712":
+            # For EIP-712: parse JSON, call callback with typed data dict, convert hex to {r,s,v}
+            typed_data = json.loads(payload)
+            sig_hex = await self.sign_callback(typed_data)
+            if not sig_hex:
+                return None
+            return self.util._sig_hex_to_hl_signature(sig_hex)
+
+        # Local signing: payload is hash string, callback returns {r,s,v} directly
+        return await self.sign_callback(action, payload, address)
+
+    def _get_hypecore_l1_payload(
+        self, action, nonce, expires_after=None, is_mainnet=True
+    ):
+        """Build L1 action payload (orders, leverage, cancels)."""
+        payload = get_l1_action_payload(action, None, nonce, expires_after, is_mainnet)
+        return self.build_sign(payload)
+
+    def _get_hypecore_user_signature_payload(self, primary_type, payload_types, action):
+        """Build user signed action payload (withdrawals, transfers, etc.)."""
+        payload = user_signed_payload(primary_type, payload_types, action)
+        return self.build_sign(payload)
+
+    def _broadcast_hypecore(self, action, nonce, signature):
+        """Broadcast a signed action to the Hyperliquid exchange."""
+        payload = {
+            "action": action,
+            "nonce": nonce,
+            "signature": signature,
+        }
+        logger.info(f"Broadcasting Hypecore payload: {payload}")
+        return self.api.post("/exchange", payload)
+
+    async def sign_and_broadcast_hypecore(self, action, address):
+        """Sign and broadcast an L1 action (orders, leverage, cancels)."""
+        nonce = get_timestamp_ms()
+        payload = self._get_hypecore_l1_payload(action, nonce)
+        if not (sig := await self.sign(payload, action, address)):
+            return USER_DECLINED_ERROR
+        return self._broadcast_hypecore(action, nonce, sig)
+
+    def _hypecore_get_user_transfers(
+        self,
+        user_address: str,
+        from_timestamp_ms: int,
+        type: Literal["deposit", "withdraw"],
+    ) -> dict[str, Decimal]:
+        """Get user deposits or withdrawals from a given timestamp."""
+        data = self.api.post(
+            "/info",
+            {
+                "type": "userNonFundingLedgerUpdates",
+                "user": Web3.to_checksum_address(user_address),
+                "startTime": int(from_timestamp_ms),
+            },
+        )
+        res = {}
+        for u in sorted(data, key=lambda x: x.get("time", 0)):
+            delta = u.get("delta")
+            if delta and delta.get("type") == type:
+                res[u["hash"]] = Decimal(str(delta["usdc"]))
+        return res
+
+    def hypecore_get_user_deposits(
+        self, user_address: str, from_timestamp_ms: int
+    ) -> dict[str, Decimal]:
+        """Get user deposits from a given timestamp."""
+        return self._hypecore_get_user_transfers(
+            user_address=user_address,
+            from_timestamp_ms=from_timestamp_ms,
+            type="deposit",
+        )
+
+    def hypecore_get_user_withdrawals(
+        self, user_address: str, from_timestamp_ms: int
+    ) -> dict[str, Decimal]:
+        """Get user withdrawals from a given timestamp."""
+        return self._hypecore_get_user_transfers(
+            user_address=user_address,
+            from_timestamp_ms=from_timestamp_ms,
+            type="withdraw",
+        )

wayfinder_paths/adapters/hyperliquid_adapter/executor.py

@@ -209,6 +209,49 @@ class LocalHyperliquidExecutor:
                 "response": {"type": "error", "data": str(exc)},
             }
 
+    async def cancel_order_by_cloid(
+        self,
+        *,
+        asset_id: int,
+        cloid: str,
+        address: str,
+    ) -> dict[str, Any]:
+        if address.lower() != self._wallet.address.lower():
+            return {
+                "status": "err",
+                "response": {"type": "error", "data": "Address mismatch"},
+            }
+
+        try:
+            is_spot = asset_id >= 10000
+            if is_spot:
+                spot_index = asset_id - 10000
+                coin = f"@{spot_index}"
+            else:
+                coin = self._get_perp_coin(asset_id)
+                if not coin:
+                    return {
+                        "status": "err",
+                        "response": {
+                            "type": "error",
+                            "data": f"Unknown asset_id: {asset_id}",
+                        },
+                    }
+
+            cloid_obj = Cloid(cloid) if isinstance(cloid, str) else cloid
+            result = self.exchange.cancel_by_cloid(name=coin, cloid=cloid_obj)
+            if asyncio.iscoroutine(result):
+                result = await result
+            logger.debug(f"Cancel by cloid result: {result}")
+            return result
+
+        except Exception as exc:
+            logger.error(f"Cancel by cloid failed: {exc}")
+            return {
+                "status": "err",
+                "response": {"type": "error", "data": str(exc)},
+            }
+
     async def update_leverage(
         self,
         *,
@@ -249,6 +292,37 @@ class LocalHyperliquidExecutor:
                 "response": {"type": "error", "data": str(exc)},
             }
 
+    async def spot_transfer(
+        self,
+        *,
+        amount: float,
+        destination: str,
+        token: str,
+        address: str,
+    ) -> dict[str, Any]:
+        if address.lower() != self._wallet.address.lower():
+            return {
+                "status": "err",
+                "response": {"type": "error", "data": "Address mismatch"},
+            }
+
+        try:
+            result = self.exchange.spot_transfer(
+                amount=float(amount),
+                destination=str(destination),
+                token=str(token),
+            )
+            if asyncio.iscoroutine(result):
+                result = await result
+            logger.debug(f"Spot transfer result: {result}")
+            return result
+        except Exception as exc:
+            logger.error(f"Spot transfer failed: {exc}")
+            return {
+                "status": "err",
+                "response": {"type": "error", "data": str(exc)},
+            }
+
     async def transfer_spot_to_perp(
         self,
         *,

wayfinder_paths/adapters/hyperliquid_adapter/local_signer.py

@@ -0,0 +1,82 @@
+from typing import Any
+
+from eth_account import Account
+
+from wayfinder_paths.core.types import HyperliquidSignCallback
+
+
+def _resolve_private_key(config: dict[str, Any]) -> str | None:
+    """Extract private key from config."""
+    # Try strategy_wallet first
+    strategy_wallet = config.get("strategy_wallet", {})
+    if isinstance(strategy_wallet, dict):
+        pk = strategy_wallet.get("private_key_hex") or strategy_wallet.get(
+            "private_key"
+        )
+        if pk:
+            return pk
+
+    # Try main_wallet as fallback (for single-wallet setups)
+    main_wallet = config.get("main_wallet", {})
+    if isinstance(main_wallet, dict):
+        pk = main_wallet.get("private_key_hex") or main_wallet.get("private_key")
+        if pk:
+            return pk
+
+    return None
+
+
+def create_local_signer(config: dict[str, Any]) -> HyperliquidSignCallback:
+    """
+    Create a Hyperliquid signing callback using private key from config.
+
+    For local signing, the payload is a keccak hash (0x...) of the encoded EIP-712 typed data.
+    The callback signs with the private key and returns a signature dict.
+
+    Args:
+        config: Configuration dict containing private key in strategy_wallet or main_wallet
+
+    Returns:
+        HyperliquidSignCallback that signs payloads with the local private key
+
+    Raises:
+        ValueError: If no private key found in config
+    """
+    # Extract private key from config
+    private_key = _resolve_private_key(config)
+    if not private_key:
+        raise ValueError(
+            "No private key found in config. "
+            "Provide strategy_wallet.private_key_hex or strategy_wallet.private_key"
+        )
+
+    # Create account
+    pk = private_key if private_key.startswith("0x") else "0x" + private_key
+    account = Account.from_key(pk)
+
+    async def sign(
+        action: dict[str, Any], payload: str, address: str
+    ) -> dict[str, str] | None:
+        """
+        Sign a Hyperliquid action with local private key.
+
+        For local signing, payload is keccak hash (0x...) of encoded typed data.
+        Sign with account and return signature dict.
+
+        Args:
+            action: The action being signed (not used for local signing)
+            payload: Keccak hash (0x...) of encoded EIP-712 typed data
+            address: The address signing (validation check)
+
+        Returns:
+            Signature dict {"r": "0x...", "s": "0x...", "v": 28} or None if validation fails
+        """
+        # Verify address matches account
+        if address.lower() != account.address.lower():
+            return None
+
+        # Sign the hash
+        signed = account.signHash(payload)
+        return {"r": hex(signed.r), "s": hex(signed.s), "v": signed.v}
+
+    return sign

wayfinder_paths/adapters/hyperliquid_adapter/test_adapter.py

@@ -45,7 +45,7 @@ class TestHyperliquidAdapter:
                 "wayfinder_paths.adapters.hyperliquid_adapter.adapter.constants",
                 mock_constants,
             ):
-                adapter = HyperliquidAdapter(config={})
+                adapter = HyperliquidAdapter(config={}, simulation=True)
                 adapter.info = mock_info
                 return adapter
 

wayfinder_paths/adapters/hyperliquid_adapter/test_adapter_live.py

@@ -5,7 +5,7 @@ from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdap
 
 @pytest.fixture
 def live_adapter():
-    return HyperliquidAdapter(config={})
+    return HyperliquidAdapter(config={}, simulation=True)
 
 
 class TestSpotAssetIDs: