async-hyperliquid 0.3.9__tar.gz → 0.4.0__tar.gz

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: async-hyperliquid
-Version: 0.3.9
+Version: 0.4.0
 Summary: Async Hyperliquid client using aiohttp
 Keywords: dex,hyperliquid,async,aiohttp,trading,cryptocurrency,defi
 Author: Yuki

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "async-hyperliquid"
-version = "0.3.9"
+version = "0.4.0"
 description = "Async Hyperliquid client using aiohttp"
 authors = [{ name = "Yuki", email = "yuqi.lyle@gmail.com" }]
 readme = "README.md"

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/async_hyperliquid.py

@@ -1,5 +1,7 @@
+import re
 import math
 import asyncio
+import warnings
 from typing import Literal
 
 from aiohttp import ClientSession, ClientTimeout
@@ -22,12 +24,13 @@ from async_hyperliquid.utils.miscs import (
 from async_hyperliquid.utils.types import (
     Cloid,
     Metas,
+    LimitTif,
     PerpMeta,
     Position,
     SpotMeta,
     OrderType,
     Portfolio,
-    LimitOrder,
+    Abstraction,
     UserDeposit,
     AccountState,
     GroupOptions,
@@ -37,12 +40,15 @@ from async_hyperliquid.utils.types import (
     SpotTokenMeta,
     UserOpenOrders,
     OrderWithStatus,
+    AgentAbstraction,
     PlaceOrderRequest,
     BatchCancelRequest,
     ClearinghouseState,
+    UserSetAbstraction,
     UserNonFundingDelta,
     BatchPlaceOrderRequest,
     SpotClearinghouseState,
+    limit_order_type,
 )
 from async_hyperliquid.utils.signing import (
     encode_order,
@@ -58,6 +64,7 @@ from async_hyperliquid.utils.signing import (
     sign_usd_class_transfer_action,
     sign_approve_builder_fee_action,
     sign_user_dex_abstraction_action,
+    sign_user_set_abstraction_action,
     sign_convert_to_multi_sig_user_action,
 )
 from async_hyperliquid.utils.constants import (
@@ -499,17 +506,12 @@ class AsyncHyperliquid(AsyncAPI):
             positions.extend(result)
         return positions
 
-    async def get_user_dex_abstraction(self, address: str | None) -> bool:
-        if not address:
-            address = self.address
-        return await self.info.get_user_dex_abstraction(address)
-
-    async def get_user_abstraction_state(
+    async def get_user_abstraction(
         self, address: str | None = None
-    ) -> str:
+    ) -> Abstraction:
         if not address:
             address = self.address
-        return await self.info.get_user_abstraction_state(address)
+        return await self.info.get_user_abstraction(address)
 
     # Exchange API
     async def _round_sz_px(self, coin: str, sz: float, px: float):
@@ -519,26 +521,46 @@ class AsyncHyperliquid(AsyncAPI):
         px_decimals = (6 if not is_spot else 8) - sz_decimals
         return asset, round_float(sz, sz_decimals), round_px(px, px_decimals)
 
-    async def place_order(
+    async def place_market_order(
         self,
         coin: str,
         is_buy: bool,
         sz: float,
-        px: float,
-        is_market: bool = True,
         *,
         ro: bool = False,
-        order_type: OrderType = LimitOrder.IOC.value,  # type: ignore
         cloid: Cloid | None = None,
         slippage: float = 0.05,  # Default slippage is 5%
         builder: OrderBuilder | None = None,
     ):
-        if is_market:
-            mid_px = await self.get_mid_price(coin)
-            slippage_factor = (1 + slippage) if is_buy else (1 - slippage)
-            px = mid_px * slippage_factor
-            # Market order is an aggressive Limit Order IoC
-            order_type = LimitOrder.IOC.value  # type: ignore
+        mid_px = await self.get_mid_price(coin)
+        slippage_factor = (1 + slippage) if is_buy else (1 - slippage)
+        px = mid_px * slippage_factor
+        # Market order is an aggressive Limit Order IoC
+        return await self.place_typed_order(
+            coin=coin,
+            is_buy=is_buy,
+            sz=sz,
+            px=px,
+            ro=ro,
+            order_type=limit_order_type(LimitTif.IOC),
+            cloid=cloid,
+            builder=builder,
+        )
+
+    async def place_typed_order(
+        self,
+        coin: str,
+        is_buy: bool,
+        sz: float,
+        px: float,
+        *,
+        ro: bool = False,
+        order_type: OrderType | None = None,
+        cloid: Cloid | None = None,
+        builder: OrderBuilder | None = None,
+    ):
+        if order_type is None:
+            order_type = limit_order_type(LimitTif.IOC)
 
         asset, sz, px = await self._round_sz_px(coin, sz, px)
 
@@ -554,6 +576,42 @@ class AsyncHyperliquid(AsyncAPI):
 
         return await self.place_orders([order_req], builder=builder)
 
+    async def place_order(
+        self,
+        coin: str,
+        is_buy: bool,
+        sz: float,
+        px: float,
+        is_market: bool = True,
+        *,
+        ro: bool = False,
+        order_type: OrderType | None = None,
+        cloid: Cloid | None = None,
+        slippage: float = 0.05,  # Default slippage is 5%
+        builder: OrderBuilder | None = None,
+    ):
+        if is_market:
+            return await self.place_market_order(
+                coin=coin,
+                is_buy=is_buy,
+                sz=sz,
+                ro=ro,
+                cloid=cloid,
+                slippage=slippage,
+                builder=builder,
+            )
+
+        return await self.place_typed_order(
+            coin=coin,
+            is_buy=is_buy,
+            sz=sz,
+            px=px,
+            ro=ro,
+            order_type=order_type,
+            cloid=cloid,
+            builder=builder,
+        )
+
     async def place_orders(
         self,
         orders: list[PlaceOrderRequest],
@@ -601,7 +659,7 @@ class AsyncHyperliquid(AsyncAPI):
         reqs = []
         dexs = list(set(get_coin_dex(o["coin"]) for o in orders))
         all_mids = await self.get_dexs_mids(dexs)
-        order_type = LimitOrder.IOC.value
+        order_type = limit_order_type(LimitTif.IOC)
         for o in orders:
             coin = o["coin"]
             market_price = all_mids[coin]
@@ -1012,6 +1070,12 @@ class AsyncHyperliquid(AsyncAPI):
     async def user_dex_abstraction(
         self, user: str | None = None, enabled: bool = True
     ):
+        warnings.warn(
+            "user_dex_abstraction is deprecated and may be removed in a "
+            "future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         nonce = get_timestamp_ms()
         if user is None:
             user = self.address
@@ -1026,11 +1090,44 @@ class AsyncHyperliquid(AsyncAPI):
         )
         return await self.exchange.post_action_with_sig(action, sig, nonce)
 
+    async def user_set_abstraction(
+        self, abstraction: UserSetAbstraction, user: str | None = None
+    ):
+        nonce = get_timestamp_ms()
+        if user is None:
+            user = self.address
+        if re.fullmatch(r"0x[a-fA-F0-9]{40}", user) is None:
+            raise ValueError(
+                f"user must be a 42-char hex address, got: {user!r}"
+            )
+        action = {
+            "type": "userSetAbstraction",
+            "user": user.lower(),
+            "abstraction": abstraction,
+            "nonce": nonce,
+        }
+        sig = sign_user_set_abstraction_action(
+            self.account, action, self.is_mainnet
+        )
+        return await self.exchange.post_action_with_sig(action, sig, nonce)
+
     async def agent_enable_dex_abstraction(self):
+        warnings.warn(
+            "agent_enable_dex_abstraction is deprecated and may be removed "
+            "in a future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         action = {"type": "agentEnableDexAbstraction"}
         return await self.exchange.post_action(
             action, vault=self.vault, expires=self.expires
         )
 
+    async def agent_set_abstraction(self, abstraction: AgentAbstraction):
+        action = {"type": "agentSetAbstraction", "abstraction": abstraction}
+        return await self.exchange.post_action(
+            action, vault=self.vault, expires=self.expires
+        )
+
 
 AsyncHyper = AsyncHyperliquid

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/exchange.py

@@ -25,7 +25,7 @@ class ExchangeAPI(AsyncAPI):
         address: str | None = None,
     ):
         self.account = account
-        self.address = address or account.address  # type: ignore
+        self.address = address or account.address
         self.is_mainnet = base_url == MAINNET_API_URL
         super().__init__(Endpoint.EXCHANGE, base_url, session)
 

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/info.py

@@ -4,6 +4,7 @@ from aiohttp import ClientSession
 
 from async_hyperliquid.async_api import AsyncAPI
 from async_hyperliquid.utils.types import (
+    Abstraction,
     Depth,
     Candles,
     Endpoint,
@@ -183,7 +184,7 @@ class InfoAPI(AsyncAPI):
         payload = {"type": "userDexAbstraction", "user": address}
         return await self.post(payload)
 
-    async def get_user_abstraction_state(self, address: str) -> str:
+    async def get_user_abstraction(self, address: str) -> Abstraction:
         payload = {"type": "userAbstraction", "user": address}
         return await self.post(payload)
 

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/utils/constants.py

@@ -99,3 +99,10 @@ USER_DEX_ABSTRACTION_SIGN_TYPES = [
     {"name": "enabled", "type": "bool"},
     {"name": "nonce", "type": "uint64"},
 ]
+
+USER_SET_ABSTRACTION_SIGN_TYPES = [
+    {"name": "hyperliquidChain", "type": "string"},
+    {"name": "user", "type": "address"},
+    {"name": "abstraction", "type": "string"},
+    {"name": "nonce", "type": "uint64"},
+]

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/utils/signing.py

@@ -8,6 +8,7 @@ from eth_utils.conversions import to_hex
 from eth_account.signers.local import LocalAccount
 
 from async_hyperliquid.utils.types import (
+    LimitTif,
     OrderType,
     OrderAction,
     EncodedOrder,
@@ -15,6 +16,9 @@ from async_hyperliquid.utils.types import (
     OrderBuilder,
     SignedAction,
     PlaceOrderRequest,
+    is_limit_order_type,
+    is_trigger_order_type,
+    limit_order_type,
 )
 from async_hyperliquid.utils.constants import (
     SIGNATURE_CHAIN_ID,
@@ -27,9 +31,10 @@ from async_hyperliquid.utils.constants import (
     APPROVE_BUILDER_FEE_TYPES,
     STAKING_TRANSFER_SIGN_TYPES,
     MULTI_SIG_ENVELOPE_SIGN_TYPES,
+    USER_SET_ABSTRACTION_SIGN_TYPES,
     USD_CLASS_TRANSFER_SIGN_TYPES,
-    CONVERT_TO_MULTI_SIG_USER_SIGN_TYPES,
     USER_DEX_ABSTRACTION_SIGN_TYPES,
+    CONVERT_TO_MULTI_SIG_USER_SIGN_TYPES,
 )
 
 
@@ -40,7 +45,7 @@ def address_to_bytes(address: str) -> bytes:
 def hash_action(
     action: dict, vault: str | None, nonce: int, expires: int | None = None
 ) -> bytes:
-    data: bytes = msgpack.packb(action)  # type: ignore
+    data: bytes = msgpack.packb(action)
     data += nonce.to_bytes(8, "big")
 
     if vault is None:
@@ -113,9 +118,9 @@ def round_float(x: float) -> str:
 
 
 def ensure_order_type(order_type: OrderType) -> OrderType:
-    if "limit" in order_type:
-        return {"limit": order_type["limit"]}
-    elif "trigger" in order_type:
+    if is_limit_order_type(order_type):
+        return limit_order_type(LimitTif(order_type["limit"]["tif"]))
+    if is_trigger_order_type(order_type):
         return {
             "trigger": {
                 "isMarket": order_type["trigger"]["isMarket"],
@@ -357,3 +362,15 @@ def sign_user_dex_abstraction_action(
         "HyperliquidTransaction:UserDexAbstraction",
         is_mainnet,
     )
+
+
+def sign_user_set_abstraction_action(
+    wallet: LocalAccount, action: dict, is_mainnet: bool
+):
+    return sign_user_signed_action(
+        wallet,
+        action,
+        USER_SET_ABSTRACTION_SIGN_TYPES,
+        "HyperliquidTransaction:UserSetAbstraction",
+        is_mainnet,
+    )

{async_hyperliquid-0.3.9 → async_hyperliquid-0.4.0}/src/async_hyperliquid/utils/types.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any, Literal, TypedDict
+from typing import Any, Literal, TypeGuard, TypedDict
 
 from typing_extensions import NotRequired
 
@@ -47,12 +47,22 @@ class LimitOrderType(TypedDict):
     limit: LimitOrderOptions
 
 
+class LimitTif(str, Enum):
+    ALO = "Alo"
+    IOC = "Ioc"
+    GTC = "Gtc"
+
+
 class LimitOrder(Enum):
     ALO = {"limit": {"tif": "Alo"}}
     IOC = {"limit": {"tif": "Ioc"}}
     GTC = {"limit": {"tif": "Gtc"}}
 
 
+def limit_order_type(tif: LimitTif) -> LimitOrderType:
+    return {"limit": {"tif": tif.value}}
+
+
 class TriggerOrderOptions(TypedDict):
     isMarket: bool
     triggerPx: str
@@ -63,9 +73,39 @@ class TriggerOrderType(TypedDict):
     trigger: TriggerOrderOptions
 
 
+class TriggerTpsl(str, Enum):
+    TP = "tp"
+    SL = "sl"
+
+
+def trigger_order_type(
+    *, is_market: bool, trigger_px: float | str, tpsl: TriggerTpsl
+) -> TriggerOrderType:
+    return {
+        "trigger": {
+            "isMarket": is_market,
+            "triggerPx": str(trigger_px),
+            "tpsl": tpsl.value,
+        }
+    }
+
+
 OrderType = LimitOrderType | TriggerOrderType
 
 GroupOptions = Literal["na", "normalTpsl", "positionTpsl"]
+Abstraction = Literal[
+    "unifiedAccount", "portfolioMargin", "disabled", "default", "dexAbstraction"
+]
+UserSetAbstraction = Literal["disabled", "unifiedAccount", "portfolioMargin"]
+AgentAbstraction = Literal["i", "u", "p"]
+
+
+def is_limit_order_type(order_type: OrderType) -> TypeGuard[LimitOrderType]:
+    return "limit" in order_type and "trigger" not in order_type
+
+
+def is_trigger_order_type(order_type: OrderType) -> TypeGuard[TriggerOrderType]:
+    return "trigger" in order_type and "limit" not in order_type
 
 
 class BasicPlaceOrderRequest(TypedDict):
@@ -837,3 +877,7 @@ class Metas(TypedDict):
 class SignType(str, Enum):
     SINGLE_SIG = "singleSig"
     MULTI_SIG = "multiSig"
+
+
+Abstraction = Literal["unifiedAccount", "portfolioMargin", "disabled"]
+AgentAbstraction = Literal["u", "p", "i"]