nautilus_bybit/
data_types.rs1use nautilus_core::UnixNanos;
23use nautilus_model::{
24 custom_data,
25 enums::PositionSide,
26 identifiers::InstrumentId,
27 types::{Price, Quantity},
28};
29#[cfg(feature = "arrow")]
30use nautilus_serialization::arrow_custom_data;
31
32#[cfg_attr(
36 feature = "arrow",
37 arrow_custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")
38)]
39#[custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")]
40pub struct BybitLiquidation {
41 pub instrument_id: InstrumentId,
43 #[custom_data_field(native_enum)]
45 pub position_side: PositionSide,
46 pub bankruptcy_price: Price,
48 pub quantity: Quantity,
50 pub ts_event: UnixNanos,
52 pub ts_init: UnixNanos,
54}
55
56#[cfg_attr(
58 feature = "arrow",
59 arrow_custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")
60)]
61#[custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")]
62pub struct BybitMarginBorrowResult {
63 pub coin: String,
65 pub amount: String,
67 pub success: bool,
69 pub message: String,
71 pub ts_event: UnixNanos,
73 pub ts_init: UnixNanos,
75}
76
77#[cfg_attr(
79 feature = "arrow",
80 arrow_custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")
81)]
82#[custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")]
83pub struct BybitMarginRepayResult {
84 pub coin: String,
86 #[custom_data_field(serde)]
88 pub amount: Option<String>,
89 pub success: bool,
91 pub result_status: String,
93 pub message: String,
95 pub ts_event: UnixNanos,
97 pub ts_init: UnixNanos,
99}
100
101#[cfg_attr(
103 feature = "arrow",
104 arrow_custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")
105)]
106#[custom_data(pyo3, stub_module = "nautilus_trader.adapters.bybit")]
107pub struct BybitMarginStatusResult {
108 pub coin: String,
110 pub borrow_amount: String,
112 pub ts_event: UnixNanos,
114 pub ts_init: UnixNanos,
116}
117
118pub fn register_bybit_custom_data() {
122 macro_rules! register {
123 ($ty:ty) => {
124 #[cfg(feature = "arrow")]
125 {
126 nautilus_serialization::ensure_custom_data_registered::<$ty>();
127 }
128
129 #[cfg(not(feature = "arrow"))]
130 {
131 let _ = nautilus_model::data::ensure_custom_data_json_registered::<$ty>();
132 }
133 };
134 }
135
136 register!(BybitLiquidation);
137 register!(BybitMarginBorrowResult);
138 register!(BybitMarginRepayResult);
139 register!(BybitMarginStatusResult);
140}
141
142#[cfg(test)]
143mod tests {
144 use nautilus_model::data::{custom::CustomDataTrait, register_custom_data_json};
145 use rstest::rstest;
146
147 use super::*;
148
149 fn liquidation() -> BybitLiquidation {
150 BybitLiquidation::new(
151 InstrumentId::from("BTCUSDT-LINEAR.BYBIT"),
152 PositionSide::Short,
153 Price::from("97410.5"),
154 Quantity::from("1.250"),
155 UnixNanos::from(1_739_502_302_929_000_000),
156 UnixNanos::from(1_739_502_303_500_000_000),
157 )
158 }
159
160 #[rstest]
161 fn test_register_bybit_custom_data_is_idempotent() {
162 register_bybit_custom_data();
163 register_bybit_custom_data();
164 }
165
166 #[rstest]
167 fn test_register_bybit_custom_data_registers_json_deserializer() {
168 register_bybit_custom_data();
169
170 let err = register_custom_data_json::<BybitLiquidation>().unwrap_err();
171
172 assert_eq!(
173 err.to_string(),
174 "Custom data type \"BybitLiquidation\" is already registered for JSON",
175 );
176 }
177
178 #[rstest]
179 fn test_bybit_liquidation_json_round_trip() {
180 let original = liquidation();
181
182 let value: serde_json::Value = serde_json::from_str(&original.to_json().unwrap()).unwrap();
183 let restored = <BybitLiquidation as CustomDataTrait>::from_json(value).unwrap();
184 let restored = restored
185 .as_any()
186 .downcast_ref::<BybitLiquidation>()
187 .unwrap();
188
189 assert_eq!(restored, &original);
190 assert_eq!(restored.instrument_id, original.instrument_id);
191 assert_eq!(restored.position_side, PositionSide::Short);
192 assert_eq!(restored.bankruptcy_price, Price::from("97410.5"));
193 assert_eq!(restored.quantity, Quantity::from("1.250"));
194 assert_eq!(restored.ts_event, original.ts_event);
195 assert_eq!(restored.ts_init, original.ts_init);
196 }
197
198 #[cfg(feature = "arrow")]
199 #[rstest]
200 fn test_bybit_liquidation_arrow_schema_uses_native_types() {
201 use arrow::datatypes::DataType;
202 use nautilus_serialization::arrow::ArrowSchemaProvider;
203
204 let schema = BybitLiquidation::get_schema(None);
205 let names: Vec<_> = schema.fields().iter().map(|f| f.name().as_str()).collect();
206
207 assert_eq!(
208 names,
209 vec![
210 "instrument_id",
211 "position_side",
212 "bankruptcy_price",
213 "quantity",
214 "ts_event",
215 "ts_init",
216 ],
217 );
218 assert!(matches!(
219 schema.field(0).data_type(),
220 DataType::Utf8 | DataType::Utf8View
221 ));
222 assert_eq!(
223 schema.field(1).data_type(),
224 &nautilus_serialization::arrow::enum_dictionary_data_type(),
225 );
226 assert_eq!(schema.field(2).data_type(), &DataType::Decimal128(38, 16));
227 assert_eq!(schema.field(3).data_type(), &DataType::Decimal128(38, 16));
228 assert_eq!(
229 schema.field(4).data_type(),
230 &nautilus_serialization::arrow::timestamp_data_type(),
231 );
232 assert_eq!(
233 schema.field(5).data_type(),
234 &nautilus_serialization::arrow::timestamp_data_type(),
235 );
236 }
237}