async-hyperliquid 0.4.3__tar.gz → 0.4.4__tar.gz

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: async-hyperliquid
-Version: 0.4.3
+Version: 0.4.4
 Summary: Async Hyperliquid client using aiohttp
 Keywords: dex,hyperliquid,async,aiohttp,trading,cryptocurrency,defi
 Author: Yuki
@@ -48,6 +48,7 @@ Requires-Dist: msgpack>=1.1.0,<2.0.0
 Requires-Dist: eth-account>=0.13.5,<0.14.0
 Requires-Dist: eth-utils>=5.2.0,<6.0.0
 Requires-Dist: hl-web3>=0.1.0
+Requires-Dist: coincurve>=21.0.0
 Requires-Python: >=3.10, <4
 Project-URL: Changelog, https://github.com/traderfiapp/async-hyperliquid/blob/master/CHANGELOG.md
 Project-URL: Documentation, https://github.com/traderfiapp/async-hyperliquid

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "async-hyperliquid"
-version = "0.4.3"
+version = "0.4.4"
 description = "Async Hyperliquid client using aiohttp"
 authors = [{ name = "Yuki", email = "yuqi.lyle@gmail.com" }]
 readme = "README.md"
@@ -40,6 +40,7 @@ dependencies = [
     "eth-account (>=0.13.5,<0.14.0)",
     "eth-utils (>=5.2.0,<6.0.0)",
     "hl-web3>=0.1.0",
+    "coincurve>=21.0.0",
 ]
 
 [dependency-groups]

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/_async_hyperliquid/actions.py

@@ -2,13 +2,9 @@ import math
 import re
 import warnings
 
-from async_hyperliquid.utils.constants import (
-    HYPE_FACTOR,
-    MAINNET_API_URL,
-    USD_FACTOR,
-)
+from async_hyperliquid.utils.constants import HYPE_FACTOR, MAINNET_API_URL, USD_FACTOR
 from async_hyperliquid.utils.decorators import private_key_required
-from async_hyperliquid.utils.miscs import get_timestamp_ms, round_token_amount
+from async_hyperliquid.utils.miscs import round_token_amount
 from async_hyperliquid.utils.signing import (
     sign_approve_agent_action,
     sign_approve_builder_fee_action,
@@ -41,7 +37,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
 
     @private_key_required
     async def usd_transfer(self, amount: float, dest: str):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "usdSend",
             "amount": round_token_amount(amount, 2),
@@ -59,7 +55,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         token_id = token_info["tokenId"]
         wei_decimals = token_info["weiDecimals"]
         token = f"{token_name}:{token_id}"
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "spotSend",
             "destination": dest,
@@ -72,7 +68,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
 
     @private_key_required
     async def initiate_withdrawal(self, amount: float):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "withdraw3",
             "amount": round_token_amount(amount, 2),
@@ -84,7 +80,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
 
     @private_key_required
     async def usd_class_transfer(self, amount: float, to_perp: bool = False):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "usdClassTransfer",
             "amount": round_token_amount(amount, 2),
@@ -111,7 +107,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         token_id = token_info["tokenId"]
         wei_decimals = token_info["weiDecimals"]
         token = f"{token_name}:{token_id}"
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "sendAsset",
             "token": token,
@@ -128,7 +124,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
     @private_key_required
     async def staking_deposit(self, amount: float):
         amount_in_wei = int(math.floor(amount * HYPE_FACTOR))
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {"type": "cDeposit", "wei": amount_in_wei, "nonce": nonce}
         sig = sign_staking_deposit_action(self.account, action, self.is_mainnet)
         return await self.exchange.post_action_with_sig(action, sig, nonce)
@@ -136,11 +132,9 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
     @private_key_required
     async def staking_withdraw(self, amount: float):
         amount_in_wei = int(math.floor(amount * HYPE_FACTOR))
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {"type": "cWithdraw", "wei": amount_in_wei, "nonce": nonce}
-        sig = sign_staking_withdraw_action(
-            self.account, action, self.is_mainnet
-        )
+        sig = sign_staking_withdraw_action(self.account, action, self.is_mainnet)
         return await self.exchange.post_action_with_sig(action, sig, nonce)
 
     @private_key_required
@@ -148,7 +142,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         self, validator: str, amount: float, is_undelegate: bool = False
     ):
         amount_in_wei = int(math.floor(amount * HYPE_FACTOR))
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "tokenDelegate",
             "validator": validator,
@@ -160,9 +154,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         return await self.exchange.post_action_with_sig(action, sig, nonce)
 
     @private_key_required
-    async def vault_transfer(
-        self, vault: str, amount: float, is_deposit: bool = True
-    ):
+    async def vault_transfer(self, vault: str, amount: float, is_deposit: bool = True):
         usd_amount = int(math.floor(amount * USD_FACTOR))
         action = {
             "type": "vaultTransfer",
@@ -173,7 +165,7 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         return await self.exchange.post_action(action)
 
     async def approve_agent(self, agent: str, name: str | None = None):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "approveAgent",
             "agentAddress": agent,
@@ -187,26 +179,20 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         return await self.exchange.post_action_with_sig(action, sig, nonce)
 
     async def approve_builder_fee(self, max_fee_rate: float, builder: str):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         action = {
             "type": "approveBuilderFee",
             "maxFeeRate": f"{max_fee_rate:.3%}",
             "builder": builder,
             "nonce": nonce,
         }
-        sig = sign_approve_builder_fee_action(
-            self.account, action, self.is_mainnet
-        )
+        sig = sign_approve_builder_fee_action(self.account, action, self.is_mainnet)
         return await self.exchange.post_action_with_sig(action, sig, nonce)
 
     async def convert_to_multi_sig_user(self, users: list[str], threshold: int):
-        nonce = get_timestamp_ms()
+        nonce = self.next_nonce()
         signers = {"authorizedUsers": sorted(users), "threshold": threshold}
-        action = {
-            "type": "convertToMultiSigUser",
-            "signers": signers,
-            "nonce": nonce,
-        }
+        action = {"type": "convertToMultiSigUser", "signers": signers, "nonce": nonce}
         sig = sign_convert_to_multi_sig_user_action(
             self.account, action, self.is_mainnet
         )
@@ -220,16 +206,14 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
         action = {"type": "evmUserModify", "usingBigBlocks": enable}
         return await self.exchange.post_action(action)
 
-    async def user_dex_abstraction(
-        self, user: str | None = None, enabled: bool = True
-    ):
+    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()
+        nonce = self.next_nonce()
         if user is None:
             user = self.address
         action = {
@@ -238,30 +222,24 @@ class AsyncHyperliquidActionsClient(AsyncHyperliquidOrdersClient):
             "enabled": enabled,
             "nonce": nonce,
         }
-        sig = sign_user_dex_abstraction_action(
-            self.account, action, self.is_mainnet
-        )
+        sig = sign_user_dex_abstraction_action(self.account, action, self.is_mainnet)
         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}"
-            )
+            raise ValueError(f"user must be a 42-char hex address, got: {user!r}")
+        nonce = self.next_nonce()
         action = {
             "type": "userSetAbstraction",
             "user": user.lower(),
             "abstraction": abstraction,
             "nonce": nonce,
         }
-        sig = sign_user_set_abstraction_action(
-            self.account, action, self.is_mainnet
-        )
+        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):

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/_async_hyperliquid/core.py

@@ -1,27 +1,24 @@
 import asyncio
+from threading import Lock
 
-from aiohttp import ClientSession, ClientTimeout
+from aiohttp import TCPConnector, BaseConnector, ClientSession, ClientTimeout
 from eth_account import Account
-from eth_account.signers.local import LocalAccount
-from hl_web3.exchange import Exchange as EVMExchange
 from hl_web3.info import Info as EVMInfo
+from hl_web3.exchange import Exchange as EVMExchange
 from hl_web3.utils.constants import HL_RPC_URL, HL_TESTNET_RPC_URL
+from eth_account.signers.local import LocalAccount
 
-from async_hyperliquid.async_api import AsyncAPI
-from async_hyperliquid.exchange import ExchangeAPI
 from async_hyperliquid.info import InfoAPI
+from async_hyperliquid.exchange import ExchangeAPI
+from async_hyperliquid.async_api import AsyncAPI
+from async_hyperliquid.utils.miscs import get_timestamp_ms
+from async_hyperliquid.utils.types import Metas, PerpMeta, SpotMeta, SpotTokenMeta
 from async_hyperliquid.utils.constants import (
+    SPOT_OFFSET,
     MAINNET_API_URL,
     PERP_DEX_OFFSET,
-    SPOT_OFFSET,
     TESTNET_API_URL,
 )
-from async_hyperliquid.utils.types import (
-    Metas,
-    PerpMeta,
-    SpotMeta,
-    SpotTokenMeta,
-)
 
 
 class AsyncHyperliquidCore(AsyncAPI):
@@ -54,15 +51,27 @@ class AsyncHyperliquidCore(AsyncAPI):
         private_key: str | None = None,
         vault: str | None = None,
         perp_dexs: list[str] = [""],
+        session: ClientSession | None = None,
+        timeout: ClientTimeout | None = None,
+        connector: BaseConnector | None = None,
     ):
         self.address = address
         self.is_mainnet = is_mainnet
         self.account = Account.from_key(api_key)
-        self.session = ClientSession(timeout=ClientTimeout(connect=3))
+        self._nonce_lock = Lock()
+        self._last_nonce = 0
+        self._owns_session = session is None
+        self.session = session or self._build_session(
+            timeout=timeout, connector=connector
+        )
         self.base_url = MAINNET_API_URL if is_mainnet else TESTNET_API_URL
         self.info = InfoAPI(self.base_url, self.session)
         self.exchange = ExchangeAPI(
-            self.account, self.session, self.base_url, address=self.address
+            self.account,
+            self.session,
+            self.base_url,
+            address=self.address,
+            nonce_factory=self.next_nonce,
         )
 
         self.coin_assets = {}
@@ -81,6 +90,25 @@ class AsyncHyperliquidCore(AsyncAPI):
     def set_expires(self, expires: int | None) -> None:
         self.expires = expires
 
+    def _build_session(
+        self, *, timeout: ClientTimeout | None, connector: BaseConnector | None
+    ) -> ClientSession:
+        resolved_timeout = timeout or ClientTimeout(
+            connect=3, sock_connect=3, sock_read=10
+        )
+        resolved_connector = connector or TCPConnector(
+            ttl_dns_cache=300, enable_cleanup_closed=True
+        )
+        return ClientSession(timeout=resolved_timeout, connector=resolved_connector)
+
+    def next_nonce(self) -> int:
+        with self._nonce_lock:
+            nonce = get_timestamp_ms()
+            if nonce <= self._last_nonce:
+                nonce = self._last_nonce + 1
+            self._last_nonce = nonce
+            return nonce
+
     def _init_evm_client(
         self, private_key: str | None, rpc_url: str | None = None
     ) -> None:
@@ -91,9 +119,7 @@ class AsyncHyperliquidCore(AsyncAPI):
 
         if private_key is None:
             if self.account.address != self.address:
-                raise ValueError(
-                    "EVM Exchange client can not init without private key"
-                )
+                raise ValueError("EVM Exchange client can not init without private key")
             private_key = self.account.key.hex()
 
         self.evm_exchange = EVMExchange(rpc_url, private_key)
@@ -107,7 +133,8 @@ class AsyncHyperliquidCore(AsyncAPI):
             self.asset_sz_decimals[asset] = info["szDecimals"]
 
     def _init_spot_meta(self, meta: SpotMeta) -> None:
-        total_tokens = len(meta["tokens"])
+        tokens = meta["tokens"]
+        total_tokens = len(tokens)
         for info in meta["universe"]:
             asset = info["index"] + SPOT_OFFSET
             asset_name = info["name"]
@@ -116,19 +143,20 @@ class AsyncHyperliquidCore(AsyncAPI):
             self.coin_names[asset_name] = asset_name
 
             base, quote = info["tokens"]
-            if base >= total_tokens or quote >= total_tokens:
-                print("Unreconized token index for: ", info)
+            if not 0 <= base < total_tokens or not 0 <= quote < total_tokens:
                 continue
 
-            base_info = meta["tokens"][base]
+            base_info = tokens[base]
             base_name = base_info["name"]
-            quote_name = meta["tokens"][quote]["name"]
+            quote_info = tokens[quote]
+            quote_name = quote_info["name"]
             name = f"{base_name}/{quote_name}"
-            if name not in self.coin_names:
-                self.coin_names[name] = asset_name
+            self.coin_names.setdefault(name, asset_name)
+            self.coin_names.setdefault(quote_name, quote_name)
 
             self.asset_sz_decimals[asset] = base_info["szDecimals"]
-            self.spot_tokens[asset_name] = meta["tokens"][base]
+            self.spot_tokens[asset_name] = base_info
+            self.spot_tokens.setdefault(quote_name, quote_info)
 
     def _update_coin_symbols(self) -> None:
         self.coin_symbols = {
@@ -171,24 +199,31 @@ class AsyncHyperliquidCore(AsyncAPI):
 
     async def get_metas(self, perp_only: bool = False) -> Metas:
         metas: Metas = {"perp": {}, "spot": [], "dexs": {}}  # type: ignore
-        perp_meta = await self.info.get_perp_meta()
         if perp_only:
-            metas["perp"] = perp_meta
+            metas["perp"] = await self.info.get_perp_meta()
             return metas
 
-        metas["spot"] = await self.info.get_spot_meta()
+        perp_meta, spot_meta = await asyncio.gather(
+            self.info.get_perp_meta(), self.info.get_spot_meta()
+        )
+        metas["perp"] = perp_meta
+        metas["spot"] = spot_meta
         return metas
 
     async def get_all_metas(self) -> Metas:
-        dexs = await self.get_all_dex_name()
-        dex_metas = {}
-
-        for dex in dexs[1:]:
-            meta = await self.info.get_perp_meta(dex)
-            dex_metas[dex] = meta
-
-        spot_meta = await self.info.get_spot_meta()
-        perp_meta = await self.info.get_perp_meta()
+        dexs, perp_meta, spot_meta = await asyncio.gather(
+            self.get_all_dex_name(),
+            self.info.get_perp_meta(),
+            self.info.get_spot_meta(),
+        )
+        dex_metas: dict[str, PerpMeta] = {}
+        if len(dexs) > 1:
+            dex_meta_results = await asyncio.gather(
+                *(self.info.get_perp_meta(dex) for dex in dexs[1:])
+            )
+            dex_metas = {
+                dex: meta for dex, meta in zip(dexs[1:], dex_meta_results, strict=True)
+            }
         return {"perp": perp_meta, "spot": spot_meta, "dexs": dex_metas}
 
     async def get_all_dex_name(self) -> list[str]:
@@ -212,7 +247,6 @@ class AsyncHyperliquidCore(AsyncAPI):
 
     async def get_coin_asset(self, coin: str) -> int:
         coin_name = await self.get_coin_name(coin)
-
         if coin_name not in self.coin_assets:
             raise ValueError(f"Coin {coin}({coin_name}) not found")
 
@@ -224,7 +258,10 @@ class AsyncHyperliquidCore(AsyncAPI):
 
     async def get_coin_sz_decimals(self, coin: str) -> int:
         coin_name = await self.get_coin_name(coin)
-        asset = await self.get_coin_asset(coin_name)
+        if coin_name not in self.coin_assets:
+            raise ValueError(f"Coin {coin}({coin_name}) not found")
+
+        asset = self.coin_assets[coin_name]
         return self.asset_sz_decimals[asset]
 
     async def get_token_info(self, coin: str) -> SpotTokenMeta:

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/_async_hyperliquid/info.py

@@ -2,11 +2,7 @@ import asyncio
 import warnings
 from typing import Literal
 
-from async_hyperliquid.utils.constants import (
-    ONE_HOUR_MS,
-    PERP_DEX_OFFSET,
-    SPOT_OFFSET,
-)
+from async_hyperliquid.utils.constants import ONE_HOUR_MS, PERP_DEX_OFFSET, SPOT_OFFSET
 from async_hyperliquid.utils.miscs import get_coin_dex, get_timestamp_ms
 from async_hyperliquid.utils.types import (
     Abstraction,
@@ -50,10 +46,15 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
         await self.init_metas()
         spot_data = None
         perp_data = None
-        if is_spot or is_all:
-            spot_data = await self.info.get_spot_meta_ctx()
-        if is_perp or is_all:
-            perp_data = await self.info.get_perp_meta_ctx()
+        if is_all:
+            spot_data, perp_data = await asyncio.gather(
+                self.info.get_spot_meta_ctx(), self.info.get_perp_meta_ctx()
+            )
+        else:
+            if is_spot:
+                spot_data = await self.info.get_spot_meta_ctx()
+            if is_perp:
+                perp_data = await self.info.get_perp_meta_ctx()
 
         is_perp = is_perp or is_all
         is_spot = is_spot or is_all
@@ -102,9 +103,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
             address = self.address
         return await self.info.get_spot_clearinghouse_state(address)
 
-    async def get_account_state(
-        self, address: str | None = None
-    ) -> AccountState:
+    async def get_account_state(self, address: str | None = None) -> AccountState:
         if not address:
             address = self.address
 
@@ -127,9 +126,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
 
         return account_state
 
-    async def get_account_portfolio(
-        self, address: str | None = None
-    ) -> Portfolio:
+    async def get_account_portfolio(self, address: str | None = None) -> Portfolio:
         if not address:
             address = self.address
 
@@ -158,9 +155,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
         start_time: int | None = None,
         end_time: int | None = None,
     ) -> list[UserDeposit]:
-        return await self.get_latest_ledgers(
-            "deposit", address, start_time, end_time
-        )  # type: ignore
+        return await self.get_latest_ledgers("deposit", address, start_time, end_time)  # type: ignore
 
     async def get_latest_withdraws(
         self,
@@ -168,9 +163,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
         start_time: int | None = None,
         end_time: int | None = None,
     ) -> list[UserWithdraw]:
-        return await self.get_latest_ledgers(
-            "withdraw", address, start_time, end_time
-        )  # type: ignore
+        return await self.get_latest_ledgers("withdraw", address, start_time, end_time)  # type: ignore
 
     async def get_latest_transfers(
         self,
@@ -183,10 +176,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
         )  # type: ignore
 
     async def get_user_open_orders(
-        self,
-        address: str | None = None,
-        is_frontend: bool = False,
-        dex: str = "",
+        self, address: str | None = None, is_frontend: bool = False, dex: str = ""
     ) -> UserOpenOrders:
         if not address:
             address = self.address
@@ -226,9 +216,7 @@ class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
             positions.extend(result)
         return positions
 
-    async def get_user_abstraction(
-        self, address: str | None = None
-    ) -> Abstraction:
+    async def get_user_abstraction(self, address: str | None = None) -> Abstraction:
         if not address:
             address = self.address
         return await self.info.get_user_abstraction(address)

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/_async_hyperliquid/orders.py

@@ -1,10 +1,7 @@
+import asyncio
 import math
 
-from async_hyperliquid.utils.constants import (
-    PERP_DEX_OFFSET,
-    SPOT_OFFSET,
-    USD_FACTOR,
-)
+from async_hyperliquid.utils.constants import PERP_DEX_OFFSET, SPOT_OFFSET, USD_FACTOR
 from async_hyperliquid.utils.miscs import get_coin_dex, round_float, round_px
 from async_hyperliquid.utils.signing import encode_order, orders_to_action
 from async_hyperliquid.utils.types import (
@@ -24,9 +21,13 @@ from .info import AsyncHyperliquidInfoClient
 
 class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
     async def _round_sz_px(self, coin: str, sz: float, px: float):
-        asset = await self.get_coin_asset(coin)
+        coin_name = await self.get_coin_name(coin)
+        if coin_name not in self.coin_assets:
+            raise ValueError(f"Coin {coin}({coin_name}) not found")
+
+        asset = self.coin_assets[coin_name]
+        sz_decimals = self.asset_sz_decimals[asset]
         is_spot = asset >= SPOT_OFFSET and asset < PERP_DEX_OFFSET
-        sz_decimals = await self.get_coin_sz_decimals(coin)
         px_decimals = (6 if not is_spot else 8) - sz_decimals
         return asset, round_float(sz, sz_decimals), round_px(px, px_decimals)
 
@@ -146,41 +147,44 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
         slippage: float = 0.05,
         builder: OrderBuilder | None = None,
     ):
-        reqs = []
         if is_market:
             reqs = await self._get_batch_market_orders(orders, slippage)
         else:
-            for o in orders:
-                asset, sz, px = await self._round_sz_px(
-                    o["coin"], o["sz"], o["px"]
-                )
-                req = {**o, "asset": asset, "sz": sz, "px": px}
-                reqs.append(req)
+            reqs = await self._get_batch_limit_orders(orders)
 
         return await self.place_orders(reqs, grouping=grouping, builder=builder)
 
+    async def _get_batch_limit_orders(self, orders: BatchPlaceOrderRequest):
+        rounded_orders = await asyncio.gather(
+            *(self._round_sz_px(o["coin"], o["sz"], o["px"]) for o in orders)
+        )
+        return [
+            {**order, "asset": asset, "sz": sz, "px": px}
+            for order, (asset, sz, px) in zip(orders, rounded_orders)
+        ]
+
     async def _get_batch_market_orders(
         self, orders: BatchPlaceOrderRequest, slippage: float = 0.05
     ):
-        reqs = []
         dexs = list(set(get_coin_dex(o["coin"]) for o in orders))
         all_mids = await self.get_dexs_mids(dexs)
         order_type = limit_order_type(LimitTif.IOC)
-        for o in orders:
-            coin = o["coin"]
-            market_price = all_mids[coin]
-            slippage_factor = (1 + slippage) if o["is_buy"] else (1 - slippage)
-            px = market_price * slippage_factor
-            asset, sz, px = await self._round_sz_px(coin, o["sz"], px)
-            req = {
-                **o,
-                "asset": asset,
-                "sz": sz,
-                "px": px,
-                "order_type": order_type,
-            }
-            reqs.append(req)
-        return reqs
+        quoted_prices = []
+        for order in orders:
+            market_price = all_mids[order["coin"]]
+            slippage_factor = (1 + slippage) if order["is_buy"] else (1 - slippage)
+            quoted_prices.append(market_price * slippage_factor)
+
+        rounded_orders = await asyncio.gather(
+            *(
+                self._round_sz_px(order["coin"], order["sz"], quoted_price)
+                for order, quoted_price in zip(orders, quoted_prices)
+            )
+        )
+        return [
+            {**order, "asset": asset, "sz": sz, "px": px, "order_type": order_type}
+            for order, (asset, sz, px) in zip(orders, rounded_orders)
+        ]
 
     async def cancel_order(self, coin: str, oid: int):
         return await self.cancel_orders([(coin, int(oid))])
@@ -189,11 +193,14 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
         return await self.cancel_orders(cancels)
 
     async def cancel_orders(self, cancels: BatchCancelRequest):
+        assets = await asyncio.gather(
+            *(self.get_coin_asset(coin) for coin, _ in cancels)
+        )
         action = {
             "type": "cancel",
             "cancels": [
-                {"a": await self.get_coin_asset(coin), "o": oid}
-                for coin, oid in cancels
+                {"a": asset, "o": oid}
+                for asset, (_, oid) in zip(assets, cancels, strict=True)
             ],
         }
 
@@ -205,14 +212,14 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
         return await self.batch_cancel_by_cloid([(coin, cloid)])
 
     async def batch_cancel_by_cloid(self, cancels: list[tuple[str, Cloid]]):
+        assets = await asyncio.gather(
+            *(self.get_coin_asset(coin) for coin, _ in cancels)
+        )
         action = {
             "type": "cancelByCloid",
             "cancels": [
-                {
-                    "asset": await self.get_coin_asset(coin),
-                    "cloid": cloid.to_raw(),
-                }
-                for coin, cloid in cancels
+                {"asset": asset, "cloid": cloid.to_raw()}
+                for asset, (_, cloid) in zip(assets, cancels, strict=True)
             ],
         }
 
@@ -255,9 +262,7 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
     async def batch_modify_orders(self, modify_req: list[dict]):
         modifies = [
             {
-                "oid": m["oid"].to_raw()
-                if isinstance(m["oid"], Cloid)
-                else m["oid"],
+                "oid": m["oid"].to_raw() if isinstance(m["oid"], Cloid) else m["oid"],
                 "order": encode_order(m["order"]),
             }
             for m in modify_req
@@ -267,9 +272,7 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
             action, vault=self.vault, expires=self.expires
         )
 
-    async def update_leverage(
-        self, leverage: int, coin: str, is_cross: bool = True
-    ):
+    async def update_leverage(self, leverage: int, coin: str, is_cross: bool = True):
         action = {
             "type": "updateLeverage",
             "asset": await self.get_coin_asset(coin),
@@ -355,29 +358,33 @@ class AsyncHyperliquidOrdersClient(AsyncHyperliquidInfoClient):
     async def close_dex_positions(self, dex: str):
         return await self.close_all_positions(dexs=[dex])
 
-    async def close_position(self, coin: str):
-        dex = get_coin_dex(coin)
-        positions = await self.get_dex_positions(dex=dex)
-        target = {}
+    async def close_positions(self, coins: list[str]):
+        if not coins:
+            return None
+
+        positions = await self.get_all_positions(
+            dexs=sorted({get_coin_dex(coin) for coin in coins})
+        )
+        targets = {coin: None for coin in coins}
         for position in positions:
-            if coin == position["coin"]:
-                target = position
+            coin = position["coin"]
+            if coin in targets:
+                targets[coin] = position
 
-        if not target:
+        orders = []
+        for coin in coins:
+            target = targets[coin]
+            if target is None:
+                continue
+            size = float(target["szi"])
+            orders.append(
+                {"coin": coin, "is_buy": size < 0, "sz": abs(size), "px": 0, "ro": True}
+            )
+
+        if not orders:
             return None
 
-        size = float(target["szi"])
-        price = await self.get_mid_price(coin)
-        if not price:
-            raise ValueError(f"Failed to retrieve market price for {coin}")
-
-        close_order = {
-            "coin": coin,
-            "is_buy": size < 0,
-            "sz": abs(size),
-            "px": price,
-            "is_market": True,
-            "ro": True,
-        }
+        return await self.batch_place_orders(orders, is_market=True)
 
-        return await self.place_order(**close_order)  # type: ignore
+    async def close_position(self, coin: str):
+        return await self.close_positions([coin])

async_hyperliquid-0.4.4/src/async_hyperliquid/async_api.py

@@ -0,0 +1,85 @@
+import logging
+from types import TracebackType
+from typing import Any
+from traceback import TracebackException
+
+from aiohttp import ClientSession
+
+from async_hyperliquid.utils.types import Endpoint
+from async_hyperliquid.utils.constants import MAINNET_API_URL
+
+logger = logging.getLogger(__name__)
+_REDACTED = "<redacted>"
+_SENSITIVE_PAYLOAD_KEYS = frozenset({"signature", "signatures"})
+
+
+def _redact_payload(payload: Any) -> Any:
+    if isinstance(payload, dict):
+        redacted: dict[str, Any] = {}
+        for key, value in payload.items():
+            if key in _SENSITIVE_PAYLOAD_KEYS:
+                redacted[key] = _REDACTED
+            elif key == "action" and isinstance(value, dict):
+                redacted[key] = {
+                    "type": value.get("type"),
+                    "keys": sorted(value.keys()),
+                }
+            else:
+                redacted[key] = _redact_payload(value)
+        return redacted
+
+    if isinstance(payload, list):
+        return [_redact_payload(item) for item in payload]
+
+    return payload
+
+
+class AsyncAPI:
+    def __init__(
+        self,
+        endpoint: Endpoint,
+        base_url: str | None = None,
+        session: ClientSession = None,  # type: ignore
+        *,
+        owns_session: bool = True,
+    ):
+        self.endpoint = endpoint
+        self.base_url = (base_url or MAINNET_API_URL).rstrip("/")
+        self.session = session
+        self._owns_session = owns_session
+        self._request_url = f"{self.base_url}/{self.endpoint.value}"
+
+    # for async with AsyncAPI() as api usage
+    async def __aenter__(self) -> "AsyncAPI":
+        return self
+
+    async def __aexit__(
+        self, exc_type: Exception, exc_val: TracebackException, traceback: TracebackType
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if (
+            getattr(self, "_owns_session", True)
+            and self.session
+            and not self.session.closed
+        ):
+            await self.session.close()
+
+    async def post(self, payload: dict | None = None) -> Any:
+        if self.session is None:
+            raise RuntimeError("ClientSession is not initialized")
+
+        payload = payload or {}
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("POST %s %s", self._request_url, _redact_payload(payload))
+
+        async with self.session.post(self._request_url, json=payload) as resp:
+            resp.raise_for_status()
+            try:
+                return await resp.json()
+            except Exception as e:
+                logger.error(
+                    "Error parsing JSON response from %s: %s", self._request_url, e
+                )
+                return await resp.text()

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/exchange.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Callable
 from typing import Any
 
 from aiohttp import ClientSession
@@ -8,10 +9,7 @@ from async_hyperliquid.async_api import AsyncAPI
 from async_hyperliquid.utils.miscs import get_timestamp_ms
 from async_hyperliquid.utils.types import Endpoint, SignType
 from async_hyperliquid.utils.signing import sign_action, sign_multi_sig_action
-from async_hyperliquid.utils.constants import (
-    MAINNET_API_URL,
-    SIGNATURE_CHAIN_ID,
-)
+from async_hyperliquid.utils.constants import MAINNET_API_URL, SIGNATURE_CHAIN_ID
 
 logger = logging.getLogger(__name__)
 
@@ -23,11 +21,13 @@ class ExchangeAPI(AsyncAPI):
         session: ClientSession,
         base_url: str | None = None,
         address: str | None = None,
+        nonce_factory: Callable[[], int] | None = None,
     ):
         self.account = account
         self.address = address or account.address
         self.is_mainnet = base_url == MAINNET_API_URL
-        super().__init__(Endpoint.EXCHANGE, base_url, session)
+        self._next_nonce = nonce_factory or get_timestamp_ms
+        super().__init__(Endpoint.EXCHANGE, base_url, session, owns_session=False)
 
     async def multi_sig(
         self,
@@ -65,7 +65,7 @@ class ExchangeAPI(AsyncAPI):
         assert self.endpoint == Endpoint.EXCHANGE, (
             "only exchange endpoint supports action"
         )
-        nonce = get_timestamp_ms()
+        nonce = self._next_nonce()
         # TODO: support multi sig
         signature = sign_action(
             self.account, action, vault, nonce, self.is_mainnet, expires
@@ -88,5 +88,12 @@ class ExchangeAPI(AsyncAPI):
             payload["vaultAddress"] = vault
         if expires:
             payload["expiresAfter"] = expires
-        logger.debug(f"Post action payload: {payload}")
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "Post action type=%s nonce=%s vault=%s expires=%s",
+                action.get("type"),
+                nonce,
+                bool(vault),
+                expires,
+            )
         return await self.post(payload)

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/info.py

@@ -45,7 +45,7 @@ from async_hyperliquid.utils.types import (
 
 class InfoAPI(AsyncAPI):
     def __init__(self, base_url: str, session: ClientSession):
-        super().__init__(Endpoint.INFO, base_url, session)
+        super().__init__(Endpoint.INFO, base_url, session, owns_session=False)
 
     async def get_all_mids(self, dex: str = "") -> dict[str, int]:
         payload = {"type": "allMids", "dex": dex}
@@ -86,12 +86,7 @@ class InfoAPI(AsyncAPI):
     async def get_order_status(
         self, order_id: str | int, address: str, dex: str = ""
     ) -> OrderWithStatus:
-        payload = {
-            "type": "orderStatus",
-            "user": address,
-            "oid": order_id,
-            "dex": dex,
-        }
+        payload = {"type": "orderStatus", "user": address, "oid": order_id, "dex": dex}
         return await self.post(payload)
 
     async def get_depth(
@@ -132,9 +127,7 @@ class InfoAPI(AsyncAPI):
         payload = {"type": "subAccounts", "user": address}
         return await self.post(payload)
 
-    async def get_vault_info(
-        self, address: str, user: str | None = None
-    ) -> VaultInfo:
+    async def get_vault_info(self, address: str, user: str | None = None) -> VaultInfo:
         payload = {"type": "vaultDetails", "vaultAddress": address}
         if user:
             payload["user"] = user
@@ -219,9 +212,7 @@ class InfoAPI(AsyncAPI):
         is_funding: bool = True,
     ) -> UserFundings:
         payload = {
-            "type": "userFunding"
-            if is_funding
-            else "userNonFundingLedgerUpdates",
+            "type": "userFunding" if is_funding else "userNonFundingLedgerUpdates",
             "user": address,
             "startTime": start_time,
             "endTime": end_time,
@@ -266,9 +257,7 @@ class InfoAPI(AsyncAPI):
         payload = {"type": "spotMetaAndAssetCtxs"}
         return await self.post(payload)
 
-    async def get_user_token_balances(
-        self, address: str
-    ) -> SpotClearinghouseState:
+    async def get_user_token_balances(self, address: str) -> SpotClearinghouseState:
         return await self.get_spot_clearinghouse_state(address)
 
     async def get_spot_clearinghouse_state(

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/utils/signing.py

@@ -37,6 +37,37 @@ from async_hyperliquid.utils.constants import (
     CONVERT_TO_MULTI_SIG_USER_SIGN_TYPES,
 )
 
+_EIP712_DOMAIN_FIELDS = [
+    {"name": "name", "type": "string"},
+    {"name": "version", "type": "string"},
+    {"name": "chainId", "type": "uint256"},
+    {"name": "verifyingContract", "type": "address"},
+]
+_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+_EXCHANGE_AGENT_DOMAIN = {
+    "chainId": 1337,
+    "name": "Exchange",
+    "verifyingContract": _ZERO_ADDRESS,
+    "version": "1",
+}
+_EXCHANGE_AGENT_MESSAGE_TYPES = {
+    "Agent": [
+        {"name": "source", "type": "string"},
+        {"name": "connectionId", "type": "bytes32"},
+    ]
+}
+_EXCHANGE_AGENT_PAYLOAD_BASE = {
+    "domain": _EXCHANGE_AGENT_DOMAIN,
+    "types": {
+        "Agent": _EXCHANGE_AGENT_MESSAGE_TYPES["Agent"],
+        "EIP712Domain": _EIP712_DOMAIN_FIELDS,
+    },
+    "primaryType": "Agent",
+}
+_USER_SIGNED_PAYLOAD_BASE_CACHE: dict[tuple[str, int, int], dict[str, Any]] = {}
+_USER_SIGNED_DOMAIN_CACHE: dict[int, dict[str, Any]] = {}
+_USER_SIGNED_MESSAGE_TYPES_CACHE: dict[tuple[str, int], dict[str, List[dict]]] = {}
+
 
 def address_to_bytes(address: str) -> bytes:
     return bytes.fromhex(address[2:] if address.startswith("0x") else address)
@@ -64,11 +95,67 @@ def hash_action(
 def sign_inner(wallet: LocalAccount, data: dict) -> SignedAction:
     encodes = encode_typed_data(full_message=data)
     signed = wallet.sign_message(encodes)
-    return {
-        "r": to_hex(signed["r"]),
-        "s": to_hex(signed["s"]),
-        "v": signed["v"],
-    }
+    return {"r": to_hex(signed["r"]), "s": to_hex(signed["s"]), "v": signed["v"]}
+
+
+def sign_typed_data(
+    wallet: LocalAccount,
+    domain_data: dict[str, Any],
+    message_types: dict[str, Any],
+    message_data: dict[str, Any],
+) -> SignedAction:
+    encodes = encode_typed_data(
+        domain_data=domain_data, message_types=message_types, message_data=message_data
+    )
+    signed = wallet.sign_message(encodes)
+    return {"r": to_hex(signed["r"]), "s": to_hex(signed["s"]), "v": signed["v"]}
+
+
+def _user_signed_domain(chain_id: int) -> dict[str, Any]:
+    payload = _USER_SIGNED_DOMAIN_CACHE.get(chain_id)
+    if payload is None:
+        payload = {
+            "name": "HyperliquidSignTransaction",
+            "version": "1",
+            "chainId": chain_id,
+            "verifyingContract": _ZERO_ADDRESS,
+        }
+        _USER_SIGNED_DOMAIN_CACHE[chain_id] = payload
+    return payload
+
+
+def _user_signed_message_types(
+    primary_type: str, payload_types: List[dict]
+) -> dict[str, List[dict]]:
+    cache_key = (primary_type, id(payload_types))
+    payload = _USER_SIGNED_MESSAGE_TYPES_CACHE.get(cache_key)
+    if payload is None:
+        payload = {primary_type: payload_types}
+        _USER_SIGNED_MESSAGE_TYPES_CACHE[cache_key] = payload
+    return payload
+
+
+def _user_signed_payload_base(
+    primary_type: str, payload_types: List[dict], chain_id: int
+):
+    cache_key = (primary_type, id(payload_types), chain_id)
+    payload = _USER_SIGNED_PAYLOAD_BASE_CACHE.get(cache_key)
+    if payload is None:
+        payload = {
+            "domain": {
+                "name": "HyperliquidSignTransaction",
+                "version": "1",
+                "chainId": chain_id,
+                "verifyingContract": _ZERO_ADDRESS,
+            },
+            "types": {
+                primary_type: payload_types,
+                "EIP712Domain": _EIP712_DOMAIN_FIELDS,
+            },
+            "primaryType": primary_type,
+        }
+        _USER_SIGNED_PAYLOAD_BASE_CACHE[cache_key] = payload
+    return payload
 
 
 def sign_action(
@@ -81,29 +168,9 @@ def sign_action(
 ) -> SignedAction:
     h = hash_action(action, active_pool, nonce, expires)
     msg = {"source": "a" if is_mainnet else "b", "connectionId": h}
-    data = {
-        "domain": {
-            "chainId": 1337,
-            "name": "Exchange",
-            "verifyingContract": "0x0000000000000000000000000000000000000000",
-            "version": "1",
-        },
-        "types": {
-            "Agent": [
-                {"name": "source", "type": "string"},
-                {"name": "connectionId", "type": "bytes32"},
-            ],
-            "EIP712Domain": [
-                {"name": "name", "type": "string"},
-                {"name": "version", "type": "string"},
-                {"name": "chainId", "type": "uint256"},
-                {"name": "verifyingContract", "type": "address"},
-            ],
-        },
-        "primaryType": "Agent",
-        "message": msg,
-    }
-    return sign_inner(wallet, data)
+    return sign_typed_data(
+        wallet, _EXCHANGE_AGENT_DOMAIN, _EXCHANGE_AGENT_MESSAGE_TYPES, msg
+    )
 
 
 def round_float(x: float) -> str:
@@ -124,9 +191,7 @@ def ensure_order_type(order_type: OrderType) -> OrderType:
         return {
             "trigger": {
                 "isMarket": order_type["trigger"]["isMarket"],
-                "triggerPx": round_float(
-                    float(order_type["trigger"]["triggerPx"])
-                ),
+                "triggerPx": round_float(float(order_type["trigger"]["triggerPx"])),
                 "tpsl": order_type["trigger"]["tpsl"],
             }
         }
@@ -168,22 +233,7 @@ def orders_to_action(
 def user_signed_payload(primary_type, payload_types, action):
     chain_id = int(action["signatureChainId"], 16)
     return {
-        "domain": {
-            "name": "HyperliquidSignTransaction",
-            "version": "1",
-            "chainId": chain_id,
-            "verifyingContract": "0x0000000000000000000000000000000000000000",
-        },
-        "types": {
-            primary_type: payload_types,
-            "EIP712Domain": [
-                {"name": "name", "type": "string"},
-                {"name": "version", "type": "string"},
-                {"name": "chainId", "type": "uint256"},
-                {"name": "verifyingContract", "type": "address"},
-            ],
-        },
-        "primaryType": primary_type,
+        **_user_signed_payload_base(primary_type, payload_types, chain_id),
         "message": action,
     }
 
@@ -197,8 +247,13 @@ def sign_user_signed_action(
 ):
     action["signatureChainId"] = SIGNATURE_CHAIN_ID
     action["hyperliquidChain"] = "Mainnet" if is_mainnet else "Testnet"
-    data = user_signed_payload(primary_type, payload_types, action)
-    return sign_inner(wallet, data)
+    chain_id = int(action["signatureChainId"], 16)
+    return sign_typed_data(
+        wallet,
+        _user_signed_domain(chain_id),
+        _user_signed_message_types(primary_type, payload_types),
+        action,
+    )
 
 
 def sign_usd_transfer_action(wallet: LocalAccount, action, is_mainnet: bool):
@@ -211,9 +266,7 @@ def sign_usd_transfer_action(wallet: LocalAccount, action, is_mainnet: bool):
     )
 
 
-def sign_spot_transfer_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_spot_transfer_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -233,9 +286,7 @@ def sign_withdraw_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     )
 
 
-def sign_usd_class_transfer_action(
-    wallet: LocalAccount, action: Any, is_mainnet: bool
-):
+def sign_usd_class_transfer_action(wallet: LocalAccount, action: Any, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -245,9 +296,7 @@ def sign_usd_class_transfer_action(
     )
 
 
-def sign_send_asset_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_send_asset_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -257,9 +306,7 @@ def sign_send_asset_action(
     )
 
 
-def sign_staking_deposit_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_staking_deposit_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -269,9 +316,7 @@ def sign_staking_deposit_action(
     )
 
 
-def sign_staking_withdraw_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_staking_withdraw_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -281,9 +326,7 @@ def sign_staking_withdraw_action(
     )
 
 
-def sign_token_delegate_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_token_delegate_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,
@@ -293,9 +336,7 @@ def sign_token_delegate_action(
     )
 
 
-def sign_approve_agent_action(
-    wallet: LocalAccount, action: dict, is_mainnet: bool
-):
+def sign_approve_agent_action(wallet: LocalAccount, action: dict, is_mainnet: bool):
     return sign_user_signed_action(
         wallet,
         action,

{async_hyperliquid-0.4.3 → async_hyperliquid-0.4.4}/src/async_hyperliquid/utils/types.py

@@ -690,11 +690,7 @@ class UserVaultWithdraw(TypedDict):
 
 
 UserNonFundingDelta = (
-    UserDeposit
-    | UserWithdraw
-    | UserTransfer
-    | UserVaultDeposit
-    | UserVaultWithdraw
+    UserDeposit | UserWithdraw | UserTransfer | UserVaultDeposit | UserVaultWithdraw
 )
 
 

async_hyperliquid-0.4.3/src/async_hyperliquid/async_api.py

@@ -1,51 +0,0 @@
-import logging
-from types import TracebackType
-from typing import Any
-from traceback import TracebackException
-
-from aiohttp import ClientSession
-
-from async_hyperliquid.utils.types import Endpoint
-from async_hyperliquid.utils.constants import MAINNET_API_URL
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncAPI:
-    def __init__(
-        self,
-        endpoint: Endpoint,
-        base_url: str | None = None,
-        session: ClientSession = None,  # type: ignore
-    ):
-        self.endpoint = endpoint
-        self.base_url = base_url or MAINNET_API_URL
-        self.session = session
-
-    # for async with AsyncAPI() as api usage
-    async def __aenter__(self) -> "AsyncAPI":
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Exception,
-        exc_val: TracebackException,
-        traceback: TracebackType,
-    ) -> None:
-        await self.close()
-
-    async def close(self) -> None:
-        if self.session and not self.session.closed:
-            await self.session.close()
-
-    async def post(self, payload: dict | None = None) -> Any:
-        payload = payload or {}
-        req_path = f"{self.base_url}/{self.endpoint.value}"
-        logger.debug(f"POST {req_path} {payload}")
-        async with self.session.post(req_path, json=payload) as resp:
-            resp.raise_for_status()
-            try:
-                return await resp.json()
-            except Exception as e:
-                logger.error(f"Error parsing JSON response: {e}")
-                return await resp.text()