Struct HyperLiquid 

pub struct HyperLiquid { /* private fields */ }

HyperLiquid exchange structure.

Implementations

impl HyperLiquid

pub async fn exchange_request( &self, action: Value, nonce: u64, ) -> Result<Value, Error>

👎Deprecated since 0.2.0: Use signed_action() builder instead

Make an exchange action request (requires authentication).

Deprecated

This method is deprecated. Use signed_action() builder instead:

let exchange = HyperLiquid::builder()
    .private_key("0x...")
    .testnet(true)
    .build()?;

let action = json!({"type": "order", "orders": [], "grouping": "na"});
let response = exchange.signed_action(action).execute().await?;

pub fn get_nonce(&self) -> u64

👎Deprecated since 0.2.0: Use signed_action() builder which auto-generates nonce

Get current timestamp as nonce.

Deprecated

This method is deprecated. The signed_action() builder automatically generates the nonce. Use signed_action().nonce(value) if you need to override the auto-generated nonce.

pub async fn fetch_markets( &self, ) -> Result<Arc<HashMap<String, Arc<Market>>>, Error>

Fetch all trading markets.

pub async fn load_markets( &self, reload: bool, ) -> Result<Arc<HashMap<String, Arc<Market>>>, Error>

Load and cache market data.

pub async fn fetch_ticker(&self, symbol: &str) -> Result<Ticker, Error>

Fetch ticker for a single trading pair.

pub async fn fetch_tickers( &self, symbols: Option<Vec<String>>, ) -> Result<Vec<Ticker>, Error>

Fetch tickers for multiple trading pairs.

pub async fn fetch_order_book( &self, symbol: &str, _limit: Option<u32>, ) -> Result<OrderBook, Error>

Fetch order book for a trading pair.

pub async fn fetch_trades( &self, symbol: &str, limit: Option<u32>, ) -> Result<Vec<Trade>, Error>

Fetch recent public trades.

pub async fn fetch_ohlcv( &self, symbol: &str, timeframe: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Ohlcv>, Error>

Fetch OHLCV (candlestick) data.

pub async fn fetch_funding_rate( &self, symbol: &str, ) -> Result<FundingRate, Error>

Fetch current funding rate for a symbol.

pub async fn fetch_balance(&self) -> Result<Balance, Error>

Fetch account balance.

pub async fn fetch_positions( &self, symbols: Option<Vec<String>>, ) -> Result<Vec<Position>, Error>

Fetch open positions.

pub async fn fetch_open_orders( &self, symbol: Option<&str>, _since: Option<i64>, _limit: Option<u32>, ) -> Result<Vec<Order>, Error>

Fetch open orders.

pub async fn create_order( &self, symbol: &str, order_type: OrderType, side: OrderSide, amount: Amount, price: Option<Price>, ) -> Result<Order, Error>

Create a new order.

Arguments

• symbol - Trading pair symbol.
• order_type - Order type (Market, Limit, etc.).
• side - Order side (Buy or Sell).
• amount - Order quantity as Amount type.
• price - Optional price as Price type (required for limit orders).

Returns

Returns the created Order structure with order details.

Errors

Returns an error if authentication fails, market is not found, or the API request fails.

pub async fn cancel_order(&self, id: &str, symbol: &str) -> Result<Order, Error>

Cancel an order.

pub async fn set_leverage( &self, symbol: &str, leverage: u32, is_cross: bool, ) -> Result<(), Error>

Set leverage for a symbol.

pub async fn cancel_all_orders( &self, symbol: Option<&str>, ) -> Result<Vec<Order>, Error>

Cancel all orders for a symbol.

impl HyperLiquid

pub fn builder() -> HyperLiquidBuilder

Creates a new HyperLiquid instance using the builder pattern.

This is the recommended way to create a HyperLiquid instance.

Example

use ccxt_exchanges::hyperliquid::HyperLiquid;

let exchange = HyperLiquid::builder()
    .private_key("0x...")
    .testnet(true)
    .build()
    .unwrap();

pub fn new_with_options( config: ExchangeConfig, options: HyperLiquidOptions, auth: Option<HyperLiquidAuth>, ) -> Result<HyperLiquid, Error>

Creates a new HyperLiquid instance with custom options.

This is used internally by the builder pattern.

Arguments

• config - Exchange configuration.
• options - HyperLiquid-specific options.
• auth - Optional authentication instance.

pub fn base(&self) -> &BaseExchange

Returns a reference to the base exchange.

pub fn base_mut(&mut self) -> &mut BaseExchange

Returns a mutable reference to the base exchange.

pub fn options(&self) -> &HyperLiquidOptions

Returns the HyperLiquid options.

pub fn auth(&self) -> Option<&HyperLiquidAuth>

Returns a reference to the authentication instance.

pub fn signed_action( &self, action: Value, ) -> HyperliquidSignedRequestBuilder<'_>

Creates a signed action builder for authenticated exchange requests.

This method provides a fluent API for constructing and executing authenticated Hyperliquid exchange actions using EIP-712 signing.

Arguments

• action - The action JSON to be signed and executed

Returns

A HyperliquidSignedRequestBuilder that can be configured and executed.

Example

use ccxt_exchanges::hyperliquid::HyperLiquid;
use serde_json::json;

let exchange = HyperLiquid::builder()
    .private_key("0x...")
    .testnet(true)
    .build()?;

// Create an order
let action = json!({
    "type": "order",
    "orders": [{"a": 0, "b": true, "p": "50000", "s": "0.001", "r": false, "t": {"limit": {"tif": "Gtc"}}}],
    "grouping": "na"
});

let response = exchange.signed_action(action)
    .execute()
    .await?;

pub fn id(&self) -> &'static str

Returns the exchange ID.

pub fn name(&self) -> &'static str

Returns the exchange name.

pub fn version(&self) -> &'static str

Returns the API version.

pub fn certified(&self) -> bool

Returns true if the exchange is CCXT-certified.

pub fn pro(&self) -> bool

Returns true if Pro version (WebSocket) is supported.

pub fn rate_limit(&self) -> u32

Returns the rate limit in requests per second.

pub fn is_sandbox(&self) -> bool

Returns true if sandbox/testnet mode is enabled.

Sandbox mode is enabled when either:

• config.sandbox is set to true
• options.testnet is set to true

Returns

true if sandbox mode is enabled, false otherwise.

Example

use ccxt_exchanges::hyperliquid::HyperLiquid;

let exchange = HyperLiquid::builder()
    .testnet(true)
    .build()
    .unwrap();
assert!(exchange.is_sandbox());

pub fn urls(&self) -> HyperLiquidUrls

Returns the API URLs.

Returns testnet URLs when sandbox mode is enabled (either via config.sandbox or options.testnet), otherwise returns mainnet URLs.

pub fn wallet_address(&self) -> Option<&str>

Returns the wallet address if authenticated.

Trait Implementations

impl Debug for HyperLiquid

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

Formats the value using the given formatter.

impl Exchange for HyperLiquid

fn id(&self) -> &'static str

Returns the exchange identifier (e.g., “binance”, “coinbase”)

fn name(&self) -> &'static str

Returns the human-readable exchange name (e.g., “Binance”, “Coinbase”)

fn version(&self) -> &'static str

Returns the API version string

fn certified(&self) -> bool

Returns whether this exchange is CCXT certified

fn has_websocket(&self) -> bool

Returns whether this exchange supports WebSocket (pro features)

fn capabilities(&self) -> ExchangeCapabilities

Returns the exchange capabilities

fn timeframes(&self) -> Vec<Timeframe>

Returns supported timeframes for OHLCV data

fn rate_limit(&self) -> u32

Returns the rate limit (requests per second)

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

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Fetch all available markets

fn load_markets<'life0, 'async_trait>( &'life0 self, reload: bool, ) -> Pin<Box<dyn Future<Output = Result<Arc<HashMap<String, Arc<Market>>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Load markets and cache them

fn fetch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Ticker, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch ticker for a single symbol

fn fetch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, symbols: Option<&'life1 [String]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ticker>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch tickers for multiple symbols (or all if None)

fn fetch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<OrderBook, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch order book for a symbol

fn fetch_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch recent public trades

fn fetch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, timeframe: Timeframe, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ohlcv>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch OHLCV candlestick data

fn create_order<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, order_type: OrderType, side: OrderSide, amount: Amount, price: Option<Price>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Create a new order

fn cancel_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HyperLiquid: 'async_trait,

Cancel an existing order

fn cancel_all_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Cancel all orders (optionally for a specific symbol)

fn fetch_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HyperLiquid: 'async_trait,

Fetch a specific order by ID

fn fetch_open_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch all open orders

fn fetch_closed_orders<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, _since: Option<i64>, _limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch closed orders

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

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Fetch account balance

fn fetch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, _since: Option<i64>, _limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Fetch user’s trade history

fn market<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<Market>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Get a specific market by symbol

fn markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Arc<HashMap<String, Arc<Market>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Get all cached markets

fn is_symbol_active<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

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

Check if a symbol is valid and active

impl HyperLiquidEndpointRouter for HyperLiquid

fn rest_endpoint(&self) -> &'static str

Returns the REST API endpoint.

fn ws_endpoint(&self) -> &str

Returns the WebSocket endpoint.

impl WsExchange for HyperLiquid

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

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Connect to the WebSocket server

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

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Disconnect from the WebSocket server

fn ws_is_connected(&self) -> bool

Check if WebSocket is connected

fn ws_state(&self) -> WsConnectionState

Get WebSocket connection state

fn subscriptions(&self) -> Vec<String>

Get list of active subscriptions

fn watch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Ticker, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch ticker updates for a symbol

fn watch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, _symbols: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Vec<Ticker>, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch tickers for multiple symbols

fn watch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, _limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<OrderBook, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch order book updates

fn watch_trades<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Vec<Trade>, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch public trades

fn watch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, _timeframe: Timeframe, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Ohlcv, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch OHLCV candlestick updates

fn watch_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Balance, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, HyperLiquid: 'async_trait,

Watch account balance updates

fn watch_orders<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Order, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch order updates

fn watch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Trade, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, HyperLiquid: 'async_trait,

Watch user trade updates

fn subscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HyperLiquid: 'async_trait,

Subscribe to a channel

fn unsubscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, HyperLiquid: 'async_trait,

Unsubscribe from a channel