25 |
26 |
27 |
28 |
29 | GIF is rendered at 10fps, can't upload larger size for some reason, but it's really much faster than how it looks here
30 |
31 |
32 |
33 |
34 |
35 | * **Lock-free**: Lock-free data structures have significantly higher throughput (no contention) as well as lower latencies as compared to alternatives that use locks under periods of heavy load.
36 | * **Real-Time**: Utilizes Barter-Data with real-time WebSocket integrations enabling the consumption of normalised tick-by-tick data.
37 | * **Multithreaded**: Uses the **[fork-join model](https://en.wikipedia.org/wiki/Fork%E2%80%93join_model)** for delegating non-blocking market event streams into different worker threads.
38 | * **High-throughput**: Uses crossbeam's unbounded MPMC channel under the hood, benchmarked to support _10 million_ market events **per second**.
39 |
40 | ## Technologies used
41 | - [Tokio](https://crates.io/crates/tokio) ([Tonic](https://github.com/hyperium/tonic) & [Tungstenite](https://github.com/snapview/tokio-tungstenite))
42 | - [Barter-data](https://crates.io/crates/barter-data)
43 | - [Barter-integration](https://crates.io/crates/barter-integration)
44 | - [egui](https://crates.io/crates/egui)
45 | - [futures](https://crates.io/crates/futures)
46 | - [Serde](https://serde.rs/)
47 |
48 | ## Getting started
49 | Just clone it and run it bro it's easy. No more CMake shenanigans 😊.
50 | ```rust
51 | cargo run
52 | ```
53 |
54 | ## 🛣️ Roadmap
55 | - Tracing subscriber for debugging and async-aware diagnostics.
56 | - Notifications (PARTIALLY DONE): See [egui-notify branch](https://github.com/g-tejas/enigma/tree/egui-notify)
57 | - Tabs and Workspace functionality to preserve layouts for traders. [Like this](https://discord.com/channels/900275882684477440/904461220592119849/1012443669451776041) is what I mean.
58 | - Improve multi-threading by delegating and scheduling new jobs to pre-initialized worker thread pool.
59 | - More widgets: Look at the [widget branch](https://github.com/g-tejas/enigma/tree/master/src/widgets) for more deets. (e.g Liquidity heatmap, watchlist)
60 | - Especially this one
61 |
62 | https://user-images.githubusercontent.com/76802638/209623672-22191104-5f69-47c7-a359-19326c5f8c14.mp4
63 |
64 |
65 | ## 📚 Resources / Other stuff
66 | - [Naming conventions](https://rust-lang.github.io/api-guidelines/naming.html)
67 | - [Egui navigation: basic centralpanel, layout stuff](https://github.com/mikael-nilsson-github/rust-egui-basic-navigation)
68 | - [Egui, to spawn separate thread for loading data](https://github.com/mikael-nilsson-github/egui-alpaca-crypto-trading)
69 | - [Egui + Reqwest + Tokio + Alpaca](https://github.com/mikael-nilsson-github/egui-async-reqwest-tokio-alpaca/blob/main/src/main.rs)
70 | - [Parasyte Tokio Original implementation](https://github.com/parasyte/egui-tokio-example/blob/main/src/main.rs)
71 | - [Chartbot by SwayStar (but it's not multithreaded)](https://github.com/SwayStar123/chart_bot/blob/master/src/chartbot.rs): For drawing lines on plots and loading data from csv.
72 |
--------------------------------------------------------------------------------
/resources/ProggyClean.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/g-tejas/enigma-rs/c18d5152f3d6cecd10d60d785c74bd91a5907e95/resources/ProggyClean.ttf
--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | edition = "2021"
2 |
3 |
--------------------------------------------------------------------------------
/src/README.md:
--------------------------------------------------------------------------------
1 | # The async drama
2 | [The original discussion](https://github.com/emilk/egui/discussions/521)
3 |
4 | Because Egui is immediate mode (updated 60 times every second or smth), async stuff works differently.
5 | We want to update our UI using data from websocket feeds. But some of this stuff is blocking, so we can't run
6 | the websocket stuff on the same thread as the main thread (the one running the egui frame). Otherwise, our await on websocket feeds would simply block the GUI process and it'd run super slow.
7 |
8 | Solution:
9 | It's possible, you just have to run the async runtime off the main thread (because most operating systems want the main thread to handle UI events, and the event loop blocks). You can spawn the tokio executor in a thread instead of trying to transform the main function into an async function with the #[tokio::main] proc macro.
10 |
11 | [Example implementation](https://github.com/parasyte/egui-tokio-example/blob/main/src/main.rs)
12 | [Plotting time series using this method](https://github.com/mikael-nilsson-github/egui-alpaca-crypto-trading/blob/main/src/app.rs)
13 |
14 | `26/12`: Trying to figure how to do it via the MPSC method to make the program lock-free and run faster. We need to initialize the channel within Machine::default()
15 |
16 | `27/12`: Lock-free concurrency with `std::sync::mpsc` implemented. A new tokio runtime is initiated in the main fn and pressing the "Connect" button spawns a new thread that will run the websocket loop. It's also passed a tx, which is the transmitter. The channel is instantiated in Machine::default(). The websocket messages are passed to the rx, receiver that will be handled in the App::update() loop, with `try_recv` and update the data accordingly.
17 | Plan is to append to a VecDeque or something.
18 |
19 | `28/12`: parasyte replied to my issue [here](https://github.com/parasyte/egui-tokio-example/issues/1). Basically, he suggested that in order to stop the spawned threads, u can simply pass in a "stop event" channel, that will listen for stop events. But leave this to the end, because, it's very unlikely we will hit any sort of performance issue this early.
20 |
21 |
22 | # Todo List
23 | - [ ] Persistence, with serde. Make sure not to serialize the fields containing marketevents. There's some #[dont serialize] i think.
24 | - [ ] OHLCV is messed up, need to fix the x axis and stuff.
25 | `01/01`: Need to add
--------------------------------------------------------------------------------
/src/app.rs:
--------------------------------------------------------------------------------
1 | use crate::defines::*;
2 | use crate::{
3 | defines, utils,
4 | widgets::{self, Widget},
5 | };
6 | use barter_data::model::{DataKind, MarketEvent};
7 | use eframe::egui;
8 | use eframe::egui::plot::PlotPoint;
9 | use egui_notify::Toasts;
10 | use std::collections::{HashMap, HashSet, VecDeque};
11 | use std::sync::mpsc::{Receiver, Sender};
12 | use std::time::Duration;
13 |
14 | // TODO: Add unique identifier to widget names OrderBook::spot::BTCUSD for example.
15 | // This is so we can have multiple orderbooks up at the same time
16 | #[allow(dead_code)]
17 | pub struct State<'a> {
18 | // Style-related fields
19 | open_tabs: HashSet,
20 | style: Option,
21 | lock_layout: bool,
22 |
23 | // Lock-free! Channel
24 | tx: Sender,
25 | rx: Receiver,
26 |
27 | // Widgets
28 | gizmos: HashMap<&'a str, Box>,
29 |
30 | // Vector of pointers to a trait value Widget, might change to Hashmap
31 | trades: VecDeque,
32 | candles: VecDeque,
33 | //orderbooks: VecDeque,
34 | best_bids: VecDeque,
35 | best_asks: VecDeque,
36 | liquidations: VecDeque,
37 |
38 | // Notifications
39 | toasts: Toasts,
40 | events_tx: Sender,
41 | events_rx: Receiver,
42 | }
43 |
44 | impl egui_dock::TabViewer for State<'_> {
45 | type Tab = String;
46 |
47 | fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
48 | // let final_result = self.gizmos.get_mut(tab.as_str());
49 | match self.gizmos.get_mut(tab.as_str()) {
50 | Some(widget) => widget.show(
51 | ui,
52 | self.tx.clone(),
53 | self.events_tx.clone(),
54 | &mut self.trades,
55 | &mut self.candles,
56 | &mut self.best_bids,
57 | &mut self.best_asks,
58 | &mut self.liquidations,
59 | ),
60 | _ => {
61 | ui.heading("NO WIDGET FOUND");
62 | }
63 | }
64 | }
65 |
66 | // when you right click a tab
67 | fn context_menu(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
68 | match self.gizmos.get_mut(tab.as_str()) {
69 | Some(widget) => widget.context_menu(ui),
70 | _ => {
71 | ui.label("No context menu found");
72 | }
73 | }
74 | }
75 |
76 | fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
77 | tab.as_str().into()
78 | }
79 |
80 | fn on_close(&mut self, tab: &mut Self::Tab) -> bool {
81 | self.open_tabs.remove(tab);
82 | true
83 | }
84 | }
85 |
86 | // impl State<'_> {
87 | // // The only things that should be stored here are styling / open_tabs related stuff
88 | // // since the things that can be accessed from self, are very limited. Or we can store the financial
89 | // // data here itself.
90 | // }
91 |
92 | pub struct Machine<'a> {
93 | state: State<'a>,
94 | tree: egui_dock::Tree,
95 | ping: i64,
96 | }
97 |
98 | impl Machine<'_> {
99 | pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
100 | #[allow(unused_mut)]
101 | let mut default = Self::default();
102 |
103 | #[cfg(feature = "persistence")]
104 | if let Some(storage) = cc.storage {
105 | if let Some(state) = eframe::get_value(storage, eframe::APP_KEY) {
106 | default.state = state;
107 | }
108 | }
109 | utils::configure_fonts(&cc.egui_ctx);
110 | default
111 | }
112 | }
113 |
114 | impl Default for Machine<'_> {
115 | // Default Layout
116 | fn default() -> Self {
117 | let mut tree = egui_dock::Tree::new(vec![
118 | MICROSTRUCTURE_TITLE.to_owned(),
119 | SETTINGS_TITLE.to_owned(),
120 | ]);
121 | let [a, b] = tree.split_left(
122 | egui_dock::NodeIndex::root(),
123 | 0.2,
124 | vec![AGGR_TRADES_TITLE.to_owned()],
125 | );
126 | let [_, _] = tree.split_below(b, 0.5, vec![AGGR_LIQS_TITLE.to_owned()]);
127 | let [_, _] = tree.split_below(a, 0.5, vec![CHART_TITLE.to_owned()]);
128 | let mut open_tabs = HashSet::new();
129 | for node in tree.iter() {
130 | if let egui_dock::Node::Leaf { tabs, .. } = node {
131 | for tab in tabs {
132 | open_tabs.insert(tab.clone());
133 | }
134 | }
135 | }
136 |
137 | // Create channel for different components to communicate
138 | let (tx, rx) = std::sync::mpsc::channel();
139 | let (events_tx, events_rx) = std::sync::mpsc::channel();
140 |
141 | // Create a Hashmap of widgets
142 | let aggr_trades_widget: Box =
143 | Box::new(widgets::aggr_trades::AggrTrades::default());
144 | let aggr_liqs_widget: Box =
145 | Box::new(widgets::aggr_liqs::AggrLiquidations::default());
146 | let chart_widget: Box = Box::new(widgets::chart::Chart::default());
147 | let settings_widget: Box = Box::new(widgets::settings::Settings::default());
148 | let dom_widget: Box =
149 | Box::new(widgets::microstructure::MicrostructureBrowser::default());
150 |
151 | let mut gizmos: HashMap<&str, Box> = HashMap::new();
152 | gizmos.insert(aggr_trades_widget.name(), aggr_trades_widget);
153 | gizmos.insert(chart_widget.name(), chart_widget);
154 | gizmos.insert(settings_widget.name(), settings_widget);
155 | gizmos.insert(dom_widget.name(), dom_widget);
156 | gizmos.insert(aggr_liqs_widget.name(), aggr_liqs_widget);
157 |
158 | let state = State {
159 | open_tabs,
160 | style: None,
161 | lock_layout: false,
162 | tx,
163 | rx,
164 | gizmos,
165 | trades: VecDeque::new(),
166 | candles: VecDeque::new(),
167 | best_bids: VecDeque::new(),
168 | best_asks: VecDeque::new(),
169 | liquidations: VecDeque::new(),
170 | toasts: Toasts::default(),
171 | events_tx,
172 | events_rx,
173 | };
174 |
175 | Self {
176 | state,
177 | tree,
178 | ping: 0,
179 | }
180 | }
181 | }
182 |
183 | impl eframe::App for Machine<'_> {
184 | // #[cfg(feature = "persistence")]
185 | // fn save(&mut self, storage: &mut dyn eframe::Storage) {
186 | // eframe::set_value(storage, eframe::APP_KEY, &self.state);
187 | // }
188 |
189 | fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
190 | if let Ok(sys_event) = self.state.events_rx.try_recv() {
191 | self.state
192 | .toasts
193 | .success(sys_event.message)
194 | .set_duration(Some(Duration::from_secs(2)))
195 | .set_closable(true);
196 | }
197 | self.state.toasts.show(ctx);
198 | // Here's where we receive data from transmitter
199 | if let Ok(event) = self.state.rx.try_recv() {
200 | // Reformat the data into a flat structure.
201 | let exchange_time = event.exchange_time;
202 | let received_time = event.received_time;
203 | let ping = received_time - exchange_time;
204 | self.ping = ping.num_milliseconds();
205 |
206 | let exchange = format!("{}", event.exchange);
207 | let ticker = format!("{}-{}", event.instrument.base, event.instrument.quote);
208 | let instrument_type = event.instrument.kind;
209 |
210 | match event.kind {
211 | DataKind::Trade(trade) => {
212 | self.state.trades.push_front(Trade {
213 | exchange_time,
214 | exchange,
215 | ticker,
216 | instrument_type,
217 | price: trade.price,
218 | quantity: trade.quantity,
219 | side: trade.side,
220 | });
221 | }
222 | DataKind::Candle(candle) => {
223 | self.state.candles.push_back(Candle {
224 | exchange,
225 | ticker,
226 | instrument_type,
227 | start_time: candle.start_time,
228 | end_time: candle.end_time,
229 | open: candle.open,
230 | high: candle.high,
231 | low: candle.low,
232 | close: candle.close,
233 | volume: candle.volume,
234 | trade_count: candle.trade_count,
235 | });
236 | }
237 | DataKind::OrderBook(orderbook) => {
238 | let best_bid: f64 = orderbook.bids[0].price.clone();
239 | let best_ask: f64 = orderbook.asks[0].price.clone();
240 |
241 | //let min_x: f64 = (exchange_time.timestamp() - 4000) as f64;
242 |
243 | self.state.best_bids.push_back(PlotPoint {
244 | x: exchange_time.timestamp_millis() as f64,
245 | y: best_bid,
246 | });
247 | self.state.best_asks.push_back(PlotPoint {
248 | x: exchange_time.timestamp_millis() as f64,
249 | y: best_ask,
250 | });
251 |
252 | //let mut i = 0;
253 | //while i < self.state.best_bids.len() {
254 | // if self.state.best_bids[i][0] < min_x {
255 | // self.state.best_bids.remove(i);
256 | // self.state.best_asks.remove(i);
257 | // } else {
258 | // i += 1;
259 | // }
260 | //}
261 | }
262 | DataKind::Liquidation(liquidation) => {
263 | self.state.liquidations.push_front(Liquidation {
264 | exchange,
265 | ticker,
266 | instrument_type,
267 | side: liquidation.side,
268 | price: liquidation.price,
269 | quantity: liquidation.quantity,
270 | time: liquidation.time,
271 | });
272 | }
273 | };
274 | // self.state.events.push_front(event);
275 | self.state.trades.truncate(50);
276 | }
277 |
278 | // Menu bar
279 | egui::TopBottomPanel::top("egui_dock::MenuBar").show(ctx, |ui| {
280 | egui::menu::bar(ui, |ui| {
281 | egui::widgets::global_dark_light_mode_switch(ui);
282 | ui.separator();
283 | ui.menu_button("⚙", |ui| {
284 | if ui.button("Quit").clicked() {
285 | frame.close();
286 | }
287 | });
288 |
289 | ui.menu_button("Widgets", |ui| {
290 | // allow certain tabs to be toggled
291 | for tab in &["Settings", "Portfolio"] {
292 | if ui
293 | .selectable_label(self.state.open_tabs.contains(*tab), *tab)
294 | .clicked()
295 | {
296 | if let Some(index) = self.tree.find_tab(&tab.to_string()) {
297 | self.tree.remove_tab(index);
298 | self.state.open_tabs.remove(*tab);
299 | } else {
300 | self.tree.push_to_focused_leaf(tab.to_string());
301 | }
302 |
303 | ui.close_menu();
304 | }
305 | }
306 | // Not using checkbox since we want to be able to add more than one tabs
307 | // for tab in &["Welcome", "Portfolio", "Watchlist", "Depth Chart"] {
308 | // ui.checkbox(&mut self.context.open_tabs.contains(*tab), *tab);
309 | // // ui.selectable_label(self.context.open_tabs.contains(*tab), *tab);
310 | // }
311 | ui.label("This is where we will add the various tabs");
312 | });
313 | })
314 | });
315 |
316 | let panel_config = egui::containers::Frame {
317 | inner_margin: egui::style::Margin {
318 | left: 4.,
319 | right: 7.,
320 | top: 0.,
321 | bottom: 3.,
322 | },
323 | fill: egui::Color32::from_rgba_unmultiplied(25, 25, 25, 200),
324 | ..Default::default()
325 | };
326 |
327 | // Add the "workspaces feature here" > more details in the README.md
328 | egui::TopBottomPanel::bottom("bottom_panel")
329 | .exact_height(25.)
330 | .resizable(false)
331 | .frame(panel_config)
332 | .show(ctx, |ui| {
333 | ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
334 | if ui.selectable_label(self.state.lock_layout, "🔒").clicked() {
335 | // let style = self.state.style.as_mut().unwrap();
336 | // ui.checkbox(&mut style.tabs_are_draggable, "Lock");
337 | self.state.lock_layout = !self.state.lock_layout;
338 | println!("locked");
339 | }
340 | ui.label(format!("{} ms", self.ping));
341 | });
342 | });
343 |
344 | // This is where the tabs and widgets are shown
345 | egui::CentralPanel::default().show(ctx, |_ui| {
346 | egui_dock::DockArea::new(&mut self.tree)
347 | .style(
348 | egui_dock::StyleBuilder::from_egui(ctx.style().as_ref())
349 | .show_add_buttons(true)
350 | .show_add_popup(true)
351 | .with_separator_color_hovered(egui::Color32::LIGHT_BLUE)
352 | .with_border_color(egui::Color32::RED)
353 | .expand_tabs(true)
354 | .build(),
355 | )
356 | .show(ctx, &mut self.state);
357 | });
358 |
359 | // Call repaint every update
360 | ctx.request_repaint();
361 | }
362 | }
363 |
--------------------------------------------------------------------------------
/src/defines.rs:
--------------------------------------------------------------------------------
1 | use barter_integration::model::{InstrumentKind, Side};
2 | use chrono::{DateTime, Utc};
3 |
4 | // ----------------------------------------------------------------------------
5 |
6 | // Store configuration stuff here
7 | pub const APP_NAME: &str = "enigma machine";
8 | // pub const APP_CONFIG_NAME: &str = "tiny_pomodoro.yaml";
9 |
10 | pub mod fonts {
11 | use include_flate::flate;
12 | flate!(pub static FONT_PROGGY_CLEAN: [u8] from "resources/ProggyClean.ttf");
13 | }
14 |
15 | // ----------------------------------------------------------------------------
16 | // All widget related definitions are stored here.
17 |
18 | pub const AGGR_TRADES_TITLE: &str = "💰 Aggregated Trades";
19 | pub const SETTINGS_TITLE: &str = "⛭ Settings";
20 | pub const CHART_TITLE: &str = "📈 Chart";
21 | pub const MICROSTRUCTURE_TITLE: &str = "🔭 Microstructure Browser";
22 | pub const AGGR_LIQS_TITLE: &str = "🕱 Aggregated Liquidations";
23 |
24 | // ----------------------------------------------------------------------------
25 |
26 | #[allow(dead_code)]
27 | /// Might not need instrument type, since ticker will show that
28 | // Implement volume function?
29 | pub struct Trade {
30 | pub exchange_time: DateTime,
31 | pub exchange: String,
32 | pub ticker: String,
33 | pub instrument_type: InstrumentKind,
34 | pub price: f64,
35 | pub quantity: f64,
36 | pub side: Side,
37 | }
38 |
39 | pub struct Candle {
40 | // pub exchange_time: DateTime,
41 | pub exchange: String,
42 | pub ticker: String,
43 | pub instrument_type: InstrumentKind,
44 | pub start_time: DateTime,
45 | pub end_time: DateTime,
46 | pub open: f64,
47 | pub high: f64,
48 | pub low: f64,
49 | pub close: f64,
50 | pub volume: f64,
51 | pub trade_count: u64,
52 | }
53 |
54 | impl Candle {
55 | pub fn avg_price(&self) -> f64 {
56 | (self.open + self.high + self.low + self.close) / 4.0
57 | }
58 | }
59 |
60 | pub struct Liquidation {
61 | // pub exchange_time: DateTime, // Since we have time below
62 | pub exchange: String,
63 | pub ticker: String,
64 | pub instrument_type: InstrumentKind,
65 | pub side: Side,
66 | pub price: f64,
67 | pub quantity: f64,
68 | pub time: DateTime,
69 | }
70 | pub struct SysEvent {
71 | pub message: String,
72 | }
73 |
--------------------------------------------------------------------------------
/src/gateway.rs:
--------------------------------------------------------------------------------
1 | use crate::utils;
2 | use barter_data::model::subscription::Subscription;
3 | use barter_data::{
4 | builder::Streams,
5 | model::{
6 | subscription::{Interval, SubKind},
7 | MarketEvent,
8 | },
9 | ExchangeId,
10 | };
11 | use barter_integration::model::InstrumentKind;
12 | use futures::StreamExt;
13 | use std::sync::mpsc::Sender;
14 |
15 | pub fn add_stream(tx: Sender, subscription: Subscription) {
16 | println!("Connecting to {:?}", subscription);
17 |
18 | tokio::spawn(async move {
19 | let streams = Streams::builder()
20 | .subscribe([subscription])
21 | .init()
22 | .await
23 | .unwrap();
24 | let mut joined_stream = streams.join_map::().await;
25 |
26 | while let Some((_exchange, event)) = joined_stream.next().await {
27 | let _result = tx.send(event);
28 | }
29 | });
30 | }
31 |
32 | pub fn add_ohlcv(tx: Sender, ticker: &'static str) {
33 | if let Ok((base, quote)) = utils::split_ticker(ticker) {
34 | println!("Successfully Connected");
35 | tokio::spawn(async move {
36 | loop {
37 | let streams = Streams::builder()
38 | .subscribe([(
39 | ExchangeId::Kraken,
40 | base,
41 | quote,
42 | InstrumentKind::Spot,
43 | SubKind::Candle(Interval::Minute1),
44 | )])
45 | .init()
46 | .await
47 | .unwrap();
48 | let mut joined_stream = streams.join_map::().await;
49 |
50 | while let Some((_exchange, event)) = joined_stream.next().await {
51 | println!("{:?}", event);
52 | let _result = tx.send(event);
53 | }
54 | }
55 | });
56 | };
57 | }
58 |
59 | pub fn add_orderbook(tx: Sender, ticker: &'static str) {
60 | if let Ok((base, quote)) = utils::split_ticker(ticker) {
61 | println!("Successfully Connected to Orderbook");
62 | tokio::spawn(async move {
63 | loop {
64 | let streams = Streams::builder()
65 | .subscribe([(
66 | ExchangeId::BinanceFuturesUsd,
67 | base,
68 | quote,
69 | InstrumentKind::FuturePerpetual,
70 | SubKind::OrderBook, // Different
71 | )])
72 | .init()
73 | .await
74 | .unwrap();
75 | let mut joined_stream = streams.join_map::().await;
76 |
77 | while let Some((_exchange, event)) = joined_stream.next().await {
78 | println!("{:?}", event);
79 | let _result = tx.send(event);
80 | }
81 | }
82 | });
83 | };
84 | }
85 |
--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
1 | use app::Machine;
2 | use eframe::{run_native, NativeOptions};
3 | use std::time::Duration;
4 | use tokio::runtime::Runtime;
5 | mod app;
6 | mod defines;
7 | mod gateway;
8 | mod utils;
9 | mod widgets;
10 |
11 | fn main() {
12 | let rt = Runtime::new().expect("Unable to create Runtime");
13 | // Enter the runtime so that `tokio::spawn` is available immediately.
14 | let _enter = rt.enter();
15 |
16 | // This block is necessary to keep the runtime running
17 | std::thread::spawn(move || {
18 | rt.block_on(async {
19 | loop {
20 | tokio::time::sleep(Duration::from_secs(3600)).await;
21 | }
22 | })
23 | });
24 |
25 | let window_options = NativeOptions {
26 | maximized: true,
27 | ..NativeOptions::default()
28 | };
29 | run_native(
30 | defines::APP_NAME,
31 | window_options,
32 | Box::new(|cc| Box::new(Machine::new(cc))),
33 | )
34 | }
35 |
--------------------------------------------------------------------------------
/src/utils.rs:
--------------------------------------------------------------------------------
1 | use crate::defines::fonts::FONT_PROGGY_CLEAN;
2 | use barter_data::model::{Candle, DataKind, MarketEvent, PublicTrade};
3 | use eframe::egui::{self, FontData, FontDefinitions};
4 | use std::io::Error;
5 |
6 | pub fn configure_fonts(ctx: &egui::Context) {
7 | let mut fonts = FontDefinitions::default();
8 | fonts.font_data.insert(
9 | "ProggyClean".to_owned(),
10 | FontData::from_static(&FONT_PROGGY_CLEAN),
11 | );
12 | fonts
13 | .families
14 | .get_mut(&egui::FontFamily::Monospace)
15 | .unwrap()
16 | .insert(0, "ProggyClean".to_owned());
17 | ctx.set_fonts(fonts);
18 | }
19 |
20 | pub fn split_ticker(input: &str) -> Result<(&str, &str), Error> {
21 | let parts: Vec<&str> = input.split("-").collect();
22 | if parts.len() != 2 {
23 | panic!("Invalid ticker");
24 | }
25 | Ok((parts[0], parts[1]))
26 | }
--------------------------------------------------------------------------------
/src/widgets/README.md:
--------------------------------------------------------------------------------
1 | # Widgets 🎛️
2 |
3 | ### Candlestick Plot
4 | [Code for creating the BoxElem's](https://github.com/SwayStar123/chart_bot/blob/master/src/chartbot.rs)
5 | Keep the BoxElem's in a VecDeque instead, so you can remove the older values, like a rolling window.
6 |
7 | 01/01 Idea: Can use the [drag and drop crate](https://github.com/lucasmerlin/egui_dnd) for time series.
8 | So for example, if I want to move one time series from this chart to another.
9 |
10 | Follow this [tutorial](https://www.youtube.com/watch?v=zUvHkkkrmIY) for the sliding window.
11 |
12 | ### Aggregated Trades
13 | Can take inspiration from [aggr](https://charts.aggr.trade/s3r1)
14 | Add a slider for size, combobox for ticker, connect button, checkbox for which exchanges you want to listen to.
15 | Columns:
16 | 1. Exchange (with icon)
17 | 2. Price (color coded according to buy/sell also)
18 | 3. Size (Color code background opacity)
19 | 4. Time (of execution, not received)
20 |
21 | ### Watchtower
22 | Follow the AlphaTerm Watchlist widget. Background color green/red based on return, with ticker name and price. Like the widget on the left in the picture below.
23 |
24 | 
25 |
26 | ### Depth Chart
27 | Tradinglite-ish liquidity map kinda depth chart? Can agggregate data from different exchanges as well.
28 |
29 | ### Liquidations
30 | Same stuff as trades I guess.
31 |
32 | ### Portfolio
33 |
34 |
35 | ### Monitor our own trades
36 | https://twitter.com/i/status/1571862452656128001
37 | Something like the link above.
38 |
39 | ### Microstructure Browser
40 | Leave this to the last. A major problem is performance, which is why we need to implement striding. As mentioned by BahamasTrading [here](https://twitter.com/BahamasTrading/status/1377351224748605442), we need to upsample/downsample based on how zoomed in you are. egui hasn't implemented this yet, implot has though, so we need to implement it in rust.
41 | [Link to tweet](https://twitter.com/BahamasTrading/status/1506729892326608901)
42 |
43 | https://user-images.githubusercontent.com/76802638/209623672-22191104-5f69-47c7-a359-19326c5f8c14.mp4
44 |
--------------------------------------------------------------------------------
/src/widgets/aggr_liqs.rs:
--------------------------------------------------------------------------------
1 | use crate::defines;
2 | use crate::defines::*;
3 | use barter_data::{
4 | model::{
5 | subscription::{SubKind, Subscription},
6 | MarketEvent,
7 | },
8 | ExchangeId,
9 | };
10 | use barter_integration::model::{Instrument, InstrumentKind, Side, Symbol};
11 | use eframe::egui::{self, Ui};
12 | use egui::plot::PlotPoint;
13 | use egui_extras::{Column, TableBuilder};
14 | use egui_notify::Toasts;
15 | use std::collections::{HashSet, VecDeque};
16 | use std::sync::mpsc::Sender;
17 |
18 | pub struct AggrLiquidations {
19 | pub filter: i32,
20 | pub show_settings: bool,
21 |
22 | // These are the input fields
23 | pub exchange: ExchangeId,
24 | pub ticker: String,
25 | pub instrument_kind: InstrumentKind,
26 |
27 | // HashSet to contain all subscriptions so we don't repeat any.
28 | pub subscriptions: HashSet,
29 | }
30 |
31 | impl Default for AggrLiquidations {
32 | fn default() -> Self {
33 | Self {
34 | filter: 10,
35 | show_settings: true,
36 | exchange: ExchangeId::BinanceFuturesUsd,
37 | ticker: String::new(),
38 | instrument_kind: InstrumentKind::FuturePerpetual,
39 | subscriptions: HashSet::new(),
40 | }
41 | }
42 | }
43 |
44 | impl super::Widget for AggrLiquidations {
45 | fn name(&self) -> &'static str {
46 | AGGR_LIQS_TITLE
47 | }
48 |
49 | fn show(
50 | &mut self,
51 | ui: &mut egui::Ui,
52 | tx: Sender,
53 | events_tx: Sender,
54 | trades: &mut VecDeque,
55 | candles: &mut VecDeque,
56 | best_bids: &mut VecDeque,
57 | best_asks: &mut VecDeque,
58 | liquidations: &mut VecDeque,
59 | ) {
60 | ui.horizontal(|ui| {
61 | ui.add(egui::Slider::new(&mut self.filter, 0..=100).text("Size"));
62 | ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
63 | if ui.selectable_label(self.show_settings, "🛠").clicked() {
64 | self.show_settings = !self.show_settings;
65 | }
66 | });
67 | });
68 |
69 | ui.separator();
70 |
71 | if self.show_settings {
72 | self.settings(ui, tx, events_tx);
73 | } else {
74 | let min = liquidations
75 | .iter()
76 | .filter_map(|trade| Some(trade.quantity))
77 | .fold(0.0, f64::min);
78 |
79 | let max = liquidations
80 | .iter()
81 | .filter_map(|trade| Some(trade.quantity))
82 | .fold(0.0, f64::max);
83 |
84 | let range = max - min;
85 | let text_height = egui::TextStyle::Body.resolve(ui.style()).size;
86 |
87 | let table = TableBuilder::new(ui)
88 | .striped(true)
89 | .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
90 | .column(Column::auto())
91 | .column(Column::auto())
92 | .column(Column::auto())
93 | //.column(Column::initial(50.0).range(40.0..=300.0).resizable(true))
94 | // .column(
95 | // Column::initial(100.0)
96 | // .at_least(40.0)
97 | // .resizable(true)
98 | // .clip(true),
99 | // )
100 | .column(Column::remainder())
101 | .min_scrolled_height(0.0);
102 | table
103 | .header(20.0, |mut header| {
104 | header.col(|ui| {
105 | ui.strong("Exchange");
106 | });
107 | header.col(|ui| {
108 | ui.strong("Price");
109 | });
110 | header.col(|ui| {
111 | ui.strong("Quantity");
112 | });
113 | header.col(|ui| {
114 | ui.strong("Time");
115 | });
116 | })
117 | .body(|mut body| {
118 | for liq in liquidations {
119 | if liq.quantity * liq.price > (self.filter * 200).into() {
120 | body.row(text_height, |mut row| {
121 | row.col(|ui| {
122 | let mut layout_job = egui::text::LayoutJob::default();
123 | let text = liq.exchange.as_str(); // need to change this to get from MarketEvent
124 | layout_job.append(
125 | &text,
126 | 0.0,
127 | egui::text::TextFormat {
128 | font_id: egui::FontId::monospace(15.0),
129 | color: egui::Color32::WHITE,
130 | ..Default::default()
131 | },
132 | );
133 |
134 | ui.label(layout_job);
135 | });
136 | row.col(|ui| {
137 | let mut layout_job = egui::text::LayoutJob::default();
138 | let text = liq.price.to_string();
139 | layout_job.append(
140 | &text,
141 | 0.0,
142 | egui::text::TextFormat {
143 | font_id: egui::FontId::monospace(15.0),
144 | color: match liq.side {
145 | Side::Buy => egui::Color32::GREEN,
146 | Side::Sell => egui::Color32::RED,
147 | },
148 | ..Default::default()
149 | },
150 | );
151 |
152 | ui.label(layout_job);
153 | });
154 | row.col(|ui| {
155 | let mut layout_job = egui::text::LayoutJob::default();
156 | let text = liq.quantity.to_string();
157 | layout_job.append(
158 | &text,
159 | 0.0,
160 | egui::text::TextFormat {
161 | font_id: egui::FontId::monospace(15.0),
162 | color: egui::Color32::WHITE,
163 | background: egui::Color32::from_rgba_unmultiplied(
164 | if liq.side == Side::Buy { 0 } else { 255 },
165 | if liq.side == Side::Buy { 255 } else { 0 },
166 | 0,
167 | (((liq.quantity - min) / range) * 200.) as u8,
168 | ),
169 | ..Default::default()
170 | },
171 | );
172 | ui.label(layout_job);
173 | });
174 | row.col(|ui| {
175 | let timestamp = liq.time.format("%H:%M:%S").to_string();
176 | ui.monospace(timestamp);
177 | });
178 | });
179 | }
180 | }
181 | });
182 | }
183 | }
184 |
185 | fn settings(
186 | &mut self,
187 | ui: &mut egui::Ui,
188 | tx: Sender,
189 | events_tx: Sender,
190 | ) {
191 | ui.heading("Add feeds");
192 | egui::Grid::new("Settings Grid")
193 | .num_columns(2)
194 | .spacing([40.0, 4.0])
195 | .striped(true)
196 | .show(ui, |ui| {
197 | ui.label("Select Exchange");
198 | egui::ComboBox::from_label("")
199 | .selected_text(format!("{:?}", self.exchange))
200 | .show_ui(ui, |ui| {
201 | ui.selectable_value(
202 | &mut self.exchange,
203 | ExchangeId::BinanceFuturesUsd,
204 | ExchangeId::BinanceFuturesUsd.as_str(),
205 | );
206 | ui.selectable_value(
207 | &mut self.exchange,
208 | ExchangeId::Binance,
209 | ExchangeId::Binance.as_str(),
210 | );
211 | ui.selectable_value(
212 | &mut self.exchange,
213 | ExchangeId::Coinbase,
214 | ExchangeId::Coinbase.as_str(),
215 | );
216 | ui.selectable_value(
217 | &mut self.exchange,
218 | ExchangeId::Kraken,
219 | ExchangeId::Kraken.as_str(),
220 | );
221 | });
222 | ui.end_row();
223 |
224 | ui.label("Ticker");
225 | ui.add(egui::TextEdit::singleline(&mut self.ticker).hint_text("for e.g, BTC-USDT"));
226 | ui.end_row();
227 |
228 | ui.label("Select instrument type");
229 | egui::ComboBox::from_id_source("test")
230 | .selected_text(format!("{:?}", self.instrument_kind))
231 | .show_ui(ui, |ui| {
232 | ui.selectable_value(
233 | &mut self.instrument_kind,
234 | InstrumentKind::FuturePerpetual,
235 | "Future Perpetual",
236 | );
237 | ui.selectable_value(
238 | &mut self.instrument_kind,
239 | InstrumentKind::Spot,
240 | "Spot",
241 | );
242 | });
243 | ui.end_row();
244 | });
245 |
246 | // For connecting to the feeds.
247 | if ui.button("Add to feed").clicked() {
248 | if let Ok((base, quote)) = crate::utils::split_ticker(self.ticker.as_str()) {
249 | let new_sub = Subscription {
250 | exchange: self.exchange,
251 | instrument: Instrument {
252 | base: Symbol::new(base),
253 | quote: Symbol::new(quote),
254 | kind: self.instrument_kind,
255 | },
256 | kind: SubKind::Liquidation,
257 | };
258 | if !self.subscriptions.contains(&new_sub) {
259 | crate::gateway::add_stream(tx.clone(), new_sub.clone());
260 | }
261 | self.subscriptions.insert(new_sub);
262 | };
263 | }
264 | ui.separator();
265 |
266 | let text_height = egui::TextStyle::Body.resolve(ui.style()).size;
267 | TableBuilder::new(ui)
268 | .striped(true)
269 | .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
270 | .column(Column::auto())
271 | .column(Column::auto())
272 | .column(Column::auto())
273 | .column(Column::remainder())
274 | .header(20.0, |mut header| {
275 | header.col(|ui| {
276 | ui.strong("Exchange");
277 | });
278 | header.col(|ui| {
279 | ui.strong("Base");
280 | });
281 | header.col(|ui| {
282 | ui.strong("Quote");
283 | });
284 | header.col(|ui| {
285 | ui.strong("Instrument Kind");
286 | });
287 | })
288 | .body(|mut body| {
289 | for subscription in &self.subscriptions {
290 | body.row(text_height, |mut row| {
291 | row.col(|ui| {
292 | ui.label(format!("{:?}", subscription.exchange));
293 | });
294 | row.col(|ui| {
295 | ui.label(format!("{:?}", subscription.instrument.base));
296 | });
297 | row.col(|ui| {
298 | ui.label(format!("{:?}", subscription.instrument.quote));
299 | });
300 | row.col(|ui| {
301 | ui.label(format!("{:?}", subscription.instrument.kind));
302 | });
303 | });
304 | }
305 | });
306 | }
307 |
308 | fn context_menu(&self, ui: &mut Ui) {
309 | ui.label("from aggr trades");
310 | }
311 | }
312 |
--------------------------------------------------------------------------------
/src/widgets/aggr_trades.rs:
--------------------------------------------------------------------------------
1 | use crate::defines;
2 | use crate::defines::*;
3 | use barter_data::model::{
4 | subscription::{SubKind, Subscription},
5 | MarketEvent,
6 | };
7 | use barter_data::ExchangeId;
8 | use barter_integration::model::{Instrument, InstrumentKind, Side, Symbol};
9 | use eframe::egui;
10 | use eframe::egui::Ui;
11 | use egui::plot::PlotPoint;
12 | use egui_extras::{Column, TableBuilder};
13 | use std::collections::{HashSet, VecDeque};
14 | use std::sync::mpsc::Sender;
15 |
16 | pub struct AggrTrades {
17 | pub filter: i32,
18 | pub show_settings: bool,
19 |
20 | // These are the input fields
21 | pub exchange: ExchangeId,
22 | pub ticker: String,
23 | pub instrument_kind: InstrumentKind,
24 |
25 | // HashSet to contain all subscriptions so we don't repeat any.
26 | pub subscriptions: HashSet,
27 | }
28 |
29 | impl Default for AggrTrades {
30 | fn default() -> Self {
31 | Self {
32 | filter: 10,
33 | show_settings: true,
34 | exchange: ExchangeId::BinanceFuturesUsd,
35 | ticker: String::new(),
36 | instrument_kind: InstrumentKind::FuturePerpetual,
37 | subscriptions: HashSet::new(),
38 | }
39 | }
40 | }
41 |
42 | impl super::Widget for AggrTrades {
43 | fn name(&self) -> &'static str {
44 | AGGR_TRADES_TITLE
45 | }
46 |
47 | fn show(
48 | &mut self,
49 | ui: &mut egui::Ui,
50 | tx: Sender,
51 | events_tx: Sender,
52 | trades: &mut VecDeque,
53 | candles: &mut VecDeque,
54 | best_bids: &mut VecDeque,
55 | best_asks: &mut VecDeque,
56 | liquidations: &mut VecDeque,
57 | ) {
58 | ui.horizontal(|ui| {
59 | ui.add(egui::Slider::new(&mut self.filter, 0..=100).text("Size"));
60 | ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
61 | if ui.selectable_label(self.show_settings, "🛠").clicked() {
62 | self.show_settings = !self.show_settings;
63 | }
64 | });
65 | });
66 |
67 | ui.separator();
68 |
69 | if self.show_settings {
70 | self.settings(ui, tx, events_tx);
71 | } else {
72 | let min = trades
73 | .iter()
74 | .map(|trade| trade.quantity)
75 | .fold(0.0, f64::min);
76 |
77 | let max = trades
78 | .iter()
79 | .map(|trade| trade.quantity)
80 | .fold(0.0, f64::max);
81 |
82 | let range = max - min;
83 | let text_height = egui::TextStyle::Body.resolve(ui.style()).size;
84 |
85 | let table = TableBuilder::new(ui)
86 | .striped(true)
87 | .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
88 | .column(Column::auto())
89 | .column(Column::auto())
90 | .column(Column::auto())
91 | //.column(Column::initial(50.0).range(40.0..=300.0).resizable(true))
92 | // .column(
93 | // Column::initial(100.0)
94 | // .at_least(40.0)
95 | // .resizable(true)
96 | // .clip(true),
97 | // )
98 | .column(Column::remainder())
99 | .min_scrolled_height(0.0);
100 | table
101 | .header(20.0, |mut header| {
102 | header.col(|ui| {
103 | ui.strong("Exchange");
104 | });
105 | header.col(|ui| {
106 | ui.strong("Price");
107 | });
108 | header.col(|ui| {
109 | ui.strong("Quantity");
110 | });
111 | header.col(|ui| {
112 | ui.strong("Time");
113 | });
114 | })
115 | .body(|mut body| {
116 | for trade in trades {
117 | if trade.quantity * trade.price > (self.filter * 200).into() {
118 | body.row(text_height, |mut row| {
119 | row.col(|ui| {
120 | let mut layout_job = egui::text::LayoutJob::default();
121 | let text = trade.exchange.as_str(); // need to change this to get from MarketEvent
122 | layout_job.append(
123 | &text,
124 | 0.0,
125 | egui::text::TextFormat {
126 | font_id: egui::FontId::monospace(15.0),
127 | color: egui::Color32::WHITE,
128 | ..Default::default()
129 | },
130 | );
131 |
132 | ui.label(layout_job);
133 | });
134 | row.col(|ui| {
135 | let mut layout_job = egui::text::LayoutJob::default();
136 | let text = trade.price.to_string();
137 | layout_job.append(
138 | &text,
139 | 0.0,
140 | egui::text::TextFormat {
141 | font_id: egui::FontId::monospace(15.0),
142 | color: match trade.side {
143 | Side::Buy => egui::Color32::GREEN,
144 | Side::Sell => egui::Color32::RED,
145 | },
146 | ..Default::default()
147 | },
148 | );
149 |
150 | ui.label(layout_job);
151 | });
152 | row.col(|ui| {
153 | let mut layout_job = egui::text::LayoutJob::default();
154 | let text = trade.quantity.to_string();
155 | layout_job.append(
156 | &text,
157 | 0.0,
158 | egui::text::TextFormat {
159 | font_id: egui::FontId::monospace(15.0),
160 | color: egui::Color32::WHITE,
161 | background: egui::Color32::from_rgba_unmultiplied(
162 | if trade.side == Side::Buy { 0 } else { 255 },
163 | if trade.side == Side::Buy { 255 } else { 0 },
164 | 0,
165 | (((trade.quantity - min) / range) * 200.) as u8,
166 | ),
167 | ..Default::default()
168 | },
169 | );
170 | ui.label(layout_job);
171 | });
172 | row.col(|ui| {
173 | let timestamp =
174 | trade.exchange_time.format("%H:%M:%S").to_string();
175 | ui.monospace(timestamp);
176 | });
177 | });
178 | }
179 | }
180 | });
181 | }
182 | }
183 |
184 | fn settings(
185 | &mut self,
186 | ui: &mut egui::Ui,
187 | tx: Sender,
188 | events_tx: Sender,
189 | ) {
190 | ui.heading("Add feeds");
191 | egui::Grid::new("my_grid")
192 | .num_columns(2)
193 | .spacing([40.0, 4.0])
194 | .striped(true)
195 | .show(ui, |ui| {
196 | ui.label("Select Exchange");
197 | egui::ComboBox::from_label("")
198 | .selected_text(format!("{:?}", self.exchange))
199 | .show_ui(ui, |ui| {
200 | ui.selectable_value(
201 | &mut self.exchange,
202 | ExchangeId::BinanceFuturesUsd,
203 | ExchangeId::BinanceFuturesUsd.as_str(),
204 | );
205 | ui.selectable_value(
206 | &mut self.exchange,
207 | ExchangeId::Binance,
208 | ExchangeId::Binance.as_str(),
209 | );
210 | ui.selectable_value(
211 | &mut self.exchange,
212 | ExchangeId::Coinbase,
213 | ExchangeId::Coinbase.as_str(),
214 | );
215 | ui.selectable_value(
216 | &mut self.exchange,
217 | ExchangeId::Kraken,
218 | ExchangeId::Kraken.as_str(),
219 | );
220 | });
221 | ui.end_row();
222 |
223 | ui.label("Ticker");
224 | ui.add(egui::TextEdit::singleline(&mut self.ticker).hint_text("for e.g, BTC-USDT"));
225 | ui.end_row();
226 |
227 | ui.label("Select instrument type");
228 | egui::ComboBox::from_id_source("test")
229 | .selected_text(format!("{:?}", self.instrument_kind))
230 | .show_ui(ui, |ui| {
231 | ui.selectable_value(
232 | &mut self.instrument_kind,
233 | InstrumentKind::FuturePerpetual,
234 | "Future Perpetual",
235 | );
236 | ui.selectable_value(
237 | &mut self.instrument_kind,
238 | InstrumentKind::Spot,
239 | "Spot",
240 | );
241 | });
242 | ui.end_row();
243 | });
244 |
245 | // For connecting to the feeds.
246 | if ui.button("Add to feed").clicked() {
247 | events_tx
248 | .send(SysEvent {
249 | message: format!("Subscribed to {} trades feed.", self.ticker),
250 | })
251 | .expect("TODO: panic message");
252 |
253 | if let Ok((base, quote)) = crate::utils::split_ticker(self.ticker.as_str()) {
254 | let new_sub = Subscription {
255 | exchange: self.exchange,
256 | instrument: Instrument {
257 | base: Symbol::new(base),
258 | quote: Symbol::new(quote),
259 | kind: self.instrument_kind,
260 | },
261 | kind: SubKind::Trade,
262 | };
263 | if !self.subscriptions.contains(&new_sub) {
264 | crate::gateway::add_stream(tx.clone(), new_sub.clone());
265 | }
266 | self.subscriptions.insert(new_sub);
267 | };
268 | }
269 | ui.separator();
270 |
271 | let text_height = egui::TextStyle::Body.resolve(ui.style()).size;
272 | TableBuilder::new(ui)
273 | .striped(true)
274 | .cell_layout(egui::Layout::left_to_right(egui::Align::Center))
275 | .column(Column::auto())
276 | .column(Column::auto())
277 | .column(Column::auto())
278 | .column(Column::remainder())
279 | .header(20.0, |mut header| {
280 | header.col(|ui| {
281 | ui.strong("Exchange");
282 | });
283 | header.col(|ui| {
284 | ui.strong("Base");
285 | });
286 | header.col(|ui| {
287 | ui.strong("Quote");
288 | });
289 | header.col(|ui| {
290 | ui.strong("Instrument Kind");
291 | });
292 | })
293 | .body(|mut body| {
294 | for subscription in &self.subscriptions {
295 | body.row(text_height, |mut row| {
296 | row.col(|ui| {
297 | ui.label(format!("{:?}", subscription.exchange));
298 | });
299 | row.col(|ui| {
300 | ui.label(format!("{:?}", subscription.instrument.base));
301 | });
302 | row.col(|ui| {
303 | ui.label(format!("{:?}", subscription.instrument.quote));
304 | });
305 | row.col(|ui| {
306 | ui.label(format!("{:?}", subscription.instrument.kind));
307 | });
308 | });
309 | }
310 | });
311 | }
312 |
313 | fn context_menu(&self, ui: &mut Ui) {
314 | ui.label("from aggr trades");
315 | }
316 | }
317 |
--------------------------------------------------------------------------------
/src/widgets/chart.rs:
--------------------------------------------------------------------------------
1 | use crate::defines;
2 | use crate::defines::*;
3 | use barter_data::model::MarketEvent;
4 | use barter_data::model::OrderBook;
5 | use eframe::egui;
6 | use eframe::egui::plot::{PlotPoint, PlotPoints};
7 | use eframe::egui::Ui;
8 | use egui::{
9 | plot::{BoxElem, BoxPlot, BoxSpread},
10 | Stroke,
11 | };
12 | use egui_notify::Toasts;
13 | use std::collections::VecDeque;
14 | use std::sync::mpsc::Sender;
15 |
16 | pub struct Chart {
17 | pub ticker: String,
18 | }
19 |
20 | impl Default for Chart {
21 | fn default() -> Self {
22 | Self {
23 | ticker: "BTC-USDT".to_string(),
24 | }
25 | }
26 | }
27 |
28 | #[allow(unused_variables)] // delete this later
29 | impl super::Widget for Chart {
30 | fn name(&self) -> &'static str {
31 | CHART_TITLE
32 | }
33 |
34 | fn show(
35 | &mut self,
36 | ui: &mut egui::Ui,
37 | tx: Sender,
38 | events_tx: Sender,
39 | trades: &mut VecDeque,
40 | candles: &mut VecDeque,
41 | best_bids: &mut VecDeque,
42 | best_asks: &mut VecDeque,
43 | liquidations: &mut VecDeque,
44 | ) {
45 | // Destructure self into fields
46 | let Self { ticker } = self;
47 |
48 | // Menu bar for configuring settings
49 | ui.horizontal(|ui| {
50 | if ui.button("Connect").clicked() {
51 | println!("Connected to ticker feed");
52 | crate::gateway::add_ohlcv(tx, "xbt-usd");
53 | }
54 |
55 | egui::ComboBox::from_label("Select one!")
56 | .selected_text(format!("{:?}", ticker))
57 | .show_ui(ui, |ui| {
58 | ui.add(egui::TextEdit::singleline(ticker).hint_text("Write something here"));
59 | ui.label("BTC");
60 | ui.label("ETH");
61 | });
62 | ui.separator();
63 | });
64 |
65 | // Plotting the shit
66 | let plot = egui::plot::Plot::new("Measurements");
67 |
68 | let sin: egui::plot::PlotPoints = (0..1000)
69 | .map(|i| {
70 | let x = i as f64 * 0.01;
71 | [x, x.sin()]
72 | })
73 | .collect();
74 | let mut candle_data: Vec = Vec::new();
75 | let mut timeseries: Vec<[f64; 2]> = Vec::new();
76 |
77 | // this shouldn't be done every time there's a new candle. should be done once
78 | // in the try_recv loop.
79 | for (count, candle) in candles.iter().enumerate() {
80 | timeseries.push([count as f64, candle.avg_price()]);
81 | candle_data.push(
82 | BoxElem::new(
83 | // candle.start_time.timestamp() as f64,
84 | count as f64,
85 | BoxSpread::new(
86 | candle.low,
87 | candle.open.min(candle.close),
88 | (candle.open + candle.close) / 2.0,
89 | candle.open.max(candle.close),
90 | candle.high,
91 | ),
92 | )
93 | .whisker_width(0.0)
94 | .fill(egui::Color32::GREEN)
95 | .stroke(Stroke::new(2.0, egui::Color32::GREEN)),
96 | );
97 | }
98 | let data = BoxPlot::new(candle_data);
99 | let timeseries_data = PlotPoints::from(timeseries);
100 |
101 | plot.show(ui, |plot_ui| {
102 | plot_ui.line(egui::plot::Line::new(timeseries_data));
103 | //plot_ui.box_plot(data);
104 | });
105 | }
106 |
107 | fn settings(
108 | &mut self,
109 | ui: &mut egui::Ui,
110 | tx: Sender,
111 | events_tx: Sender,
112 | ) {
113 | todo!()
114 | }
115 |
116 | fn context_menu(&self, ui: &mut Ui) {
117 | ui.label("from charts");
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/src/widgets/microstructure.rs:
--------------------------------------------------------------------------------
1 | use crate::defines::*;
2 | use barter_data::model::MarketEvent;
3 | use eframe::egui::plot::{LinkedAxisGroup, PlotPoint, PlotPoints};
4 | use eframe::egui::{
5 | self,
6 | plot::{Bar, BarChart, Line, Plot},
7 | Color32, Ui,
8 | };
9 | use egui_notify::Toasts;
10 | use std::collections::VecDeque;
11 | use std::sync::mpsc::Sender;
12 |
13 | pub struct MicrostructureBrowser {
14 | pub ticker: String,
15 | pub group: LinkedAxisGroup,
16 | }
17 |
18 | impl Default for MicrostructureBrowser {
19 | fn default() -> Self {
20 | Self {
21 | ticker: String::from("BTC-USDT"),
22 | group: LinkedAxisGroup::new(true, false),
23 | }
24 | }
25 | }
26 |
27 | impl super::Widget for MicrostructureBrowser {
28 | fn name(&self) -> &'static str {
29 | MICROSTRUCTURE_TITLE
30 | }
31 |
32 | fn show(
33 | &mut self,
34 | ui: &mut egui::Ui,
35 | tx: Sender,
36 | events_tx: Sender,
37 | _trades: &mut VecDeque,
38 | _candles: &mut VecDeque,
39 | best_bids: &mut VecDeque,
40 | best_asks: &mut VecDeque,
41 | _liquidations: &mut VecDeque,
42 | ) {
43 | // Menu bar for configuring settings
44 | ui.horizontal(|ui| {
45 | if ui.button("Connect").clicked() {
46 | println!("Connected to ticker feed");
47 | crate::gateway::add_orderbook(tx, "BTC-USDT");
48 | }
49 | });
50 |
51 | // Plots
52 | let micro_plot = Plot::new(MICROSTRUCTURE_TITLE);
53 | let inv_plot = Plot::new("Inventory");
54 |
55 | let bb_px: PlotPoints = PlotPoints::Owned(Vec::from_iter(best_bids.iter().copied()));
56 | let ba_px: PlotPoints = PlotPoints::Owned(Vec::from_iter(best_asks.iter().copied()));
57 |
58 | let mut bar_chart = BarChart::new(vec![
59 | Bar::new(0.5, 1.0).name("Day 1"),
60 | Bar::new(1.5, 3.0).name("Day 2"),
61 | Bar::new(2.5, 1.0).name("Day 3"),
62 | Bar::new(3.5, 2.0).name("Day 4"),
63 | Bar::new(4.5, 4.0).name("Day 5"),
64 | ]);
65 | micro_plot
66 | //.link_axis(self.group.clone())
67 | .show_axes([false, false])
68 | .auto_bounds_y()
69 | .height(ui.available_height() * 0.8)
70 | .show(ui, |plot_ui| {
71 | plot_ui.line(egui::plot::Line::new(bb_px).color(Color32::GREEN));
72 | plot_ui.line(egui::plot::Line::new(ba_px).color(Color32::RED).fill(0.));
73 | });
74 |
75 | inv_plot
76 | .link_axis(self.group.clone())
77 | .show(ui, |plot_ui| {});
78 |
79 | //plot.height(ui.available_height() * 0.8)
80 | // .show_axes([false, false])
81 | // .auto_bounds_x()
82 | // .link_axis(self.group.clone())
83 | // .show(ui, |plot_ui| {
84 | // plot_ui.line(egui::plot::Line::new(best_bid_line).width(100.));
85 | // plot_ui.line(egui::plot::Line::new(best_ask_line).color(egui::Color32::RED));
86 | // });
87 | //
88 | //inventory_plot
89 | // .show_axes([false, false])
90 | // .auto_bounds_x()
91 | // .auto_bounds_y()
92 | // .link_axis(self.group.clone())
93 | // .show(ui, |plot_ui| {
94 | // plot_ui.line(egui::plot::Line::new(PlotPoints::from_explicit_callback(
95 | // move |x| x.sin(),
96 | // ..,
97 | // 100,
98 | // )));
99 | // });
100 |
101 | //let mut chart = BarChart::new(
102 | // (-395..=395)
103 | // .step_by(10)
104 | // .map(|x| x as f64 * 0.01)
105 | // .map(|x| {
106 | // (
107 | // x,
108 | // (-x * x / 2.0).exp() / (2.0 * std::f64::consts::PI).sqrt(),
109 | // )
110 | // })
111 | // // The 10 factor here is purely for a nice 1:1 aspect ratio
112 | // .map(|(x, f)| Bar::new(x, f * 10.0).width(0.095))
113 | // .collect(),
114 | //)
115 | //.color(Color32::LIGHT_BLUE)
116 | //.name("Normal Distribution");
117 | //chart = chart.horizontal();
118 | //
119 | //Plot::new("Normal Distribution Demo")
120 | // .legend(Legend::default())
121 | // .show_axes([false, false])
122 | // .show_x(false)
123 | // .show_y(false)
124 | // .allow_scroll(false)
125 | // .allow_drag(false)
126 | // //.center_x_axis(true)
127 | // .center_y_axis(true)
128 | // //.clamp_grid(true)
129 | // .show(ui, |plot_ui| plot_ui.bar_chart(chart));
130 | }
131 |
132 | fn settings(
133 | &mut self,
134 | ui: &mut egui::Ui,
135 | tx: Sender,
136 | events_tx: Sender,
137 | ) {
138 | todo!()
139 | }
140 |
141 | fn context_menu(&self, ui: &mut Ui) {
142 | ui.label("Show shit");
143 | }
144 | }
145 |
--------------------------------------------------------------------------------
/src/widgets/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod aggr_liqs;
2 | pub mod aggr_trades;
3 | pub mod chart;
4 | pub mod microstructure;
5 | pub mod settings;
6 |
7 | use crate::defines;
8 | use crate::defines::{Candle, Liquidation, SysEvent, Trade};
9 | use barter_data::model::{MarketEvent, OrderBook};
10 | use eframe::egui;
11 | use eframe::egui::plot::PlotPoint;
12 | use egui_notify::Toasts;
13 | use std::collections::VecDeque;
14 | use std::sync::mpsc::Sender;
15 |
16 | // ----------------------------------------------------------------------------
17 |
18 | /// All widgets have to implement this trait
19 | pub trait Widget {
20 | /// `&'static` so we can also use it as a key to store open/close state.
21 | fn name(&self) -> &'static str;
22 |
23 | /// Show windows, etc
24 | fn show(
25 | &mut self,
26 | ui: &mut egui::Ui,
27 | tx: Sender,
28 | events_tx: Sender,
29 | trades: &mut VecDeque,
30 | candles: &mut VecDeque,
31 | //orderbooks: &mut VecDeque,
32 | best_bids: &mut VecDeque,
33 | best_asks: &mut VecDeque,
34 | liquidations: &mut VecDeque,
35 | );
36 |
37 | fn settings(&mut self, ui: &mut egui::Ui, tx: Sender, events_tx: Sender);
38 |
39 | fn context_menu(&self, ui: &mut egui::Ui);
40 | }
41 |
--------------------------------------------------------------------------------
/src/widgets/settings.rs:
--------------------------------------------------------------------------------
1 | use crate::defines;
2 | use crate::defines::*;
3 | use barter_data::model::{MarketEvent, OrderBook};
4 | use eframe::egui::plot::PlotPoint;
5 | use eframe::egui::{self, Ui};
6 | use egui_notify::Toasts;
7 | use std::collections::VecDeque;
8 | use std::sync::mpsc::Sender;
9 |
10 | pub struct Settings {
11 | pub api_key: String,
12 | pub api_secret: String,
13 | }
14 |
15 | impl Default for Settings {
16 | fn default() -> Self {
17 | Self {
18 | api_key: "".to_string(),
19 | api_secret: "".to_string(),
20 | }
21 | }
22 | }
23 |
24 | impl super::Widget for Settings {
25 | fn name(&self) -> &'static str {
26 | SETTINGS_TITLE
27 | }
28 |
29 | fn show(
30 | &mut self,
31 | ui: &mut egui::Ui,
32 | tx: Sender,
33 | events: Sender,
34 | trades: &mut VecDeque,
35 | candles: &mut VecDeque,
36 | best_bids: &mut VecDeque,
37 | best_asks: &mut VecDeque,
38 | liquidations: &mut VecDeque,
39 | ) {
40 | let Self {
41 | api_key,
42 | api_secret,
43 | } = self;
44 | ui.heading("Enigma Machine Configuration");
45 | ui.separator();
46 |
47 | ui.collapsing("Credentials", |ui| {
48 | ui.horizontal(|ui| {
49 | ui.monospace("API Key:");
50 | ui.text_edit_singleline(api_key);
51 | });
52 | ui.horizontal(|ui| {
53 | ui.monospace("API Secret:");
54 | ui.text_edit_singleline(api_secret);
55 | });
56 | });
57 | ui.separator();
58 |
59 | ui.collapsing("Aesthetics", |ui| {
60 | ui.label("Edit shit here");
61 | // ui.checkbox(&mut style.tabs_are_draggable, "Tabs are draggable");
62 | });
63 | }
64 |
65 | fn settings(
66 | &mut self,
67 | ui: &mut eframe::egui::Ui,
68 | tx: Sender,
69 | events_tx: Sender,
70 | ) {
71 | todo!()
72 | }
73 |
74 | fn context_menu(&self, ui: &mut Ui) {
75 | ui.label("from settings");
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
13 |
14 | 
28 |