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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: async-hyperliquid
-Version: 0.4.3
+Version: 0.4.5
 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.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "async-hyperliquid"
-version = "0.4.3"
+version = "0.4.5"
 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.5}/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.5}/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 = {
@@ -136,6 +164,13 @@ class AsyncHyperliquidCore(AsyncAPI):
         }
 
     async def init_metas(self) -> None:
+        # TODO: Add HIP-4 outcome meta initialization from the spot info
+        # `outcomeMeta` endpoint once outcomes move beyond testnet-only rollout.
+        # Outcome asset IDs do not follow the current perp/spot offset scheme:
+        # `encoding = 10 * outcome + side`, coin names use `#{encoding}`, token
+        # names use `+{encoding}`, and `asset_id = 100_000_000 + encoding`, so
+        # this path will need dedicated outcome mappings instead of reusing the
+        # existing perp/spot logic.
         meta_task = self.info.get_perp_meta()
         spot_meta_task = self.info.get_spot_meta()
         all_dex_names_task = self.get_all_dex_name()
@@ -171,24 +206,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 +254,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 +265,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.5}/src/async_hyperliquid/_async_hyperliquid/info.py

@@ -1,21 +1,21 @@
 import asyncio
 import warnings
-from typing import Literal
+from typing import Literal, cast
 
-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,
     AccountState,
     ClearinghouseState,
     OrderWithStatus,
+    PerpMeta,
+    PerpMetaCtxItem,
     Portfolio,
     Position,
+    SpotMeta,
     SpotClearinghouseState,
+    SpotMetaCtxItem,
     UserDeposit,
     UserNonFundingDelta,
     UserOpenOrders,
@@ -27,13 +27,49 @@ from .core import AsyncHyperliquidCore
 
 
 class AsyncHyperliquidInfoClient(AsyncHyperliquidCore):
+    async def _get_perp_mark_price(self, coin_name: str, dex: str = "") -> float:
+        meta_ctx = await self.info.get_perp_meta_ctx(dex)
+        meta = cast(PerpMeta, meta_ctx[0])
+        asset_ctxs = cast(list[PerpMetaCtxItem], meta_ctx[1])
+
+        for idx, info in enumerate(meta["universe"]):
+            if info["name"] == coin_name:
+                return float(asset_ctxs[idx]["markPx"])
+
+        raise ValueError(f"Coin {coin_name} not found in perp dex '{dex}'")
+
+    async def _get_spot_mark_price(self, coin_name: str) -> float:
+        meta_ctx = await self.info.get_spot_meta_ctx()
+        meta = cast(SpotMeta, meta_ctx[0])
+        asset_ctxs = cast(list[SpotMetaCtxItem], meta_ctx[1])
+
+        for info in meta["universe"]:
+            if info["name"] == coin_name:
+                asset_index = info["index"]
+                return float(asset_ctxs[asset_index]["markPx"])
+
+        raise ValueError(f"Coin {coin_name} not found in spot metadata")
+
+    async def get_mark_price(self, coin: str) -> float:
+        if ":" in coin:
+            return await self._get_perp_mark_price(coin, get_coin_dex(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]
+        is_spot_asset = SPOT_OFFSET <= asset < PERP_DEX_OFFSET
+        if is_spot_asset:
+            return await self._get_spot_mark_price(coin_name)
+
+        return await self._get_perp_mark_price(coin_name, get_coin_dex(coin_name))
+
     async def get_market_price(self, coin: str) -> float:
         warnings.warn(
             "get_market_price is deprecated and will remove in the future, use get_mid_price instead"
         )
-        coin_name = await self.get_coin_name(coin)
-        market_prices = await self.get_all_market_prices()
-        return market_prices[coin_name]
+        return await self.get_mark_price(coin)
 
     async def get_all_market_prices(
         self, market: Literal["spot", "perp", "all"] = "all"
@@ -50,10 +86,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 +143,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 +166,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 +195,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 +203,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 +216,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 +256,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)