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

New strategy

Browse Source
This commit is contained in:
Sik Yoon 2024-02-04 01:48:48 +09:00
parent a247ee63f0
commit 8010c23f20
3 changed files with 139 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/strategy_team/mod.rs
View File

@ -3,7 +3,7 @@ pub mod strategy_002;
pub mod strategy_003;
pub mod strategy_004;
pub mod strategy_005;
// pub mod strategy_006;
pub mod strategy_006;
// pub mod strategy_test;
pub mod strategy_manager;

337
src/strategy_team/strategy_006.rs
View File

@ -1,200 +1,152 @@
use super::{
dec, decimal_add, decimal_sub, ema, exists_record, insert_pre_suggested_coins,
dec, decimal_add, decimal_sub, decimal_div, decimal_mul, 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, adx, AdxData, server_epoch, MacdData, ema_macd,
duplicate_filter
Arc, Client, ClientBuilder, Decimal, EmaData, ExchangeInfo, FilteredDataValue, Mutex,
RealtimePriceData, RoundingStrategy, RsiData, StochRsiData, SupertrendData, TradeFee, update_record3, adx, AdxData, get_server_epoch, MacdData, ema_macd,
BollingerBandData, ToPrimitive, duplicate_filter, HashMap, HashSet, remove_keys, SuperTrendArea, SuperTrendSignal, get_current_price
};
// Triple SuperTrend strategy
// SuperTrend length: 20, multiplier: 1.5, BUY signal
// ADX(10, 10) < 25.0
// BUY conditions
// (1) 1d MACD (3, 7, 30): MACD_current - Signal_current < 0, MACD_prev - Signal_prev < MACD_current - Signal_current
// (2) stoch RSI(3, 3, 2, 2): K_prev < 10, K_prev < K_current
// stoploss: (update) supertrend(10, 1.5) lowerband
// target price: (fixed) stoploss inverse x 3 times profit
pub async fn list_up_for_buy(
alldata: AllData,
alldata: &AllData,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
// print rt_price for debugging
// let a = alldata.rt_price_30m_vec.iter().position(|a| a.0 == "BTCUSDT");
// println!("BTCUSDT: {:?}", alldata.rt_price_30m_vec[a.unwrap()].1.last().unwrap());
// 1st filtering: filtering valid trade pair
let mut filtered_data_1st: Vec<FilteredData> = Vec::new();
let mut filtered_data: HashMap<String, FilteredDataValue> = HashMap::new();
for symbol in &alldata.valid_symbol_vec {
let mut filtered_data = FilteredData::new();
filtered_data.symbol = symbol.clone();
filtered_data_1st.push(filtered_data);
filtered_data.insert(symbol.clone(), FilteredDataValue::new());
}
// 2nd filtering: supertrend(ATR period 20, multiplier: 1.5, 30m close price), signal should be BUY
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();
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 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 supertrend_option_30m =
supertrend(&element.symbol, &rt_price_30m_vec_c, 20, 1.5, 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();
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 {
band_value,
signal,
area,
close_time,
}| *close_time,
);
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
{
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 = supertrend_vec[supertrend_search_result.unwrap()].close_time;
filtered_data.current_price = 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_2nd_lock.push(filtered_data);
}
}
// 2nd filtering: 1d MACD (3, 7, 30) cross
let mut keys_to_remove: HashSet<String> = HashSet::new();
let macd_1d_map = ema_macd(3, 7, 30, &alldata.rt_price_1d_vec, &filtered_data).await?;
let server_epoch = get_server_epoch().await;
for (symbol, values) in &mut filtered_data {
if let (Some(macd_vec), Some(rt_price_vec)) = (macd_1d_map.get(symbol), alldata.rt_price_1d_vec.get(symbol)) {
if macd_vec.last().unwrap().close_time == rt_price_vec.last().unwrap().close_time &&
rt_price_vec.last().unwrap().close_time > server_epoch {
if (macd_vec[macd_vec.len()-1].macd_value - macd_vec[macd_vec.len()-1].signal_value).is_sign_negative() &&
(macd_vec[macd_vec.len()-2].macd_value - macd_vec[macd_vec.len()-2].signal_value).is_sign_negative() &&
(macd_vec[macd_vec.len()-1].macd_value - macd_vec[macd_vec.len()-1].signal_value >
macd_vec[macd_vec.len()-2].macd_value - macd_vec[macd_vec.len()-2].signal_value) {
values.current_price = rust_decimal::prelude::FromPrimitive::from_f64(rt_price_vec.last().unwrap().close_price).unwrap();
values.closetime = rt_price_vec.last().unwrap().close_time;
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
}));
} else {
keys_to_remove.insert(symbol.clone());
}
}
try_join_all(task_vec).await?;
remove_keys(&mut filtered_data, keys_to_remove).await;
// 3rd filtering: the 5 previous ADX(10, 10)s are over 25.0 and increased
let filtered_data_2nd = filtered_data_2nd_arc.lock().await.clone();
let mut filtered_data_3rd: Vec<FilteredData> = Vec::new();
let adx_vec = adx(10, 10, &alldata.rt_price_30m_vec, &filtered_data_2nd).await?;
for element in filtered_data_2nd {
let idx_result = adx_vec.iter().position(|elem| elem.0 == element.symbol);
if idx_result.is_some(){
let closetime_idx_result = adx_vec[idx_result.unwrap()].1.iter().position(|elem| elem.close_time == element.closetime);
if closetime_idx_result.is_some() {
if adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-1].adx > 25.0 &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-2].adx > 25.0 &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-3].adx > 25.0 &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-4].adx > 25.0 &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-5].adx > 25.0 &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-1].adx > adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-2].adx &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-2].adx > adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-3].adx &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-3].adx > adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-4].adx &&
adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-4].adx > adx_vec[idx_result.unwrap()].1[closetime_idx_result.unwrap()-5].adx {
// 1d StochRSI (RSI_len: 3, StochRSI_len: 3, K: 2, D: 2) K_prev < 10, K_prev < K_current
let mut keys_to_remove: HashSet<String> = HashSet::new();
let stoch_rsis = stoch_rsi(30, 30, 3, 3, &alldata.rt_price_1d_vec, &filtered_data).await?;
for (symbol, values) in &mut filtered_data {
if stoch_rsis.contains_key(symbol) {
let stoch_rsi_vec = stoch_rsis.get(symbol).unwrap();
let search_result = stoch_rsi_vec.iter().position(|x| x.close_time == values.closetime);
if search_result.is_some_and(|a| stoch_rsi_vec[a-1].k < 10.0 &&
stoch_rsi_vec[a-1].k <= stoch_rsi_vec[a].k) {
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
}
remove_keys(&mut filtered_data, keys_to_remove).await;
// 2nd filtering: supertrend(ATR period 14, multiplier: 1.2, 1d close price)
let mut keys_to_remove: HashSet<String> = HashSet::new();
let server_epoch = get_server_epoch().await;
let supertrend_1d_map = supertrend(14, 1.2, true, &alldata.rt_price_1d_vec, &filtered_data).await?;
for (symbol, values) in &mut filtered_data {
if let (Some(supertrend_vec), Some(rt_price_vec)) = (supertrend_1d_map.get(symbol), alldata.rt_price_1d_vec.get(symbol)) {
if supertrend_vec.last().unwrap().close_time == rt_price_vec.last().unwrap().close_time &&
rt_price_vec.last().unwrap().close_time > server_epoch {
// input stoploss, target_price
let band_value: Decimal = rust_decimal::prelude::FromPrimitive::from_f64(supertrend_vec.last().unwrap().band_value).unwrap();
if supertrend_vec.last().unwrap().area == SuperTrendArea::DOWN &&
supertrend_vec.last().unwrap().band_value > values.current_price.to_f64().unwrap()
{
values.stoploss = decimal_sub(values.current_price, decimal_sub(band_value, values.current_price));
values.target_price = decimal_add(decimal_mul(decimal_sub(values.current_price, values.stoploss), dec!(2.0)), values.current_price);
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_3rd.push(filtered_data);
} else if supertrend_vec.last().unwrap().area == SuperTrendArea::UP &&
supertrend_vec.last().unwrap().band_value < values.current_price.to_f64().unwrap()
{
values.stoploss = band_value;
values.target_price = decimal_add(decimal_mul(decimal_sub(values.current_price, values.stoploss), dec!(2.0)), values.current_price);
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
}
remove_keys(&mut filtered_data, keys_to_remove).await;
// 4th filtering: the latest 5 30m candle close prices > EMA 200
let mut filtered_data_4th: Vec<FilteredData> = Vec::new();
let ema_vec = ema(200, &alldata.rt_price_30m_vec, &filtered_data_3rd).await?;
for element in filtered_data_3rd {
let ema_search_result = ema_vec.iter().position(|x| x.0 == element.symbol);
let candle_search_result = alldata.rt_price_30m_vec.iter().position(|x| x.0 == element.symbol);
if ema_search_result.is_some() && candle_search_result.is_some() {
let search_result = ema_vec[ema_search_result.unwrap()].1.binary_search_by_key(
&alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.last().unwrap().close_time,
|EmaData {
ema_value,
close_time,
}| *close_time);
if search_result.is_ok_and(|x| ema_vec[ema_search_result.unwrap()].1[search_result.unwrap()].ema_value < alldata.rt_price_30m_vec[candle_search_result.unwrap()].1[alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.len()-1].close_price) &&
search_result.is_ok_and(|x| ema_vec[ema_search_result.unwrap()].1[search_result.unwrap()-1].ema_value < alldata.rt_price_30m_vec[candle_search_result.unwrap()].1[alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.len()-2].close_price) &&
search_result.is_ok_and(|x| ema_vec[ema_search_result.unwrap()].1[search_result.unwrap()-2].ema_value < alldata.rt_price_30m_vec[candle_search_result.unwrap()].1[alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.len()-3].close_price) &&
search_result.is_ok_and(|x: usize| ema_vec[ema_search_result.unwrap()].1[search_result.unwrap()-3].ema_value < alldata.rt_price_30m_vec[candle_search_result.unwrap()].1[alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.len()-4].close_price) &&
search_result.is_ok_and(|x| ema_vec[ema_search_result.unwrap()].1[search_result.unwrap()-4].ema_value < alldata.rt_price_30m_vec[candle_search_result.unwrap()].1[alldata.rt_price_30m_vec[candle_search_result.unwrap()].1.len()-5].close_price) {
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;
// limit buy price: 3 * abs(이전 3 개 중 최대값 제거 한 opclo 값 평균 - 현재 open 값) + 현재 open 값 > current_price
let mut keys_to_remove: HashSet<String> = HashSet::new();
let server_epoch = get_server_epoch().await;
for (symbol, values) in &mut filtered_data {
if let Some(rt_price_vec) = alldata.rt_price_1d_vec.get(symbol) {
if rt_price_vec.last().unwrap().close_time > server_epoch && rt_price_vec.len() >= 6 {
let mut opclo_vec: Vec<f64> = Vec::new();
opclo_vec.push(rt_price_vec[rt_price_vec.len()-2].opclo_price);
opclo_vec.push(rt_price_vec[rt_price_vec.len()-3].opclo_price);
opclo_vec.push(rt_price_vec[rt_price_vec.len()-4].opclo_price);
opclo_vec.push(rt_price_vec[rt_price_vec.len()-5].opclo_price);
opclo_vec.push(rt_price_vec[rt_price_vec.len()-6].opclo_price);
let max_idx = opclo_vec.iter().position(|&x| x == *opclo_vec.iter().max_by(|&a, &b| a.partial_cmp(b).unwrap()).unwrap());
opclo_vec.remove(max_idx.unwrap());
filtered_data_4th.push(filtered_data);
let mut mean = 0.0;
for element in &opclo_vec {
mean += element;
}
mean /= opclo_vec.len() as f64;
let current_price = rt_price_vec.last().unwrap().close_price;
let difference = (mean - rt_price_vec.last().unwrap().open_price).abs();
if current_price < rt_price_vec.last().unwrap().open_price + (3.0 * difference) {
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
} else {
keys_to_remove.insert(symbol.clone());
}
}
// 5th filtering: 0.5% <= the average amplitude of the latest 10 30m candles <= 1.0%
let mut filtered_data_5th: Vec<FilteredData> = Vec::new();
for element in filtered_data_4th {
let position_idx = alldata.rt_price_30m_vec.iter().position(|elem| elem.0 == element.symbol);
if position_idx.is_some() {
let vec_len = alldata.rt_price_30m_vec[position_idx.unwrap()].1.len();
if vec_len >= 11 {
let candles = alldata.rt_price_30m_vec[position_idx.unwrap()].1.get(vec_len-12..vec_len-1).unwrap();
let windows = candles.windows(2);
let mut average_amplitude = 0.0;
remove_keys(&mut filtered_data, keys_to_remove).await;
for window in windows {
average_amplitude += (window.last().unwrap().high_price - window.last().unwrap().low_price) / window.first().unwrap().close_price;
}
average_amplitude /= 10.0;
if 0.005 <= average_amplitude && average_amplitude <= 0.01 {
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.push(filtered_data);
}
}
}
}
let final_filtered_data = duplicate_filter(6, &filtered_data_5th).await?;
insert_pre_suggested_coins(6, false, &final_filtered_data, &alldata).await;
let final_filtered_data = duplicate_filter(6, &filtered_data).await?;
insert_pre_suggested_coins(5, false, &final_filtered_data, &alldata).await;
Ok(())
}
pub async fn list_up_for_sell(
all_data: &AllData,
exchange_info_vec: &Vec<ExchangeInfo>,
trade_fee_vec: &Vec<TradeFee>,
exchange_info_map: &HashMap<String, ExchangeInfo>,
trade_fee_map: &HashMap<String, TradeFee>,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let filled_buy_orders = select_filled_buy_orders(6).await?;
@ -204,32 +156,19 @@ pub async fn list_up_for_sell(
.build()
.unwrap();
let mut supertrend_vec: Vec<SupertrendData> = Vec::new();
let server_epoch = server_epoch().await;
let server_epoch = get_server_epoch().await;
let mut filtered_symbols: HashMap<String, FilteredDataValue> = HashMap::new();
for element in &filled_buy_orders {
filtered_symbols.insert(element.symbol.clone(), FilteredDataValue::new());
}
let supertrend_1d = supertrend(14, 1.2, true, &all_data.rt_price_1d_vec, &filtered_symbols).await?;
for element in filled_buy_orders {
if element.used_usdt >= dec!(10.0) {
let lot_step_size_option = exchange_info_vec
.iter()
.position(|exchange_info| exchange_info.symbol == element.symbol);
let quote_commission_precision_option = exchange_info_vec
.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, 20, 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()
{
if let (Some(exchange_info), Some(tradefee), Some(supertrend_vec)) =
(exchange_info_map.get(&element.symbol), trade_fee_map.get(&element.symbol), supertrend_1d.get(&element.symbol)) {
// 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")
if supertrend_vec.last().unwrap().area == SuperTrendArea::UP
&& band_value > element.stoploss {
let update_table_name = String::from("buy_ordered_coin_list");
let update_value = vec![
@ -241,52 +180,48 @@ pub async fn list_up_for_sell(
.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()]
.quote_commission_precision;
let lot_step_size = exchange_info.stepsize;
let quote_commission_precision = exchange_info.quote_commission_precision;
let base_qty_to_be_ordered =
element.base_qty_ordered.round_dp_with_strategy(
lot_step_size.normalize().scale(),
RoundingStrategy::ToZero,
);
if (element.is_long == 0 || element.is_long == 1)
&& !element.current_price.is_zero()
{
if element.current_price >= element.target_price
&& element.pure_profit_percent >= 0.1
{
if element.current_price <= element.stoploss {
limit_order_sell(
&element,
element.current_price,
base_qty_to_be_ordered,
&client,
&exchange_info_vec,
&trade_fee_vec,
&exchange_info_map,
&trade_fee_map,
)
.await;
} else if element.current_price <= element.stoploss {
} else if element.current_price >= element.target_price {
limit_order_sell(
&element,
element.current_price,
base_qty_to_be_ordered,
&client,
&exchange_info_vec,
&trade_fee_vec,
&exchange_info_map,
&trade_fee_map,
)
.await;
} else if server_epoch - element.transact_time > (1_800_000) * 10 && element.pure_profit_percent.is_sign_positive() {
} else if element.pure_profit_percent >= 20.0 {
limit_order_sell(
&element,
element.current_price,
base_qty_to_be_ordered,
&client,
&exchange_info_vec,
&trade_fee_vec,
&exchange_info_map,
&trade_fee_map,
)
.await;
}
}
// TODO: sell_count가 1일 때 적용하기
// else if (supertrend_vec
// .last()

2
src/strategy_team/strategy_manager.rs
View File

@ -36,6 +36,7 @@ pub async fn execute_list_up_for_buy(
crate::strategy_team::strategy_003::list_up_for_buy(all_data).await;
crate::strategy_team::strategy_004::list_up_for_buy(all_data).await;
crate::strategy_team::strategy_005::list_up_for_buy(all_data).await;
crate::strategy_team::strategy_006::list_up_for_buy(all_data).await;
Ok(())
}
@ -50,6 +51,7 @@ pub async fn execute_list_up_for_sell(
crate::strategy_team::strategy_003::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
crate::strategy_team::strategy_004::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
crate::strategy_team::strategy_005::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
crate::strategy_team::strategy_006::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
Ok(())
}