止损：止损订单消费者完成，结构体设计完毕，关联方式设计完毕，准备实现逻辑。

src/core_libs.rs

@@ -13,7 +13,7 @@ use tracing::{error, info};
 use global::cci::CentralControlInfo;
 use global::params::Params;
 use global::trace_stack::TraceStack;
-use standard::Order;
+use standard::{Order, PriceOrder};
 use strategy::model::OrderInfo;
 
 pub async fn init(params: Params,
@@ -27,12 +27,14 @@ pub async fn init(params: Params,
     exchange_params.insert("pass_key".to_string(), params.pass_key.clone());
 
     let (order_sender, mut order_receiver) = mpsc::channel::<Order>(100);
+    let (price_order_sender, _price_order_receiver) = mpsc::channel::<PriceOrder>(100);
     let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);
 
     let mut core_obj = Core::new(params.exchange.clone(),
                                    params.clone(),
                                    exchange_params.clone(),
                                    order_sender.clone(),
+                                   price_order_sender.clone(),
                                    error_sender.clone(),
                                    running.clone(),
                                    cci_arc.clone()).await;

standard/src/binance_swap.rs

@@ -23,11 +23,17 @@ pub struct BinanceSwap {
     request: BinanceSwapRest,
     market: Market,
     order_sender: Sender<Order>,
+    price_order_sender: Sender<PriceOrder>,
     error_sender: Sender<Error>,
 }
 
 impl BinanceSwap {
-    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BinanceSwap {
+    pub async fn new(symbol: String,
+                     is_colo: bool,
+                     params: BTreeMap<String, String>,
+                     order_sender: Sender<Order>,
+                     price_order_sender: Sender<PriceOrder>,
+                     error_sender: Sender<Error>) -> BinanceSwap {
         let market = Market::new();
         let mut binance_swap = BinanceSwap {
             exchange: ExchangeEnum::BinanceSwap,
@@ -37,6 +43,7 @@ impl BinanceSwap {
             request: BinanceSwapRest::new(is_colo, params.clone()),
             market,
             order_sender,
+            price_order_sender,
             error_sender,
         };
         binance_swap.market = BinanceSwap::get_market(&mut binance_swap).await.unwrap_or(binance_swap.market);

standard/src/bybit_swap.rs

@@ -38,11 +38,17 @@ pub struct BybitSwap {
     request: BybitSwapRest,
     market: Market,
     order_sender: Sender<Order>,
+    price_order_sender: Sender<PriceOrder>,
     error_sender: Sender<Error>,
 }
 
 impl BybitSwap {
-    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BybitSwap {
+    pub async fn new(symbol: String,
+                     is_colo: bool,
+                     params: BTreeMap<String, String>,
+                     order_sender: Sender<Order>,
+                     price_order_sender: Sender<PriceOrder>,
+                     error_sender: Sender<Error>) -> BybitSwap {
         let market = Market::new();
         let mut bybit_swap = BybitSwap {
             exchange: ExchangeEnum::BybitSwap,
@@ -53,6 +59,7 @@ impl BybitSwap {
             request: BybitSwapRest::new(is_colo, params.clone()),
             market,
             order_sender,
+            price_order_sender,
             error_sender,
         };
 

standard/src/exchange.rs

@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap};
 use std::io::Error;
 use tokio::sync::mpsc::Sender;
-use crate::{Order, Platform};
+use crate::{Order, Platform, PriceOrder};
 use crate::binance_swap::BinanceSwap;
 // use crate::binance_spot::BinanceSpot;
 // use crate::gate_spot::GateSpot;
@@ -66,36 +66,42 @@ pub enum ExchangeEnum {
 /// let (order_sender, _order_receiver): (mpsc::Sender<Order>, mpsc::Receiver<Order>) = mpsc::channel(1024);
 /// let (error_sender, _error_receiver): (mpsc::Sender<Error>, mpsc::Receiver<Error>) = mpsc::channel(1024);
 ///
-/// let exchange = Exchange::new(ExchangeEnum::GateSwap, "BTC_USDT".to_string(), false, params, order_sender, error_sender);
+/// // let exchange = Exchange::new(ExchangeEnum::GateSwap, "BTC_USDT".to_string(), false, params, order_sender, error_sender);
 #[derive(Debug, Clone)]
 pub struct Exchange;
 
 impl Exchange {
-    pub async fn new(exchange: ExchangeEnum, symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> Box<dyn Platform + Send + Sync> {
+    pub async fn new(exchange: ExchangeEnum,
+                     symbol: String,
+                     is_colo: bool,
+                     params: BTreeMap<String, String>,
+                     order_sender: Sender<Order>,
+                     price_order_sender: Sender<PriceOrder>,
+                     error_sender: Sender<Error>) -> Box<dyn Platform + Send + Sync> {
         match exchange {
             ExchangeEnum::BinanceSwap => {
-                Box::new(BinanceSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+                Box::new(BinanceSwap::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             }
             ExchangeEnum::GateSwap => {
-                Box::new(GateSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+                Box::new(GateSwap::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             }
             // ExchangeEnum::GateSpot => {
             //     Box::new(GateSpot::new(symbol, is_colo, params))
             // }
             // ExchangeEnum::KucoinSwap => {
-            //     Box::new(KucoinSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+            //     Box::new(KucoinSwap::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             // }
             // ExchangeEnum::KucoinSpot =>{
-            //     Box::new(KucoinSpot::new(symbol, is_colo, params, order_sender, error_sender).await)
+            //     Box::new(KucoinSpot::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             // }
             // ExchangeEnum::OkxSwap => {
-            //     Box::new(OkxSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+            //     Box::new(OkxSwap::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             // }
             // ExchangeEnum::BitgetSpot => {
-            //     Box::new(BitgetSpot::new(symbol, is_colo, params, order_sender, error_sender).await)
+            //     Box::new(BitgetSpot::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             // }
             ExchangeEnum::BybitSwap => {
-                Box::new(BybitSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+                Box::new(BybitSwap::new(symbol, is_colo, params, order_sender, price_order_sender, error_sender).await)
             }
         }
     }

standard/src/gate_swap.rs

@@ -25,11 +25,17 @@ pub struct GateSwap {
     request: GateSwapRest,
     market: Market,
     order_sender: Sender<Order>,
+    price_order_sender: Sender<PriceOrder>,
     error_sender: Sender<Error>,
 }
 
 impl GateSwap {
-    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> GateSwap {
+    pub async fn new(symbol: String,
+                     is_colo: bool,
+                     params: BTreeMap<String, String>,
+                     order_sender: Sender<Order>,
+                     price_order_sender: Sender<PriceOrder>,
+                     error_sender: Sender<Error>) -> GateSwap {
         let market = Market::new();
         let mut gate_swap = GateSwap {
             exchange: ExchangeEnum::GateSwap,
@@ -39,6 +45,7 @@ impl GateSwap {
             request: GateSwapRest::new(is_colo, params.clone()),
             market,
             order_sender,
+            price_order_sender,
             error_sender,
         };
 
@@ -618,8 +625,6 @@ impl Platform for GateSwap {
                         result.trace_stack = ts;
 
                         self_clone.order_sender.send(result).await.unwrap();
-
-
                     }
                     Err(error) => {
                         let mut err_order = Order::new();

standard/src/lib.rs

@@ -284,11 +284,6 @@ pub struct Order {
     pub trace_stack: TraceStack,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PriceOrder {
-    pub id: String,
-}
-
 impl Order {
     pub fn new() -> Order {
         Order {
@@ -305,6 +300,11 @@ impl Order {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PriceOrder {
+    pub id: String,
+}
+
 /// Ticker结构体(市场行情)
 /// - `time(i64)`: 毫秒级别时间戳
 /// - `high(Decimal)`: 最高价

strategy/src/core.rs

@@ -20,7 +20,7 @@ use global::cci::CentralControlInfo;
 use global::params::Params;
 use global::public_params::{ASK_PRICE_INDEX, BID_PRICE_INDEX, LENGTH};
 use global::trace_stack::TraceStack;
-use standard::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, SpecialTicker, Ticker};
+use standard::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, PriceOrder, SpecialTicker, Ticker};
 use standard::exchange::{Exchange};
 use standard::exchange::ExchangeEnum::{BinanceSwap, BybitSwap, GateSwap};
 
@@ -47,6 +47,8 @@ pub struct Core {
     pub local_orders: HashMap<String, OrderInfo>,
     // 本地订单缓存队列
     pub local_orders_backup: HashMap<String, OrderInfo>,
+    // 本地订单对应的止损订单，注意key是本地订单id，value是其对应的止损单实体
+    pub local_price_orders: HashMap<String, PriceOrder>,
     // 本地订单缓存cid队列
     pub local_orders_backup_cid: Vec<String>,
     // 本地已处理cid缓存队列
@@ -122,6 +124,7 @@ impl Core {
                      params: Params,
                      exchange_params: BTreeMap<String, String>,
                      order_sender: Sender<Order>,
+                     price_order_sender: Sender<PriceOrder>,
                      error_sender: Sender<Error>,
                      running: Arc<AtomicBool>,
                      cci_arc: Arc<Mutex<CentralControlInfo>>) -> Core {
@@ -138,6 +141,7 @@ impl Core {
             strategy: Strategy::new(&params, true),
             local_orders: Default::default(),
             local_orders_backup: Default::default(),
+            local_price_orders: Default::default(),
             local_orders_backup_cid: Default::default(),
             handled_orders_cid: Default::default(),
             local_profit: Default::default(),
@@ -204,28 +208,28 @@ impl Core {
             },
             platform_rest: match exchange.as_str() {
                 // "kucoin_usdt_swap" => {
-                //     Exchange::new(KucoinSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                //     Exchange::new(KucoinSwap, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 // }
                 "gate_usdt_swap" => {
-                    Exchange::new(GateSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                    Exchange::new(GateSwap, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 }
                 // "gate_usdt_spot" => {
-                //     Exchange::new(GateSpot, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                //     Exchange::new(GateSpot, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 // }
                 "binance_usdt_swap" => {
-                    Exchange::new(BinanceSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                    Exchange::new(BinanceSwap, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 }
                 // "binance_spot" => {
-                //     Exchange::new(BinanceSpot, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                //     Exchange::new(BinanceSpot, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 // }
                 // "bitget_spot" => {
-                //     Exchange::new(BitgetSpot, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                //     Exchange::new(BitgetSpot, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 // }
                 // "okex_usdt_swap" => {
-                //     Exchange::new(OkxSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                //     Exchange::new(OkxSwap, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 // }
                 "bybit_usdt_swap" => {
-                    Exchange::new(BybitSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                    Exchange::new(BybitSwap, symbol, params.colo != 0i8, exchange_params, order_sender, price_order_sender, error_sender).await
                 }
                 _ => {
                     error!("203未找到对应的交易所rest枚举！");