Struct HyperliquidHttpClient 

pub struct HyperliquidHttpClient { /* private fields */ }

Provides a high-level HTTP client for the Hyperliquid REST API.

This domain client wraps HyperliquidRawHttpClient and provides methods that work with Nautilus domain types. It maintains an instrument cache and handles conversions between Hyperliquid API responses and Nautilus domain models.

Implementations

impl HyperliquidHttpClient

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

Creates a new HyperliquidHttpClient for public endpoints only.

Errors

Returns an error if the HTTP client cannot be created.

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

Creates a new HyperliquidHttpClient configured with credentials.

Errors

Returns an error if the HTTP client cannot be created.

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 from_credentials( private_key: &str, vault_address: Option<&str>, is_testnet: bool, timeout_secs: Option<u64>, proxy_url: Option<String>, ) -> Result<Self>

Creates a new HyperliquidHttpClient configured with explicit credentials.

Errors

Returns Error::Auth if the private key is invalid or cannot be parsed.

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 cache_instrument(&self, instrument: InstrumentAny)

Caches a single instrument.

This is required for parsing orders, fills, and positions into reports. Any existing instrument with the same symbol will be replaced.

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 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: HyperliquidBarInterval, start_time: u64, end_time: u64, ) -> Result<HyperliquidCandleSnapshot>

Get candle/bar data for a coin.

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

Post an action to the exchange endpoint (low-level delegation).

pub async fn post_action_exec( &self, action: &HyperliquidExecAction, ) -> Result<HyperliquidExchangeResponse>

Post an execution action (low-level delegation).

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

Get metadata about available markets (low-level delegation).

pub async fn cancel_order( &self, instrument_id: InstrumentId, client_order_id: Option<ClientOrderId>, venue_order_id: Option<VenueOrderId>, ) -> Result<()>

Cancel an order on the Hyperliquid exchange.

Can cancel either by venue order ID or client order ID. At least one ID must be provided.

Errors

Returns an error if credentials are missing, no order ID is provided, 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 cache_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 cache_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 cache_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_bars( &self, bar_type: BarType, start: Option<DateTime<Utc>>, end: Option<DateTime<Utc>>, limit: Option<u32>, ) -> Result<Vec<Bar>>

Request historical bars for an instrument.

Fetches candle data from the Hyperliquid API and converts it to Nautilus bars. Incomplete bars (where end_timestamp >= current time) are filtered out.

Errors

Returns an error if:

• The instrument is not found in cache.
• The bar aggregation is unsupported by Hyperliquid.
• The API request fails.
• Parsing fails.

References

https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint#candles-snapshot

pub async fn submit_order( &self, instrument_id: InstrumentId, client_order_id: ClientOrderId, order_side: OrderSide, order_type: OrderType, quantity: Quantity, time_in_force: TimeInForce, price: Option<Price>, trigger_price: Option<Price>, post_only: bool, reduce_only: bool, ) -> Result<OrderStatusReport>

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_order_from_order_any( &self, order: &OrderAny, ) -> Result<OrderStatusReport>

Submit an order using an OrderAny object.

This is a convenience method that wraps submit_order.

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.

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 high-level HTTP client for the [Hyperliquid](https://hyperliquid.xyz/) REST API. /// /// This domain client wraps [`HyperliquidRawHttpClient`] and provides methods that work /// with Nautilus domain types. It maintains an instrument cache and handles conversions /// between Hyperliquid API responses and Nautilus domain 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 = "(private_key=None, vault_address=None, is_testnet=False, timeout_secs=None, proxy_url=None)"

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

impl ExtractPyClassWithClone for HyperliquidHttpClient