1  pub mod bot_functions;
  2  pub mod fsm;
  3  pub mod router;
  4  use actix::Actor;
  5  use color_print::cprintln;
  6  use ethos_sledb::storage::Storage;
  7  use once_cell::sync::Lazy;
  8  use serde_json::Value;
  9  use sled::*;
 10  use std::sync::Arc;
 11  use tokio::task::LocalSet;
 12  
 13  use crate::{
 14      bot_functions::{
 15          bot_functions::BotFunction,
 16          ngrok_webhook::start_webhook_listener,
 17          sysinfo::log_resource_usage_loop,
 18          utils::{cut_after_dot_symbol, get_ticksize_for_symbol},
 19          ws_connect::WSConnect,
 20      },
 21      fsm::{InitialData, FSM},
 22      router::{Router, WebhookMsg, WsMsg},
 23  };
 24  
 25  use ethos_algorithm_of_god_lib::trade_functions::{
 26      constants::leverage_constants::{Position, PositionResult},
 27      trade_functions::{self, AlgorithmOfGod, LeverageData, LeverageDetail},
 28  };
 29  
 30  /* static DB: Lazy<Arc<Db>> = Lazy::new(|| Arc::new(sled::open("db").expect("DB not open"))); */
 31  
 32  #[tokio::main(flavor = "current_thread")]
 33  async fn main() {
 34      let local = LocalSet::new();
 35  
 36      local
 37          .run_until(async {
 38              /*   const API_KEY: &'static str =
 39                  "0RUgccRJth6CPvytb1cywm6NUN0oDFm3Pja6EvcpAtXF1xaMqIIGFIQneFTa5YoR";
 40              const API_SECRET_KEY: &'static str =
 41                  "V5fkaOVNAxDRNslgvFFlsG6CwKiZeV6Ot9HXGxSUP1eLx0MttdQoZDS0FM0VJGR0"; */
 42  
 43              /* const API_KEY: &'static str =
 44                             "a80c845267c8985d51a1f368b195977814b52d152ad9f9aae714ca66270f76fd";
 45                         const API_SECRET_KEY: &'static str =
 46                             "b2efda99d3dba4d248b452f7cb1e4650acfa0a0e5a7cbbd09612649e920ef7bc";
 47              */
 48  
 49              const API_KEY: &'static str =
 50                  "0RUgccRJth6CPvytb1cywm6NUN0oDFm3Pja6EvcpAtXF1xaMqIIGFIQneFTa5YoR";
 51              const API_SECRET_KEY: &'static str =
 52                  "V5fkaOVNAxDRNslgvFFlsG6CwKiZeV6Ot9HXGxSUP1eLx0MttdQoZDS0FM0VJGR0";
 53  
 54              //const API_URL: &'static str = "https://testnet.binancefuture.com";
 55              const API_URL: &'static str = "https://fapi.binance.com";
 56  
 57              let leverage_data = vec![LeverageData {
 58                  user_id: 1,
 59                  lev_data: vec![],
 60              }];
 61  
 62              let initial_data = InitialData {
 63                  first_entrence_fee: 1.0 * 50.0,
 64                  spec_fold: 3,
 65              };
 66  
 67              let storage = Arc::new(Storage::new("db"));
 68              let algo = Arc::new(AlgorithmOfGod::new(leverage_data, Arc::clone(&storage)));
 69  
 70              let bot = Arc::new(BotFunction::new(
 71                  API_KEY.into(),
 72                  API_SECRET_KEY.into(),
 73                  API_URL.into(),
 74              ));
 75  
 76              bot.exchange_info().await;
 77  
 78              let router_addr =
 79                  Router::new(Arc::clone(&bot), Arc::clone(&algo), initial_data.clone()).start();
 80  
 81              let bot_ws = Arc::clone(&bot);
 82              let mut ws_rx = WSConnect::listen(bot_ws).await;
 83  
 84              let router_ws = router_addr.clone();
 85              let ws_task = tokio::task::spawn_local(async move {
 86                  while let Some(msg) = ws_rx.recv().await {
 87                      router_ws.do_send(WsMsg { data: msg });
 88                  }
 89              });
 90  
 91              let router_webhook = router_addr.clone();
 92              let cb = Arc::new(move |mut data: Value| {
 93                  println!("raw data : {:#?}",data);
 94                  if let Some(sym) = data.get("symbol").and_then(|v| v.as_str()) {
 95                      let clean = cut_after_dot_symbol(sym);
 96                      if let Some(obj) = data.as_object_mut() {
 97                          obj.insert("symbol".into(), Value::String(clean));
 98                      }
 99                  }
100                  println!("data : {:#?}",data);
101  
102                  router_webhook.do_send(WebhookMsg { data });
103              });
104              tokio::task::spawn_local(start_webhook_listener(cb));
105  
106              tokio::spawn(async move {
107                  loop {
108                      log_resource_usage_loop().await;
109                      tokio::time::sleep(std::time::Duration::from_secs(5)).await;
110                  }
111              });
112  
113              tokio::signal::ctrl_c().await.unwrap();
114              ws_task.abort();
115          })
116          .await;
117  }