Struct HyperliquidHttpClient 

pub struct HyperliquidHttpClient { /* private fields */ }

Provides a lower-level HTTP client for connecting to the Hyperliquid REST API.

This client wraps the underlying HttpClient to handle functionality specific to Hyperliquid, such as request signing (for authenticated endpoints), forming request URLs, and deserializing responses into specific data models.

Implementations

impl HyperliquidHttpClient

pub fn new(is_testnet: bool, timeout_secs: Option<u64>) -> Self

Creates a new HyperliquidHttpClient using the default Hyperliquid HTTP URL, optionally overridden with a custom timeout.

This version of the client has no credentials, so it can only call publicly accessible endpoints.

pub fn with_credentials(secrets: &Secrets, timeout_secs: Option<u64>) -> Self

Creates a new HyperliquidHttpClient configured with credentials for authenticated requests.

pub fn from_env() -> Result<Self>

Creates an authenticated client from environment variables.

Errors

Returns Error::Auth if required environment variables are not set.

pub fn with_rate_limits(self) -> Self

Configure rate limiting parameters (chainable).

pub fn is_testnet(&self) -> bool

Returns whether this client is configured for testnet.

pub fn get_user_address(&self) -> Result<String>

Gets the user address derived from the private key (if client has credentials).

Errors

Returns Error::Auth if the client has no signer configured.

pub fn add_instrument(&self, instrument: InstrumentAny)

Add an instrument to the internal cache for report generation.

This is required for parsing orders, fills, and positions into reports. Instruments are stored under two keys:

1. The Nautilus symbol (e.g., “BTC-USD-PERP”)
2. The Hyperliquid coin identifier (base currency, e.g., “BTC” or “vntls:vCURSOR”)

Panics

Panics if the instrument lock cannot be acquired.

pub fn set_account_id(&mut self, account_id: AccountId)

Set the account ID for this client.

This is required for generating reports with the correct account ID.

pub async fn info_meta(&self) -> Result<HyperliquidMeta>

Get metadata about available markets.

pub async fn get_spot_meta(&self) -> Result<SpotMeta>

Get complete spot metadata (tokens and pairs).

pub async fn get_perp_meta_and_ctxs(&self) -> Result<PerpMetaAndCtxs>

Get perpetuals metadata with asset contexts (for price precision refinement).

pub async fn get_spot_meta_and_ctxs(&self) -> Result<SpotMetaAndCtxs>

Get spot metadata with asset contexts (for price precision refinement).

pub async fn request_instruments(&self) -> Result<Vec<InstrumentAny>>

Fetch and parse all available instrument definitions from Hyperliquid.

pub async fn info_l2_book(&self, coin: &str) -> Result<HyperliquidL2Book>

Get L2 order book for a coin.

pub async fn info_user_fills(&self, user: &str) -> Result<HyperliquidFills>

Get user fills (trading history).

pub async fn info_order_status( &self, user: &str, oid: u64, ) -> Result<HyperliquidOrderStatus>

Get order status for a user.

pub async fn info_open_orders(&self, user: &str) -> Result<Value>

Get all open orders for a user.

pub async fn info_frontend_open_orders(&self, user: &str) -> Result<Value>

Get frontend open orders (includes more detail) for a user.

pub async fn info_clearinghouse_state(&self, user: &str) -> Result<Value>

Get clearinghouse state (balances, positions, margin) for a user.

pub async fn info_candle_snapshot( &self, coin: &str, interval: &str, start_time: u64, end_time: u64, ) -> Result<HyperliquidCandleSnapshot>

Get candle/bar data for a coin.

Arguments

• coin - The coin symbol (e.g., “BTC”)
• interval - The timeframe (e.g., “1m”, “5m”, “15m”, “1h”, “4h”, “1d”)
• start_time - Start timestamp in milliseconds
• end_time - End timestamp in milliseconds

pub async fn send_info_request_raw( &self, request: &InfoRequest, ) -> Result<Value>

Generic info request method that returns raw JSON (useful for new endpoints and testing).

pub async fn post_action( &self, action: &ExchangeAction, ) -> Result<HyperliquidExchangeResponse>

Send a signed action to the exchange.

pub async fn submit_order(&self, order: &OrderAny) -> Result<OrderStatusReport>

Submit a single order to the Hyperliquid exchange.

Uses the existing order conversion logic from common::parse::order_to_hyperliquid_request to avoid code duplication and ensure consistency.

Errors

Returns an error if credentials are missing, order validation fails, serialization fails, or the API returns an error.

pub async fn submit_orders( &self, orders: &[&OrderAny], ) -> Result<Vec<OrderStatusReport>>

Submit multiple orders to the Hyperliquid exchange in a single request.

Uses the existing order conversion logic from common::parse::orders_to_hyperliquid_requests to avoid code duplication and ensure consistency.

Errors

Returns an error if credentials are missing, order validation fails, serialization fails, or the API returns an error.

pub async fn request_order_status_reports( &self, user: &str, instrument_id: Option<InstrumentId>, ) -> Result<Vec<OrderStatusReport>>

Request order status reports for a user.

Fetches open orders via info_frontend_open_orders and parses them into OrderStatusReports. This method requires instruments to be added to the client cache via add_instrument().

For vault tokens (starting with “vntls:”) that are not in the cache, synthetic instruments will be created automatically.

Errors

Returns an error if the API request fails or parsing fails.

pub async fn request_fill_reports( &self, user: &str, instrument_id: Option<InstrumentId>, ) -> Result<Vec<FillReport>>

Request fill reports for a user.

Fetches user fills via info_user_fills and parses them into FillReports. This method requires instruments to be added to the client cache via add_instrument().

For vault tokens (starting with “vntls:”) that are not in the cache, synthetic instruments will be created automatically.

Errors

Returns an error if the API request fails or parsing fails.

pub async fn request_position_status_reports( &self, user: &str, instrument_id: Option<InstrumentId>, ) -> Result<Vec<PositionStatusReport>>

Request position status reports for a user.

Fetches clearinghouse state via info_clearinghouse_state and parses positions into PositionStatusReports. This method requires instruments to be added to the client cache via add_instrument().

For vault tokens (starting with “vntls:”) that are not in the cache, synthetic instruments will be created automatically.

Errors

Returns an error if the API request fails or parsing fails.

pub async fn rest_limiter_snapshot(&self) -> RateLimitSnapshot

Best-effort gauge for diagnostics/metrics

Trait Implementations

impl Clone for HyperliquidHttpClient

fn clone(&self) -> HyperliquidHttpClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HyperliquidHttpClient

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

Formats the value using the given formatter.

impl Default for HyperliquidHttpClient

fn default() -> Self

Returns the “default value” for a type.

impl<'py> IntoPyObject<'py> for HyperliquidHttpClient

type Target = HyperliquidHttpClient

The Python output type

type Output = Bound<'py, <HyperliquidHttpClient as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for HyperliquidHttpClient

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for HyperliquidHttpClient

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Provides a lower-level HTTP client for connecting to the [Hyperliquid](https://hyperliquid.xyz/) REST API. /// /// This client wraps the underlying `HttpClient` to handle functionality /// specific to Hyperliquid, such as request signing (for authenticated endpoints), /// forming request URLs, and deserializing responses into specific data models.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<HyperliquidHttpClient>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for HyperliquidHttpClient

const TEXT_SIGNATURE: &'static str = "(is_testnet=False, timeout_secs=None)"

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder HyperliquidHttpClient

type Holder = Option<PyClassGuard<'a, HyperliquidHttpClient>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut HyperliquidHttpClient

type Holder = Option<PyClassGuardMut<'a, HyperliquidHttpClient>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<HyperliquidHttpClient> for PyClassImplCollector<HyperliquidHttpClient>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for HyperliquidHttpClient

const NAME: &'static str = "HyperliquidHttpClient"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for HyperliquidHttpClient