main.rs
1 use bincode::{Decode, Encode}; 2 use ethos_algorithm_of_god_lib::trade_functions::{ 3 constants::leverage_constants::{OrderType, Position, PositionResult}, 4 trade_functions::{AlgorithmOfGod, LeverageData, LeverageDetail}, 5 }; 6 use ethos_sledb::storage::Storage; 7 use std::sync::Arc; 8 9 #[derive(Encode, Decode, Debug)] 10 pub struct SymbolData { 11 pub entrence_fee: i32, 12 } 13 14 #[tokio::main] 15 async fn main() { 16 let storage = Arc::new(Storage::new("./test")); 17 18 let leverage_data = vec![LeverageData { 19 user_id: 1, 20 lev_data: vec![ 21 /* LeverageDetail { 22 symbol: String::from("BTC"), 23 entrence_fee: 2.0, 24 leverage: 10, 25 position: Position::NONE, 26 close_profit_loss: PositionResult::NONE, 27 }, 28 LeverageDetail { 29 symbol: String::from("ETH"), 30 entrence_fee: 3.0, 31 leverage: 50, 32 position: Position::NONE, 33 close_profit_loss: PositionResult::NONE, 34 }, */ 35 ], 36 }]; 37 38 let algo = AlgorithmOfGod::new(leverage_data, storage); 39 40 algo.append_leverage_data(1, "ADA", 5.0, 50, Position::SHORT, PositionResult::NONE); 41 let is_reverse = algo.folding_system(2, "ADA"); 42 43 algo.append_leverage_data(1, "ADA", 5.0, 50, Position::LONG, PositionResult::NONE); 44 45 let is_reverse = algo.folding_system(1, "ADA"); 46 algo.append_guard_vault_data(1, "ADA", 1.0, 2); 47 algo.guard_vault(1, "ADA"); 48 49 let folding_fee = match algo.get_leverage_data_symbol(1, "ADA") { 50 Some(folding_fee) => folding_fee.current_entrence_fee, 51 None => 5.0, 52 }; 53 54 let guard_result = algo.get_last_guard_vault_user(1, "ADA"); 55 56 println!("guard result : {:#?}",guard_result); 57 58 let is_guard_folding_fee = match guard_result { 59 Some(guard_folding_fee) => guard_folding_fee, 60 None => folding_fee, 61 }; 62 println!("is_guard_folding_fee : {:#?}",is_guard_folding_fee); 63 64 /* algo.append_leverage_data(1, "ADA", 5.0, 50, Position::LONG, PositionResult::NONE); 65 66 let is_reverse = algo.folding_system(1, "ADA"); 67 algo.folding_control_user_save(1, "ADA", is_reverse.1.as_str()); 68 69 let folding_control = algo.get_folding_control(1, "ADA"); 70 println!("2 fold{:#?}", folding_control); 71 72 algo.folding_control_folding_fee_save(1, "ADA", 250.0); 73 74 let folding_control = algo.get_folding_control(1, "ADA"); 75 println!("3 fold{:#?}", folding_control); 76 */ 77 78 /* let is_reverse = algo.folding_system(2, "ADA"); */ 79 /* algo.folding_control_user_save(1, "SOL", is_reverse.1.as_str()); 80 algo.append_leverage_data(1, "SOL", 5.0, 50, Position::SHORT, PositionResult::NONE); 81 let lev_data = algo.get_leverage_data_symbol(1, "ADA"); 82 83 println!("1.is_reverse{:#?}", lev_data); 84 algo.append_guard_vault_data(1, "SOL", 1.0, 4); 85 algo.append_leverage_data(1, "SOL", 2.0, 50, Position::LONG, PositionResult::NONE); 86 87 let is_reverse = algo.folding_system(1, "SOL"); 88 algo.folding_control_user_save(1, "SOL", is_reverse.1.as_str()); 89 90 let folding_control = algo.get_folding_control(1, "SOL"); 91 println!("{:#?}", folding_control); 92 93 94 95 96 97 let folding_control1 = algo.get_folding_control(1, "SOL"); 98 println!("{:#?}", folding_control1); */ 99 /* let is_reverse1 = algo.folding_system(1, "ADA"); 100 println!("{:#?}",is_reverse1); */ 101 /* let lev_data = algo.get_leverage_data_symbol(1, "ADA"); */ 102 103 /* println!("2.is_reverse {:#?}", lev_data); 104 105 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::SHORT, PositionResult::NONE); 106 107 let is_reverse = algo.folding_system(1, "ADA"); 108 algo.append_guard_vault_data(1, "ADA", 2.0, 4); 109 let lev_data = algo.get_leverage_data_symbol(1, "ADA"); 110 111 println!("3.is_reverse {:#?}", lev_data); 112 113 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::LONG, PositionResult::NONE); 114 115 let is_reverse = algo.folding_system(1, "ADA"); 116 algo.append_guard_vault_data(1, "ADA", 5.0, 4); 117 let lev_data = algo.get_leverage_data_symbol(1, "ADA"); 118 119 println!("4.is_reverse {:#?}", lev_data); 120 121 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::SHORT, PositionResult::NONE); 122 123 let is_reverse = algo.folding_system(1, "ADA"); 124 algo.append_guard_vault_data(1, "ADA", 4.0, 4); 125 126 let lev_data = algo.get_leverage_data_symbol(1, "ADA"); 127 128 println!("5.is_reverse {:#?}", lev_data); 129 130 let last_guard_result = algo.get_last_guard_vault_user(1, "ADA"); 131 132 println!("{:#?}", last_guard_result); 133 134 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::LONG, PositionResult::NONE); 135 136 let is_reverse = algo.folding_system(1, "ADA"); 137 algo.append_guard_vault_data(1, "ADA", 4.0, 4); 138 139 let lev_data = algo.get_leverage_data_symbol(1, "ADA"); 140 141 println!("6.is_reverse {:#?}", lev_data); */ 142 143 /* algo.append_user_open_order_data( 144 1, 145 "ADA", 146 Position::LONG.to_string(), 147 "ada1_market".to_string(), 148 OrderType::MARKET.to_string(), 149 123, 150 Some(123.0), 151 Some(2.0), 152 ); 153 154 algo.append_user_open_order_data( 155 1, 156 "ADA", 157 Position::LONG.to_string(), 158 "ada1_take_profit".to_string(), 159 OrderType::TAKE_PROFIT_MARKET.to_string(), 160 345, 161 None, 162 None, 163 ); 164 165 algo.append_user_open_order_data( 166 1, 167 "ADA", 168 Position::LONG.to_string(), 169 "ada1_stop_market".to_string(), 170 OrderType::STOP_MARKET.to_string(), 171 2345, 172 Some(124444.0), 173 Some(4.0), 174 ); 175 176 177 algo.append_user_open_order_data( 178 1, 179 "ADA", 180 Position::LONG.to_string(), 181 "ada2_market_market".to_string(), 182 OrderType::MARKET.to_string(), 183 123123123123, 184 Some(124444.0), 185 Some(4.0), 186 ); 187 */ 188 189 /* let open_order = algo.get_user_open_order_struct(1, "ADA"); 190 println!("{:#?}", open_order); 191 192 let last_folding_fee = algo.get_leverage_data_symbol(1, "ADA"); 193 println!("1.last fee ADA: {:#?}", last_folding_fee); 194 195 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::SHORT, PositionResult::NONE); 196 algo.append_guard_vault_data(1, "ADA", 2.20, 4); 197 let is_reverse = algo.folding_system(1, "ADA"); 198 let last_folding_fee = algo.get_last_folding_fee_user(1, "ADA"); 199 println!("2.last fee ADA: {:#?}", last_folding_fee); 200 201 algo.append_leverage_data(1, "ADA", 2.0, 50, Position::NONE, PositionResult::TP); 202 algo.append_guard_vault_data(1, "ADA", 2.20, 4); 203 let is_reverse = algo.folding_system(1, "ADA"); 204 /* let last_folding_fee = algo.get_last_folding_fee_user(1, "ADA"); */ 205 let last_folding_fee = algo.get_leverage_data_symbol(1, "ADA"); 206 println!("tp fee ADA: {:#?}", last_folding_fee); 207 208 let last_folding_fee = algo.get_last_folding_fee_user(1, "ADA"); 209 println!("last fee ADA: {:#?}", last_folding_fee); 210 211 let is_reverse = algo.folding_system(1, "ADA"); 212 213 algo.append_leverage_data(1, "ZCASH", 2.0, 50, Position::SHORT, PositionResult::NONE); 214 215 let is_reverse = algo.folding_system(1, "ZCASH"); 216 217 println!("is_reverse {:#?}", is_reverse); 218 219 algo.append_leverage_data(1, "ZCASH", 2.0, 50, Position::LONG, PositionResult::NONE); 220 algo.append_guard_vault_data(1, "ZCASH", 1.10, 4); 221 let is_reverse = algo.folding_system(1, "ZCASH"); 222 223 println!("is_reverse {:#?}", is_reverse); 224 225 algo.append_leverage_data(1, "ZCASH", 2.0, 50, Position::SHORT, PositionResult::NONE); 226 algo.append_guard_vault_data(1, "ZCASH", 2.30, 4); 227 228 let is_reverse = algo.folding_system(1, "ZCASH"); 229 230 println!("is_reverse {:#?}", is_reverse); 231 232 algo.append_leverage_data(1, "ZCASH", 2.0, 50, Position::LONG, PositionResult::NONE); 233 algo.append_guard_vault_data(1, "ZCASH", 3.50, 4); 234 let is_reverse = algo.folding_system(1, "ZCASH"); 235 236 println!("is_reverse {:#?}", is_reverse); 237 238 algo.append_leverage_data(1, "ZCASH", 2.0, 50, Position::LONG, PositionResult::NONE); 239 240 let is_reverse = algo.folding_system(1, "ZCASH"); 241 242 println!("is_reverse {:#?}", is_reverse); 243 244 algo.append_leverage_data(2, "DOG", 2.0, 50, Position::LONG, PositionResult::NONE); 245 let is_reverse = algo.folding_system(2, "DOG"); 246 247 algo.append_leverage_data(2, "DOG", 2.0, 50, Position::NONE, PositionResult::SL); 248 algo.append_guard_vault_data(2, "DOG", 1.6, 4); 249 let is_reverse = algo.folding_system(2, "DOG"); 250 251 algo.append_leverage_data(2, "DOG", 2.0, 50, Position::LONG, PositionResult::NONE); 252 let is_reverse = algo.folding_system(2, "DOG"); 253 254 let last_folding_fee = algo.get_last_folding_fee_user(2, "DOG"); 255 let last_guard_result = algo.get_last_guard_vault_user(2, "DOG"); 256 257 println!( 258 "last_folding_fee :{:#?}, last_guard_result: {:#?}", 259 last_folding_fee, last_guard_result 260 ); 261 262 algo.append_leverage_data(2, "DOG", 2.0, 50, Position::SHORT, PositionResult::NONE); 263 algo.append_guard_vault_data(2, "DOG", 1.70, 4); 264 let is_reverse = algo.folding_system(2, "DOG"); */ 265 266 /* algo.append_leverage_data(2, "ADA", 1.5, 30, Position::LONG, PositionResult::NONE); 267 268 algo.append_guard_vault_data(2, "ADA", 1.00002, 3); 269 algo.folding_system("ADA"); 270 271 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::NONE, PositionResult::SL); 272 algo.folding_system("ADA"); 273 274 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::SHORT, PositionResult::NONE); 275 algo.folding_system("ADA"); 276 277 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::SHORT, PositionResult::NONE); 278 algo.folding_system("ADA"); */ 279 280 /* 281 282 283 284 285 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::NONE, PositionResult::TP); 286 287 288 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::LONG, PositionResult::NONE); 289 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::SHORT, PositionResult::NONE); 290 algo.append_leverage_data(2, "ADA", 1.5, 30, Position::NONE, PositionResult::SL); */ 291 292 /* algo.append_guard_vault_data(2, "ADA", 1.00002, 4); */ 293 294 /* let after_leverage_data = LeverageData { 295 user_id: 3, 296 lev_data: vec![ 297 LeverageDetail { 298 symbol: String::from("SOL"), 299 entrence_fee: 2.0, 300 leverage: 10, 301 position: Position::SHORT, 302 close_profit_loss: PositionResult::SL, 303 }, 304 LeverageDetail { 305 symbol: String::from("AVAX"), 306 entrence_fee: 3.0, 307 leverage: 50, 308 position: Position::LONG, 309 close_profit_loss: PositionResult::SL, 310 }, 311 ], 312 }; 313 314 algo.append_user_data(after_leverage_data); */ 315 316 //algo.update_last_close_profit_loss(1,"ADA",PositionResult::TP); 317 318 /* 319 leverage_system 320 user_id:sybmol_name 321 - entrence_fee 322 323 324 */ 325 /* let mut algo = AlgorithmOfGod::new(2.0, 50, Arc::new(storage)); 326 327 let _ = algo 328 .folding_system("BTCUSDT", "SHORT".to_string(), Some("tp".to_string()), None) 329 .await; 330 331 let _ = algo 332 .folding_system("BTCUSDT", "LONG".to_string(), None, None) 333 .await; 334 335 let _ = algo 336 .folding_system("BTCUSDT", "SHORT".to_string(), None, None) 337 .await; 338 339 let _ = algo 340 .folding_system("BTCUSDT", "LONG".to_string(), None, None) 341 .await; 342 343 let (symbol, lev_count) = algo.get_leverage_count("BTCUSDT"); 344 345 println!("symbol : {} lev: {}",symbol,lev_count); */ 346 347 /* let algorithm_of_god = Arc::new(Mutex::new(AlgorithmOfGod::new(2.0, 50))); 348 let guard_vault = Arc::new(Mutex::new(TradingGuard::new())); 349 350 let cloned_algorithm = Arc::clone(&algorithm_of_god); 351 let cloned_guard_vault = Arc::clone(&guard_vault); 352 let _ = tokio::spawn(async move { 353 let mut algorithm = cloned_algorithm.lock().await; 354 let mut guard_vault = cloned_guard_vault.lock().await; 355 356 let (message, is_reverse) = algorithm 357 .folding_system("BTCUSDT", "SHORT".to_string(), None, Some("sl".to_string())) 358 .await 359 .unwrap(); 360 let (symbol, leverage_count) = algorithm.get_leverage_count("BTCUSDT"); 361 let vault = guard_vault 362 .vault_guard_system( 363 &symbol, 364 leverage_count, 365 algorithm.get_quantity("BTCUSDT")[0], 366 1.2, 367 0.0, 368 0.3, 369 ) 370 .await; 371 let result = algorithm.get_result("BTCUSDT").unwrap(); 372 println!("mesaj : {:#?}", result); 373 println!("katlama sayisi : {}", leverage_count); 374 println!( 375 "değerler : {:#?}", 376 guard_vault 377 .get_protection_info("BTCUSDT", leverage_count as f32, 0.3) 378 .await 379 ); 380 println!( 381 "toplam kayip : {:#?}", 382 guard_vault.get_total_loss("BTCUSDT").await 383 ); 384 }) 385 .await 386 .unwrap(); */ 387 }