Kwant Bot

20 |

21 |

22 |

23 |

{pos ? '+' : ''}{pnl.toFixed(2)}

24 |

25 | ); 26 | }; 27 | 28 | const MarketCard: React.FC = ({ market, onTogglePause, onRemove }) => { 29 | const { asset, price, lev, margin, params, pnl, is_paused, indicators } = market; 30 | const { strategy } = params; 31 | const { risk, style, stance } = strategy.custom; 32 | 33 | return ( 34 | 35 | {/* Head */} 36 |

37 |

38 |

Asset

39 |

40 |

{asset}

41 | {is_paused ? 'Paused' : 'Live'} 42 |

43 |

${formatPrice(price)} • {lev}×

44 |

45 |

46 | 49 | 52 |

53 |

54 | 55 | {/* Metrics */} 56 |

57 |

58 |

Price

59 |

${formatPrice(price)}

60 |

61 |

62 |

Leverage

63 |

{lev}×

64 |

65 |

66 |

Margin

67 |

${margin.toFixed(2)}

68 |

69 |

70 | 71 | {/* PnL */} 72 |

73 |

PnL

74 | 75 |

76 | 77 | {/* Indicators */} 78 |

79 | {indicators.map((data, i) => { 80 | const { kind, timeframe, value } = decompose(data); 81 | const kindKey = Object.keys(kind)[0] as keyof typeof indicatorColors; 82 | return ( 83 | 84 | {indicatorLabels[kindKey] || (kindKey as string)} — {fromTimeFrame(timeframe)} 85 | 86 | ); 87 | })} 88 |

89 | 90 | {/* Strategy */} 91 |

92 |

93 |

Strategy

94 |

{style} / {stance}

95 |

96 |

97 |

Risk

98 |

{risk}

99 |

100 |

101 |

Trend Following

102 |

{strategy.custom.followTrend ? 'Yes' : 'No'}

103 |

104 |

105 | 106 | ); 107 | }; 108 | 109 | export default MarketCard; 110 | -------------------------------------------------------------------------------- /src/bin/kwant.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | use tokio::{sync::{mpsc::{unbounded_channel, UnboundedSender}, broadcast::{self, Sender as BroadcastSender}}, time::Duration}; 3 | use actix::{Actor, StreamHandler, Handler, Message}; 4 | use actix_cors::Cors; 5 | use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder, Error as ActixError}; 6 | use actix::ActorContext; 7 | use actix::AsyncContext; 8 | use actix_web_actors::ws; 9 | use dotenv::dotenv; 10 | use env_logger; 11 | use log::{error, info}; 12 | use serde_json; 13 | use hyperliquid_rust_bot::{ 14 | Bot, BotEvent, UpdateFrontend, LocalWallet, Wallet, BaseUrl, 15 | }; 16 | use hyperliquid_rust_bot::strategy::{Strategy, CustomStrategy, Risk, Style, Stance}; 17 | 18 | #[actix_web::main] 19 | async fn main() -> Result<(), Box> { 20 | dotenv().ok(); 21 | env_logger::init(); 22 | 23 | let url = BaseUrl::Mainnet; 24 | let wallet: LocalWallet = env::var("PRIVATE_KEY")?.parse()?; 25 | let pubkey = env::var("WALLET")?; 26 | let wallet = Wallet::new(url, pubkey, wallet).await?; 27 | 28 | let (mut bot, cmd_sender) = Bot::new(wallet).await?; 29 | let (update_tx, mut update_rx) = unbounded_channel::(); 30 | tokio::spawn(async move { bot.start(update_tx).await }); 31 | 32 | let (bcast_tx, _) = broadcast::channel::(128); 33 | let bcast_cl = bcast_tx.clone(); 34 | 35 | let mut _dummy_rx = bcast_tx.subscribe(); 36 | tokio::spawn(async move { 37 | loop { 38 | let _ = _dummy_rx.recv().await; 39 | } 40 | }); 41 | 42 | tokio::spawn(async move { 43 | while let Some(update) = update_rx.recv().await { 44 | if let Err(err) = bcast_tx.send(update) { 45 | error!("broadcast send error: {}", err); 46 | } 47 | } 48 | }); 49 | 50 | let cmd_data = web::Data::new(cmd_sender.clone()); 51 | let bcast_data = web::Data::new(bcast_cl.clone()); 52 | 53 | HttpServer::new(move || { 54 | App::new() 55 | .app_data(cmd_data.clone()) 56 | .app_data(bcast_data.clone()) 57 | .wrap( 58 | Cors::default() 59 | .allow_any_origin() 60 | .allow_any_method() 61 | .allow_any_header() 62 | .supports_credentials(), 63 | ) 64 | .route("/command", web::post().to(execute)) 65 | .route("/ws", web::get().to(ws_route)) 66 | }) 67 | .bind(("127.0.0.1", 8090))? 68 | .run() 69 | .await?; 70 | 71 | Ok(()) 72 | } 73 | 74 | async fn execute( 75 | raw: web::Bytes, 76 | sender: web::Data>, 77 | ) -> impl Responder { 78 | // Log the raw request body 79 | let body_str = String::from_utf8_lossy(&raw); 80 | println!("Incoming raw body: {}", body_str); 81 | 82 | // Try to deserialize 83 | match serde_json::from_slice::(&raw) { 84 | Ok(event) => { 85 | if let Err(err) = sender.send(event) { 86 | error!("failed to send command: {}", err); 87 | return HttpResponse::InternalServerError().finish(); 88 | } 89 | HttpResponse::Ok().finish() 90 | } 91 | Err(err) => { 92 | error!("Failed to deserialize BotEvent: {}", err); 93 | HttpResponse::BadRequest().body(format!("Invalid BotEvent: {}", err)) 94 | } 95 | } 96 | } 97 | 98 | async fn ws_route( 99 | req: HttpRequest, 100 | stream: web::Payload, 101 | bcast: web::Data>, 102 | ) -> Result { 103 | let rx = bcast.subscribe(); 104 | let ws = MyWebSocket { rx }; 105 | ws::start(ws, &req, stream) 106 | } 107 | 108 | #[derive(Message)] 109 | #[rtype(result = "()")] 110 | struct ServerMessage(String); 111 | 112 | struct MyWebSocket { 113 | rx: broadcast::Receiver, 114 | } 115 | 116 | impl Actor for MyWebSocket { 117 | type Context = ws::WebsocketContext; 118 | 119 | fn started(&mut self, ctx: &mut Self::Context) { 120 | ctx.run_interval(Duration::from_secs(30), |_, ctx| ctx.ping(b"")); 121 | 122 | let mut rx = self.rx.resubscribe(); 123 | let addr = ctx.address(); 124 | tokio::spawn(async move { 125 | loop { 126 | match rx.recv().await { 127 | Ok(update) => { 128 | if let Ok(text) = serde_json::to_string(&update) { 129 | println!("\n{}\n", text); 130 | addr.do_send(ServerMessage(text)); 131 | } 132 | } 133 | Err(broadcast::error::RecvError::Lagged(cnt)) => { 134 | error!("missed {} messages", cnt); 135 | continue; 136 | } 137 | Err(broadcast::error::RecvError::Closed) => break, 138 | } 139 | } 140 | addr.do_send(ServerMessage("__SERVER_CLOSED__".into())); 141 | }); 142 | } 143 | } 144 | 145 | impl Handler for MyWebSocket { 146 | type Result = (); 147 | 148 | fn handle(&mut self, msg: ServerMessage, ctx: &mut Self::Context) { 149 | if msg.0 == "__SERVER_CLOSED__" { 150 | ctx.close(None); 151 | ctx.stop(); 152 | } else { 153 | ctx.text(msg.0); 154 | } 155 | } 156 | } 157 | 158 | impl StreamHandler> for MyWebSocket { 159 | fn handle(&mut self, msg: Result, ctx: &mut Self::Context) { 160 | if let Ok(ws::Message::Ping(p)) = msg { 161 | ctx.pong(&p); 162 | } else if let Ok(ws::Message::Close(reason)) = msg { 163 | ctx.close(reason); 164 | ctx.stop(); 165 | } 166 | } 167 | } 168 | 169 | 170 | -------------------------------------------------------------------------------- /src/frontend/interface/src/types.ts: -------------------------------------------------------------------------------- 1 | export type IndicatorKind = 2 | | { rsi: number } 3 | | { smaOnRsi: { periods: number; smoothingLength: number } } 4 | | { stochRsi: { periods: number; kSmoothing?: number | null; dSmoothing?: number | null } } 5 | | { adx: { periods: number; diLength: number } } 6 | | { atr: number } 7 | | { ema: number } 8 | | { emaCross: { short: number; long: number } } 9 | | { sma: number }; 10 | 11 | export interface MarketInfo{ 12 | asset: string, 13 | lev: number, 14 | price: number, 15 | margin: number, 16 | params: TradeParams, 17 | pnl: number, 18 | is_paused: boolean, 19 | indicators: indicatorData[], 20 | trades: TradeInfo[], 21 | } 22 | 23 | export interface indicatorData { 24 | id: IndexId, 25 | value?: Value 26 | }; 27 | 28 | export type Value = 29 | | { rsiValue: number } 30 | | { stochRsiValue: { k: number; d: number } } 31 | | { emaValue: number } 32 | | { emaCrossValue: { short: number; long: number; trend: boolean } } 33 | | { smaValue: number } 34 | | { smaRsiValue: number } 35 | | { adxValue: number } 36 | | { atrValue: number } 37 | 38 | export function get_value(v?: Value): string { 39 | if (!v) return "No value"; 40 | if ("rsiValue" in v) return `RSI: ${v.rsiValue.toFixed(2)}`; 41 | if ("stochRsiValue" in v) return `StochRSI: K=${v.stochRsiValue.k.toFixed(2)}, D=${v.stochRsiValue.d.toFixed(2)}`; 42 | if ("emaValue" in v) return `EMA: ${v.emaValue.toFixed(2)}`; 43 | if ("emaCrossValue" in v) return `EMA Cross: short=${v.emaCrossValue.short.toFixed(2)}, long=${v.emaCrossValue.long.toFixed(2)}, trend=${v.emaCrossValue.trend ? "↑" : "↓"}`; 44 | if ("smaValue" in v) return `SMA: ${v.smaValue.toFixed(2)}`; 45 | if ("smaRsiValue" in v) return `SMA on RSI: ${v.smaRsiValue.toFixed(2)}`; 46 | if ("adxValue" in v) return `ADX: ${v.adxValue.toFixed(2)}`; 47 | if ("atrValue" in v) return `ATR: ${v.atrValue.toFixed(2)}`; 48 | return "Unknown"; 49 | } 50 | 51 | export type Decomposed = { 52 | kind: IndicatorKind 53 | timeframe: TimeFrame 54 | value?: Value 55 | } 56 | 57 | 58 | 59 | export function decompose(ind: indicatorData): Decomposed { 60 | const [kind, timeframe] = ind.id 61 | return { kind, timeframe, value: ind.value } 62 | } 63 | 64 | export type IndexId = [IndicatorKind, TimeFrame]; 65 | 66 | 67 | export type TimeFrame = 68 | | "min1" 69 | | "min3" 70 | | "min5" 71 | | "min15" 72 | | "min30" 73 | | "hour1" 74 | | "hour2" 75 | | "hour4" 76 | | "hour12" 77 | | "day1" 78 | | "day3" 79 | | "week" 80 | | "month"; 81 | 82 | export const TIMEFRAME_CAMELCASE: Record = { 83 | "1m": "min1", 84 | "3m": "min3", 85 | "5m": "min5", 86 | "15m": "min15", 87 | "30m": "min30", 88 | "1h": "hour1", 89 | "2h": "hour2", 90 | "4h": "hour4", 91 | "12h": "hour12", 92 | "1d": "day1", 93 | "3d": "day3", 94 | "w": "week", 95 | "m": "month", 96 | }; 97 | 98 | const TIMEFRAME_SHORT: Record = Object.entries(TIMEFRAME_CAMELCASE) 99 | .reduce((acc, [short, tf]) => { 100 | acc[tf] = short; 101 | return acc; 102 | }, {} as Record); 103 | 104 | export function fromTimeFrame(tf: TimeFrame): string { 105 | return TIMEFRAME_SHORT[tf]; 106 | } 107 | 108 | export function into(tf: string): TimeFrame { 109 | return TIMEFRAME_CAMELCASE[tf]; 110 | } 111 | 112 | 113 | 114 | 115 | export type Risk = "Low" | "Normal" | "High"; 116 | export type Style = "Scalp" | "Swing"; 117 | export type Stance = "Bull" | "Bear" | "Neutral"; 118 | 119 | export interface CustomStrategy { 120 | risk: Risk; 121 | style: Style; 122 | stance: Stance; 123 | followTrend: boolean; 124 | } 125 | 126 | export type Strategy = { custom: CustomStrategy }; 127 | 128 | export interface TradeParams { 129 | timeFrame: TimeFrame; 130 | lev: number; 131 | strategy: Strategy; 132 | tradeTime: number; 133 | } 134 | 135 | export type MarginAllocation = 136 | | {alloc: number } 137 | | {amount: number }; 138 | 139 | 140 | 141 | 142 | export interface AddMarketInfo { 143 | asset: string; 144 | marginAlloc: MarginAllocation; 145 | tradeParams: TradeParams; 146 | config?: IndexId[]; 147 | }; 148 | 149 | export type Message = 150 | | { confirmMarket: MarketInfo } 151 | | { updatePrice: assetPrice } 152 | | { newTradeInfo: MarketTradeInfo } 153 | | { updateTotalMargin: number} 154 | | { updateMarketMargin: assetMargin } 155 | | { updateIndicatorValues: {asset: string, data: indicatorData[] }} 156 | | { marketInfoEdit: [string, editMarketInfo]} 157 | | { userError: string } 158 | | { loadSession: MarketInfo[]}; 159 | 160 | 161 | export type assetPrice = [string, number]; 162 | export type assetMargin = [string, number]; 163 | 164 | 165 | export type editMarketInfo = 166 | | {lev: number} 167 | | {strategy: Strategy} 168 | | {margin: number}; 169 | 170 | 171 | export interface TradeInfo{ 172 | open: number, 173 | close: number, 174 | pnl: number, 175 | fee: number, 176 | is_long: number, 177 | duration?: number, 178 | oid: [number, number] 179 | }; 180 | 181 | 182 | export interface MarketTradeInfo{ 183 | asset: string, 184 | info: TradeInfo, 185 | } 186 | 187 | 188 | export const indicatorLabels: Record = { 189 | rsi: 'RSI', 190 | smaOnRsi: 'SMA on RSI', 191 | stochRsi: 'Stoch RSI', 192 | adx: 'ADX', 193 | atr: 'ATR', 194 | ema: 'EMA', 195 | emaCross: 'EMA Cross', 196 | sma: 'SMA', 197 | }; 198 | 199 | export const indicatorColors: Record = { 200 | rsi: 'bg-green-800 text-green-200', 201 | smaOnRsi: 'bg-indigo-800 text-indigo-200', 202 | stochRsi: 'bg-purple-800 text-purple-200', 203 | adx: 'bg-yellow-800 text-yellow-200', 204 | atr: 'bg-red-800 text-red-200', 205 | ema: 'bg-blue-800 text-blue-200', 206 | emaCross: 'bg-pink-800 text-pink-200', 207 | sma: 'bg-gray-800 text-gray-200', 208 | }; 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | -------------------------------------------------------------------------------- /src/trade_setup.rs: -------------------------------------------------------------------------------- 1 | use std::fmt; 2 | 3 | use log::info; 4 | use hyperliquid_rust_sdk::{ExchangeClient, ExchangeResponseStatus, Error, TradeInfo as HLTradeInfo}; 5 | //use kwant::indicators::Price; 6 | 7 | use crate::strategy::{Strategy, CustomStrategy}; 8 | use serde::{Deserialize, Serialize}; 9 | 10 | 11 | 12 | #[derive(Clone, Debug, Deserialize, Serialize)] 13 | #[serde(rename_all = "camelCase")] 14 | pub struct TradeParams { 15 | pub strategy: Strategy, 16 | pub lev: u32, 17 | pub trade_time: u64, 18 | pub time_frame: TimeFrame, 19 | } 20 | 21 | 22 | 23 | impl TradeParams{ 24 | 25 | pub async fn update_lev(&mut self, lev: u32, client: &ExchangeClient, asset: &str, first_time: bool) -> Result{ 26 | if !first_time && self.lev == lev{ 27 | return Err(Error::Custom(format!("Leverage is unchanged"))); 28 | } 29 | 30 | let response = client 31 | .update_leverage(lev, asset, false, None) 32 | .await?; 33 | 34 | info!("Update leverage response: {response:?}"); 35 | match response{ 36 | ExchangeResponseStatus::Ok(_) => { 37 | self.lev = lev; 38 | return Ok(lev); 39 | }, 40 | ExchangeResponseStatus::Err(e)=>{ 41 | return Err(Error::Custom(e)); 42 | }, 43 | } 44 | } 45 | 46 | } 47 | 48 | 49 | 50 | impl Default for TradeParams { 51 | fn default() -> Self { 52 | Self { 53 | strategy: Strategy::Custom(CustomStrategy::default()), 54 | lev: 20, 55 | trade_time: 300, 56 | time_frame: TimeFrame::Min5, 57 | } 58 | } 59 | } 60 | 61 | impl fmt::Display for TradeParams { 62 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 63 | write!( 64 | f, 65 | "leverage: {}\nStrategy: {:?}\nTrade time: {} s\ntime_frame: {}", 66 | self.lev, 67 | self.strategy, 68 | self.trade_time, 69 | self.time_frame.as_str(), 70 | ) 71 | } 72 | } 73 | 74 | 75 | #[derive(Clone, Debug, Copy, Serialize, Deserialize)] 76 | #[serde(rename_all = "camelCase")] 77 | pub enum TradeCommand{ 78 | ExecuteTrade {size: f64, is_long: bool, duration: u64}, 79 | OpenTrade {size: f64, is_long: bool}, 80 | CloseTrade{size: f64}, 81 | BuildPosition {size: f64, is_long: bool, interval: u64}, 82 | CancelTrade, 83 | Liquidation(LiquidationFillInfo), 84 | Toggle, 85 | Resume, 86 | Pause, 87 | } 88 | 89 | 90 | #[derive(Clone, Debug, Copy, Deserialize, Serialize)] 91 | #[serde(rename_all = "camelCase")] 92 | pub struct TradeInfo{ 93 | pub open: f64, 94 | pub close: f64, 95 | pub pnl: f64, 96 | pub fee: f64, 97 | pub is_long: bool, 98 | pub duration: Option, 99 | pub oid: (u64, u64), 100 | } 101 | 102 | 103 | 104 | #[derive(Clone, Debug, Serialize)] 105 | #[serde(rename_all = "camelCase")] 106 | pub struct MarketTradeInfo{ 107 | pub asset: String, 108 | pub info: TradeInfo, 109 | } 110 | 111 | 112 | 113 | 114 | #[derive(Clone, Debug, Serialize, Deserialize)] 115 | #[serde(rename_all = "camelCase")] 116 | pub struct TradeFillInfo{ 117 | pub price: f64, 118 | pub fill_type: String, 119 | pub sz: f64, 120 | pub oid: u64, 121 | pub is_long: bool, } 122 | 123 | impl From for TradeFillInfo{ 124 | 125 | fn from(liq: LiquidationFillInfo) -> Self{ 126 | let LiquidationFillInfo {price, sz, oid, is_long} = liq; 127 | 128 | TradeFillInfo{ 129 | price, 130 | fill_type: "Liquidation".to_string(), 131 | sz, 132 | oid, 133 | is_long, 134 | } 135 | } 136 | } 137 | 138 | 139 | #[derive(Clone, Debug, Copy, Serialize, Deserialize)] 140 | #[serde(rename_all = "camelCase")] 141 | pub struct LiquidationFillInfo{ 142 | pub price: f64, 143 | pub sz: f64, 144 | pub oid: u64, 145 | pub is_long: bool, //was the user going long ? 146 | } 147 | 148 | 149 | 150 | impl From> for LiquidationFillInfo{ 151 | 152 | fn from(trades: Vec) -> Self{ 153 | let n = trades.len(); 154 | let is_long = match trades[0].side.as_str(){ 155 | "A" => true, 156 | "B" => false, 157 | _ => panic!("THIS IS INSANE"), 158 | }; 159 | 160 | let mut sz: f64 = f64::from_bits(1); 161 | let mut total: f64 = f64::from_bits(1); 162 | 163 | trades.iter().for_each(|t| { 164 | let size = t.sz.parse::().unwrap(); 165 | total += size * t.px.parse::().unwrap(); 166 | sz += size; 167 | }); 168 | 169 | let avg_px = total / sz; 170 | 171 | Self{ 172 | price: avg_px, 173 | sz, 174 | oid: 000000, 175 | is_long, 176 | } 177 | } 178 | } 179 | 180 | 181 | 182 | 183 | 184 | 185 | //TIME FRAME 186 | #[derive(Debug, Clone, Copy, PartialEq, Eq,Deserialize,Serialize, Hash)] 187 | #[serde(rename_all = "camelCase")] 188 | pub enum TimeFrame { 189 | Min1, 190 | Min3, 191 | Min5, 192 | Min15, 193 | Min30, 194 | Hour1, 195 | Hour2, 196 | Hour4, 197 | Hour12, 198 | Day1, 199 | Day3, 200 | Week, 201 | Month, 202 | } 203 | 204 | 205 | 206 | 207 | impl TimeFrame{ 208 | 209 | pub fn to_secs(&self) -> u64{ 210 | match *self { 211 | TimeFrame::Min1 => 1 * 60, 212 | TimeFrame::Min3 => 3 * 60, 213 | TimeFrame::Min5 => 5 * 60, 214 | TimeFrame::Min15 => 15 * 60, 215 | TimeFrame::Min30 => 30 * 60, 216 | TimeFrame::Hour1 => 1 * 60 * 60, 217 | TimeFrame::Hour2 => 2 * 60 * 60, 218 | TimeFrame::Hour4 => 4 * 60 * 60, 219 | TimeFrame::Hour12 => 12 * 60 * 60, 220 | TimeFrame::Day1 => 24 * 60 * 60, 221 | TimeFrame::Day3 => 3 * 24 * 60 * 60, 222 | TimeFrame::Week => 7 * 24 * 60 * 60, 223 | TimeFrame::Month => 30 * 24 * 60 * 60, // approximate month as 30 days 224 | } 225 | } 226 | 227 | pub fn to_millis(&self) -> u64{ 228 | self.to_secs() * 1000 229 | } 230 | 231 | 232 | } 233 | 234 | impl TimeFrame { 235 | pub fn as_str(&self) -> &'static str { 236 | match self { 237 | TimeFrame::Min1 => "1m", 238 | TimeFrame::Min3 => "3m", 239 | TimeFrame::Min5 => "5m", 240 | TimeFrame::Min15 => "15m", 241 | TimeFrame::Min30 => "30m", 242 | TimeFrame::Hour1 => "1h", 243 | TimeFrame::Hour2 => "2h", 244 | TimeFrame::Hour4 => "4h", 245 | TimeFrame::Hour12 => "12h", 246 | TimeFrame::Day1 => "1d", 247 | TimeFrame::Day3 => "3d", 248 | TimeFrame::Week => "w", 249 | TimeFrame::Month => "m", 250 | } 251 | } 252 | pub fn to_string(&self) -> String{ 253 | 254 | self.as_str().to_string() 255 | 256 | } 257 | 258 | } 259 | 260 | impl std::fmt::Display for TimeFrame { 261 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 262 | f.write_str(self.as_str()) 263 | } 264 | } 265 | 266 | 267 | 268 | impl std::str::FromStr for TimeFrame { 269 | 270 | type Err = String; 271 | fn from_str(s: &str) -> Result { 272 | 273 | match s { 274 | "1m" => Ok(TimeFrame::Min1), 275 | "3m" => Ok(TimeFrame::Min3), 276 | "5m" => Ok(TimeFrame::Min5), 277 | "15m" => Ok(TimeFrame::Min15), 278 | "30m" => Ok(TimeFrame::Min30), 279 | "1h" => Ok(TimeFrame::Hour1), 280 | "2h" => Ok(TimeFrame::Hour2), 281 | "4h" => Ok(TimeFrame::Hour4), 282 | "12h" => Ok(TimeFrame::Hour12), 283 | "1d" => Ok(TimeFrame::Day1), 284 | "3d" => Ok(TimeFrame::Day3), 285 | "w" => Ok(TimeFrame::Week), 286 | "m" => Ok(TimeFrame::Month), 287 | _ => Err(format!("Invalid TimeFrame string: '{}'", s)), 288 | } 289 | } 290 | } 291 | 292 | 293 | 294 | -------------------------------------------------------------------------------- /src/signal/types.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::Debug; 2 | use std::collections::HashMap; 3 | use std::sync::Arc; 4 | 5 | use std::hash::BuildHasherDefault; 6 | use rustc_hash::FxHasher; 7 | 8 | use arraydeque::{ArrayDeque, behavior::Wrapping}; 9 | use kwant::indicators::{Rsi, Atr, StochasticRsi, Price, Indicator, Ema, EmaCross, Sma, SmaRsi, Adx, Value}; 10 | 11 | use crate::trade_setup::TimeFrame; 12 | use crate::helper::get_time_now; 13 | use crate::MAX_HISTORY; 14 | use crate::IndicatorData; 15 | 16 | use serde::{Deserialize, Serialize}; 17 | 18 | #[derive(Debug, Copy, Clone)] 19 | pub struct ExecParams{ 20 | pub margin: f64, 21 | pub lev: u32, 22 | pub tf: TimeFrame, 23 | } 24 | 25 | impl ExecParams{ 26 | pub fn new(margin: f64, lev:u32, tf: TimeFrame)-> Self{ 27 | Self{ 28 | margin, 29 | lev, 30 | tf, 31 | } 32 | } 33 | } 34 | 35 | pub enum ExecParam{ 36 | Margin(f64), 37 | Lev(u32), 38 | Tf(TimeFrame), 39 | } 40 | 41 | 42 | #[derive(Debug, Clone,Copy, PartialEq, Eq, Hash, Deserialize, Serialize)] 43 | #[serde(rename_all = "camelCase")] 44 | pub enum IndicatorKind{ 45 | Rsi(u32), 46 | SmaOnRsi{periods: u32, smoothing_length: u32}, 47 | StochRsi{periods: u32, k_smoothing: Option, d_smoothing: Option}, 48 | Adx{periods: u32, di_length: u32}, 49 | Atr(u32), 50 | Ema(u32), 51 | EmaCross{short:u32, long:u32}, 52 | Sma(u32), 53 | } 54 | 55 | #[derive(Debug)] 56 | pub struct Handler{ 57 | pub indicator: Box, 58 | pub is_active: bool, 59 | } 60 | 61 | impl Handler{ 62 | 63 | pub fn new(indicator: IndicatorKind) -> Handler{ 64 | Handler{ 65 | indicator: match_kind(indicator), 66 | is_active: true, 67 | } 68 | } 69 | 70 | fn toggle(&mut self) -> bool{ 71 | self.is_active = !self.is_active; 72 | self.is_active 73 | } 74 | 75 | pub fn update(&mut self,price: Price, after_close: bool){ 76 | if !after_close{ 77 | self.indicator.update_before_close(price); 78 | }else{ 79 | self.indicator.update_after_close(price); 80 | } 81 | } 82 | pub fn get_value(&self) -> Option{ 83 | self.indicator.get_last() 84 | } 85 | 86 | pub fn load<'a,I: IntoIterator>(&mut self, price_data: I){ 87 | let data_vec: Vec = price_data.into_iter().copied().collect(); 88 | self.indicator.load(&data_vec); 89 | } 90 | 91 | pub fn reset(&mut self){ 92 | self.indicator.reset(); 93 | } 94 | 95 | } 96 | 97 | 98 | unsafe impl Send for Handler {} 99 | 100 | 101 | pub type IndexId = (IndicatorKind, TimeFrame); 102 | 103 | fn match_kind(kind: IndicatorKind) -> Box { 104 | match kind { 105 | IndicatorKind::Rsi (periods) => { 106 | Box::new(Rsi::new(periods, periods, None,None, None)) 107 | } 108 | IndicatorKind::SmaOnRsi{periods, smoothing_length} => { 109 | Box::new(SmaRsi::new(periods, smoothing_length)) 110 | } 111 | IndicatorKind::StochRsi{periods, k_smoothing, d_smoothing}=> { 112 | Box::new(StochasticRsi::new(periods, k_smoothing, d_smoothing)) 113 | } 114 | IndicatorKind::Adx { periods, di_length } => { 115 | Box::new(Adx::new(periods, di_length)) 116 | } 117 | IndicatorKind::Atr(periods) => { 118 | Box::new(Atr::new(periods)) 119 | } 120 | IndicatorKind::Ema(periods) => { 121 | Box::new(Ema::new(periods)) 122 | } 123 | IndicatorKind::EmaCross { short, long } => { 124 | Box::new(EmaCross::new(short, long)) 125 | } 126 | IndicatorKind::Sma(periods) => { 127 | Box::new(Sma::new(periods)) 128 | } 129 | } 130 | } 131 | 132 | 133 | type History = Box>; 134 | 135 | #[derive(Debug)] 136 | pub struct Tracker{ 137 | pub price_data: History, 138 | pub indicators: HashMap>, 139 | tf: TimeFrame, 140 | next_close: u64, 141 | } 142 | 143 | 144 | 145 | impl Tracker{ 146 | pub fn new(tf: TimeFrame) -> Self{ 147 | Tracker{ 148 | price_data: Box::new(ArrayDeque::new()), 149 | indicators: HashMap::default(), 150 | tf, 151 | next_close: Self::calc_next_close(tf), 152 | } 153 | } 154 | 155 | 156 | pub fn digest(&mut self, price: Price){ 157 | let time = get_time_now(); 158 | 159 | if time >= self.next_close{ 160 | self.next_close = Self::calc_next_close(self.tf); 161 | self.price_data.push_back(price); 162 | self.update_indicators(price, true); 163 | }else{ 164 | self.update_indicators(price, false); 165 | } 166 | 167 | } 168 | 169 | fn update_indicators(&mut self,price: Price, after_close: bool){ 170 | 171 | for (_kind, handler) in &mut self.indicators{ 172 | handler.update(price, after_close); 173 | } 174 | } 175 | 176 | fn calc_next_close(tf: TimeFrame)-> u64 { 177 | let now = get_time_now(); 178 | 179 | let tf_ms = tf.to_millis(); 180 | ((now / tf_ms) + 1) * tf_ms 181 | } 182 | 183 | 184 | pub async fn load>(&mut self, price_data: I){ 185 | let buffer: Vec = price_data.into_iter().collect(); 186 | let safe_buff: Arc<[Price]> = buffer.clone().into(); 187 | 188 | let mut handles: Vec> = Vec::new(); 189 | let mut temp_handlers = std::mem::take(&mut self.indicators); 190 | 191 | for (kind, mut handler) in temp_handlers{ 192 | let buff = safe_buff.clone(); 193 | 194 | let handle = tokio::spawn(async move{ 195 | handler.load(&*buff); 196 | (kind, handler) 197 | }); 198 | 199 | handles.push(handle); 200 | } 201 | 202 | let new_indicators: HashMap> = futures::future::join_all(handles) 203 | .await 204 | .into_iter() 205 | .map(Result::unwrap) // unwrap JoinHandle 206 | .collect(); 207 | 208 | self.indicators = new_indicators; 209 | self.price_data.extend(buffer); 210 | } 211 | 212 | 213 | pub fn add_indicator(&mut self, kind: IndicatorKind, load: bool){ 214 | let mut handler = Handler::new(kind); 215 | if load{ 216 | handler.load(&*self.price_data); 217 | } 218 | self.indicators.insert(kind, handler); 219 | } 220 | 221 | pub fn remove_indicator(&mut self, kind: IndicatorKind){ 222 | self.indicators.remove(&kind); 223 | } 224 | 225 | pub fn toggle_indicator(&mut self, kind: IndicatorKind){ 226 | if let Some(handler) = self.indicators.get_mut(&kind){ 227 | let _ = handler.toggle(); 228 | } 229 | } 230 | 231 | pub fn get_active_values(&self) -> Vec{ 232 | let mut values = Vec::new(); 233 | for (_kind, handler) in &self.indicators{ 234 | if let Some(val) = handler.get_value(){ 235 | values.push(val); 236 | } 237 | } 238 | values 239 | } 240 | 241 | 242 | pub fn get_indicators_data(&self) -> Vec{ 243 | let mut values = Vec::new(); 244 | for (kind, handler) in &self.indicators{ 245 | if let Some(val) = handler.get_value(){ 246 | values.push( 247 | IndicatorData{ 248 | id: (*kind, self.tf), 249 | value: Some(val), 250 | } 251 | ); 252 | } 253 | } 254 | values 255 | } 256 | 257 | pub fn reset(&mut self){ 258 | self.price_data.clear(); 259 | for (_kind, handler) in &mut self.indicators{ 260 | handler.reset(); 261 | } 262 | } 263 | 264 | } 265 | 266 | 267 | 268 | pub type TimeFrameData = HashMap>; 269 | 270 | #[derive(Copy, Clone, Debug,PartialEq, Deserialize)] 271 | #[serde(rename_all = "camelCase")] 272 | pub struct Entry{ 273 | pub id: IndexId, 274 | pub edit: EditType 275 | } 276 | 277 | #[derive(Copy, Clone, Debug, Deserialize, PartialEq)] 278 | #[serde(rename_all = "camelCase")] 279 | pub enum EditType{ 280 | Toggle, 281 | Add, 282 | Remove, 283 | } 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | -------------------------------------------------------------------------------- /src/bin/enginetest.rs: -------------------------------------------------------------------------------- 1 | #![allow(unused_imports)] 2 | #![allow(unused_mut)] 3 | #![allow(unused_variables)] 4 | #![allow(dead_code)] 5 | 6 | use std::{ 7 | env, fs, 8 | str::FromStr, 9 | }; 10 | 11 | // 12 | use dotenv::dotenv; 13 | use log::info; 14 | use std::sync::Arc; 15 | use hyperliquid_rust_sdk::Error; 16 | use hyperliquid_rust_bot::{ 17 | Bot, 18 | BotEvent, 19 | MarginAllocation, 20 | AssetMargin, 21 | BotToMarket, 22 | MarketCommand, 23 | IndexId, Entry, EditType, IndicatorKind, 24 | MARKETS, 25 | TradeParams,TimeFrame, AddMarketInfo, UpdateFrontend, 26 | 27 | LocalWallet, Wallet, BaseUrl, 28 | }; 29 | use hyperliquid_rust_bot::strategy::{Strategy, CustomStrategy, Risk, Style, Stance}; 30 | 31 | use tokio::{ 32 | sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}, 33 | time::{sleep, Duration}, 34 | }; 35 | 36 | 37 | const COIN: &str = "BTC"; 38 | const URL: BaseUrl = BaseUrl::Mainnet; 39 | 40 | #[tokio::main] 41 | async fn main() -> Result<(), Error>{ 42 | use IndicatorKind::*; 43 | env_logger::init(); 44 | match URL{ 45 | BaseUrl::Mainnet => dotenv().ok(), 46 | BaseUrl::Testnet => dotenv::from_filename("testnet").ok(), 47 | BaseUrl::Localhost => dotenv::from_filename(".env.test").ok(), 48 | }; 49 | let wallet = load_wallet(BaseUrl::Mainnet).await?; 50 | let strat = Strategy::Custom(load_strategy("./config.toml")); 51 | 52 | let trade_params = TradeParams{ 53 | strategy: strat, 54 | lev: 20, 55 | trade_time: 300, 56 | time_frame: TimeFrame::from_str("5m").unwrap_or(TimeFrame::Min1), 57 | 58 | }; 59 | 60 | let config = Vec::from([ 61 | ( 62 | IndicatorKind::Rsi(12), 63 | TimeFrame::Min1, 64 | ), 65 | ( 66 | IndicatorKind::SmaOnRsi{periods: 14, smoothing_length: 9}, 67 | TimeFrame::Hour1, 68 | ), 69 | ( 70 | IndicatorKind::StochRsi{periods: 16,k_smoothing: Some(4), d_smoothing: Some(4)}, 71 | TimeFrame::Hour4, 72 | ), 73 | 74 | ( 75 | IndicatorKind::EmaCross{short: 21, long: 200}, 76 | TimeFrame::Day1, 77 | ), 78 | ( 79 | IndicatorKind::Adx { 80 | periods: 14, 81 | di_length: 14, 82 | }, 83 | TimeFrame::Min5, 84 | ), 85 | ( 86 | IndicatorKind::Atr(14), 87 | TimeFrame::Min15, 88 | ), 89 | ( 90 | IndicatorKind::Sma(50), 91 | TimeFrame::Hour1, 92 | ), 93 | ]); 94 | 95 | let (app_tx, mut app_rv) = unbounded_channel::(); 96 | 97 | let (mut bot, sender) = Bot::new(wallet).await?; 98 | 99 | tokio::spawn(async move { 100 | bot.start(app_tx).await; 101 | }); 102 | 103 | 104 | 105 | tokio::spawn(async move { 106 | let market_add = AddMarketInfo{ 107 | asset: COIN.to_string(), 108 | margin_alloc: MarginAllocation::Alloc(0.1), 109 | trade_params: trade_params.clone(), 110 | config: Some(config), 111 | }; 112 | let market_add2 = AddMarketInfo{ 113 | asset: "SOL".to_string(), 114 | margin_alloc: MarginAllocation::Alloc(0.1), 115 | trade_params: TradeParams::default(), 116 | config: None, 117 | }; 118 | let market_add3 = AddMarketInfo{ 119 | asset: "xrp ".to_string(), 120 | margin_alloc: MarginAllocation::Amount(50.0), 121 | trade_params: trade_params, 122 | config: None, 123 | }; 124 | let cmd = BotToMarket{ 125 | asset:"BTC".to_string(), 126 | cmd: MarketCommand::UpdateLeverage(40), 127 | }; 128 | 129 | let cmd2 = BotToMarket{ 130 | asset: "SOL".to_string(), 131 | cmd: MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(33), TimeFrame::Hour4),edit: EditType::Add}])), 132 | }; 133 | 134 | let cmd3 = BotToMarket{ 135 | asset: "XRP".to_string(), 136 | cmd: MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(33), TimeFrame::Hour4),edit: EditType::Toggle}, 137 | Entry{id: (Rsi(12), TimeFrame::Min1),edit: EditType::Add}, 138 | ]) 139 | ), 140 | }; 141 | 142 | let _ = sleep(Duration::from_secs(5)).await; 143 | sender.send(BotEvent::AddMarket(market_add.clone())); 144 | let _ = sleep(Duration::from_secs(5)).await; 145 | sender.send(BotEvent::AddMarket(market_add2)); 146 | sender.send(BotEvent::AddMarket(market_add3)); 147 | //let _ = sleep(Duration::from_secs(20)).await; 148 | //sender.send(BotEvent::RemoveMarket("BTC".to_string())); 149 | let _ = sleep(Duration::from_secs(5)).await; 150 | sender.send(BotEvent::MarketComm(cmd)); 151 | sender.send(BotEvent::MarketComm(cmd2)); 152 | let _ = sleep(Duration::from_secs(5)).await; 153 | sender.send(BotEvent::MarketComm(cmd3)); 154 | let _ = sleep(Duration::from_secs(10)).await; 155 | 156 | sender.send(BotEvent::PauseAll); 157 | let _ = sleep(Duration::from_secs(10)).await; 158 | sender.send(BotEvent::ResumeAll); 159 | let _ = sleep(Duration::from_secs(10)).await; 160 | sender.send(BotEvent::CloseAll); 161 | let _ = sleep(Duration::from_secs(10)).await; 162 | sender.send(BotEvent::AddMarket(market_add)); 163 | }); 164 | 165 | 166 | while let Some(update) = app_rv.recv().await{ 167 | info!("FRONT END RECEIVED {:?}", update); 168 | } 169 | 170 | /* tokio::spawn(async move{ 171 | 172 | /*let _ = sleep(Duration::from_secs(10)).await; 173 | sender.send(MarketCommand::UpdateLeverage(50)).await; 174 | let _ = sleep(Duration::from_secs(10)).await; 175 | sender.send(MarketCommand::UpdateLeverage(40)).await;*/ 176 | 177 | //let _ = sleep(Duration::from_secs(120)).await; 178 | //sender.send(MarketCommand::Pause).await; 179 | let _ = sleep(Duration::from_secs(20)).await; 180 | //sender.send(MarketCommand::UpdateTimeFrame(TimeFrame::from_str("4h").unwrap())).await; 181 | let _ = sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(33), TimeFrame::Hour1),edit: EditType::Add}, 182 | Entry{id: (SmaOnRsi{periods: 12, smoothing_length: 9}, TimeFrame::Min1),edit: EditType::Add} 183 | ]))).await; 184 | 185 | let _ = sleep(Duration::from_secs(20)).await; 186 | let _ = sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(33), TimeFrame::Hour4),edit: EditType::Add}]))).await; 187 | let _ = sleep(Duration::from_secs(10)).await; 188 | let _ = sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(33), TimeFrame::Hour1),edit: EditType::Toggle}]))).await; 189 | 190 | let _ = sleep(Duration::from_secs(20)).await; 191 | let _ = sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Sma(10), TimeFrame::Min5),edit: EditType::Add}]))).await; 192 | let _ = sleep(Duration::from_secs(20)).await; 193 | sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Ema(10), TimeFrame::Hour4),edit: EditType::Remove}, 194 | Entry{id: (Sma(10), TimeFrame::Min5),edit: EditType::Remove}, 195 | Entry{id: (Atr(14), TimeFrame::Min15),edit: EditType::Remove}, 196 | Entry{id: (Rsi(12), TimeFrame::Min1),edit: EditType::Toggle} 197 | ]))).await; 198 | let _ = sleep(Duration::from_secs(30)).await; 199 | let _ = sender.send(MarketCommand::EditIndicators(Vec::from([]))).await; 200 | let _ =sender.send(MarketCommand::EditIndicators(Vec::from([Entry{id: (Rsi(12), TimeFrame::Min1),edit: EditType::Toggle}]))).await; 201 | let _ = sleep(Duration::from_secs(100000)).await; 202 | sender.send(MarketCommand::Close).await; 203 | //let _ = sleep(Duration::from_secs(30)).await; 204 | //let _ = sender.send(MarketCommand::Close).await; 205 | }); 206 | */ 207 | 208 | Ok(()) 209 | } 210 | 211 | 212 | 213 | 214 | fn load_strategy(path: &str) -> CustomStrategy { 215 | let content = fs::read_to_string(path).expect("failed to read file"); 216 | toml::from_str(&content).expect("failed to parse toml") 217 | } 218 | 219 | 220 | async fn load_wallet(url: BaseUrl) -> Result{ 221 | let wallet = std::env::var("PRIVATE_KEY").expect("Error fetching PRIVATE_KEY") 222 | .parse(); 223 | 224 | if let Err(ref e) = wallet{ 225 | return Err(Error::Custom(format!("Failed to load wallet: {}", e))); 226 | } 227 | let pubkey: String = std::env::var("WALLET").expect("Error fetching WALLET address"); 228 | Ok(Wallet::new(url , pubkey, wallet.unwrap()).await?) 229 | } 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | -------------------------------------------------------------------------------- /src/signal/signal.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | use std::hash::BuildHasherDefault; 3 | use rustc_hash::FxHasher; 4 | 5 | use log::info; 6 | 7 | use kwant::indicators::{Price, Indicator, Value}; 8 | 9 | use crate::trade_setup::{TimeFrame,TradeParams, TradeCommand}; 10 | use crate::strategy::Strategy; 11 | use crate::{IndicatorData, MarketCommand}; 12 | 13 | use tokio::sync::mpsc::{UnboundedReceiver, Sender as tokioSender, unbounded_channel}; 14 | use flume::{Sender, bounded}; 15 | 16 | use super::types::{ 17 | Tracker, 18 | IndexId, 19 | ExecParam, 20 | ExecParams, 21 | TimeFrameData, 22 | EditType, 23 | Entry, 24 | }; 25 | 26 | 27 | pub struct SignalEngine{ 28 | engine_rv: UnboundedReceiver, 29 | trade_tx: Sender, 30 | data_tx: Option>, 31 | trackers: HashMap, BuildHasherDefault>, 32 | strategy: Strategy, 33 | exec_params: ExecParams, 34 | } 35 | 36 | 37 | 38 | impl SignalEngine{ 39 | 40 | pub async fn new( 41 | config: Option>, 42 | trade_params: TradeParams, 43 | engine_rv: UnboundedReceiver, 44 | data_tx: Option>, 45 | trade_tx: Sender, 46 | margin: f64, 47 | ) -> Self{ 48 | let mut trackers:HashMap, BuildHasherDefault> = HashMap::default(); 49 | trackers.insert(trade_params.time_frame, Box::new(Tracker::new(trade_params.time_frame))); 50 | 51 | if let Some(list) = config{ 52 | if !list.is_empty(){ 53 | for id in list{ 54 | if let Some(tracker) = &mut trackers.get_mut(&id.1){ 55 | tracker.add_indicator(id.0, false); 56 | }else{ 57 | let mut new_tracker = Tracker::new(id.1); 58 | new_tracker.add_indicator(id.0, false); 59 | trackers.insert(id.1, Box::new(new_tracker)); 60 | } 61 | } 62 | }}; 63 | 64 | SignalEngine{ 65 | engine_rv, 66 | trade_tx, 67 | data_tx, 68 | trackers, 69 | strategy: trade_params.strategy, 70 | exec_params: ExecParams::new(margin, trade_params.lev, trade_params.time_frame), 71 | } 72 | } 73 | 74 | pub fn reset(&mut self){ 75 | for (_tf, tracker) in &mut self.trackers{ 76 | tracker.reset(); 77 | } 78 | } 79 | 80 | 81 | pub fn add_indicator(&mut self, id: IndexId){ 82 | if let Some(tracker) = &mut self.trackers.get_mut(&id.1){ 83 | tracker.add_indicator(id.0, true); 84 | }else{ 85 | let mut new_tracker = Tracker::new(id.1); 86 | new_tracker.add_indicator(id.0, false); 87 | self.trackers.insert(id.1, Box::new(new_tracker)); 88 | } 89 | } 90 | 91 | pub fn remove_indicator(&mut self, id: IndexId){ 92 | if let Some(tracker) = &mut self.trackers.get_mut(&id.1){ 93 | tracker.remove_indicator(id.0); 94 | } 95 | } 96 | 97 | pub fn toggle_indicator(&mut self, id: IndexId){ 98 | if let Some(tracker) = &mut self.trackers.get_mut(&id.1){ 99 | tracker.toggle_indicator(id.0); 100 | } 101 | } 102 | 103 | pub fn get_active_indicators(&self) -> Vec{ 104 | let mut active = Vec::new(); 105 | for (tf, tracker) in &self.trackers{ 106 | for (kind, handler) in &tracker.indicators{ 107 | if handler.is_active{ 108 | active.push((*kind, *tf)); 109 | } 110 | } 111 | } 112 | active 113 | } 114 | 115 | pub fn get_active_values(&self) -> Vec{ 116 | let mut values = Vec::new(); 117 | for (_tf, tracker) in &self.trackers{ 118 | values.extend(tracker.get_active_values()); 119 | } 120 | values 121 | } 122 | 123 | pub fn get_indicators_data(&self) -> Vec{ 124 | let mut values = Vec::new(); 125 | for (_tf, tracker) in &self.trackers{ 126 | values.extend(tracker.get_indicators_data()); 127 | } 128 | values 129 | } 130 | 131 | pub fn display_values(&self){ 132 | for (tf, tracker) in &self.trackers{ 133 | for (kind, handler) in &tracker.indicators{ 134 | if handler.is_active{ 135 | info!("\nKind: {:?} TF: {}\nValue: {:?}\n", kind, tf.as_str(), handler.get_value()); 136 | } 137 | } 138 | } 139 | } 140 | 141 | pub fn change_strategy(&mut self, strategy: Strategy){ 142 | self.strategy = strategy; 143 | info!("Strategy changed to: {:?}", self.strategy); 144 | } 145 | 146 | pub fn get_strategy(&self) -> &Strategy{ 147 | &self.strategy 148 | } 149 | 150 | pub async fn load>(&mut self,tf: TimeFrame, price_data: I) { 151 | if let Some(tracker) = self.trackers.get_mut(&tf){ 152 | tracker.load(price_data).await 153 | } 154 | } 155 | 156 | 157 | fn get_signal(&self, price: f64, values: Vec) -> Option{ 158 | 159 | match self.strategy{ 160 | Strategy::Custom(brr) => brr.generate_signal(values, price, self.exec_params) 161 | } 162 | } 163 | 164 | } 165 | 166 | impl SignalEngine{ 167 | 168 | pub async fn start(&mut self){ 169 | 170 | let mut tick: u64 = 0; 171 | 172 | while let Some(cmd) = self.engine_rv.recv().await{ 173 | 174 | match cmd { 175 | 176 | EngineCommand::UpdatePrice(price) => { 177 | for (_tf, tracker) in &mut self.trackers{ 178 | tracker.digest(price); 179 | } 180 | 181 | //self.display_indicators(price.close); 182 | let ind = self.get_indicators_data(); 183 | let values: Vec = ind.iter().filter_map(|t| t.value).collect(); 184 | 185 | if tick % 5 == 0{ 186 | if let Some(sender) = &self.data_tx{ 187 | sender.send(MarketCommand::UpdateIndicatorData(ind)).await; 188 | } 189 | } 190 | 191 | if let Some(trade) = self.get_signal(price.close, values){ 192 | let _ = self.trade_tx.try_send(trade); 193 | } 194 | 195 | tick += 1; 196 | }, 197 | 198 | EngineCommand::UpdateStrategy(new_strat) =>{ 199 | self.change_strategy(new_strat); 200 | }, 201 | 202 | 203 | EngineCommand::EditIndicators{indicators, price_data} =>{ 204 | info!("Received Indicator Edit Vec of length : {}", indicators.len()); 205 | 206 | 207 | for entry in indicators{ 208 | match entry.edit{ 209 | EditType::Add => { self.add_indicator(entry.id);}, 210 | EditType::Remove => {self.remove_indicator(entry.id);}, 211 | EditType::Toggle => {self.toggle_indicator(entry.id)}, 212 | } 213 | } 214 | if let Some(data) = price_data{ 215 | for (tf, prices) in data{ 216 | self.load(tf, prices); 217 | } 218 | } 219 | 220 | } 221 | 222 | EngineCommand::UpdateExecParams(param)=>{ 223 | use ExecParam::*; 224 | match param{ 225 | Margin(m)=>{ 226 | self.exec_params.margin = m; 227 | }, 228 | Lev(l) => { 229 | self.exec_params.lev = l; 230 | }, 231 | Tf(t) => { 232 | self.exec_params.tf = t; 233 | }, 234 | } 235 | }, 236 | 237 | EngineCommand::Stop =>{ 238 | return; 239 | }, 240 | } 241 | } 242 | } 243 | 244 | pub fn display_indicators(&mut self, price: f64){ 245 | info!("\nPrice => {}\n", price); 246 | //let vec = self.get_active_indicators(); 247 | self.display_values(); 248 | //Update 249 | } 250 | 251 | 252 | 253 | pub fn new_backtest(trade_params: TradeParams, config: Option>, margin: f64) -> Self{ 254 | let mut trackers:HashMap, BuildHasherDefault> = HashMap::default(); 255 | trackers.insert(trade_params.time_frame, Box::new(Tracker::new(trade_params.time_frame))); 256 | 257 | if let Some(list) = config{ 258 | if !list.is_empty(){ 259 | for id in list{ 260 | if let Some(tracker) = &mut trackers.get_mut(&id.1){ 261 | tracker.add_indicator(id.0, false); 262 | }else{ 263 | let mut new_tracker = Tracker::new(id.1); 264 | new_tracker.add_indicator(id.0, false); 265 | trackers.insert(id.1, Box::new(new_tracker)); 266 | } 267 | } 268 | }} 269 | 270 | 271 | //channels won't be used in backtesting, these are placeholders 272 | let (_tx, dummy_rv) = unbounded_channel::(); 273 | let (dummy_tx, _rx) = bounded::(0); 274 | 275 | SignalEngine{ 276 | engine_rv: dummy_rv, 277 | trade_tx: dummy_tx, 278 | data_tx: None, 279 | trackers, 280 | strategy: trade_params.strategy, 281 | exec_params: ExecParams{margin, lev: trade_params.lev, tf: trade_params.time_frame}, 282 | } 283 | } 284 | } 285 | 286 | 287 | 288 | 289 | pub enum EngineCommand{ 290 | 291 | UpdatePrice(Price), 292 | UpdateStrategy(Strategy), 293 | EditIndicators{indicators: Vec,price_data: Option}, 294 | UpdateExecParams(ExecParam), 295 | Stop, 296 | } 297 | 298 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | -------------------------------------------------------------------------------- /src/frontend/interface/src/components/AddMarket.tsx: -------------------------------------------------------------------------------- 1 | import React, { useState, useMemo } from 'react'; 2 | import { into, TIMEFRAME_CAMELCASE, indicatorLabels, indicatorColors } from '../types'; 3 | import type { 4 | TimeFrame, 5 | Risk, 6 | Style, 7 | Stance, 8 | CustomStrategy, 9 | TradeParams, 10 | AddMarketInfo, 11 | IndexId, 12 | IndicatorKind, 13 | AddMarketProps, 14 | } from '../types'; 15 | 16 | const riskOptions: Risk[] = ['Low', 'Normal', 'High']; 17 | const styleOptions: Style[] = ['Scalp', 'Swing']; 18 | const stanceOptions: Stance[] = ['Bull', 'Bear', 'Neutral']; 19 | const indicatorKinds: IndicatorKind[] = ['rsi', 'smaOnRsi', 'stochRsi', 'adx', 'atr', 'ema', 'emaCross', 'sma']; 20 | 21 | export const AddMarket: React.FC = ({ onClose, totalMargin }) => { 22 | const [asset, setAsset] = useState(''); 23 | const [marginType, setMarginType] = useState<'alloc' | 'amount'>('alloc'); 24 | const [marginValue, setMarginValue] = useState(0.1); 25 | const [tfSymbol, setTfSymbol] = useState('1m'); 26 | const [lev, setLev] = useState(1); 27 | const [tradeTime, setTradeTime] = useState(0); 28 | const [risk, setRisk] = useState('Low'); 29 | const [style, setStyle] = useState 255 |