hyperliquid-python-sdk-async 0.24.6__py3-none-any.whl

hyperliquid/utils/types.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Tuple, TypedDict, Union, cast
+from typing_extensions import NotRequired
+
+Any = Any
+Option = Optional
+cast = cast
+Callable = Callable
+NamedTuple = NamedTuple
+NotRequired = NotRequired
+
+AssetInfo = TypedDict("AssetInfo", {"name": str, "szDecimals": int})
+Meta = TypedDict("Meta", {"universe": List[AssetInfo]})
+Side = Union[Literal["A"], Literal["B"]]
+SIDES: List[Side] = ["A", "B"]
+
+SpotAssetInfo = TypedDict("SpotAssetInfo", {"name": str, "tokens": List[int], "index": int, "isCanonical": bool})
+SpotTokenInfo = TypedDict(
+    "SpotTokenInfo",
+    {
+        "name": str,
+        "szDecimals": int,
+        "weiDecimals": int,
+        "index": int,
+        "tokenId": str,
+        "isCanonical": bool,
+        "evmContract": Optional[str],
+        "fullName": Optional[str],
+    },
+)
+SpotMeta = TypedDict("SpotMeta", {"universe": List[SpotAssetInfo], "tokens": List[SpotTokenInfo]})
+SpotAssetCtx = TypedDict(
+    "SpotAssetCtx",
+    {"dayNtlVlm": str, "markPx": str, "midPx": Optional[str], "prevDayPx": str, "circulatingSupply": str, "coin": str},
+)
+SpotMetaAndAssetCtxs = Tuple[SpotMeta, List[SpotAssetCtx]]
+
+AllMidsSubscription = TypedDict("AllMidsSubscription", {"type": Literal["allMids"]})
+BboSubscription = TypedDict("BboSubscription", {"type": Literal["bbo"], "coin": str})
+L2BookSubscription = TypedDict("L2BookSubscription", {"type": Literal["l2Book"], "coin": str})
+TradesSubscription = TypedDict("TradesSubscription", {"type": Literal["trades"], "coin": str})
+UserEventsSubscription = TypedDict("UserEventsSubscription", {"type": Literal["userEvents"], "user": str})
+UserFillsSubscription = TypedDict("UserFillsSubscription", {"type": Literal["userFills"], "user": str})
+CandleSubscription = TypedDict("CandleSubscription", {"type": Literal["candle"], "coin": str, "interval": str})
+OrderUpdatesSubscription = TypedDict("OrderUpdatesSubscription", {"type": Literal["orderUpdates"], "user": str})
+UserFundingsSubscription = TypedDict("UserFundingsSubscription", {"type": Literal["userFundings"], "user": str})
+UserNonFundingLedgerUpdatesSubscription = TypedDict(
+    "UserNonFundingLedgerUpdatesSubscription", {"type": Literal["userNonFundingLedgerUpdates"], "user": str}
+)
+WebData2Subscription = TypedDict("WebData2Subscription", {"type": Literal["webData2"], "user": str})
+ActiveAssetCtxSubscription = TypedDict("ActiveAssetCtxSubscription", {"type": Literal["activeAssetCtx"], "coin": str})
+ActiveAssetDataSubscription = TypedDict(
+    "ActiveAssetDataSubscription", {"type": Literal["activeAssetData"], "user": str, "coin": str}
+)
+# If adding new subscription types that contain coin's don't forget to handle automatically rewrite name to coin in info.subscribe
+Subscription = Union[
+    AllMidsSubscription,
+    BboSubscription,
+    L2BookSubscription,
+    TradesSubscription,
+    UserEventsSubscription,
+    UserFillsSubscription,
+    CandleSubscription,
+    OrderUpdatesSubscription,
+    UserFundingsSubscription,
+    UserNonFundingLedgerUpdatesSubscription,
+    WebData2Subscription,
+    ActiveAssetCtxSubscription,
+    ActiveAssetDataSubscription,
+]
+
+AllMidsData = TypedDict("AllMidsData", {"mids": Dict[str, str]})
+AllMidsMsg = TypedDict("AllMidsMsg", {"channel": Literal["allMids"], "data": AllMidsData})
+L2Level = TypedDict("L2Level", {"px": str, "sz": str, "n": int})
+L2BookData = TypedDict("L2BookData", {"coin": str, "levels": Tuple[List[L2Level], List[L2Level]], "time": int})
+L2BookMsg = TypedDict("L2BookMsg", {"channel": Literal["l2Book"], "data": L2BookData})
+BboData = TypedDict("BboData", {"coin": str, "time": int, "bbo": Tuple[Optional[L2Level], Optional[L2Level]]})
+BboMsg = TypedDict("BboMsg", {"channel": Literal["bbo"], "data": BboData})
+PongMsg = TypedDict("PongMsg", {"channel": Literal["pong"]})
+Trade = TypedDict("Trade", {"coin": str, "side": Side, "px": str, "sz": int, "hash": str, "time": int})
+CrossLeverage = TypedDict(
+    "CrossLeverage",
+    {
+        "type": Literal["cross"],
+        "value": int,
+    },
+)
+IsolatedLeverage = TypedDict(
+    "IsolatedLeverage",
+    {
+        "type": Literal["isolated"],
+        "value": int,
+        "rawUsd": str,
+    },
+)
+Leverage = Union[CrossLeverage, IsolatedLeverage]
+TradesMsg = TypedDict("TradesMsg", {"channel": Literal["trades"], "data": List[Trade]})
+PerpAssetCtx = TypedDict(
+    "PerpAssetCtx",
+    {
+        "funding": str,
+        "openInterest": str,
+        "prevDayPx": str,
+        "dayNtlVlm": str,
+        "premium": str,
+        "oraclePx": str,
+        "markPx": str,
+        "midPx": Optional[str],
+        "impactPxs": Optional[Tuple[str, str]],
+        "dayBaseVlm": str,
+    },
+)
+ActiveAssetCtx = TypedDict("ActiveAssetCtx", {"coin": str, "ctx": PerpAssetCtx})
+ActiveSpotAssetCtx = TypedDict("ActiveSpotAssetCtx", {"coin": str, "ctx": SpotAssetCtx})
+ActiveAssetCtxMsg = TypedDict("ActiveAssetCtxMsg", {"channel": Literal["activeAssetCtx"], "data": ActiveAssetCtx})
+ActiveSpotAssetCtxMsg = TypedDict(
+    "ActiveSpotAssetCtxMsg", {"channel": Literal["activeSpotAssetCtx"], "data": ActiveSpotAssetCtx}
+)
+ActiveAssetData = TypedDict(
+    "ActiveAssetData",
+    {
+        "user": str,
+        "coin": str,
+        "leverage": Leverage,
+        "maxTradeSzs": Tuple[str, str],
+        "availableToTrade": Tuple[str, str],
+        "markPx": str,
+    },
+)
+ActiveAssetDataMsg = TypedDict("ActiveAssetDataMsg", {"channel": Literal["activeAssetData"], "data": ActiveAssetData})
+Fill = TypedDict(
+    "Fill",
+    {
+        "coin": str,
+        "px": str,
+        "sz": str,
+        "side": Side,
+        "time": int,
+        "startPosition": str,
+        "dir": str,
+        "closedPnl": str,
+        "hash": str,
+        "oid": int,
+        "crossed": bool,
+        "fee": str,
+        "tid": int,
+        "feeToken": str,
+    },
+)
+# TODO: handle other types of user events
+UserEventsData = TypedDict("UserEventsData", {"fills": List[Fill]}, total=False)
+UserEventsMsg = TypedDict("UserEventsMsg", {"channel": Literal["user"], "data": UserEventsData})
+UserFillsData = TypedDict("UserFillsData", {"user": str, "isSnapshot": bool, "fills": List[Fill]})
+UserFillsMsg = TypedDict("UserFillsMsg", {"channel": Literal["userFills"], "data": UserFillsData})
+OtherWsMsg = TypedDict(
+    "OtherWsMsg",
+    {
+        "channel": Union[
+            Literal["candle"],
+            Literal["orderUpdates"],
+            Literal["userFundings"],
+            Literal["userNonFundingLedgerUpdates"],
+            Literal["webData2"],
+        ],
+        "data": Any,
+    },
+    total=False,
+)
+WsMsg = Union[
+    AllMidsMsg,
+    BboMsg,
+    L2BookMsg,
+    TradesMsg,
+    UserEventsMsg,
+    PongMsg,
+    UserFillsMsg,
+    OtherWsMsg,
+    ActiveAssetCtxMsg,
+    ActiveSpotAssetCtxMsg,
+    ActiveAssetDataMsg,
+]
+
+# b is the public address of the builder, f is the amount of the fee in tenths of basis points. e.g. 10 means 1 basis point
+BuilderInfo = TypedDict("BuilderInfo", {"b": str, "f": int})
+Abstraction = Literal["unifiedAccount", "portfolioMargin", "disabled"]
+AgentAbstraction = Literal["u", "p", "i"]
+
+PerpDexSchemaInput = TypedDict(
+    "PerpDexSchemaInput", {"fullName": str, "collateralToken": int, "oracleUpdater": Optional[str]}
+)
+
+
+class Cloid:
+    def __init__(self, raw_cloid: str):
+        self._raw_cloid: str = raw_cloid
+        self._validate()
+
+    def _validate(self):
+        if not self._raw_cloid[:2] == "0x":
+            raise TypeError("cloid is not a hex string")
+        if not len(self._raw_cloid[2:]) == 32:
+            raise TypeError("cloid is not 16 bytes")
+
+    def __str__(self):
+        return str(self._raw_cloid)
+
+    def __repr__(self):
+        return str(self._raw_cloid)
+
+    @staticmethod
+    def from_int(cloid: int) -> Cloid:
+        return Cloid(f"{cloid:#034x}")
+
+    @staticmethod
+    def from_str(cloid: str) -> Cloid:
+        return Cloid(cloid)
+
+    def to_raw(self):
+        return self._raw_cloid

hyperliquid/websocket_manager.py

@@ -0,0 +1,197 @@
+import asyncio
+import inspect
+import json
+import logging
+from collections import defaultdict
+
+import websockets
+
+from hyperliquid.utils.types import Any, Callable, Dict, List, NamedTuple, Optional, Subscription, Tuple, WsMsg
+
+ActiveSubscription = NamedTuple("ActiveSubscription", [("callback", Callable[[Any], None]), ("subscription_id", int)])
+
+
+def subscription_to_identifier(subscription: Subscription) -> str:
+    if subscription["type"] == "allMids":
+        return "allMids"
+    elif subscription["type"] == "l2Book":
+        return f'l2Book:{subscription["coin"].lower()}'
+    elif subscription["type"] == "trades":
+        return f'trades:{subscription["coin"].lower()}'
+    elif subscription["type"] == "userEvents":
+        return "userEvents"
+    elif subscription["type"] == "userFills":
+        return f'userFills:{subscription["user"].lower()}'
+    elif subscription["type"] == "candle":
+        return f'candle:{subscription["coin"].lower()},{subscription["interval"]}'
+    elif subscription["type"] == "orderUpdates":
+        return "orderUpdates"
+    elif subscription["type"] == "userFundings":
+        return f'userFundings:{subscription["user"].lower()}'
+    elif subscription["type"] == "userNonFundingLedgerUpdates":
+        return f'userNonFundingLedgerUpdates:{subscription["user"].lower()}'
+    elif subscription["type"] == "webData2":
+        return f'webData2:{subscription["user"].lower()}'
+    elif subscription["type"] == "bbo":
+        return f'bbo:{subscription["coin"].lower()}'
+    elif subscription["type"] == "activeAssetCtx":
+        return f'activeAssetCtx:{subscription["coin"].lower()}'
+    elif subscription["type"] == "activeAssetData":
+        return f'activeAssetData:{subscription["coin"].lower()},{subscription["user"].lower()}'
+    raise ValueError(f"Unsupported subscription type: {subscription['type']}")
+
+
+def ws_msg_to_identifier(ws_msg: WsMsg) -> Optional[str]:
+    if ws_msg["channel"] == "pong":
+        return "pong"
+    elif ws_msg["channel"] == "allMids":
+        return "allMids"
+    elif ws_msg["channel"] == "l2Book":
+        return f'l2Book:{ws_msg["data"]["coin"].lower()}'
+    elif ws_msg["channel"] == "trades":
+        trades = ws_msg["data"]
+        if len(trades) == 0:
+            return None
+        return f'trades:{trades[0]["coin"].lower()}'
+    elif ws_msg["channel"] == "user":
+        return "userEvents"
+    elif ws_msg["channel"] == "userFills":
+        return f'userFills:{ws_msg["data"]["user"].lower()}'
+    elif ws_msg["channel"] == "candle":
+        return f'candle:{ws_msg["data"]["s"].lower()},{ws_msg["data"]["i"]}'
+    elif ws_msg["channel"] == "orderUpdates":
+        return "orderUpdates"
+    elif ws_msg["channel"] == "userFundings":
+        return f'userFundings:{ws_msg["data"]["user"].lower()}'
+    elif ws_msg["channel"] == "userNonFundingLedgerUpdates":
+        return f'userNonFundingLedgerUpdates:{ws_msg["data"]["user"].lower()}'
+    elif ws_msg["channel"] == "webData2":
+        return f'webData2:{ws_msg["data"]["user"].lower()}'
+    elif ws_msg["channel"] == "bbo":
+        return f'bbo:{ws_msg["data"]["coin"].lower()}'
+    elif ws_msg["channel"] == "activeAssetCtx" or ws_msg["channel"] == "activeSpotAssetCtx":
+        return f'activeAssetCtx:{ws_msg["data"]["coin"].lower()}'
+    elif ws_msg["channel"] == "activeAssetData":
+        return f'activeAssetData:{ws_msg["data"]["coin"].lower()},{ws_msg["data"]["user"].lower()}'
+    return None
+
+
+class WebsocketManager:
+    def __init__(self, base_url: str):
+        self.subscription_id_counter = 0
+        self.queued_subscriptions: List[Tuple[Subscription, ActiveSubscription]] = []
+        self.active_subscriptions: Dict[str, List[ActiveSubscription]] = defaultdict(list)
+        self.ws_url = "ws" + base_url[len("http") :] + "/ws"
+        self.ws = None
+        self._runner_task: Optional[asyncio.Task] = None
+        self._ping_task: Optional[asyncio.Task] = None
+        self._ready_event = asyncio.Event()
+        self._stop_event = asyncio.Event()
+
+    async def start(self) -> None:
+        if self._runner_task is not None and not self._runner_task.done():
+            return
+        self._stop_event.clear()
+        self._runner_task = asyncio.create_task(self._run())
+
+    async def stop(self) -> None:
+        self._stop_event.set()
+        if self.ws is not None:
+            await self.ws.close()
+        if self._runner_task is not None:
+            await self._runner_task
+        self._ready_event.clear()
+
+    async def _run(self) -> None:
+        try:
+            async with websockets.connect(self.ws_url, ping_interval=None) as websocket:
+                self.ws = websocket
+                self._ready_event.set()
+                for subscription, active_subscription in list(self.queued_subscriptions):
+                    await self.subscribe(subscription, active_subscription.callback, active_subscription.subscription_id)
+                self.queued_subscriptions.clear()
+                self._ping_task = asyncio.create_task(self._send_ping())
+                await self._consume_messages()
+        finally:
+            self.ws = None
+            self._ready_event.clear()
+            if self._ping_task is not None:
+                self._ping_task.cancel()
+                try:
+                    await self._ping_task
+                except asyncio.CancelledError:
+                    pass
+                self._ping_task = None
+
+    async def _send_ping(self) -> None:
+        try:
+            while not self._stop_event.is_set():
+                await asyncio.sleep(50)
+                if self.ws is None:
+                    break
+                logging.debug("Websocket sending ping")
+                await self.ws.send(json.dumps({"method": "ping"}))
+        except asyncio.CancelledError:
+            raise
+        finally:
+            logging.debug("Websocket ping sender stopped")
+
+    async def _consume_messages(self) -> None:
+        assert self.ws is not None
+        async for message in self.ws:
+            if message == "Websocket connection established.":
+                logging.debug(message)
+                continue
+            logging.debug("on_message %s", message)
+            ws_msg: WsMsg = json.loads(message)
+            identifier = ws_msg_to_identifier(ws_msg)
+            if identifier == "pong":
+                logging.debug("Websocket received pong")
+                continue
+            if identifier is None:
+                logging.debug("Websocket not handling empty message")
+                continue
+            active_subscriptions = self.active_subscriptions[identifier]
+            if len(active_subscriptions) == 0:
+                print("Websocket message from an unexpected subscription:", message, identifier)
+                continue
+            for active_subscription in active_subscriptions:
+                result = active_subscription.callback(ws_msg)
+                if inspect.isawaitable(result):
+                    asyncio.create_task(result)
+
+    async def subscribe(
+        self, subscription: Subscription, callback: Callable[[Any], None], subscription_id: Optional[int] = None
+    ) -> int:
+        if subscription_id is None:
+            self.subscription_id_counter += 1
+            subscription_id = self.subscription_id_counter
+        if not self._ready_event.is_set():
+            logging.debug("enqueueing subscription")
+            self.queued_subscriptions.append((subscription, ActiveSubscription(callback, subscription_id)))
+            return subscription_id
+
+        logging.debug("subscribing")
+        identifier = subscription_to_identifier(subscription)
+        if identifier == "userEvents" or identifier == "orderUpdates":
+            # TODO: ideally the userEvent and orderUpdates messages would include the user so that we can multiplex
+            if len(self.active_subscriptions[identifier]) != 0:
+                raise NotImplementedError(f"Cannot subscribe to {identifier} multiple times")
+
+        self.active_subscriptions[identifier].append(ActiveSubscription(callback, subscription_id))
+        assert self.ws is not None
+        await self.ws.send(json.dumps({"method": "subscribe", "subscription": subscription}))
+        return subscription_id
+
+    async def unsubscribe(self, subscription: Subscription, subscription_id: int) -> bool:
+        if not self._ready_event.is_set():
+            raise NotImplementedError("Can't unsubscribe before websocket connected")
+
+        identifier = subscription_to_identifier(subscription)
+        active_subscriptions = self.active_subscriptions[identifier]
+        new_active_subscriptions = [x for x in active_subscriptions if x.subscription_id != subscription_id]
+        if len(new_active_subscriptions) == 0:
+            assert self.ws is not None
+            await self.ws.send(json.dumps({"method": "unsubscribe", "subscription": subscription}))
+        self.active_subscriptions[identifier] = new_active_subscriptions
+        return len(active_subscriptions) != len(new_active_subscriptions)

hyperliquid_python_sdk_async-0.24.6.dist-info/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Hyperliquid Labs Pte. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

hyperliquid_python_sdk_async-0.24.6.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.1
+Name: hyperliquid-python-sdk-async
+Version: 0.24.6
+Summary: SDK for Hyperliquid API trading with Python.
+Home-page: https://github.com/hyperliquid-dex/hyperliquid-python-sdk
+License: MIT
+Author: Hyperliquid
+Author-email: hello@hyperliquid.xyz
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: aiohttp (>=3.10,<4.0)
+Requires-Dist: eth-account (>=0.13.5,<0.14.0)
+Requires-Dist: eth-utils (>=5.2.0,<6.0.0)
+Requires-Dist: msgpack (>=1.0.5,<2.0.0)
+Requires-Dist: websockets (>=15.0.1,<16.0.0)
+Project-URL: Repository, https://github.com/hyperliquid-dex/hyperliquid-python-sdk
+Description-Content-Type: text/markdown
+
+# hyperliquid-python-sdk
+
+<div align="center">
+
+[![Dependencies Status](https://img.shields.io/badge/dependencies-up%20to%20date-brightgreen.svg)](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Aapp%2Fdependabot)
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Security: bandit](https://img.shields.io/badge/security-bandit-green.svg)](https://github.com/PyCQA/bandit)
+[![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/blob/master/.pre-commit-config.yaml)
+[![Semantic Versions](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--versions-e10079.svg)](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/releases)
+[![License](https://img.shields.io/pypi/l/hyperliquid-python-sdk)](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/blob/master/LICENSE.md)
+
+SDK for Hyperliquid API trading with Python.
+
+</div>
+
+## Installation
+```bash
+pip install hyperliquid-python-sdk
+```
+## Configuration 
+
+- Set the public key as the `account_address` in examples/config.json.
+- Set your private key as the `secret_key` in examples/config.json.
+- See the example of loading the config in examples/example_utils.py
+
+### [Optional] Generate a new API key for an API Wallet
+Generate and authorize a new API private key on https://app.hyperliquid.xyz/API, and set the API wallet's private key as the `secret_key` in examples/config.json. Note that you must still set the public key of the main wallet *not* the API wallet as the `account_address` in examples/config.json
+
+## Usage Examples
+```python
+import asyncio
+
+from hyperliquid.info import Info
+from hyperliquid.utils import constants
+
+
+async def main():
+    async with Info(constants.TESTNET_API_URL, skip_ws=True) as info:
+        user_state = await info.user_state("0xcd5051944f780a621ee62e39e493c489668acf4d")
+        print(user_state)
+
+
+asyncio.run(main())
+```
+See [examples](examples) for more complete examples. You can also checkout the repo and run any of the examples after configuring your private key e.g. 
+```bash
+cp examples/config.json.example examples/config.json
+vim examples/config.json
+python examples/basic_order.py
+```
+
+## Getting started with contributing to this repo
+
+1. Download `Poetry`: https://python-poetry.org/. 
+   - Note that in the install script you might have to set `symlinks=True` in `venv.EnvBuilder`.
+   - Note that Poetry v2 is not supported, so you'll need to specify a specific version e.g. curl -sSL https://install.python-poetry.org | POETRY_VERSION=1.4.1 python3 - 
+
+2. Point poetry to correct version of python. For development we require python 3.10 exactly. Some dependencies have issues on 3.11, while older versions don't have correct typing support.
+`brew install python@3.10 && poetry env use /opt/homebrew/Cellar/python@3.10/3.10.16/bin/python3.10`
+
+3. Install dependencies:
+
+```bash
+make install
+```
+
+### Makefile usage
+
+CLI commands for faster development. See `make help` for more details.
+
+```bash
+check-safety          Run safety checks on dependencies
+cleanup               Cleanup project
+install               Install dependencies from poetry.lock
+install-types         Find and install additional types for mypy
+lint                  Alias for the pre-commit target
+lockfile-update       Update poetry.lock
+lockfile-update-full  Fully regenerate poetry.lock
+poetry-download       Download and install poetry
+pre-commit            Run linters + formatters via pre-commit, run "make pre-commit hook=black" to run only black
+test                  Run tests with pytest
+update-dev-deps       Update development dependencies to latest versions
+```
+
+## Releases
+
+You can see the list of available releases on the [GitHub Releases](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/releases) page.
+
+We follow the [Semantic Versions](https://semver.org/) specification and use [`Release Drafter`](https://github.com/marketplace/actions/release-drafter). As pull requests are merged, a draft release is kept up-to-date listing the changes, ready to publish when you’re ready. With the categories option, you can categorize pull requests in release notes using labels.
+
+### List of labels and corresponding titles
+
+|               **Label**               |  **Title in Releases**  |
+| :-----------------------------------: | :---------------------: |
+|       `enhancement`, `feature`        |        Features         |
+| `bug`, `refactoring`, `bugfix`, `fix` |  Fixes & Refactoring    |
+|       `build`, `ci`, `testing`        |  Build System & CI/CD   |
+|              `breaking`               |    Breaking Changes     |
+|            `documentation`            |     Documentation       |
+|            `dependencies`             |  Dependencies updates   |
+
+### Building and releasing
+
+Building a new version of the application contains steps:
+
+- Bump the version of your package with `poetry version <version>`. You can pass the new version explicitly, or a rule such as `major`, `minor`, or `patch`. For more details, refer to the [Semantic Versions](https://semver.org/) standard.
+- Make a commit to `GitHub`
+- Create a `GitHub release`
+- `poetry publish --build`
+
+## License
+
+This project is licensed under the terms of the `MIT` license. See [LICENSE](LICENSE.md) for more details.
+
+```bibtex
+@misc{hyperliquid-python-sdk,
+  author = {Hyperliquid},
+  title = {SDK for Hyperliquid API trading with Python.},
+  year = {2024},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/hyperliquid-dex/hyperliquid-python-sdk}}
+}
+```
+
+## Credits
+
+This project was generated with [`python-package-template`](https://github.com/TezRomacH/python-package-template).
+

hyperliquid_python_sdk_async-0.24.6.dist-info/RECORD

@@ -0,0 +1,15 @@
+hyperliquid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperliquid/api.py,sha256=5te2RzF6IrBm0avQQkgKc__nJf-__9RkFDZWfzO4gy4,2698
+hyperliquid/exchange.py,sha256=CDF6Kp68JTQqrrRKNEdVmecTiRWUNUYtUhpgPkfb14k,34604
+hyperliquid/info.py,sha256=eCpFr7d6v5Dd5HFypYwI-zgQoA6e4ynJNYKJKE_2mr4,12299
+hyperliquid/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperliquid/utils/constants.py,sha256=waLKEHF26qm-eyIZ2mpqg_rz5NuobN4VxKiH-mD1Tbg,144
+hyperliquid/utils/error.py,sha256=reXFISI7tHtv-ZLBkN-IP37LAHVvvxDUrSIOW7hXXMI,479
+hyperliquid/utils/signing.py,sha256=k47AoflhGHS0I8qUZpbhmnHTLRRwn1IepdUm9DmMC4U,16099
+hyperliquid/utils/types.py,sha256=UWHfz8XqOfFUDU5o_9eVILn1q3r_nOiKhEDW5tq7iLo,7944
+hyperliquid/websocket_manager.py,sha256=THqWiNqq_HUX9XO0o82amxvJ_usl6oVH529ddFHYq7Q,9022
+hyperliquid_python_sdk_async-0.24.6.dist-info/LICENSE.md,sha256=6lWTEWwNp94-WEWUHIzn8sBpLuRnH3s-OqmKiHJrkTw,1092
+hyperliquid_python_sdk_async-0.24.6.dist-info/METADATA,sha256=C5XxqffzScoKUyKRTqcxaRwYxnUF-zLgCxTn8GWAvYY,7264
+hyperliquid_python_sdk_async-0.24.6.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+hyperliquid_python_sdk_async-0.24.6.dist-info/entry_points.txt,sha256=2rSUHnXv0f5Qg5I5sFZs954V2TrG2SzLQezTh1U6iq0,67
+hyperliquid_python_sdk_async-0.24.6.dist-info/RECORD,,

hyperliquid_python_sdk_async-0.24.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.5.2
+Root-Is-Purelib: true
+Tag: py3-none-any

hyperliquid_python_sdk_async-0.24.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+hyperliquid-python-sdk=hyperliquid.__main__:app
+