Struct HyperliquidClient 

pub struct HyperliquidClient { /* private fields */ }

Hyperliquid perpetual futures execution client.

Wraps the official hyperliquid_rust_sdk to implement the ExecutionClient trait. Supports perpetual futures trading on Hyperliquid DEX.

Implementations

impl HyperliquidClient

pub async fn connect( config: HyperliquidConfig, ) -> Result<Self, ConnectivityError>

Create a new client asynchronously.

Use this when calling from an async context (e.g., tokio tests). For sync contexts, use ExecutionClient::new().

pub fn wallet_address(&self) -> String

Returns the wallet address as a hex string (for logging/debugging).

Trait Implementations

impl Clone for HyperliquidClient

fn clone(&self) -> HyperliquidClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HyperliquidClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl ExecutionClient for HyperliquidClient

fn new(config: Self::Config) -> Self

Creates a new Hyperliquid client synchronously.

Panics

• If no Tokio runtime is available on the current thread
• If called from within an async context (e.g., inside async fn, spawn, or block_on)
• If SDK initialization fails (network error, invalid credentials)

Recommended Usage

Use HyperliquidClient::connect instead — it’s async-safe and returns Result. This method exists only for trait compliance; prefer connect() in all new code.

async fn account_stream( &self, _assets: &[AssetNameExchange], _instruments: &[InstrumentNameExchange], ) -> Result<Self::AccountStream, UnindexedClientError>

Returns a live stream of account events (fills, order updates).

Instrument filtering

The instruments parameter is ignored — Hyperliquid’s WebSocket API does not support per-instrument subscriptions for user events. All fills and order updates across all instruments are delivered. Consumers requiring instrument filtering must filter client-side.

Task lifecycle

Spawns two background tasks (fills, orders) that are automatically cancelled when the returned stream is dropped. The ws_client is held by the orders task; when cancelled, both tasks exit and the WebSocket connection closes.

const EXCHANGE: ExchangeId = ExchangeId::HyperliquidPerp

type Config = HyperliquidConfig

type AccountStream = Pin<Box<dyn Stream<Item = AccountEvent<ExchangeId, AssetNameExchange, InstrumentNameExchange>> + Send>>

async fn account_snapshot( &self, _assets: &[AssetNameExchange], instruments: &[InstrumentNameExchange], ) -> Result<UnindexedAccountSnapshot, UnindexedClientError>

async fn cancel_order( &self, request: OrderRequestCancel<ExchangeId, &InstrumentNameExchange>, ) -> Option<UnindexedOrderResponseCancel>

async fn open_order( &self, request: OrderRequestOpen<ExchangeId, &InstrumentNameExchange>, ) -> Option<Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>>

Place an order on the exchange.

async fn fetch_balances( &self, _assets: &[AssetNameExchange], ) -> Result<Vec<AssetBalance<AssetNameExchange>>, UnindexedClientError>

Fetch current balances for the specified assets.

async fn fetch_open_orders( &self, instruments: &[InstrumentNameExchange], ) -> Result<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>, UnindexedClientError>

Fetch currently open orders, optionally filtered by instrument.

async fn fetch_trades( &self, time_since: DateTime<Utc>, instruments: &[InstrumentNameExchange], ) -> Result<Vec<Trade<AssetNameExchange, InstrumentNameExchange>>, UnindexedClientError>

Fetch trades (fills) since time_since, optionally filtered by instrument.

fn cancel_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestCancel<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = Option<UnindexedOrderResponseCancel>> + Send

fn open_orders<'a>( &self, requests: impl IntoIterator<Item = OrderRequestOpen<ExchangeId, &'a InstrumentNameExchange>>, ) -> impl Stream<Item = Option<Order<ExchangeId, InstrumentNameExchange, UnindexedOrderState>>> + Send