simple market maker bot

mm2src/coins/lp_coins.rs

@@ -31,7 +31,7 @@
 #[macro_use] extern crate ser_error_derive;
 
 use async_trait::async_trait;
-use bigdecimal::{BigDecimal, ParseBigDecimalError};
+use bigdecimal::{BigDecimal, ParseBigDecimalError, Zero};
 use common::executor::{spawn, Timer};
 use common::mm_ctx::{from_ctx, MmArc, MmWeak};
 use common::mm_error::prelude::*;
@@ -118,6 +118,7 @@ cfg_wasm32! {
 
 pub type BalanceResult<T> = Result<T, MmError<BalanceError>>;
 pub type BalanceFut<T> = Box<dyn Future<Item = T, Error = MmError<BalanceError>> + Send>;
+pub type NonZeroBalanceFut<T> = Box<dyn Future<Item = T, Error = MmError<GetNonZeroBalance>> + Send>;
 pub type NumConversResult<T> = Result<T, MmError<NumConversError>>;
 pub type WithdrawResult = Result<TransactionDetails, MmError<WithdrawError>>;
 pub type WithdrawFut = Box<dyn Future<Item = TransactionDetails, Error = MmError<WithdrawError>> + Send>;
@@ -331,6 +332,16 @@ pub trait MarketCoinOps {
 
     fn my_address(&self) -> Result<String, String>;
 
+    fn get_non_zero_balance(&self) -> NonZeroBalanceFut<MmNumber> {
+        let closure = |spendable: BigDecimal| {
+            if spendable.is_zero() {
+                return MmError::err(GetNonZeroBalance::BalanceIsZero);
+            }
+            Ok(MmNumber::from(spendable))
+        };
+        Box::new(self.my_spendable_balance().map_err(From::from).and_then(closure))
+    }
+
     fn my_balance(&self) -> BalanceFut<CoinBalance>;
 
     fn my_spendable_balance(&self) -> BalanceFut<BigDecimal> {
@@ -684,6 +695,18 @@ pub enum BalanceError {
     Internal(String),
 }
 
+#[derive(Debug, PartialEq, Display)]
+pub enum GetNonZeroBalance {
+    #[display(fmt = "Internal error when retrieving balance - skipping")]
+    MyBalanceError(BalanceError),
+    #[display(fmt = "Balance is zero - skipping")]
+    BalanceIsZero,
+}
+
+impl From<BalanceError> for GetNonZeroBalance {
+    fn from(e: BalanceError) -> Self { GetNonZeroBalance::MyBalanceError(e) }
+}
+
 impl From<NumConversError> for BalanceError {
     fn from(e: NumConversError) -> Self { BalanceError::Internal(e.to_string()) }
 }

mm2src/common/mm_ctx.rs

@@ -76,6 +76,7 @@ pub struct MmCtx {
     pub stop_listeners: Mutex<Vec<StopListenerCallback>>,
     /// The context belonging to the `ordermatch` mod: `OrdermatchContext`.
     pub ordermatch_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
+    pub simple_market_maker_bot_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     pub p2p_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     pub peer_id: Constructible<String>,
     /// The context belonging to the `coins` crate: `CoinsContext`.
@@ -111,6 +112,7 @@ impl MmCtx {
             ffi_handle: Constructible::default(),
             stop_listeners: Mutex::new(Vec::new()),
             ordermatch_ctx: Mutex::new(None),
+            simple_market_maker_bot_ctx: Mutex::new(None),
             p2p_ctx: Mutex::new(None),
             peer_id: Constructible::default(),
             coins_ctx: Mutex::new(None),

mm2src/lp_ordermatch.rs

@@ -77,6 +77,9 @@ cfg_wasm32! {
 }
 
 #[path = "lp_ordermatch/best_orders.rs"] mod best_orders;
+#[path = "lp_ordermatch/lp_bot.rs"] mod lp_bot;
+pub use lp_bot::{process_price_request, start_simple_market_maker_bot, stop_simple_market_maker_bot,
+                 StartSimpleMakerBotRequest};
 #[path = "lp_ordermatch/my_orders_storage.rs"]
 mod my_orders_storage;
 #[path = "lp_ordermatch/new_protocol.rs"] mod new_protocol;
@@ -112,6 +115,18 @@ const TRIE_ORDER_HISTORY_TIMEOUT: u64 = 3;
 type AlbOrderedOrderbookPair = String;
 type PubkeyOrders = Vec<(Uuid, OrderbookP2PItem)>;
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CancelAllOrdersResponse {
+    cancelled: Vec<Uuid>,
+    currently_matching: Vec<Uuid>,
+}
+
+#[derive(Debug, Deserialize, Display, Serialize, SerializeErrorType)]
+#[serde(tag = "error_type", content = "error_data")]
+pub enum CancelAllOrdersError {
+    LegacyError(String),
+}
+
 impl From<(new_protocol::MakerOrderCreated, String)> for OrderbookItem {
     fn from(tuple: (new_protocol::MakerOrderCreated, String)) -> OrderbookItem {
         let (order, pubkey) = tuple;
@@ -3577,7 +3592,7 @@ impl OrderbookItem {
 fn get_true() -> bool { true }
 
 #[derive(Deserialize)]
-struct SetPriceReq {
+pub struct SetPriceReq {
     base: String,
     rel: String,
     price: MmNumber,
@@ -3597,7 +3612,7 @@ struct SetPriceReq {
 }
 
 #[derive(Deserialize)]
-struct MakerOrderUpdateReq {
+pub struct MakerOrderUpdateReq {
     uuid: Uuid,
     new_price: Option<MmNumber>,
     max: Option<bool>,
@@ -3757,7 +3772,7 @@ impl<'a> From<&'a MakerOrder> for MakerOrderForRpc<'a> {
 /// https://github.com/KomodoPlatform/atomicDEX-API/issues/794
 async fn cancel_orders_on_error<T, E>(ctx: &MmArc, req: &SetPriceReq, error: E) -> Result<T, E> {
     if req.cancel_previous {
-        let ordermatch_ctx = OrdermatchContext::from_ctx(&ctx).unwrap();
+        let ordermatch_ctx = OrdermatchContext::from_ctx(ctx).unwrap();
         cancel_previous_maker_orders(ctx, &ordermatch_ctx, &req.base, &req.rel).await;
     }
     Err(error)
@@ -3780,53 +3795,51 @@ async fn get_max_volume(ctx: &MmArc, my_coin: &MmCoinEnum, other_coin: &MmCoinEn
     ))
 }
 
-pub async fn set_price(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
-    let req: SetPriceReq = try_s!(json::from_value(req));
-
-    let base_coin: MmCoinEnum = match try_s!(lp_coinfind(&ctx, &req.base).await) {
+pub async fn create_maker_order(ctx: &MmArc, req: SetPriceReq) -> Result<MakerOrder, String> {
+    let base_coin: MmCoinEnum = match try_s!(lp_coinfind(ctx, &req.base).await) {
         Some(coin) => coin,
         None => return ERR!("Base coin {} is not found", req.base),
     };
 
-    let rel_coin: MmCoinEnum = match try_s!(lp_coinfind(&ctx, &req.rel).await) {
+    let rel_coin: MmCoinEnum = match try_s!(lp_coinfind(ctx, &req.rel).await) {
         Some(coin) => coin,
         None => return ERR!("Rel coin {} is not found", req.rel),
     };
 
-    if base_coin.wallet_only(&ctx) {
+    if base_coin.wallet_only(ctx) {
         return ERR!("Base coin {} is wallet only", req.base);
     }
-    if rel_coin.wallet_only(&ctx) {
+    if rel_coin.wallet_only(ctx) {
         return ERR!("Rel coin {} is wallet only", req.rel);
     }
 
     let volume = if req.max {
         try_s!(
-            get_max_volume(&ctx, &base_coin, &rel_coin)
-                .or_else(|e| cancel_orders_on_error(&ctx, &req, e))
+            get_max_volume(ctx, &base_coin, &rel_coin)
+                .or_else(|e| cancel_orders_on_error(ctx, &req, e))
                 .await
         )
     } else {
         try_s!(
             check_balance_for_maker_swap(
-                &ctx,
+                ctx,
                 &base_coin,
                 &rel_coin,
                 req.volume.clone(),
                 None,
                 None,
                 FeeApproxStage::OrderIssue
             )
-            .or_else(|e| cancel_orders_on_error(&ctx, &req, e))
+            .or_else(|e| cancel_orders_on_error(ctx, &req, e))
             .await
         );
         req.volume.clone()
     };
 
-    let ordermatch_ctx = try_s!(OrdermatchContext::from_ctx(&ctx));
+    let ordermatch_ctx = try_s!(OrdermatchContext::from_ctx(ctx));
 
     if req.cancel_previous {
-        cancel_previous_maker_orders(&ctx, &ordermatch_ctx, &req.base, &req.rel).await;
+        cancel_previous_maker_orders(ctx, &ordermatch_ctx, &req.base, &req.rel).await;
     }
 
     let conf_settings = OrderConfirmationsSettings {
@@ -3845,7 +3858,7 @@ pub async fn set_price(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, Strin
     let new_order = try_s!(builder.build());
 
     let request_orderbook = false;
-    try_s!(subscribe_to_orderbook_topic(&ctx, &new_order.base, &new_order.rel, request_orderbook).await);
+    try_s!(subscribe_to_orderbook_topic(ctx, &new_order.base, &new_order.rel, request_orderbook).await);
     save_my_new_maker_order(ctx.clone(), &new_order).await;
     maker_order_created_p2p_notify(
         ctx.clone(),
@@ -3854,12 +3867,17 @@ pub async fn set_price(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, Strin
         rel_coin.coin_protocol_info(),
     )
     .await;
-    let rpc_result = MakerOrderForRpc::from(&new_order);
-    let res = try_s!(json::to_vec(&json!({ "result": rpc_result })));
 
     let mut my_orders = ordermatch_ctx.my_maker_orders.lock().await;
-    my_orders.insert(new_order.uuid, new_order);
+    my_orders.insert(new_order.uuid, new_order.clone());
+    Ok(new_order)
+}
 
+pub async fn set_price(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
+    let req: SetPriceReq = try_s!(json::from_value(req));
+    let maker_order = create_maker_order(&ctx, req).await?;
+    let rpc_result = MakerOrderForRpc::from(&maker_order);
+    let res = try_s!(json::to_vec(&json!({ "result": rpc_result })));
     Ok(try_s!(Response::builder().body(res)))
 }
 
@@ -3898,10 +3916,8 @@ async fn cancel_previous_maker_orders(
     *my_maker_orders = my_actual_maker_orders;
 }
 
-pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
-    let req: MakerOrderUpdateReq = try_s!(json::from_value(req));
-
-    let ordermatch_ctx = try_s!(OrdermatchContext::from_ctx(&ctx));
+pub async fn update_maker_order(ctx: &MmArc, req: MakerOrderUpdateReq) -> Result<MakerOrder, String> {
+    let ordermatch_ctx = try_s!(OrdermatchContext::from_ctx(ctx));
     let my_maker_orders = ordermatch_ctx.my_maker_orders.lock().await;
 
     let (base_coin, rel_coin, original_price, original_volume, updated_conf_settings, matches, reserved_amount) =
@@ -3911,13 +3927,13 @@ pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8
                     return ERR!("Can't update an order that has ongoing matches");
                 }
                 let base = order.base.as_str();
-                let base_coin: MmCoinEnum = match try_s!(lp_coinfind(&ctx, base).await) {
+                let base_coin: MmCoinEnum = match try_s!(lp_coinfind(ctx, base).await) {
                     Some(coin) => coin,
                     None => return ERR!("Base coin {} has been removed from config", base),
                 };
 
                 let rel = order.rel.as_str();
-                let rel_coin: MmCoinEnum = match try_s!(lp_coinfind(&ctx, rel).await) {
+                let rel_coin: MmCoinEnum = match try_s!(lp_coinfind(ctx, rel).await) {
                     Some(coin) => coin,
                     None => return ERR!("Rel coin {} has been removed from config", rel),
                 };
@@ -3976,7 +3992,7 @@ pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8
 
     // Calculate order volume and add to update_msg if new_volume is found in the request
     let new_volume = if req.max.unwrap_or(false) {
-        let max_volume = try_s!(get_max_volume(&ctx, &base_coin, &rel_coin).await) + reserved_amount.clone();
+        let max_volume = try_s!(get_max_volume(ctx, &base_coin, &rel_coin).await) + reserved_amount.clone();
         update_msg.with_new_max_volume(max_volume.clone().into());
         max_volume
     } else if Option::is_some(&req.volume_delta) {
@@ -3986,7 +4002,7 @@ pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8
         }
         try_s!(
             check_balance_for_maker_swap(
-                &ctx,
+                ctx,
                 &base_coin,
                 &rel_coin,
                 volume.clone(),
@@ -4020,7 +4036,7 @@ pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8
     ));
 
     let mut my_maker_orders = ordermatch_ctx.my_maker_orders.lock().await;
-    let (rpc_result, base, rel) = match my_maker_orders.get_mut(&req.uuid) {
+    match my_maker_orders.get_mut(&req.uuid) {
         None => return ERR!("Order with UUID: {} has been deleted", req.uuid),
         Some(order) => {
             if order.matches.len() != matches.len() || !order.matches.keys().all(|k| matches.contains_key(k)) {
@@ -4031,11 +4047,17 @@ pub async fn update_maker_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8
             order.apply_updated(&update_msg);
             save_maker_order_on_update(ctx.clone(), order, new_change).await;
             update_msg.with_new_max_volume((new_volume - reserved_amount).into());
-            (MakerOrderForRpc::from(&*order), order.base.as_str(), order.rel.as_str())
+            maker_order_updated_p2p_notify(ctx.clone(), order.base.as_str(), order.rel.as_str(), update_msg).await;
+            Ok(order.clone())
         },
-    };
+    }
+}
+
+pub async fn update_maker_order_rpc(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
+    let req: MakerOrderUpdateReq = try_s!(json::from_value(req));
+    let order = try_s!(update_maker_order(&ctx, req).await);
+    let rpc_result = MakerOrderForRpc::from(&order);
     let res = try_s!(json::to_vec(&json!({ "result": rpc_result })));
-    maker_order_updated_p2p_notify(ctx.clone(), base, rel, update_msg).await;
 
     Ok(try_s!(Response::builder().body(res)))
 }
@@ -4258,11 +4280,73 @@ pub async fn orders_history_by_filter(ctx: MmArc, req: Json) -> Result<Response<
 }
 
 #[derive(Deserialize)]
-struct CancelOrderReq {
+pub struct CancelOrderReq {
     uuid: Uuid,
 }
 
-pub async fn cancel_order(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
+#[derive(Debug, Deserialize, Serialize, SerializeErrorType, Display)]
+#[serde(tag = "error_type", content = "error_data")]
+pub enum CancelOrderError {
+    #[display(fmt = "Cannot retrieve order match context.")]
+    CannotRetrieveOrderMatchContext,
+    #[display(fmt = "Order {} is being matched now, can't cancel", uuid)]
+    OrderBeingMatched { uuid: Uuid },
+    #[display(fmt = "Order {} not found", uuid)]
+    UUIDNotFound { uuid: Uuid },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CancelOrderResponse {
+    result: String,
+}
+
+pub async fn cancel_order(ctx: MmArc, req: CancelOrderReq) -> Result<CancelOrderResponse, MmError<CancelOrderError>> {
+    let ordermatch_ctx = match OrdermatchContext::from_ctx(&ctx) {
+        Ok(x) => x,
+        Err(_) => return Err(MmError::new(CancelOrderError::CannotRetrieveOrderMatchContext)),
+    };
+    let mut maker_orders = ordermatch_ctx.my_maker_orders.lock().await;
+    match maker_orders.entry(req.uuid) {
+        Entry::Occupied(order) => {
+            if !order.get().is_cancellable() {
+                return MmError::err(CancelOrderError::OrderBeingMatched { uuid: req.uuid });
+            }
+            let order = order.remove();
+            maker_order_cancelled_p2p_notify(ctx.clone(), &order).await;
+            delete_my_maker_order(ctx, order, MakerOrderCancellationReason::Cancelled)
+                .compat()
+                .await
+                .ok();
+            return Ok(CancelOrderResponse {
+                result: "success".to_string(),
+            });
+        },
+        // look for taker order with provided uuid
+        Entry::Vacant(_) => (),
+    }
+
+    let mut taker_orders = ordermatch_ctx.my_taker_orders.lock().await;
+    match taker_orders.entry(req.uuid) {
+        Entry::Occupied(order) => {
+            if !order.get().is_cancellable() {
+                return MmError::err(CancelOrderError::UUIDNotFound { uuid: req.uuid });
+            }
+            let order = order.remove();
+            delete_my_taker_order(ctx, order, TakerOrderCancellationReason::Cancelled)
+                .compat()
+                .await
+                .ok();
+            return Ok(CancelOrderResponse {
+                result: "success".to_string(),
+            });
+        },
+        // error is returned
+        Entry::Vacant(_) => (),
+    }
+    MmError::err(CancelOrderError::UUIDNotFound { uuid: req.uuid })
+}
+
+pub async fn cancel_order_rpc(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
     let req: CancelOrderReq = try_s!(json::from_value(req));
 
     let ordermatch_ctx = try_s!(OrdermatchContext::from_ctx(&ctx));
@@ -4609,7 +4693,21 @@ pub async fn cancel_orders_by(ctx: &MmArc, cancel_by: CancelBy) -> Result<(Vec<U
     Ok((cancelled, currently_matching))
 }
 
-pub async fn cancel_all_orders(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
+pub async fn cancel_all_orders(
+    ctx: MmArc,
+    cancel_by: CancelBy,
+) -> Result<CancelAllOrdersResponse, MmError<CancelAllOrdersError>> {
+    let (cancelled, currently_matching) = match cancel_orders_by(&ctx, cancel_by).await {
+        Ok(x) => x,
+        Err(err) => return Err(MmError::new(CancelAllOrdersError::LegacyError(err))),
+    };
+    Ok(CancelAllOrdersResponse {
+        cancelled,
+        currently_matching,
+    })
+}
+
+pub async fn cancel_all_orders_rpc(ctx: MmArc, req: Json) -> Result<Response<Vec<u8>>, String> {
     let cancel_by: CancelBy = try_s!(json::from_value(req["cancel_by"].clone()));
 
     let (cancelled, currently_matching) = try_s!(cancel_orders_by(&ctx, cancel_by).await);