nautilus_hyperliquid/
factories.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Factory functions for creating Hyperliquid clients and components.
17
18use std::{any::Any, cell::RefCell, rc::Rc};
19
20use nautilus_common::{
21    cache::Cache,
22    clients::{DataClient, ExecutionClient},
23    clock::Clock,
24};
25use nautilus_live::ExecutionClientCore;
26use nautilus_model::{
27    enums::{AccountType, OmsType},
28    identifiers::{AccountId, ClientId, TraderId},
29};
30use nautilus_system::factories::{ClientConfig, DataClientFactory, ExecutionClientFactory};
31
32use crate::{
33    common::consts::HYPERLIQUID_VENUE,
34    config::{HyperliquidDataClientConfig, HyperliquidExecClientConfig},
35    data::HyperliquidDataClient,
36    execution::HyperliquidExecutionClient,
37};
38
39impl ClientConfig for HyperliquidDataClientConfig {
40    fn as_any(&self) -> &dyn Any {
41        self
42    }
43}
44
45impl ClientConfig for HyperliquidExecClientConfig {
46    fn as_any(&self) -> &dyn Any {
47        self
48    }
49}
50
51/// Factory for creating Hyperliquid data clients.
52#[derive(Debug, Clone)]
53#[cfg_attr(
54    feature = "python",
55    pyo3::pyclass(
56        module = "nautilus_trader.core.nautilus_pyo3.hyperliquid",
57        from_py_object
58    )
59)]
60#[cfg_attr(
61    feature = "python",
62    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.hyperliquid")
63)]
64pub struct HyperliquidDataClientFactory;
65
66impl HyperliquidDataClientFactory {
67    /// Creates a new [`HyperliquidDataClientFactory`] instance.
68    #[must_use]
69    pub const fn new() -> Self {
70        Self
71    }
72}
73
74impl Default for HyperliquidDataClientFactory {
75    fn default() -> Self {
76        Self::new()
77    }
78}
79
80impl DataClientFactory for HyperliquidDataClientFactory {
81    fn create(
82        &self,
83        name: &str,
84        config: &dyn ClientConfig,
85        _cache: Rc<RefCell<Cache>>,
86        _clock: Rc<RefCell<dyn Clock>>,
87    ) -> anyhow::Result<Box<dyn DataClient>> {
88        let hyperliquid_config = config
89            .as_any()
90            .downcast_ref::<HyperliquidDataClientConfig>()
91            .ok_or_else(|| {
92                anyhow::anyhow!(
93                    "Invalid config type for HyperliquidDataClientFactory. Expected HyperliquidDataClientConfig, was {config:?}",
94                )
95            })?
96            .clone();
97
98        let client_id = ClientId::from(name);
99        let client = HyperliquidDataClient::new(client_id, hyperliquid_config)?;
100        Ok(Box::new(client))
101    }
102
103    fn name(&self) -> &'static str {
104        "HYPERLIQUID"
105    }
106
107    fn config_type(&self) -> &'static str {
108        "HyperliquidDataClientConfig"
109    }
110}
111
112/// Configuration for creating Hyperliquid execution clients via factory.
113///
114/// This wraps [`HyperliquidExecClientConfig`] with the additional trader and account
115/// identifiers required by the [`ExecutionClientCore`].
116#[derive(Clone, Debug)]
117#[cfg_attr(
118    feature = "python",
119    pyo3::pyclass(
120        module = "nautilus_trader.core.nautilus_pyo3.hyperliquid",
121        from_py_object
122    )
123)]
124#[cfg_attr(
125    feature = "python",
126    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.hyperliquid")
127)]
128pub struct HyperliquidExecFactoryConfig {
129    /// The trader ID for the execution client.
130    pub trader_id: TraderId,
131    /// The account ID for the execution client.
132    pub account_id: AccountId,
133    /// The underlying execution client configuration.
134    pub config: HyperliquidExecClientConfig,
135}
136
137impl ClientConfig for HyperliquidExecFactoryConfig {
138    fn as_any(&self) -> &dyn Any {
139        self
140    }
141}
142
143/// Factory for creating Hyperliquid execution clients.
144#[derive(Debug, Clone)]
145#[cfg_attr(
146    feature = "python",
147    pyo3::pyclass(
148        module = "nautilus_trader.core.nautilus_pyo3.hyperliquid",
149        from_py_object
150    )
151)]
152#[cfg_attr(
153    feature = "python",
154    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.hyperliquid")
155)]
156pub struct HyperliquidExecutionClientFactory;
157
158impl HyperliquidExecutionClientFactory {
159    /// Creates a new [`HyperliquidExecutionClientFactory`] instance.
160    #[must_use]
161    pub const fn new() -> Self {
162        Self
163    }
164}
165
166impl Default for HyperliquidExecutionClientFactory {
167    fn default() -> Self {
168        Self::new()
169    }
170}
171
172impl ExecutionClientFactory for HyperliquidExecutionClientFactory {
173    fn create(
174        &self,
175        name: &str,
176        config: &dyn ClientConfig,
177        cache: Rc<RefCell<Cache>>,
178    ) -> anyhow::Result<Box<dyn ExecutionClient>> {
179        let factory_config = config
180            .as_any()
181            .downcast_ref::<HyperliquidExecFactoryConfig>()
182            .ok_or_else(|| {
183                anyhow::anyhow!(
184                    "Invalid config type for HyperliquidExecutionClientFactory. Expected HyperliquidExecFactoryConfig, was {config:?}",
185                )
186            })?
187            .clone();
188
189        // Hyperliquid uses netting for perpetual futures
190        let oms_type = OmsType::Netting;
191
192        // Hyperliquid is always margin (perpetual futures)
193        let account_type = AccountType::Margin;
194
195        let core = ExecutionClientCore::new(
196            factory_config.trader_id,
197            ClientId::from(name),
198            *HYPERLIQUID_VENUE,
199            oms_type,
200            factory_config.account_id,
201            account_type,
202            None,
203            cache,
204        );
205
206        let client = HyperliquidExecutionClient::new(core, factory_config.config)?;
207        Ok(Box::new(client))
208    }
209
210    fn name(&self) -> &'static str {
211        "HYPERLIQUID"
212    }
213
214    fn config_type(&self) -> &'static str {
215        "HyperliquidExecFactoryConfig"
216    }
217}
218
219#[cfg(test)]
220mod tests {
221    use std::{cell::RefCell, rc::Rc};
222
223    use nautilus_common::{cache::Cache, clock::TestClock};
224    use nautilus_model::identifiers::{AccountId, TraderId};
225    use nautilus_system::factories::{ClientConfig, DataClientFactory, ExecutionClientFactory};
226    use rstest::rstest;
227
228    use super::*;
229    use crate::config::{HyperliquidDataClientConfig, HyperliquidExecClientConfig};
230
231    #[rstest]
232    fn test_hyperliquid_data_client_factory_creation() {
233        let factory = HyperliquidDataClientFactory::new();
234        assert_eq!(factory.name(), "HYPERLIQUID");
235        assert_eq!(factory.config_type(), "HyperliquidDataClientConfig");
236    }
237
238    #[rstest]
239    fn test_hyperliquid_data_client_factory_default() {
240        let factory = HyperliquidDataClientFactory;
241        assert_eq!(factory.name(), "HYPERLIQUID");
242    }
243
244    #[rstest]
245    fn test_hyperliquid_execution_client_factory_creation() {
246        let factory = HyperliquidExecutionClientFactory::new();
247        assert_eq!(factory.name(), "HYPERLIQUID");
248        assert_eq!(factory.config_type(), "HyperliquidExecFactoryConfig");
249    }
250
251    #[rstest]
252    fn test_hyperliquid_execution_client_factory_default() {
253        let factory = HyperliquidExecutionClientFactory;
254        assert_eq!(factory.name(), "HYPERLIQUID");
255    }
256
257    #[rstest]
258    fn test_hyperliquid_data_client_config_implements_client_config() {
259        let config = HyperliquidDataClientConfig::default();
260        let boxed_config: Box<dyn ClientConfig> = Box::new(config);
261        let downcasted = boxed_config
262            .as_any()
263            .downcast_ref::<HyperliquidDataClientConfig>();
264
265        assert!(downcasted.is_some());
266    }
267
268    #[rstest]
269    fn test_hyperliquid_exec_factory_config_implements_client_config() {
270        let config = HyperliquidExecFactoryConfig {
271            trader_id: TraderId::from("TRADER-001"),
272            account_id: AccountId::from("HYPERLIQUID-001"),
273            config: HyperliquidExecClientConfig::new(Some("test_private_key".to_string())),
274        };
275
276        let boxed_config: Box<dyn ClientConfig> = Box::new(config);
277        let downcasted = boxed_config
278            .as_any()
279            .downcast_ref::<HyperliquidExecFactoryConfig>();
280
281        assert!(downcasted.is_some());
282    }
283
284    #[rstest]
285    fn test_hyperliquid_data_client_factory_rejects_wrong_config_type() {
286        let factory = HyperliquidDataClientFactory::new();
287        let wrong_config = HyperliquidExecFactoryConfig {
288            trader_id: TraderId::from("TRADER-001"),
289            account_id: AccountId::from("HYPERLIQUID-001"),
290            config: HyperliquidExecClientConfig::new(Some("test_private_key".to_string())),
291        };
292
293        let cache = Rc::new(RefCell::new(Cache::default()));
294        let clock = Rc::new(RefCell::new(TestClock::new()));
295
296        let result = factory.create("HYPERLIQUID-TEST", &wrong_config, cache, clock);
297        assert!(result.is_err());
298        assert!(
299            result
300                .err()
301                .unwrap()
302                .to_string()
303                .contains("Invalid config type")
304        );
305    }
306
307    #[rstest]
308    fn test_hyperliquid_execution_client_factory_rejects_wrong_config_type() {
309        let factory = HyperliquidExecutionClientFactory::new();
310        let wrong_config = HyperliquidDataClientConfig::default();
311
312        let cache = Rc::new(RefCell::new(Cache::default()));
313
314        let result = factory.create("HYPERLIQUID-TEST", &wrong_config, cache);
315        assert!(result.is_err());
316        assert!(
317            result
318                .err()
319                .unwrap()
320                .to_string()
321                .contains("Invalid config type")
322        );
323    }
324}
nautilus_hyperliquid/factories.rs

nautilus_hyperliquid/
factories.rs
