Struct HyperliquidClient 

pub struct HyperliquidClient { /* private fields */ }

Implementations

impl HyperliquidClient

pub fn new() -> Self

pub fn with_auth(user_address: impl Into<String>, private_key: String) -> Self

Examples found in repository

examples/check_balance.rs (line 8)

async fn main() {
    let addr = std::env::var("HYPERLIQUID_WALLET_ADDRESS").expect("missing addr");
    let key = std::env::var("HYPERLIQUID_WALLET_KEY").expect("missing key");
    let client = HyperliquidClient::with_auth(addr, key);

    match client.get_balance().await {
        Ok(balances) => {
            println!("{} balances returned:", balances.len());
            for b in &balances {
                println!("\n--- {} ---", b.token);
                println!("  equity:     {}", b.equity);
                println!("  free:       {}", b.free);
                println!("  hold:       {}", b.hold);
                println!("  safe:       {:?}", b.safe);
                println!("  usable:     {}", b.usable);
                println!("  maintenance:{:?}", b.maintenance);
                println!("  margin_used:{:?}", b.margin_used);
            }
        }
        Err(e) => eprintln!("ERROR: {e}"),
    }
}

pub fn with_external_signer( user_address: impl Into<String>, signer: Arc<dyn ExternalSigner>, ) -> Self

Create a client authenticated via an external signer (TPM, Secure Enclave, etc.).

The signer handles the actual ECDSA signing; the private key never leaves the hardware. The client computes the EIP-712 digest and delegates signing to the external signer.

pub fn with_budgets(self, rest_weight: u32, addr_budget: u64) -> Self

Configure rate limit budgets (rest_weight/min, address_requests). Defaults: 1200 rest weight/min, 10000 address requests.

Trait Implementations

impl Default for HyperliquidClient

fn default() -> Self

Returns the “default value” for a type.

impl GetAccountSnapshot for HyperliquidClient

fn get_positions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Position>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns open positions from clearinghouseState. Requires with_auth. Zero-size positions are filtered out. Positive szi = long, negative = short.

fn get_open_orders<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<OpenOrder>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns resting orders from Hyperliquid’s openOrders endpoint. Requires with_auth. filled_quantity is derived as origSz - sz (original size minus remaining size).

fn get_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<AccountBalance>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all per-asset balances from spotClearinghouseState with margin health. Also fetches clearinghouseState to populate margin_used on the USDC entry. Requires with_auth.

fn get_user_rate_limit<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<UserRateLimit, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the user’s address-level API rate limit budget. Queries Hyperliquid’s userRateLimit info endpoint for authoritative server-side counts.

impl GetMarketData for HyperliquidClient

fn get_symbol<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all perpetual asset names from Hyperliquid’s meta endpoint.

fn get_open_interest<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = Result<Decimal, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current open interest for symbol from metaAndAssetCtxs.

fn get_asset_context<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = Result<AssetContext, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a full AssetContext snapshot for symbol from metaAndAssetCtxs.

fn get_all_asset_contexts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<AssetContext>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetches metaAndAssetCtxs once and returns all asset contexts in universe order. Prefer this over repeated get_asset_context calls to avoid rate-limiting.

fn get_sz_decimals<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = Result<i32, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the number of decimal places for order size for a symbol.

fn get_all_sz_decimals<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, i32>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns sz_decimals for all symbols from the meta universe.

fn get_l2_orderbook<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = Result<L2Snapshot, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a full L2 orderbook snapshot for symbol from the l2Book REST endpoint.

fn get_price<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = Result<Decimal, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the mid-price of symbol (e.g. “BTC”) from allMids.

fn get_predicted_fundings<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PredictedFunding>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns predicted funding rates for all symbols across all venues. Null venue entries (unsupported coins) are silently skipped.

impl ManageOrder for HyperliquidClient

fn place_order<'life0, 'async_trait>( &'life0 self, symbol: String, side: OrderSide, price: Decimal, volume: Decimal, order_type: OrderType, time_in_force: TimeInForce, trigger_price: Option<Decimal>, reduce_only: bool, cloid: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<OrderPlacement, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Places an order on Hyperliquid. Requires with_auth. Returns an OrderPlacement with the exchange-assigned order ID. Market orders are submitted as aggressive limit orders (IOC).

If cloid is provided, Hyperliquid attaches it to the order lifecycle — fills and order updates will carry the same cloid back, enabling end-to-end intent tracing without a separate order_id mapping.

Trigger orders (TakeProfit / StopLoss) require trigger_price to be set. The order activates when the mark price reaches triggerPx, then executes as a market or limit order depending on time_in_force (Ioc = market, Gtc = limit).

fn change_order_by_cloid<'life0, 'async_trait>( &'life0 self, cloid: i64, price: Decimal, volume: Decimal, ) -> Pin<Box<dyn Future<Output = Result<i64, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Modifies price and size of an existing order by its order ID. Requires with_auth. Fetches the order’s current coin and side before submitting the modify action.

fn cancel_order_by_cloid<'life0, 'async_trait>( &'life0 self, cloid: String, ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancels a single order by its client order ID (cloid). Requires with_auth. Fetches open orders to resolve the order ID for the matching cloid, then submits a cancel action using the order ID — this works for all order types including trigger orders (TakeProfit/StopLoss).

fn cancel_all_order<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancels all open orders. Requires with_auth. Fetches all open orders and submits a batch cancel in a single signed request.

impl SubscribeMarketData for HyperliquidClient

fn unsubscribe_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gracefully shut down all market data subscriptions. Closes all broadcast channels so subscribers exit without reconnecting.

fn subscribe_l2_update( &self, symbol: String, ) -> BoxStream<Result<L2Update, String>>

subscribe to L2 orderbook updates for a symbol

fn subscribe_l2_snapshot( &self, symbol: String, ) -> BoxStream<Result<L2Snapshot, String>>

subscribe to full L2 orderbook snapshots for a symbol

fn subscribe_asset_context( &self, symbol: String, ) -> BoxStream<Result<AssetContext, String>>

subscribe to asset context updates (OI, funding rate, mark price, 24h volume)

fn subscribe_liquidation( &self, user: String, ) -> BoxStream<Result<Liquidation, String>>

subscribe to liquidation events for a user address

fn subscribe_fill(&self, symbol: String) -> BoxStream<Result<Fill, String>>

subscribe to market fill events for a symbol

impl SubscribeMarketDataOps for HyperliquidClient

fn unsubscribe_market_data<'life0, 'async_trait>( &'life0 self, symbol: String, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

unsubscribe from market data streams for a symbol

impl SubscribeUserEvents for HyperliquidClient

fn subscribe_spot_balance( &self, ) -> BoxStream<Result<Vec<AccountBalance>, String>>

Subscribe to spot wallet balance updates for the registered user address.

fn subscribe_spot_balance_with_address( &self, address: String, ) -> BoxStream<Result<Vec<AccountBalance>, String>>

Subscribe to spot wallet balance updates for a specific address.

fn subscribe_user_fills(&self) -> BoxStream<Result<UserFill, String>>

stream executions of the user’s own orders

fn subscribe_order_updates(&self) -> BoxStream<Result<OrderUpdate, String>>

stream order lifecycle updates

fn subscribe_funding_payments( &self, ) -> BoxStream<Result<FundingPayment, String>>

stream funding payments applied to positions

fn subscribe_deposits(&self) -> BoxStream<Result<Deposit, String>>

stream account deposit events

fn subscribe_withdrawals(&self) -> BoxStream<Result<Withdrawal, String>>

stream account withdrawal events

fn unsubscribe_user_events<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

unsubscribe from all user event streams

impl TestServer for HyperliquidClient

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends a lightweight allMids request; returns true if the server responds 200 OK.

fn get_server_time<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<i64, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Hyperliquid has no dedicated server-time endpoint; returns local UTC ms.