build(deps): bump num_enum from 0.5.1 to 0.5.4

.github/workflows/integration-test.yml

@@ -136,5 +136,4 @@ jobs:
           npx ts-node tests/trade.ts
           sleep 5
           npx ts-node tests/print_orders.ts
-          npx ts-node tests/transfer.ts
           npx ts-node tests/put_batch_orders.ts

Cargo.toml

@@ -30,7 +30,7 @@ jsonwebtoken = "7.2.0"
 lazy_static = "1.4.0"
 log = "0.4.14"
 nix = "0.20.0"
-num_enum = "0.5.1"
+num_enum = "0.5.4"
 orchestra = { git = "https://github.com/gcomte/orchestra.git", branch = "master", features = [ "exchange" ] }
 paperclip = { git = "https://github.com/fluidex/paperclip.git", features = [ "actix", "chrono", "rust_decimal" ] }
 qstring = "0.7.2"

examples/js/RESTClient.ts

@@ -14,27 +14,6 @@ class RESTClient {
     });
   }
 
-  async internal_txs(
-    user_id: number | string,
-    params?: {
-      limit?: number;
-      offset?: number;
-      start_time?: number;
-      end_time?: number;
-      order?: "asc" | "desc";
-      side?: "from" | "to" | "both";
-    }
-  ) {
-    let resp = await this.client.get(`/internal_txs/${user_id}`, {
-      params: _.pickBy(params, _.identity),
-    });
-    if (resp.status === 200) {
-      return resp.data;
-    } else {
-      throw new Error(`request failed with ${resp.status} ${resp.statusText}`);
-    }
-  }
-
   async closed_orders(token: string) {
     if (token !== "") {
       this.client.defaults.headers.common["Authorization"] = "LoremIpsum";

src/bin/dump_unify_messages.rs

@@ -18,7 +18,6 @@ use fluidex_common::rdkafka::message::{BorrowedMessage, Message};
 fn get_msg_tag_from_topic(t: &str) -> Option<&'static str> {
     Some(match t {
         "deposits" => "DepositMessage",
-        "internaltransfer" => "TransferMessage",
         "orders" => "OrderMessage",
         "trades" => "TradeMessage",
         "withdraws" => "WithdrawMessage",

src/bin/persistor.rs

@@ -61,8 +61,6 @@ fn main() {
 
         let persistor_balance: DatabaseWriter<models::BalanceHistory> = DatabaseWriter::new(&write_config).start_schedule(&pool).unwrap();
 
-        let persistor_transfer: DatabaseWriter<models::InternalTx> = DatabaseWriter::new(&write_config).start_schedule(&pool).unwrap();
-
         let trade_cfg = TopicConfig::<message::Trade>::new(message::TRADES_TOPIC)
             .persist_to(&persistor_kline)
             .persist_to(&persistor_trade)
@@ -76,13 +74,10 @@ fn main() {
 
         let balance_cfg = TopicConfig::<message::BalanceMessage>::new(message::BALANCES_TOPIC).persist_to(&persistor_balance);
 
-        let internaltx_cfg = TopicConfig::<message::TransferMessage>::new(message::INTERNALTX_TOPIC).persist_to(&persistor_transfer);
-
         let auto_commit = vec![
             trade_cfg.auto_commit_start(consumer.clone()),
             order_cfg.auto_commit_start(consumer.clone()),
             balance_cfg.auto_commit_start(consumer.clone()),
-            internaltx_cfg.auto_commit_start(consumer.clone()),
         ];
         let consumer = consumer.as_ref();
 
@@ -91,7 +86,6 @@ fn main() {
                 .add_topic_config(&trade_cfg).unwrap()
                 .add_topic_config(&order_cfg).unwrap()
                 .add_topic_config(&balance_cfg).unwrap()
-                .add_topic_config(&internaltx_cfg).unwrap()
 //                .add_topic(message::TRADES_TOPIC, MsgDataPersistor::new(&persistor).handle_message::<message::Trade>())
                 ;
 
@@ -112,7 +106,6 @@ fn main() {
             persistor_trade.finish(),
             persistor_order.finish(),
             persistor_balance.finish(),
-            persistor_transfer.finish(),
         )
         .expect("all persistor should success finish");
         let final_commits: Vec<Pin<Box<dyn std::future::Future<Output = ()> + Send>>> = auto_commit

src/bin/restapi.rs

@@ -4,7 +4,7 @@ use actix_web_httpauth::extractors::AuthenticationError;
 use actix_web_httpauth::middleware::HttpAuthentication;
 use dingir_exchange::matchengine::authentication;
 use dingir_exchange::restapi::manage::market;
-use dingir_exchange::restapi::personal_history::{my_internal_txs, my_orders};
+use dingir_exchange::restapi::personal_history::my_orders;
 use dingir_exchange::restapi::public_history::{order_trades, recent_trades};
 use dingir_exchange::restapi::state::{AppCache, AppState};
 use dingir_exchange::restapi::tradingview::{chart_config, history, search_symbols, symbols, ticker, unix_timestamp};
@@ -58,7 +58,6 @@ async fn main() -> std::io::Result<()> {
                     .route("/recenttrades/{market}", web::get().to(recent_trades))
                     .route("/ordertrades/{market}/{order_id}", web::get().to(order_trades))
                     .route("/closedorders/{market}", web::get().to(my_orders))
-                    .route("/internal_txs", web::get().to(my_internal_txs))
                     .route("/ticker_{ticker_inv}/{market}", web::get().to(ticker))
                     .service(
                         web::scope("/tradingview")

src/matchengine/controller.rs

@@ -563,106 +563,6 @@ impl Controller {
         Ok(())
     }
 
-    pub fn transfer(&mut self, real: bool, req: TransferRequest, user_id: Uuid) -> Result<TransferResponse, Status> {
-        if !self.check_service_available() {
-            return Err(Status::unavailable(""));
-        }
-
-        let asset = &req.asset;
-        if !self.balance_manager.asset_manager.asset_exist(asset) {
-            return Err(Status::invalid_argument("invalid asset"));
-        }
-
-        let to_user_id = req.to.clone();
-
-        let balance_manager = &self.balance_manager;
-        let balance_from = balance_manager.get(user_id, BalanceType::AVAILABLE, asset);
-
-        let zero = Decimal::from(0);
-        let delta = Decimal::from_str(&req.delta).unwrap_or(zero);
-
-        if delta <= zero || delta > balance_from {
-            return Ok(TransferResponse {
-                success: false,
-                asset: asset.to_owned(),
-                balance_from: balance_from.to_string(),
-            });
-        }
-
-        let prec = self.balance_manager.asset_manager.asset_prec_show(asset);
-        let change = delta.round_dp(prec);
-
-        let business = "transfer";
-        let timestamp = FTimestamp(current_timestamp());
-        let business_id = (timestamp.0 * 1_000_f64) as u64; // milli-seconds
-        let detail_json: serde_json::Value = if req.memo.is_empty() {
-            json!({})
-        } else {
-            serde_json::from_str(req.memo.as_str()).map_err(|_| Status::invalid_argument("invalid memo"))?
-        };
-
-        // Get market price of requested base asset and quote asset of USDT.
-        let market_price = self
-            .asset_market_names
-            .get(&(asset.to_owned(), "USDT".to_owned()))
-            .map_or(Decimal::zero(), |market_name| self.markets.get(market_name).unwrap().price);
-        let persistor = if real { &mut self.persistor } else { &mut self.dummy_persistor };
-        self.update_controller
-            .update_user_balance(
-                &mut self.balance_manager,
-                persistor,
-                BalanceUpdateParams {
-                    balance_type: BalanceType::AVAILABLE,
-                    business_type: BusinessType::Transfer,
-                    user_id,
-                    asset: asset.to_owned(),
-                    business: business.to_owned(),
-                    business_id,
-                    market_price,
-                    change: -change,
-                    detail: detail_json.clone(),
-                },
-            )
-            .map_err(|e| Status::invalid_argument(format!("{}", e)))?;
-
-        let persistor = if real { &mut self.persistor } else { &mut self.dummy_persistor };
-        self.update_controller
-            .update_user_balance(
-                &mut self.balance_manager,
-                persistor,
-                BalanceUpdateParams {
-                    balance_type: BalanceType::AVAILABLE,
-                    business_type: BusinessType::Transfer,
-                    user_id: to_user_id.parse().unwrap(),
-                    asset: asset.to_owned(),
-                    business: business.to_owned(),
-                    business_id,
-                    market_price: Decimal::zero(),
-                    change,
-                    detail: detail_json,
-                },
-            )
-            .map_err(|e| Status::invalid_argument(format!("{}", e)))?;
-
-        if real {
-            self.persistor.put_transfer(models::InternalTx {
-                time: timestamp.into(),
-                user_from: user_id.to_string(),
-                user_to: to_user_id,
-                asset: asset.to_owned(),
-                amount: change,
-            });
-
-            self.append_operation_log(OPERATION_TRANSFER, &req, user_id);
-        }
-
-        Ok(TransferResponse {
-            success: true,
-            asset: asset.to_owned(),
-            balance_from: (balance_from - change).to_string(),
-        })
-    }
-
     pub async fn debug_reset(&mut self, _req: DebugResetRequest) -> Result<DebugResetResponse, Status> {
         async {
             log::info!("do full reset: memory and db");
@@ -760,9 +660,6 @@ impl Controller {
             OPERATION_BATCH_ORDER_PUT => {
                 self.batch_order_put(false, serde_json::from_str(params)?, user_id)?;
             }
-            OPERATION_TRANSFER => {
-                self.transfer(false, serde_json::from_str(params)?, user_id)?;
-            }
             _ => bail!("invalid operation {}", method),
         }
         Ok(())