Struct HyperLiquid 

pub struct HyperLiquid { /* private fields */ }

HyperLiquid exchange structure.

Implementations

impl HyperLiquid

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

Fetch all trading markets.

pub async fn load_markets( &self, reload: bool, ) -> Result<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: f64, price: Option<f64>, ) -> Result<Order, Error>

Create a new order.

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 id(&self) -> &str

Returns the exchange ID.

pub fn name(&self) -> &str

Returns the exchange name.

pub fn version(&self) -> &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) -> &str

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

fn name(&self) -> &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<HashMap<String, 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: Decimal, price: Option<Decimal>, ) -> 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<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 = HashMap<String, 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 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