Change requests applied

Author: Vadim Nicolai

crates/adapters/hyperliquid/src/data/mod.rs

@@ -46,12 +46,9 @@ use nautilus_core::{
 };
 use nautilus_data::client::DataClient;
 use nautilus_model::{
-    currencies::CURRENCY_MAP,
     data::Data,
-    enums::CurrencyType,
-    identifiers::{ClientId, InstrumentId, Symbol, Venue},
-    instruments::{CryptoPerpetual, CurrencyPair, Instrument, InstrumentAny},
-    types::{Currency, Price, Quantity},
+    identifiers::{ClientId, InstrumentId, Venue},
+    instruments::{Instrument, InstrumentAny},
 };
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
@@ -62,102 +59,10 @@ use crate::{
         credential::{EvmPrivateKey, Secrets},
     },
     config::HyperliquidDataClientConfig,
-    http::{
-        client::HyperliquidHttpClient,
-        parse::{HyperliquidInstrumentDef, HyperliquidMarketType},
-    },
+    http::client::HyperliquidHttpClient,
     websocket::client::HyperliquidWebSocketClient,
 };
 
-/// Returns a currency, either from the internal currency map or creates a default crypto.
-fn get_currency(code: &str) -> Currency {
-    // SAFETY: Mutex should not be poisoned in normal operation
-    CURRENCY_MAP
-        .lock()
-        .expect("Failed to acquire CURRENCY_MAP lock")
-        .get(code)
-        .copied()
-        .unwrap_or(Currency::new(code, 8, 0, code, CurrencyType::Crypto))
-}
-
-/// Creates a Nautilus instrument from a Hyperliquid instrument definition.
-fn create_instrument_from_def(def: &HyperliquidInstrumentDef) -> Option<InstrumentAny> {
-    let ts_event = get_atomic_clock_realtime().get_time_ns();
-    let ts_init = ts_event;
-
-    // Create instrument ID from the symbol
-    let symbol = Symbol::new(&def.symbol);
-    let venue = Venue::new("HYPERLIQUID");
-    let instrument_id = InstrumentId::new(symbol, venue);
-
-    let raw_symbol = Symbol::new(&def.symbol);
-    let base_currency = get_currency(&def.base);
-    let quote_currency = get_currency(&def.quote);
-    let price_increment = Price::from(&def.tick_size.to_string());
-    let size_increment = Quantity::from(&def.lot_size.to_string());
-
-    // For now, use minimal parameters - no fees, margins, or lot sizes
-    match def.market_type {
-        HyperliquidMarketType::Spot => {
-            Some(InstrumentAny::CurrencyPair(CurrencyPair::new(
-                instrument_id,
-                raw_symbol,
-                base_currency,
-                quote_currency,
-                def.price_decimals as u8,
-                def.size_decimals as u8,
-                price_increment,
-                size_increment,
-                None, // multiplier
-                None, // lot_size
-                None, // max_quantity
-                None, // min_quantity
-                None, // max_notional
-                None, // min_notional
-                None, // max_price
-                None, // min_price
-                None, // margin_init
-                None, // margin_maint
-                None, // maker_fee
-                None, // taker_fee
-                ts_event,
-                ts_init,
-            )))
-        }
-        HyperliquidMarketType::Perp => {
-            // For Hyperliquid, perps are USD-quoted and USDC-settled
-            let settlement_currency = get_currency("USDC");
-
-            Some(InstrumentAny::CryptoPerpetual(CryptoPerpetual::new(
-                instrument_id,
-                raw_symbol,
-                base_currency,
-                quote_currency,
-                settlement_currency,
-                false, // is_inverse - Hyperliquid perps are linear
-                def.price_decimals as u8,
-                def.size_decimals as u8,
-                price_increment,
-                size_increment,
-                None, // multiplier
-                None, // lot_size
-                None, // max_quantity
-                None, // min_quantity
-                None, // max_notional
-                None, // min_notional
-                None, // max_price
-                None, // min_price
-                None, // margin_init
-                None, // margin_maint
-                None, // maker_fee
-                None, // taker_fee
-                ts_event,
-                ts_init,
-            )))
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct HyperliquidDataClient {
     client_id: ClientId,
@@ -227,24 +132,20 @@ impl HyperliquidDataClient {
     }
 
     async fn bootstrap_instruments(&mut self) -> Result<Vec<InstrumentAny>> {
-        let mut instruments = Vec::new();
-
-        match self.http_client.request_instruments().await {
-            Ok(defs) => {
+        let instruments = match self.http_client.request_instruments().await {
+            Ok(mut instruments) => {
                 tracing::debug!(
-                    count = defs.len(),
-                    "Received Hyperliquid instrument definitions"
+                    count = instruments.len(),
+                    "Received Hyperliquid instruments"
                 );
-                for def in defs {
-                    if let Some(instrument) = create_instrument_from_def(&def) {
-                        instruments.push(instrument);
-                    }
-                }
+                instruments.sort_by_key(|instrument| instrument.id());
+                instruments
             }
             Err(err) => {
                 tracing::warn!(%err, "Failed to request Hyperliquid instruments");
+                Vec::new()
             }
-        }
+        };
 
         tracing::info!(count = instruments.len(), "Loaded Hyperliquid instruments");
 

crates/adapters/hyperliquid/src/http/client.rs

@@ -29,6 +29,7 @@ use std::{
 
 use anyhow::Context;
 use nautilus_core::consts::NAUTILUS_USER_AGENT;
+use nautilus_model::instruments::InstrumentAny;
 use nautilus_network::{http::HttpClient, ratelimiter::quota::Quota};
 use reqwest::{Method, header::USER_AGENT};
 use serde_json::Value;
@@ -40,10 +41,12 @@ use crate::{
         credential::{Secrets, VaultAddress},
     },
     http::{
+        conversion::instruments_from_defs_owned,
         error::{Error, Result},
         models::{
             HyperliquidExchangeRequest, HyperliquidExchangeResponse, HyperliquidFills,
-            HyperliquidL2Book, HyperliquidMeta, HyperliquidOrderStatus,
+            HyperliquidL2Book, HyperliquidMeta, HyperliquidOrderStatus, PerpMeta, PerpMetaAndCtxs,
+            SpotMeta, SpotMetaAndCtxs,
         },
         parse::{HyperliquidInstrumentDef, parse_perp_instruments, parse_spot_instruments},
         query::{ExchangeAction, InfoRequest},
@@ -67,6 +70,10 @@ pub static HYPERLIQUID_REST_QUOTA: LazyLock<Quota> =
 /// specific to Hyperliquid, such as request signing (for authenticated endpoints),
 /// forming request URLs, and deserializing responses into specific data models.
 #[derive(Debug, Clone)]
+#[cfg_attr(
+    feature = "python",
+    pyo3::pyclass(module = "nautilus_trader.core.nautilus_pyo3.adapters")
+)]
 pub struct HyperliquidHttpClient {
     client: HttpClient,
     is_testnet: bool,
@@ -188,39 +195,32 @@ impl HyperliquidHttpClient {
         serde_json::from_value(response).map_err(Error::Serde)
     }
 
-    /// Get complete perpetuals metadata.
-    pub async fn get_perp_meta(&self) -> Result<crate::http::models::PerpMeta> {
-        let request = InfoRequest::meta();
-        let response = self.send_info_request(&request).await?;
-        serde_json::from_value(response).map_err(Error::Serde)
-    }
-
     /// Get complete spot metadata (tokens and pairs).
-    pub async fn get_spot_meta(&self) -> Result<crate::http::models::SpotMeta> {
+    pub async fn get_spot_meta(&self) -> Result<SpotMeta> {
         let request = InfoRequest::spot_meta();
         let response = self.send_info_request(&request).await?;
         serde_json::from_value(response).map_err(Error::Serde)
     }
 
     /// Get perpetuals metadata with asset contexts (for price precision refinement).
-    pub async fn get_perp_meta_and_ctxs(&self) -> Result<crate::http::models::PerpMetaAndCtxs> {
+    pub async fn get_perp_meta_and_ctxs(&self) -> Result<PerpMetaAndCtxs> {
         let request = InfoRequest::meta_and_asset_ctxs();
         let response = self.send_info_request(&request).await?;
         serde_json::from_value(response).map_err(Error::Serde)
     }
 
     /// Get spot metadata with asset contexts (for price precision refinement).
-    pub async fn get_spot_meta_and_ctxs(&self) -> Result<crate::http::models::SpotMetaAndCtxs> {
+    pub async fn get_spot_meta_and_ctxs(&self) -> Result<SpotMetaAndCtxs> {
         let request = InfoRequest::spot_meta_and_asset_ctxs();
         let response = self.send_info_request(&request).await?;
         serde_json::from_value(response).map_err(Error::Serde)
     }
 
     /// Fetch and parse all available instrument definitions from Hyperliquid.
-    pub async fn request_instruments(&self) -> Result<Vec<HyperliquidInstrumentDef>> {
-        let mut defs = Vec::new();
+    pub async fn request_instruments(&self) -> Result<Vec<InstrumentAny>> {
+        let mut defs: Vec<HyperliquidInstrumentDef> = Vec::new();
 
-        match self.get_perp_meta().await {
+        match self.load_perp_meta().await {
             Ok(perp_meta) => match parse_perp_instruments(&perp_meta) {
                 Ok(perp_defs) => {
                     tracing::debug!(
@@ -256,7 +256,13 @@ impl HyperliquidHttpClient {
             }
         }
 
-        Ok(defs)
+        Ok(instruments_from_defs_owned(defs))
+    }
+
+    pub(crate) async fn load_perp_meta(&self) -> Result<PerpMeta> {
+        let request = InfoRequest::meta();
+        let response = self.send_info_request(&request).await?;
+        serde_json::from_value(response).map_err(Error::Serde)
     }
 
     /// Get L2 order book for a coin.

crates/adapters/hyperliquid/src/http/conversion.rs

@@ -0,0 +1,131 @@
+// -------------------------------------------------------------------------------------------------
+//  Copyright (C) 2015-2025 Nautech Systems Pty Ltd. All rights reserved.
+//  https://nautechsystems.io
+//
+//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
+//  You may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+// -------------------------------------------------------------------------------------------------
+
+//! Helpers for converting Hyperliquid instrument definitions into Nautilus instruments.
+
+use nautilus_core::time::get_atomic_clock_realtime;
+use nautilus_model::{
+    currencies::CURRENCY_MAP,
+    enums::CurrencyType,
+    identifiers::{InstrumentId, Symbol},
+    instruments::{CryptoPerpetual, CurrencyPair, InstrumentAny},
+    types::{Currency, Price, Quantity},
+};
+
+use crate::{
+    common::consts::HYPERLIQUID_VENUE,
+    http::parse::{HyperliquidInstrumentDef, HyperliquidMarketType},
+};
+
+fn get_currency(code: &str) -> Currency {
+    CURRENCY_MAP
+        .lock()
+        .expect("Failed to acquire CURRENCY_MAP lock")
+        .get(code)
+        .copied()
+        .unwrap_or_else(|| Currency::new(code, 8, 0, code, CurrencyType::Crypto))
+}
+
+/// Converts a single Hyperliquid instrument definition into a Nautilus `InstrumentAny`.
+///
+/// Returns `None` if the conversion fails (e.g., unsupported market type).
+#[must_use]
+pub fn create_instrument_from_def(def: &HyperliquidInstrumentDef) -> Option<InstrumentAny> {
+    let clock = get_atomic_clock_realtime();
+    let ts_event = clock.get_time_ns();
+    let ts_init = ts_event;
+
+    let symbol = Symbol::new(&def.symbol);
+    let venue = *HYPERLIQUID_VENUE;
+    let instrument_id = InstrumentId::new(symbol, venue);
+
+    let raw_symbol = Symbol::new(&def.symbol);
+    let base_currency = get_currency(&def.base);
+    let quote_currency = get_currency(&def.quote);
+    let price_increment = Price::from(&def.tick_size.to_string());
+    let size_increment = Quantity::from(&def.lot_size.to_string());
+
+    match def.market_type {
+        HyperliquidMarketType::Spot => Some(InstrumentAny::CurrencyPair(CurrencyPair::new(
+            instrument_id,
+            raw_symbol,
+            base_currency,
+            quote_currency,
+            def.price_decimals as u8,
+            def.size_decimals as u8,
+            price_increment,
+            size_increment,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            ts_event,
+            ts_init,
+        ))),
+        HyperliquidMarketType::Perp => {
+            let settlement_currency = get_currency("USDC");
+
+            Some(InstrumentAny::CryptoPerpetual(CryptoPerpetual::new(
+                instrument_id,
+                raw_symbol,
+                base_currency,
+                quote_currency,
+                settlement_currency,
+                false,
+                def.price_decimals as u8,
+                def.size_decimals as u8,
+                price_increment,
+                size_increment,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+                ts_event,
+                ts_init,
+            )))
+        }
+    }
+}
+
+/// Convert a collection of Hyperliquid instrument definitions into Nautilus instruments,
+/// discarding any definitions that fail to convert.
+#[must_use]
+pub fn instruments_from_defs(defs: &[HyperliquidInstrumentDef]) -> Vec<InstrumentAny> {
+    defs.iter().filter_map(create_instrument_from_def).collect()
+}
+
+/// Convert owned definitions into Nautilus instruments, consuming the input vector.
+#[must_use]
+pub fn instruments_from_defs_owned(defs: Vec<HyperliquidInstrumentDef>) -> Vec<InstrumentAny> {
+    defs.into_iter()
+        .filter_map(|def| create_instrument_from_def(&def))
+        .collect()
+}

crates/adapters/hyperliquid/src/http/mod.rs

@@ -14,6 +14,7 @@
 // -------------------------------------------------------------------------------------------------
 
 pub mod client;
+pub mod conversion;
 pub mod error;
 pub mod models;
 pub mod parse;