1use derive_builder::Builder;
19#[cfg(test)]
20use nautilus_core::string::secret::REDACTED;
21use nautilus_core::string::secret::SecretString;
22use serde::{Deserialize, Serialize};
23use zeroize::Zeroize;
24
25use crate::common::{
26 enums::{
27 BybitAccountType, BybitBboSideType, BybitExecType, BybitInstrumentStatus,
28 BybitKlineInterval, BybitMarginMode, BybitMarketUnit, BybitOpenOnly, BybitOptionType,
29 BybitOrderFilter, BybitOrderSide, BybitOrderSmpType, BybitOrderStatus, BybitOrderType,
30 BybitPositionIdx, BybitPositionMode, BybitProductType, BybitStopOrderType,
31 BybitTimeInForce, BybitTpSlMode, BybitTriggerDirection, BybitTriggerType,
32 BybitWithdrawAccountType, BybitWithdrawFeeType, BybitWithdrawForceChain, BybitWithdrawType,
33 },
34 parse::opt_bool_as_int,
35};
36
37#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
42#[serde(rename_all = "camelCase")]
43#[builder(default)]
44#[builder(setter(into))]
45pub struct BybitInstrumentsInfoParams {
46 pub category: BybitProductType,
47 #[builder(setter(strip_option))]
48 #[serde(skip_serializing_if = "Option::is_none")]
49 pub symbol: Option<String>,
50 #[builder(setter(strip_option))]
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub status: Option<BybitInstrumentStatus>,
53 #[builder(setter(strip_option))]
54 #[serde(skip_serializing_if = "Option::is_none")]
55 pub base_coin: Option<String>,
56 #[builder(setter(strip_option))]
57 #[serde(skip_serializing_if = "Option::is_none")]
58 pub limit: Option<u32>,
59 #[builder(setter(strip_option))]
60 #[serde(skip_serializing_if = "Option::is_none")]
61 pub cursor: Option<String>,
62}
63
64#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
69#[serde(rename_all = "camelCase")]
70#[builder(default)]
71#[builder(setter(into))]
72pub struct BybitTickersParams {
73 pub category: BybitProductType,
74 #[serde(skip_serializing_if = "Option::is_none")]
75 #[builder(setter(strip_option))]
76 pub symbol: Option<String>,
77 #[serde(skip_serializing_if = "Option::is_none")]
78 #[builder(setter(strip_option))]
79 pub base_coin: Option<String>,
80 #[serde(skip_serializing_if = "Option::is_none")]
81 #[builder(setter(strip_option))]
82 pub exp_date: Option<String>,
83}
84
85#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
90#[serde(rename_all = "camelCase")]
91#[builder(setter(into, strip_option), default)]
92pub struct BybitKlinesParams {
93 pub category: BybitProductType,
94 pub symbol: String,
95 pub interval: BybitKlineInterval,
96 #[serde(skip_serializing_if = "Option::is_none")]
97 pub start: Option<i64>,
98 #[serde(skip_serializing_if = "Option::is_none")]
99 pub end: Option<i64>,
100 #[serde(skip_serializing_if = "Option::is_none")]
101 pub limit: Option<u32>,
102}
103
104impl Default for BybitKlinesParams {
105 fn default() -> Self {
106 Self {
107 category: BybitProductType::Linear,
108 symbol: String::new(),
109 interval: BybitKlineInterval::Minute1,
110 start: None,
111 end: None,
112 limit: None,
113 }
114 }
115}
116
117#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
122#[serde(rename_all = "camelCase")]
123#[builder(setter(into, strip_option), default)]
124pub struct BybitTradesParams {
125 pub category: BybitProductType,
126 pub symbol: String,
127 #[serde(skip_serializing_if = "Option::is_none")]
128 pub base_coin: Option<String>,
129 #[serde(skip_serializing_if = "Option::is_none")]
130 pub option_type: Option<BybitOptionType>,
131 #[serde(skip_serializing_if = "Option::is_none")]
132 pub limit: Option<u32>,
133}
134
135impl Default for BybitTradesParams {
136 fn default() -> Self {
137 Self {
138 category: BybitProductType::Linear,
139 symbol: String::new(),
140 base_coin: None,
141 option_type: None,
142 limit: None,
143 }
144 }
145}
146
147#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
152#[serde(rename_all = "camelCase")]
153#[builder(setter(into, strip_option), default)]
154pub struct BybitFundingParams {
155 pub category: BybitProductType,
156 pub symbol: String,
157 #[serde(skip_serializing_if = "Option::is_none")]
158 pub start_time: Option<i64>,
159 #[serde(skip_serializing_if = "Option::is_none")]
160 pub end_time: Option<i64>,
161 #[serde(skip_serializing_if = "Option::is_none")]
162 pub limit: Option<u32>,
163}
164
165impl Default for BybitFundingParams {
166 fn default() -> Self {
167 Self {
168 category: BybitProductType::Linear,
169 symbol: String::new(),
170 start_time: None,
171 end_time: None,
172 limit: None,
173 }
174 }
175}
176
177#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
182#[builder(setter(into, strip_option), default)]
183pub struct BybitOrderbookParams {
184 pub category: BybitProductType,
185 pub symbol: String,
186 #[serde(skip_serializing_if = "Option::is_none")]
187 pub limit: Option<u32>,
188}
189
190impl Default for BybitOrderbookParams {
191 fn default() -> Self {
192 Self {
193 category: BybitProductType::Linear,
194 symbol: String::new(),
195 limit: None,
196 }
197 }
198}
199
200#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
205#[serde(rename_all = "camelCase")]
206#[builder(default)]
207#[builder(setter(into))]
208pub struct BybitCoinInfoParams {
209 #[serde(skip_serializing_if = "Option::is_none")]
210 #[builder(setter(strip_option))]
211 pub coin: Option<String>,
212}
213
214#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
219#[serde(rename_all = "camelCase")]
220#[builder(default)]
221#[builder(setter(into))]
222pub struct BybitFeeRateParams {
223 pub category: BybitProductType,
224 #[builder(setter(strip_option))]
225 #[serde(skip_serializing_if = "Option::is_none")]
226 pub symbol: Option<String>,
227 #[builder(setter(strip_option))]
228 #[serde(skip_serializing_if = "Option::is_none")]
229 pub base_coin: Option<String>,
230}
231
232#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
237#[serde(rename_all = "camelCase")]
238pub struct BybitWalletBalanceParams {
239 pub account_type: BybitAccountType,
240 #[serde(skip_serializing_if = "Option::is_none")]
241 #[builder(setter(strip_option))]
242 pub coin: Option<String>,
243}
244
245#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
250#[serde(rename_all = "camelCase")]
251#[builder(default)]
252#[builder(setter(into))]
253pub struct BybitPositionListParams {
254 pub category: BybitProductType,
255 #[serde(skip_serializing_if = "Option::is_none")]
256 #[builder(setter(strip_option))]
257 pub symbol: Option<String>,
258 #[serde(skip_serializing_if = "Option::is_none")]
259 #[builder(setter(strip_option))]
260 pub base_coin: Option<String>,
261 #[serde(skip_serializing_if = "Option::is_none")]
262 #[builder(setter(strip_option))]
263 pub settle_coin: Option<String>,
264 #[serde(skip_serializing_if = "Option::is_none")]
265 #[builder(setter(strip_option))]
266 pub limit: Option<u32>,
267 #[serde(skip_serializing_if = "Option::is_none")]
268 #[builder(setter(strip_option))]
269 pub cursor: Option<String>,
270}
271
272#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
277#[serde(rename_all = "camelCase")]
278pub struct BybitSetMarginModeParams {
279 pub set_margin_mode: BybitMarginMode,
280}
281
282#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
287#[serde(rename_all = "camelCase")]
288pub struct BybitSetLeverageParams {
289 pub category: BybitProductType,
290 pub symbol: String,
291 pub buy_leverage: String,
292 pub sell_leverage: String,
293}
294
295#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
300#[serde(rename_all = "camelCase")]
301pub struct BybitSwitchModeParams {
302 pub category: BybitProductType,
303 #[builder(default)]
304 #[serde(skip_serializing_if = "Option::is_none")]
305 #[builder(setter(strip_option))]
306 pub symbol: Option<String>,
307 #[builder(default)]
308 #[serde(skip_serializing_if = "Option::is_none")]
309 #[builder(setter(strip_option))]
310 pub coin: Option<String>,
311 pub mode: BybitPositionMode,
312}
313
314#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
319#[serde(rename_all = "camelCase")]
320pub struct BybitSetTradingStopParams {
321 pub category: BybitProductType,
322 pub symbol: String,
323 pub position_idx: BybitPositionIdx,
324 #[serde(skip_serializing_if = "Option::is_none")]
325 pub take_profit: Option<String>,
326 #[serde(skip_serializing_if = "Option::is_none")]
327 pub stop_loss: Option<String>,
328 #[serde(skip_serializing_if = "Option::is_none")]
329 pub trailing_stop: Option<String>,
330 #[serde(skip_serializing_if = "Option::is_none")]
331 pub tp_trigger_by: Option<BybitTriggerType>,
332 #[serde(skip_serializing_if = "Option::is_none")]
333 pub sl_trigger_by: Option<BybitTriggerType>,
334 #[serde(skip_serializing_if = "Option::is_none")]
335 pub active_price: Option<String>,
336 #[serde(skip_serializing_if = "Option::is_none")]
337 pub tpsl_mode: Option<BybitTpSlMode>,
338 #[serde(skip_serializing_if = "Option::is_none")]
339 pub tp_size: Option<String>,
340 #[serde(skip_serializing_if = "Option::is_none")]
341 pub sl_size: Option<String>,
342 #[serde(skip_serializing_if = "Option::is_none")]
343 pub tp_limit_price: Option<String>,
344 #[serde(skip_serializing_if = "Option::is_none")]
345 pub sl_limit_price: Option<String>,
346 #[serde(skip_serializing_if = "Option::is_none")]
347 pub tp_order_type: Option<BybitOrderType>,
348 #[serde(skip_serializing_if = "Option::is_none")]
349 pub sl_order_type: Option<BybitOrderType>,
350}
351
352#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
358#[serde(rename_all = "camelCase")]
359pub struct BybitBorrowParams {
360 pub coin: String,
361 pub amount: String,
362}
363
364#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
370#[serde(rename_all = "camelCase")]
371pub struct BybitNoConvertRepayParams {
372 pub coin: String,
373 #[serde(skip_serializing_if = "Option::is_none")]
374 #[builder(setter(strip_option), default)]
375 pub amount: Option<String>,
376}
377
378#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
384#[serde(rename_all = "camelCase")]
385pub struct BybitRepayParams {
386 #[serde(skip_serializing_if = "Option::is_none")]
387 #[builder(setter(strip_option), default)]
388 pub coin: Option<String>,
389 #[serde(skip_serializing_if = "Option::is_none")]
390 #[builder(setter(strip_option), default)]
391 pub amount: Option<String>,
392 #[serde(skip_serializing_if = "Option::is_none")]
393 #[builder(setter(strip_option), default)]
394 pub repayment_type: Option<String>,
395}
396
397#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
403#[serde(rename_all = "camelCase")]
404pub struct BybitWithdrawParams {
405 pub coin: String,
406 #[serde(skip_serializing_if = "Option::is_none")]
407 #[builder(setter(strip_option), default)]
408 pub chain: Option<String>,
409 pub address: String,
410 #[serde(skip_serializing_if = "Option::is_none")]
411 #[builder(setter(strip_option), default)]
412 pub tag: Option<String>,
413 pub amount: String,
414 pub timestamp: i64,
415 #[serde(skip_serializing_if = "Option::is_none")]
416 #[builder(setter(strip_option), default)]
417 pub force_chain: Option<BybitWithdrawForceChain>,
418 pub account_type: BybitWithdrawAccountType,
419 #[serde(skip_serializing_if = "Option::is_none")]
420 #[builder(setter(strip_option), default)]
421 pub fee_type: Option<BybitWithdrawFeeType>,
422 #[serde(skip_serializing_if = "Option::is_none")]
423 #[builder(setter(strip_option), default)]
424 pub request_id: Option<String>,
425 #[serde(skip_serializing_if = "Option::is_none")]
426 #[builder(setter(strip_option), default)]
427 pub questionnaire: Option<String>,
428}
429
430#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
436#[serde(rename_all = "camelCase")]
437#[builder(default)]
438pub struct BybitWithdrawalRecordsParams {
439 #[serde(rename = "withdrawID", skip_serializing_if = "Option::is_none")]
440 #[builder(setter(strip_option))]
441 pub withdraw_id: Option<String>,
442 #[serde(rename = "txID", skip_serializing_if = "Option::is_none")]
443 #[builder(setter(strip_option))]
444 pub tx_id: Option<String>,
445 #[serde(skip_serializing_if = "Option::is_none")]
446 #[builder(setter(strip_option))]
447 pub coin: Option<String>,
448 #[serde(skip_serializing_if = "Option::is_none")]
449 #[builder(setter(strip_option))]
450 pub withdraw_type: Option<BybitWithdrawType>,
451 #[serde(skip_serializing_if = "Option::is_none")]
452 #[builder(setter(strip_option))]
453 pub start_time: Option<i64>,
454 #[serde(skip_serializing_if = "Option::is_none")]
455 #[builder(setter(strip_option))]
456 pub end_time: Option<i64>,
457 #[serde(skip_serializing_if = "Option::is_none")]
458 #[builder(setter(strip_option))]
459 pub limit: Option<u32>,
460 #[serde(skip_serializing_if = "Option::is_none")]
461 #[builder(setter(strip_option))]
462 pub cursor: Option<String>,
463}
464
465#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
470#[serde(rename_all = "camelCase")]
471pub struct BybitBatchPlaceOrderEntry {
472 pub symbol: String,
473 #[builder(default)]
474 #[serde(skip_serializing_if = "Option::is_none")]
475 pub is_leverage: Option<i32>,
476 pub side: BybitOrderSide,
477 pub order_type: BybitOrderType,
478 pub qty: String,
479 #[builder(default)]
480 #[serde(skip_serializing_if = "Option::is_none")]
481 pub price: Option<String>,
482 #[builder(default)]
483 #[serde(skip_serializing_if = "Option::is_none")]
484 pub market_unit: Option<BybitMarketUnit>,
485 #[builder(default)]
486 #[serde(skip_serializing_if = "Option::is_none")]
487 pub trigger_direction: Option<BybitTriggerDirection>,
488 #[builder(default)]
489 #[serde(skip_serializing_if = "Option::is_none")]
490 pub order_filter: Option<BybitOrderFilter>,
491 #[builder(default)]
492 #[serde(skip_serializing_if = "Option::is_none")]
493 pub trigger_price: Option<String>,
494 #[builder(default)]
495 #[serde(skip_serializing_if = "Option::is_none")]
496 pub trigger_by: Option<BybitTriggerType>,
497 #[builder(default)]
498 #[serde(skip_serializing_if = "Option::is_none")]
499 pub order_iv: Option<String>,
500 #[builder(default)]
501 #[serde(skip_serializing_if = "Option::is_none")]
502 pub time_in_force: Option<BybitTimeInForce>,
503 #[builder(default)]
504 #[serde(skip_serializing_if = "Option::is_none")]
505 pub position_idx: Option<BybitPositionIdx>,
506 #[builder(default)]
507 #[serde(skip_serializing_if = "Option::is_none")]
508 #[builder(setter(strip_option))]
509 pub order_link_id: Option<String>,
510 #[builder(default)]
511 #[serde(skip_serializing_if = "Option::is_none")]
512 pub take_profit: Option<String>,
513 #[builder(default)]
514 #[serde(skip_serializing_if = "Option::is_none")]
515 pub stop_loss: Option<String>,
516 #[builder(default)]
517 #[serde(skip_serializing_if = "Option::is_none")]
518 pub tp_trigger_by: Option<BybitTriggerType>,
519 #[builder(default)]
520 #[serde(skip_serializing_if = "Option::is_none")]
521 pub sl_trigger_by: Option<BybitTriggerType>,
522 #[builder(default)]
523 #[serde(skip_serializing_if = "Option::is_none")]
524 pub reduce_only: Option<bool>,
525 #[builder(default)]
526 #[serde(skip_serializing_if = "Option::is_none")]
527 pub close_on_trigger: Option<bool>,
528 #[builder(default)]
529 #[serde(skip_serializing_if = "Option::is_none")]
530 pub smp_type: Option<BybitOrderSmpType>,
531 #[builder(default)]
532 #[serde(skip_serializing_if = "Option::is_none")]
533 pub mmp: Option<bool>,
534 #[builder(default)]
535 #[serde(skip_serializing_if = "Option::is_none")]
536 pub tpsl_mode: Option<BybitTpSlMode>,
537 #[builder(default)]
538 #[serde(skip_serializing_if = "Option::is_none")]
539 pub tp_limit_price: Option<String>,
540 #[builder(default)]
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub sl_limit_price: Option<String>,
543 #[builder(default)]
544 #[serde(skip_serializing_if = "Option::is_none")]
545 pub tp_order_type: Option<BybitOrderType>,
546 #[builder(default)]
547 #[serde(skip_serializing_if = "Option::is_none")]
548 pub sl_order_type: Option<BybitOrderType>,
549 #[builder(default)]
550 #[serde(skip_serializing_if = "Option::is_none")]
551 pub bbo_side_type: Option<BybitBboSideType>,
552 #[builder(default)]
553 #[serde(skip_serializing_if = "Option::is_none")]
554 pub bbo_level: Option<String>,
555}
556
557#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
562#[serde(rename_all = "camelCase")]
563pub struct BybitBatchPlaceOrderParams {
564 pub category: BybitProductType,
565 pub request: Vec<BybitBatchPlaceOrderEntry>,
566}
567
568#[derive(Debug, Clone, Default)]
579pub struct BybitNativeTpSlParams {
580 pub take_profit: Option<String>,
581 pub stop_loss: Option<String>,
582 pub tp_trigger_by: Option<BybitTriggerType>,
583 pub sl_trigger_by: Option<BybitTriggerType>,
584 pub tp_order_type: Option<BybitOrderType>,
585 pub sl_order_type: Option<BybitOrderType>,
586 pub tp_limit_price: Option<String>,
587 pub sl_limit_price: Option<String>,
588 pub tpsl_mode: Option<BybitTpSlMode>,
589 pub close_on_trigger: Option<bool>,
590 pub order_iv: Option<String>,
591 pub mmp: Option<bool>,
592}
593
594impl BybitNativeTpSlParams {
595 #[must_use]
597 pub fn is_empty(&self) -> bool {
598 self.take_profit.is_none()
599 && self.stop_loss.is_none()
600 && self.tp_trigger_by.is_none()
601 && self.sl_trigger_by.is_none()
602 && self.tp_order_type.is_none()
603 && self.sl_order_type.is_none()
604 && self.tp_limit_price.is_none()
605 && self.sl_limit_price.is_none()
606 && self.tpsl_mode.is_none()
607 && self.close_on_trigger.is_none()
608 && self.order_iv.is_none()
609 && self.mmp.is_none()
610 }
611}
612
613#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
618#[serde(rename_all = "camelCase")]
619pub struct BybitPlaceOrderParams {
620 #[serde(flatten)]
621 pub order: BybitBatchPlaceOrderEntry,
622 pub category: BybitProductType,
623 #[builder(default)]
624 #[serde(skip_serializing_if = "Option::is_none")]
625 pub slippage_tolerance_type: Option<String>,
626 #[builder(default)]
627 #[serde(skip_serializing_if = "Option::is_none")]
628 pub slippage_tolerance: Option<String>,
629}
630
631#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
636#[serde(rename_all = "camelCase")]
637pub struct BybitBatchAmendOrderEntry {
638 pub symbol: String,
639 #[builder(default)]
640 #[serde(skip_serializing_if = "Option::is_none")]
641 #[builder(setter(strip_option))]
642 pub order_id: Option<String>,
643 #[builder(default)]
644 #[serde(skip_serializing_if = "Option::is_none")]
645 #[builder(setter(strip_option))]
646 pub order_link_id: Option<String>,
647 #[builder(default)]
648 #[serde(skip_serializing_if = "Option::is_none")]
649 pub order_iv: Option<String>,
650 #[builder(default)]
651 #[serde(skip_serializing_if = "Option::is_none")]
652 pub trigger_price: Option<String>,
653 #[builder(default)]
654 #[serde(skip_serializing_if = "Option::is_none")]
655 pub qty: Option<String>,
656 #[builder(default)]
657 #[serde(skip_serializing_if = "Option::is_none")]
658 pub price: Option<String>,
659 #[builder(default)]
660 #[serde(skip_serializing_if = "Option::is_none")]
661 pub tpsl_mode: Option<BybitTpSlMode>,
662 #[builder(default)]
663 #[serde(skip_serializing_if = "Option::is_none")]
664 pub take_profit: Option<String>,
665 #[builder(default)]
666 #[serde(skip_serializing_if = "Option::is_none")]
667 pub stop_loss: Option<String>,
668 #[builder(default)]
669 #[serde(skip_serializing_if = "Option::is_none")]
670 pub tp_trigger_by: Option<BybitTriggerType>,
671 #[builder(default)]
672 #[serde(skip_serializing_if = "Option::is_none")]
673 pub sl_trigger_by: Option<BybitTriggerType>,
674 #[builder(default)]
675 #[serde(skip_serializing_if = "Option::is_none")]
676 pub trigger_by: Option<BybitTriggerType>,
677 #[builder(default)]
678 #[serde(skip_serializing_if = "Option::is_none")]
679 pub tp_limit_price: Option<String>,
680 #[builder(default)]
681 #[serde(skip_serializing_if = "Option::is_none")]
682 pub sl_limit_price: Option<String>,
683}
684
685#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
690#[serde(rename_all = "camelCase")]
691pub struct BybitBatchAmendOrderParams {
692 pub category: BybitProductType,
693 pub request: Vec<BybitBatchAmendOrderEntry>,
694}
695
696#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
701#[serde(rename_all = "camelCase")]
702pub struct BybitAmendOrderParams {
703 #[serde(flatten)]
704 pub order: BybitBatchAmendOrderEntry,
705 pub category: BybitProductType,
706}
707
708#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
713#[serde(rename_all = "camelCase")]
714pub struct BybitBatchCancelOrderEntry {
715 pub symbol: String,
716 #[builder(default)]
717 #[serde(skip_serializing_if = "Option::is_none")]
718 #[builder(setter(strip_option))]
719 pub order_id: Option<String>,
720 #[builder(default)]
721 #[serde(skip_serializing_if = "Option::is_none")]
722 #[builder(setter(strip_option))]
723 pub order_link_id: Option<String>,
724 #[builder(default)]
725 #[serde(skip_serializing_if = "Option::is_none")]
726 pub order_filter: Option<BybitOrderFilter>,
727}
728
729#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
734#[serde(rename_all = "camelCase")]
735pub struct BybitBatchCancelOrderParams {
736 pub category: BybitProductType,
737 pub request: Vec<BybitBatchCancelOrderEntry>,
738}
739
740#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
745#[serde(rename_all = "camelCase")]
746pub struct BybitCancelOrderParams {
747 #[serde(flatten)]
748 pub order: BybitBatchCancelOrderEntry,
749 pub category: BybitProductType,
750}
751
752#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
757#[serde(rename_all = "camelCase")]
758#[builder(default)]
759#[builder(setter(into))]
760pub struct BybitCancelAllOrdersParams {
761 pub category: BybitProductType,
762 #[serde(skip_serializing_if = "Option::is_none")]
763 #[builder(setter(strip_option))]
764 pub symbol: Option<String>,
765 #[serde(skip_serializing_if = "Option::is_none")]
766 #[builder(setter(strip_option))]
767 pub base_coin: Option<String>,
768 #[serde(skip_serializing_if = "Option::is_none")]
769 #[builder(setter(strip_option))]
770 pub settle_coin: Option<String>,
771 #[serde(skip_serializing_if = "Option::is_none")]
772 #[builder(setter(strip_option))]
773 pub order_filter: Option<BybitOrderFilter>,
774 #[serde(skip_serializing_if = "Option::is_none")]
775 #[builder(setter(strip_option))]
776 pub stop_order_type: Option<BybitStopOrderType>,
777}
778
779#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
784#[serde(rename_all = "camelCase")]
785#[builder(default)]
786#[builder(setter(into))]
787pub struct BybitOpenOrdersParams {
788 pub category: BybitProductType,
789 #[serde(skip_serializing_if = "Option::is_none")]
790 #[builder(setter(strip_option))]
791 pub symbol: Option<String>,
792 #[serde(skip_serializing_if = "Option::is_none")]
793 #[builder(setter(strip_option))]
794 pub base_coin: Option<String>,
795 #[serde(skip_serializing_if = "Option::is_none")]
796 #[builder(setter(strip_option))]
797 pub settle_coin: Option<String>,
798 #[serde(skip_serializing_if = "Option::is_none")]
799 #[builder(setter(strip_option))]
800 pub order_id: Option<String>,
801 #[serde(skip_serializing_if = "Option::is_none")]
802 #[builder(setter(strip_option))]
803 pub order_link_id: Option<String>,
804 #[serde(skip_serializing_if = "Option::is_none")]
805 #[builder(setter(strip_option))]
806 pub open_only: Option<BybitOpenOnly>,
807 #[serde(skip_serializing_if = "Option::is_none")]
808 #[builder(setter(strip_option))]
809 pub order_filter: Option<BybitOrderFilter>,
810 #[serde(skip_serializing_if = "Option::is_none")]
811 #[builder(setter(strip_option))]
812 pub limit: Option<u32>,
813 #[serde(skip_serializing_if = "Option::is_none")]
814 #[builder(setter(strip_option))]
815 pub cursor: Option<String>,
816}
817
818#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
823#[serde(rename_all = "camelCase")]
824#[builder(default)]
825#[builder(setter(into))]
826pub struct BybitOrderHistoryParams {
827 pub category: BybitProductType,
828 #[serde(skip_serializing_if = "Option::is_none")]
829 #[builder(setter(strip_option))]
830 pub symbol: Option<String>,
831 #[serde(skip_serializing_if = "Option::is_none")]
832 #[builder(setter(strip_option))]
833 pub base_coin: Option<String>,
834 #[serde(skip_serializing_if = "Option::is_none")]
835 #[builder(setter(strip_option))]
836 pub settle_coin: Option<String>,
837 #[serde(skip_serializing_if = "Option::is_none")]
838 #[builder(setter(strip_option))]
839 pub order_id: Option<String>,
840 #[serde(skip_serializing_if = "Option::is_none")]
841 #[builder(setter(strip_option))]
842 pub order_link_id: Option<String>,
843 #[serde(skip_serializing_if = "Option::is_none")]
844 #[builder(setter(strip_option))]
845 pub open_only: Option<BybitOpenOnly>,
846 #[serde(skip_serializing_if = "Option::is_none")]
847 #[builder(setter(strip_option))]
848 pub order_filter: Option<BybitOrderFilter>,
849 #[serde(skip_serializing_if = "Option::is_none")]
850 #[builder(setter(strip_option))]
851 pub order_status: Option<BybitOrderStatus>,
852 #[serde(skip_serializing_if = "Option::is_none")]
853 #[builder(setter(strip_option))]
854 pub start_time: Option<i64>,
855 #[serde(skip_serializing_if = "Option::is_none")]
856 #[serde(rename = "endTime")]
857 #[builder(setter(strip_option))]
858 pub end_time: Option<i64>,
859 #[serde(skip_serializing_if = "Option::is_none")]
860 #[builder(setter(strip_option))]
861 pub limit: Option<u32>,
862 #[serde(skip_serializing_if = "Option::is_none")]
863 #[builder(setter(strip_option))]
864 pub cursor: Option<String>,
865}
866
867#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
872#[serde(rename_all = "camelCase")]
873#[builder(default)]
874#[builder(setter(into))]
875pub struct BybitTradeHistoryParams {
876 pub category: BybitProductType,
877 #[serde(skip_serializing_if = "Option::is_none")]
878 #[builder(setter(strip_option))]
879 pub symbol: Option<String>,
880 #[serde(skip_serializing_if = "Option::is_none")]
881 #[builder(setter(strip_option))]
882 pub base_coin: Option<String>,
883 #[serde(skip_serializing_if = "Option::is_none")]
884 #[builder(setter(strip_option))]
885 pub order_id: Option<String>,
886 #[serde(skip_serializing_if = "Option::is_none")]
887 #[builder(setter(strip_option))]
888 pub order_link_id: Option<String>,
889 #[serde(skip_serializing_if = "Option::is_none")]
890 #[builder(setter(strip_option))]
891 pub start_time: Option<i64>,
892 #[serde(skip_serializing_if = "Option::is_none")]
893 #[serde(rename = "endTime")]
894 #[builder(setter(strip_option))]
895 pub end_time: Option<i64>,
896 #[serde(skip_serializing_if = "Option::is_none")]
897 #[builder(setter(strip_option))]
898 pub exec_type: Option<BybitExecType>,
899 #[serde(skip_serializing_if = "Option::is_none")]
900 #[builder(setter(strip_option))]
901 pub limit: Option<u32>,
902 #[serde(skip_serializing_if = "Option::is_none")]
903 #[builder(setter(strip_option))]
904 pub cursor: Option<String>,
905}
906
907#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
926#[serde(rename_all = "PascalCase")]
927#[builder(default)]
928#[builder(setter(into, strip_option))]
929pub struct BybitApiKeyPermissionUpdate {
930 #[serde(skip_serializing_if = "Option::is_none")]
931 pub contract_trade: Option<Vec<String>>,
932 #[serde(skip_serializing_if = "Option::is_none")]
933 pub spot: Option<Vec<String>>,
934 #[serde(skip_serializing_if = "Option::is_none")]
935 pub wallet: Option<Vec<String>>,
936 #[serde(skip_serializing_if = "Option::is_none")]
937 pub options: Option<Vec<String>>,
938 #[serde(skip_serializing_if = "Option::is_none")]
939 pub derivatives: Option<Vec<String>>,
940 #[serde(skip_serializing_if = "Option::is_none")]
941 pub exchange: Option<Vec<String>>,
942 #[serde(skip_serializing_if = "Option::is_none")]
943 pub earn: Option<Vec<String>>,
944 #[serde(skip_serializing_if = "Option::is_none")]
945 pub affiliate: Option<Vec<String>>,
946 #[serde(skip_serializing_if = "Option::is_none")]
947 pub block_trade: Option<Vec<String>>,
948 #[serde(skip_serializing_if = "Option::is_none")]
949 pub copy_trading: Option<Vec<String>>,
950 #[serde(rename = "NFT", skip_serializing_if = "Option::is_none")]
953 pub nft: Option<Vec<String>>,
954 #[serde(rename = "FiatP2P", skip_serializing_if = "Option::is_none")]
956 pub fiat_p2p: Option<Vec<String>>,
957 #[serde(skip_serializing_if = "Option::is_none")]
958 pub fiat_bybit_pay: Option<Vec<String>>,
959 #[serde(skip_serializing_if = "Option::is_none")]
960 pub fiat_bit_pay: Option<Vec<String>>,
961 #[serde(skip_serializing_if = "Option::is_none")]
962 pub fiat_convert_broker: Option<Vec<String>>,
963 #[serde(skip_serializing_if = "Option::is_none")]
964 pub bit_card: Option<Vec<String>>,
965 #[serde(rename = "ByXPost", skip_serializing_if = "Option::is_none")]
967 pub byx_post: Option<Vec<String>>,
968}
969
970#[derive(Debug, Clone, Deserialize, Serialize, Default, Builder)]
978#[serde(rename_all = "camelCase")]
979#[builder(setter(into))]
980pub struct BybitUpdateSubApiParams {
981 #[builder(default)]
982 #[serde(skip_serializing_if = "Option::is_none")]
983 #[builder(setter(strip_option))]
984 pub api_key: Option<SecretString>,
985 #[builder(default)]
988 #[serde(skip_serializing_if = "Option::is_none", with = "opt_bool_as_int")]
989 #[builder(setter(strip_option))]
990 pub read_only: Option<bool>,
991 #[builder(default)]
992 #[serde(skip_serializing_if = "Option::is_none")]
993 #[builder(setter(strip_option))]
994 pub ips: Option<String>,
995 #[builder(default)]
996 #[serde(skip_serializing_if = "Option::is_none")]
997 #[builder(setter(strip_option))]
998 pub permissions: Option<BybitApiKeyPermissionUpdate>,
999}
1000
1001impl Zeroize for BybitUpdateSubApiParams {
1002 fn zeroize(&mut self) {
1003 self.api_key.zeroize();
1004 }
1005}
1006
1007#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
1018#[serde(rename_all = "camelCase")]
1019#[builder(default)]
1020#[builder(setter(into))]
1021pub struct BybitUpdateMasterApiParams {
1022 #[serde(skip_serializing_if = "Option::is_none", with = "opt_bool_as_int")]
1023 #[builder(setter(strip_option))]
1024 pub read_only: Option<bool>,
1025 #[serde(skip_serializing_if = "Option::is_none")]
1026 #[builder(setter(strip_option))]
1027 pub permissions: Option<BybitApiKeyPermissionUpdate>,
1028}
1029
1030#[derive(Clone, Debug, Deserialize, Serialize, Default, Builder)]
1042#[serde(rename_all = "camelCase")]
1043#[builder(default)]
1044#[builder(setter(into))]
1045pub struct BybitSubMembersPageParams {
1046 #[serde(skip_serializing_if = "Option::is_none")]
1047 #[builder(setter(strip_option))]
1048 pub page_size: Option<u32>,
1049 #[serde(skip_serializing_if = "Option::is_none")]
1050 #[builder(setter(strip_option))]
1051 pub next_cursor: Option<String>,
1052}
1053
1054#[derive(Clone, Debug, Deserialize, Serialize, Builder)]
1063#[serde(rename_all = "camelCase")]
1064#[builder(setter(into))]
1065pub struct BybitSubApiKeysParams {
1066 pub sub_member_id: String,
1067 #[serde(skip_serializing_if = "Option::is_none")]
1068 #[builder(setter(strip_option), default)]
1069 pub limit: Option<u32>,
1070 #[serde(skip_serializing_if = "Option::is_none")]
1071 #[builder(setter(strip_option), default)]
1072 pub cursor: Option<String>,
1073}
1074
1075#[cfg(test)]
1076mod tests {
1077 use rstest::rstest;
1078 use zeroize::Zeroize;
1079
1080 use super::*;
1081
1082 #[rstest]
1083 fn test_update_sub_api_preserves_wire_value_and_redacts_debug() {
1084 let mut params = BybitUpdateSubApiParamsBuilder::default()
1085 .api_key("sub-api-key-secret".to_string())
1086 .read_only(true)
1087 .build()
1088 .unwrap();
1089
1090 let value = serde_json::to_value(¶ms).unwrap();
1091 let debug = format!("{params:?}");
1092
1093 assert_eq!(value["apiKey"], "sub-api-key-secret");
1094 assert_eq!(value["readOnly"], 1);
1095 assert!(debug.contains(REDACTED));
1096 assert!(!debug.contains("sub-api-key-secret"));
1097
1098 params.zeroize();
1099 assert!(params.api_key.is_none());
1100 }
1101
1102 #[rstest]
1103 fn test_amend_entry_builds_with_only_order_id() {
1104 let entry = BybitBatchAmendOrderEntryBuilder::default()
1105 .symbol("ETHUSDT".to_string())
1106 .order_id("12345".to_string())
1107 .price(Some("1600.0".to_string()))
1108 .build()
1109 .expect("amend entry should build with only order_id");
1110
1111 assert_eq!(entry.order_id.as_deref(), Some("12345"));
1112 assert_eq!(entry.order_link_id, None);
1113 }
1114
1115 #[rstest]
1116 fn test_amend_entry_builds_with_only_order_link_id() {
1117 let entry = BybitBatchAmendOrderEntryBuilder::default()
1118 .symbol("ETHUSDT".to_string())
1119 .order_link_id("link-1".to_string())
1120 .qty(Some("0.02".to_string()))
1121 .build()
1122 .expect("amend entry should build with only order_link_id");
1123
1124 assert_eq!(entry.order_link_id.as_deref(), Some("link-1"));
1125 assert_eq!(entry.order_id, None);
1126 }
1127
1128 #[rstest]
1129 fn test_amend_entry_builds_with_no_identifiers() {
1130 let entry = BybitBatchAmendOrderEntryBuilder::default()
1131 .symbol("ETHUSDT".to_string())
1132 .price(Some("1600.0".to_string()))
1133 .build()
1134 .expect("amend entry optional identifiers default to None");
1135
1136 assert_eq!(entry.order_id, None);
1137 assert_eq!(entry.order_link_id, None);
1138 }
1139
1140 #[rstest]
1141 fn test_cancel_entry_builds_with_only_order_id() {
1142 let entry = BybitBatchCancelOrderEntryBuilder::default()
1143 .symbol("ETHUSDT".to_string())
1144 .order_id("12345".to_string())
1145 .build()
1146 .expect("cancel entry should build with only order_id");
1147
1148 assert_eq!(entry.order_id.as_deref(), Some("12345"));
1149 assert_eq!(entry.order_link_id, None);
1150 }
1151
1152 #[rstest]
1153 fn test_cancel_entry_builds_with_only_order_link_id() {
1154 let entry = BybitBatchCancelOrderEntryBuilder::default()
1155 .symbol("ETHUSDT".to_string())
1156 .order_link_id("link-1".to_string())
1157 .build()
1158 .expect("cancel entry should build with only order_link_id");
1159
1160 assert_eq!(entry.order_link_id.as_deref(), Some("link-1"));
1161 assert_eq!(entry.order_id, None);
1162 }
1163}