Sik/tradingbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New strategy_004

Browse Source
This commit is contained in:
Sik Yoon 2024-01-01 18:15:26 +09:00
parent e3b6f9e293
commit f023ac22c8
2 changed files with 155 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

454
src/strategy_team/strategy_004.rs
View File

@ -1,14 +1,16 @@
use crate::value_estimation_team::indicators::bollingerband::bollingerband;
use super::{
dec, decimal_add, decimal_sub, ema, exists_record, insert_pre_suggested_coins,
dec, decimal_add, decimal_sub, decimal_div, ema, exists_record, insert_pre_suggested_coins,
limit_order_sell, rsi, select_filled_buy_orders, stoch_rsi, supertrend, try_join_all, AllData,
Arc, Client, ClientBuilder, Decimal, EmaData, ExchangeInfo, FilteredData, Mutex,
RealtimePriceData, RoundingStrategy, RsiData, StochRsiData, SupertrendData, TradeFee, update_record3, server_epoch
RealtimePriceData, RoundingStrategy, RsiData, StochRsiData, SupertrendData, TradeFee, update_record3, adx, AdxData, server_epoch, MacdData, ema_macd,
BollingerBandData, ToPrimitive
};
// Triple SuperTrend strategy
// SuperTrend length: 10, multiplier: 3, already up area
// SuperTrend length: 10, multiplier: 2, already up area
// SuperTrend length: 10, multiplier: 1.2, buy signal
// BB lowerband + SuperTrend + StochRSI
// SuperTrend length: 20, multiplier: 1.5, BUY signal
// ADX(10, 10) < 25.0
pub async fn list_up_for_buy(
alldata: AllData,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@ -31,7 +33,7 @@ pub async fn list_up_for_buy(
let mut exists_condition_build = String::from("symbol=\'");
exists_condition_build.push_str(symbol.as_str());
exists_condition_build.push_str("\' AND registerer=");
exists_condition_build.push_str(4.to_string().as_str());
exists_condition_build.push_str(5.to_string().as_str());
// exists_condition_build.push_str("\' AND close_time=");
// exists_condition_build.push_str(element.1.to_string().as_str());
let exists_condition = Some(exists_condition_build);
@ -68,30 +70,83 @@ pub async fn list_up_for_buy(
}
try_join_all(task_vec).await?;
// 2nd filtering: supertrend(ATR period 10, multiplier: 1.2, 30m close price), signal should be BUY
// 2nd filtering: BollingerBand (len:10, multiplier 2.5) previous_30m_price (close or low price) < lower_band
let filtered_data_1st = filtered_data_1st_arc.lock().await.clone();
let mut filtered_data_2nd: Vec<FilteredData> = Vec::new();
let mut filtered_data_2nd_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_2nd));
let mut task_vec = Vec::new();
let bollingerbands = bollingerband(10, 2.5, &alldata.rt_price_30m_vec, &filtered_data_1st).await?;
for element in filtered_data_1st {
let mut rt_30m_vec: Vec<RealtimePriceData> = Vec::new();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let mut bb_vec: Vec<BollingerBandData> = Vec::new();
let rt_price_30m_vec_c: Vec<(String, Vec<RealtimePriceData>)> = alldata.rt_price_30m_vec.clone();
let bollingerbands_c = bollingerbands.clone();
let filtered_data_2nd_arc_c = Arc::clone(&filtered_data_2nd_arc);
task_vec.push(tokio::spawn(async move {
let rt_30m_option = rt_price_30m_vec_c
.iter()
.position(|x| *x.0 == element.symbol);
let bb_option_30m = bollingerbands_c.iter().position(|x| x.0 == element.symbol);
if rt_30m_option.is_some() && bb_option_30m.is_some() {
rt_30m_vec = rt_price_30m_vec_c[rt_30m_option.unwrap()].1.clone();
bb_vec = bollingerbands_c[bb_option_30m.unwrap()].1.clone();
let server_epoch = server_epoch().await;
if rt_30m_vec.len() >= 3 && bb_vec.len() >= 3 && rt_30m_vec.last().unwrap().close_time > server_epoch {
let bb_search_result = bb_vec.binary_search_by_key(
&rt_30m_vec.last().unwrap().close_time,
|BollingerBandData {
sma,
upperband,
lowerband,
close_time,
}| *close_time,
);
if bb_search_result.is_ok() {
if bb_vec[bb_search_result.unwrap()-1].lowerband > rt_30m_vec[rt_30m_vec.len()-2].low_price &&
rt_30m_vec[rt_30m_vec.len()-2].opclo_price > rt_30m_vec.last().unwrap().close_price &&
rt_30m_vec[rt_30m_vec.len()-2].candle_type.contains("DOWN") &&
rt_30m_vec[rt_30m_vec.len()-2].high_price < bb_vec[bb_search_result.unwrap()-1].sma
{
let mut filtered_data_2nd_lock = filtered_data_2nd_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = rt_30m_vec.last().unwrap().close_time;
filtered_data.current_price = rust_decimal::prelude::FromPrimitive::from_f64(rt_30m_vec.last().unwrap().close_price).unwrap();;
filtered_data_2nd_lock.push(filtered_data);
}
}
}
}
}));
}
try_join_all(task_vec).await?;
// 3rd filtering: supertrend(ATR period 10, multiplier: 2, 30m close price), area should be DOWN
let filtered_data_2nd = filtered_data_2nd_arc.lock().await.clone();
let mut filtered_data_3rd: Vec<FilteredData> = Vec::new();
let mut filtered_data_3rd_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_3rd));
let mut task_vec = Vec::new();
for element in filtered_data_2nd {
let mut rt_30m_vec: Vec<RealtimePriceData> = Vec::new();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let filtered_data_3rd_arc_c = Arc::clone(&filtered_data_3rd_arc);
task_vec.push(tokio::spawn(async move {
let rt_30m_option = rt_price_30m_vec_c
.iter()
.position(|x| *x.0 == element.symbol);
let supertrend_option_30m =
supertrend(&element.symbol, &rt_price_30m_vec_c, 10, 1.2, true).await;
supertrend(&element.symbol, &rt_price_30m_vec_c, 20, 2.0, true).await;
if rt_30m_option.is_some() && supertrend_option_30m.is_some() {
rt_30m_vec = rt_price_30m_vec_c[rt_30m_option.unwrap()].1.clone();
supertrend_vec = supertrend_option_30m.unwrap();
if rt_30m_vec.len() >= 3 && supertrend_vec.len() >= 3 {
let server_epoch = server_epoch().await;
if rt_30m_vec.len() >= 3 && supertrend_vec.len() >= 3 && rt_30m_vec.last().unwrap().close_time > server_epoch {
let supertrend_search_result = supertrend_vec.binary_search_by_key(
&rt_30m_vec.last().unwrap().close_time,
|SupertrendData {
@ -104,73 +159,19 @@ pub async fn list_up_for_buy(
if supertrend_search_result.is_ok() {
let current_price: Decimal = rust_decimal::prelude::FromPrimitive::from_f64(rt_30m_vec.last().unwrap().close_price).unwrap();
if supertrend_vec[supertrend_search_result.unwrap()].signal.as_ref().is_some_and(|x| x.contains("BUY"))
&& current_price
< rust_decimal::prelude::FromPrimitive::from_f64(
supertrend_vec[supertrend_search_result.unwrap()-1].band_value * 1.002,
)
.unwrap()
&& supertrend_vec[supertrend_search_result.unwrap()-1].band_value > supertrend_vec[supertrend_search_result.unwrap()].band_value
if supertrend_vec[supertrend_search_result.unwrap()].area.contains("DOWN")
&& supertrend_vec[supertrend_search_result.unwrap()].band_value > element.current_price.to_f64().unwrap()
{
let mut filtered_data_2nd_lock = filtered_data_2nd_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = rt_30m_vec.last().unwrap().close_time;
filtered_data.current_price = current_price;
filtered_data_2nd_lock.push(filtered_data);
}
}
}
}
}));
}
try_join_all(task_vec).await?;
// 3rd filtering: supertrend(ATR period 50, multiplier: 2.0, 30m close price), the area should be in UP area.
let filtered_data_2nd = filtered_data_2nd_arc.lock().await.clone();
let mut filtered_data_3rd: Vec<FilteredData> = Vec::new();
let mut filtered_data_3rd_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_3rd));
let mut task_vec = Vec::new();
let valid_symbol_vec_c = alldata.valid_symbol_vec.clone();
for element in filtered_data_2nd {
let mut opclo_30m_vec: Vec<RealtimePriceData> = Vec::new();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let filtered_data_3rd_arc_c = Arc::clone(&filtered_data_3rd_arc);
task_vec.push(tokio::spawn(async move {
let supertrend_option_30m =
supertrend(&element.symbol, &rt_price_30m_vec_c, 50, 2.0, true).await;
if supertrend_option_30m.is_some() {
supertrend_vec = supertrend_option_30m.unwrap();
if supertrend_vec.len() >= 3 {
let supertrend_search_result = supertrend_vec.binary_search_by_key(
&element.closetime,
|SupertrendData {
band_value,
signal,
area,
close_time,
}| *close_time,
);
if supertrend_search_result.is_ok() {
if supertrend_vec[supertrend_search_result.unwrap()]
.area
.contains("UP")
{
let mut filtered_3rd_symbols_lock =
filtered_data_3rd_arc_c.lock().await;
let mut filtered_data_3rd_lock = filtered_data_3rd_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = element.closetime;
filtered_data.current_price = element.current_price;
filtered_data.stoploss = element.stoploss;
filtered_data.target_price = element.target_price;
filtered_data.target_price = rust_decimal::prelude::FromPrimitive::from_f64(supertrend_vec[supertrend_search_result.unwrap()].band_value).unwrap();
let stop_loss = decimal_sub(filtered_data.current_price, decimal_div(decimal_sub(filtered_data.target_price, filtered_data.current_price), dec!(2)));
filtered_data.stoploss = stop_loss;
filtered_3rd_symbols_lock.push(filtered_data);
filtered_data_3rd_lock.push(filtered_data);
}
}
}
@ -179,88 +180,24 @@ pub async fn list_up_for_buy(
}
try_join_all(task_vec).await?;
// 4th filtering: supertrend(ATR period 10, multiplier: 1.5, 30m close price), the area should be UP
// set stoploss and target_price
let filtered_data_3rd_c = filtered_data_3rd_arc.lock().await.clone();
// 4th filtering: MACD 1d (fast:3, slow:7, smoothing:3) MACD > signal
let filtered_data_3rd = filtered_data_3rd_arc.lock().await.clone();
let mut filtered_data_4th: Vec<FilteredData> = Vec::new();
let mut filtered_data_4th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_4th));
let mut task_vec = Vec::new();
for element in filtered_data_3rd_c {
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let filtered_data_4th_arc_c = Arc::clone(&filtered_data_4th_arc);
task_vec.push(tokio::spawn(async move {
let supertrend_option_30m =
supertrend(&element.symbol, &rt_price_30m_vec_c, 10, 1.5, true).await;
if supertrend_option_30m.is_some() {
supertrend_vec = supertrend_option_30m.unwrap();
if supertrend_vec.len() >= 3 {
let supertrend_search_result = supertrend_vec.binary_search_by_key(
&element.closetime,
|SupertrendData {
band_value,
signal,
area,
close_time,
}| *close_time,
);
if supertrend_search_result.is_ok() {
if supertrend_vec[supertrend_search_result.unwrap()]
.area
.contains("UP")
{
let mut filtered_data_4th_lock = filtered_data_4th_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = element.closetime;
filtered_data.current_price = element.current_price;
filtered_data.stoploss = rust_decimal::prelude::FromPrimitive::from_f64(supertrend_vec[supertrend_search_result.unwrap()].band_value).unwrap();
let target_price = decimal_add(
filtered_data.current_price,
decimal_sub(filtered_data.current_price, filtered_data.stoploss),
);
filtered_data.target_price = target_price;
filtered_data_4th_lock.push(filtered_data);
}
}
}
}
}));
}
try_join_all(task_vec).await?;
// 5th filtering: supertrend(ATR period 3, multiplier: 1.1, 1d close price), the area should be in UP area.
let filtered_data_4th = filtered_data_4th_arc.lock().await.clone();
let mut filtered_data_5th: Vec<FilteredData> = Vec::new();
let mut filtered_data_5th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_5th));
let mut task_vec = Vec::new();
let valid_symbol_vec_c = alldata.valid_symbol_vec.clone();
for element in filtered_data_4th {
let macd_vec = ema_macd(3, 7, 3, &alldata.rt_price_1d_vec, &filtered_data_3rd).await?;
for element in filtered_data_3rd {
let mut opclo_1d_vec: Vec<RealtimePriceData> = Vec::new();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_1d_vec_c = alldata.rt_price_1d_vec.clone();
let filtered_data_5th_arc_c = Arc::clone(&filtered_data_5th_arc);
let macd_vec_c = macd_vec.clone();
let filtered_data_4th_arc_c = Arc::clone(&filtered_data_4th_arc);
task_vec.push(tokio::spawn(async move {
let supertrend_option_1d =
supertrend(&element.symbol, &rt_price_1d_vec_c, 3, 1.1, true).await;
let search_result = macd_vec_c.iter().position(|x| x.0 == element.symbol);
if supertrend_option_1d.is_some() {
supertrend_vec = supertrend_option_1d.unwrap();
if supertrend_vec.len() >= 3 {
if supertrend_vec.last().unwrap()
.area
.contains("UP")
{
let mut filtered_5th_symbols_lock =
filtered_data_5th_arc_c.lock().await;
if search_result.is_some_and(|a| macd_vec_c[a].1.last().unwrap().macd_value > macd_vec_c[a].1.last().unwrap().signal_value) {
let mut filtered_4th_symbols_lock =
filtered_data_4th_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = element.closetime;
@ -268,24 +205,22 @@ pub async fn list_up_for_buy(
filtered_data.stoploss = element.stoploss;
filtered_data.target_price = element.target_price;
filtered_5th_symbols_lock.push(filtered_data);
}
}
filtered_4th_symbols_lock.push(filtered_data);
}
}));
}
try_join_all(task_vec).await?;
// 6th filtering: 0.5% <= the average amplitude of the latest 10 30m candles <= 1.0%
let filtered_data_5th_c = filtered_data_5th_arc.lock().await.clone();
let mut filtered_data_6th: Vec<FilteredData> = Vec::new();
let mut filtered_data_6th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_6th));
// 5th filtering: 0.5% <= the average amplitude of the latest 10 30m candles <= 1.0%
let filtered_data_4th_c = filtered_data_4th_arc.lock().await.clone();
let mut filtered_data_5th: Vec<FilteredData> = Vec::new();
let mut filtered_data_5th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_5th));
let mut task_vec = Vec::new();
for element in filtered_data_5th_c {
for element in filtered_data_4th_c {
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let filtered_data_6th_arc_c = Arc::clone(&filtered_data_6th_arc);
let filtered_data_5th_arc_c = Arc::clone(&filtered_data_5th_arc);
task_vec.push(tokio::spawn(async move {
let position_idx = rt_price_30m_vec_c.iter().position(|elem| elem.0 == element.symbol);
@ -303,6 +238,41 @@ pub async fn list_up_for_buy(
average_amplitude /= 10.0;
if 0.005 <= average_amplitude && average_amplitude <= 0.01 {
let mut filtered_data_5th_lock = filtered_data_5th_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = element.closetime;
filtered_data.current_price = element.current_price;
filtered_data.stoploss = element.stoploss;
filtered_data.target_price = element.target_price;
filtered_data_5th_lock.push(filtered_data);
}
}
}
}));
}
try_join_all(task_vec).await?;
// 6th filtering: 30m StochRSI (RSI_len: 10, StochRSI_len: 10, K: 3, D: 3) current K, D < 20
let filtered_data_5th_c = filtered_data_5th_arc.lock().await.clone();
let mut filtered_data_6th: Vec<FilteredData> = Vec::new();
let mut filtered_data_6th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_6th));
let mut task_vec = Vec::new();
let stoch_rsis = stoch_rsi(10, 10, 3, 3, &alldata.rt_price_30m_vec, &filtered_data_5th_c).await?;
for element in filtered_data_5th_c {
let stoch_rsis_c = stoch_rsis.clone();
let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
let filtered_data_6th_arc_c = Arc::clone(&filtered_data_6th_arc);
task_vec.push(tokio::spawn(async move {
let position_idx = stoch_rsis_c.iter().position(|elem| elem.0 == element.symbol);
if position_idx.is_some() {
let stoch_rsi_vec = stoch_rsis_c[position_idx.unwrap()].1.clone();
let search_result = stoch_rsi_vec.iter().position(|x| x.close_time == element.closetime);
if search_result.is_some_and(|a| stoch_rsi_vec[a].k < 20.0 && stoch_rsi_vec[a].d < 20.0) {
let mut filtered_data_6th_lock = filtered_data_6th_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
@ -314,139 +284,11 @@ pub async fn list_up_for_buy(
filtered_data_6th_lock.push(filtered_data);
}
}
}
}));
}
try_join_all(task_vec).await?;
// 7th filtering: ema3_30m < ema5_30m latest 3 candles
let filtered_data_6th_c = filtered_data_6th_arc.lock().await.clone();
let mut filtered_data_7th: Vec<FilteredData> = Vec::new();
let mut filtered_data_7th_arc: Arc<Mutex<Vec<FilteredData>>> =
Arc::new(Mutex::new(filtered_data_7th));
let mut task_vec = Vec::new();
let ema3_30m_data = ema(3, &alldata.rt_price_30m_vec, &filtered_data_6th_c).await?;
let ema5_30m_data = ema(5, &alldata.rt_price_30m_vec, &filtered_data_6th_c).await?;
for element in filtered_data_6th_c {
let filtered_data_7th_arc_c = Arc::clone(&filtered_data_7th_arc);
let ema3_30m_data_c = ema3_30m_data.clone();
let ema5_30m_data_c = ema5_30m_data.clone();
task_vec.push(tokio::spawn(async move {
let ema3_idx = ema3_30m_data_c.iter().position(|elem| elem.0 == element.symbol);
let ema5_idx = ema5_30m_data_c.iter().position(|elem| elem.0 == element.symbol);
if ema3_idx.is_some() && ema5_idx.is_some() {
let ema3_30m = &ema3_30m_data_c[ema3_idx.unwrap()].1;
let ema5_30m = &ema5_30m_data_c[ema3_idx.unwrap()].1;
let ema3_close_time_idx = ema3_30m.iter().position(|elem| elem.close_time == element.closetime);
let ema5_close_time_idx = ema5_30m.iter().position(|elem| elem.close_time == element.closetime);
if ema3_30m.len() >= 5 && ema5_30m.len() >= 5 && ema3_close_time_idx.is_some() && ema5_close_time_idx.is_some() {
if ema3_30m[ema3_close_time_idx.unwrap()-1].ema_value < ema5_30m[ema5_close_time_idx.unwrap()-1].ema_value ||
ema3_30m[ema3_close_time_idx.unwrap()-2].ema_value < ema5_30m[ema5_close_time_idx.unwrap()-2].ema_value ||
ema3_30m[ema3_close_time_idx.unwrap()-3].ema_value < ema5_30m[ema5_close_time_idx.unwrap()-3].ema_value {
let mut filtered_data_7th_lock = filtered_data_7th_arc_c.lock().await;
let mut filtered_data = FilteredData::new();
filtered_data.symbol = element.symbol.clone();
filtered_data.closetime = element.closetime;
filtered_data.current_price = element.current_price;
filtered_data.stoploss = element.stoploss;
filtered_data.target_price = element.target_price;
filtered_data_7th_lock.push(filtered_data);
}
}
}
}));
}
try_join_all(task_vec).await?;
// // 4th filtering: StochRSI (RSI length: 3, Stoch length: 3, smooth k: 3, smooth d: 3) 80 > k > kn-1
// let filtered_4th_symbol_c = filtered_data_4th_arc.lock().await.clone();
// let mut rsi10_1d_data: Vec<(String, Vec<RsiData>)> =
// rsi(3, &alldata.rt_price_1d_vec, &filtered_4th_symbol_c).await?;
// let stoch_rsi_data = stoch_rsi(&rsi10_1d_data, 3, 3, 3).await?;
// let mut stoch_rsi3_1d_vec: Vec<StochRsiData> = Vec::new();
// let mut filtered_data_5th: Vec<FilteredData> = Vec::new();
// let mut filtered_data_5th_arc: Arc<Mutex<Vec<FilteredData>>> =
// Arc::new(Mutex::new(filtered_data_5th));
// let mut task_vec = Vec::new();
// for element in filtered_4th_symbol_c {
// let stoch_rsi3_1d_option = stoch_rsi_data.iter().position(|x| *x.0 == element.symbol);
// let filtered_data_5th_arc_c = Arc::clone(&filtered_data_5th_arc);
// if stoch_rsi3_1d_option.is_some() {
// stoch_rsi3_1d_vec = stoch_rsi_data[stoch_rsi3_1d_option.unwrap()].1.clone();
// if stoch_rsi3_1d_vec.len() >= 3 {
// task_vec.push(tokio::spawn(async move {
// let stoch_rsi_search_result = stoch_rsi3_1d_vec
// .binary_search_by_key(&element.closetime, |&StochRsiData { k, d, close_time }| {
// close_time
// });
// if stoch_rsi_search_result.is_ok() {
// if 95.0 >= stoch_rsi3_1d_vec[stoch_rsi_search_result.unwrap()].k
// && stoch_rsi3_1d_vec[stoch_rsi_search_result.unwrap()].k
// > stoch_rsi3_1d_vec[stoch_rsi_search_result.unwrap() - 1].k
// && stoch_rsi3_1d_vec[stoch_rsi_search_result.unwrap()].k
// > stoch_rsi3_1d_vec[stoch_rsi_search_result.unwrap()].d
// {
// let mut filtered_data_5th_lock = filtered_data_5th_arc_c.lock().await;
// let mut filtered_data = FilteredData::new();
// filtered_data.symbol = element.symbol.clone();
// filtered_data.closetime = element.closetime;
// filtered_data.current_price = element.current_price;
// filtered_data.stoploss = element.stoploss;
// filtered_data.target_price = element.target_price;
// filtered_data_5th_lock.push(filtered_data);
// }
// }
// }));
// }
// }
// }
// 6th filtertering: coefficient-of-variation 0.5<= CV <= 1.0
// 20개 amplitude 기준 CV 계산
// // 6th filtering: Avoid high volatility
// let filtered_data_5th_c = filtered_data_5th_arc.lock().await.clone();
// let mut filtered_data_6th: Vec<FilteredData> = Vec::new();
// let mut filtered_data_6th_arc: Arc<Mutex<Vec<FilteredData>>> =
// Arc::new(Mutex::new(filtered_data_6th));
// let mut task_vec = Vec::new();
// for element in filtered_data_5th_c {
// let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
// let rt_price_30m_vec_c = alldata.rt_price_30m_vec.clone();
// let filtered_data_6th_arc_c = Arc::clone(&filtered_data_5th_arc);
// task_vec.push(tokio::spawn(async move {
// let mut filtered_data = FilteredData::new();
// if rt_price_30m_vec_c.len() >= 50 {
// let mut filtered_data_5th_lock = filtered_data_6th_arc_c.lock().await;
// filtered_data.symbol = element.symbol.clone();
// filtered_data.closetime = element.closetime;
// filtered_data.current_price = element.current_price;
// filtered_data.stoploss = element.stoploss;
// filtered_data.target_price = element.target_price;
// filtered_data_5th_lock.push(filtered_data);
// }
// }));
// }
// try_join_all(task_vec).await?;
let final_filtered_data = filtered_data_7th_arc.lock().await.clone();
let final_filtered_data = filtered_data_6th_arc.lock().await.clone();
insert_pre_suggested_coins(4, false, &final_filtered_data, &alldata).await;
Ok(())
@ -465,6 +307,7 @@ pub async fn list_up_for_sell(
.build()
.unwrap();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let server_epoch = server_epoch().await;
for element in filled_buy_orders {
if element.used_usdt >= dec!(10.0) {
let lot_step_size_option = exchange_info_vec
@ -474,33 +317,9 @@ pub async fn list_up_for_sell(
.iter()
.position(|exchange_info| exchange_info.symbol == element.symbol);
let opclo_30m_option = all_data
.rt_price_30m_vec
.iter()
.position(|x| *x.0 == element.symbol);
let supertrend_option_30m =
supertrend(&element.symbol, &all_data.rt_price_30m_vec, 10, 1.5, true).await;
if lot_step_size_option.is_some()
&& quote_commission_precision_option.is_some()
&& opclo_30m_option.is_some()
&& supertrend_option_30m.is_some()
{
// update stoploss
supertrend_vec = supertrend_option_30m.unwrap();
let band_value: Decimal = rust_decimal::prelude::FromPrimitive::from_f64(supertrend_vec.last().unwrap().band_value).unwrap();
if supertrend_vec.last().unwrap().area.contains("UP")
&& band_value > element.stoploss {
let update_table_name = String::from("buy_ordered_coin_list");
let update_value = vec![
(String::from("stoploss"), band_value.to_string()),
];
let update_condition = vec![(String::from("id"), element.id.to_string())];
update_record3(&update_table_name, &update_value, &update_condition)
.await
.unwrap();
}
let lot_step_size = exchange_info_vec[lot_step_size_option.unwrap()].stepsize;
let quote_commission_precision = exchange_info_vec
[quote_commission_precision_option.unwrap()]
@ -515,7 +334,6 @@ pub async fn list_up_for_sell(
&& !element.current_price.is_zero()
{
if element.current_price >= element.target_price
&& element.pure_profit_percent >= 0.1
{
limit_order_sell(
&element,
@ -536,6 +354,16 @@ pub async fn list_up_for_sell(
&trade_fee_vec,
)
.await;
} else if server_epoch - element.transact_time > (1_800_000) * 20 {
limit_order_sell(
&element,
element.current_price,
base_qty_to_be_ordered,
&client,
&exchange_info_vec,
&trade_fee_vec,
)
.await;
}
// TODO: sell_count가 1일 때 적용하기
// else if (supertrend_vec

8
src/strategy_team/strategy_manager.rs
View File

@ -34,7 +34,7 @@ pub async fn execute_list_up_for_buy(
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let mut task_vec = Vec::new();
// let all_data_c3 = all_data.clone();
// let all_data_c4 = all_data.clone();
let all_data_c4 = all_data.clone();
let all_data_c5 = all_data.clone();
let all_data_c6 = all_data.clone();
@ -43,9 +43,9 @@ pub async fn execute_list_up_for_buy(
// task_vec.push(tokio::spawn(async move {
// crate::strategy_team::strategy_003::list_up_for_buy(all_data_c3).await;
// }));
// task_vec.push(tokio::spawn(async move {
// crate::strategy_team::strategy_004::list_up_for_buy(all_data_c4).await;
// }));
task_vec.push(tokio::spawn(async move {
crate::strategy_team::strategy_004::list_up_for_buy(all_data_c4).await;
}));
task_vec.push(tokio::spawn(async move {
crate::strategy_team::strategy_005::list_up_for_buy(all_data_c5).await;
}));