diff --git a/Cargo.lock b/Cargo.lock
index 463cb0b..79d0ea0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2327,6 +2327,7 @@ dependencies = [
"arti-hyper",
"benri",
"bytes",
+ "derive_more",
"dirs",
"eframe",
"egui",
@@ -2348,6 +2349,7 @@ dependencies = [
"regex",
"rfd",
"serde",
+ "serde-this-or-that",
"serde_json",
"static_vcruntime",
"strip-ansi-escapes",
@@ -4165,6 +4167,15 @@ dependencies = [
"serde_derive",
]
+[[package]]
+name = "serde-this-or-that"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634c5a3cb041e56cc2964386151c67d520f845445789da3bd46bfb1c94f5e3bb"
+dependencies = [
+ "serde",
+]
+
[[package]]
name = "serde-value"
version = "0.7.0"
diff --git a/Cargo.toml b/Cargo.toml
index 3c18d52..2634ea4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,7 +75,8 @@ walkdir = "2.4.0"
zeroize = "1.7.0"
strsim = "0.11.0"
strip-ansi-escapes = "0.2.0"
-
+derive_more = {version="0.99.17", default-features=false, features=["display"]}
+serde-this-or-that = "0.4.2"
# Unix dependencies
[target.'cfg(unix)'.dependencies]
tar = "0.4.40"
diff --git a/src/app/mod.rs b/src/app/mod.rs
index 3756069..128f5e2 100644
--- a/src/app/mod.rs
+++ b/src/app/mod.rs
@@ -18,6 +18,7 @@ use crate::helper::p2pool::ImgP2pool;
use crate::helper::p2pool::PubP2poolApi;
use crate::helper::xmrig::ImgXmrig;
use crate::helper::xmrig::PubXmrigApi;
+use crate::helper::xvb::PubXvbApi;
use crate::helper::Helper;
use crate::helper::Process;
use crate::helper::ProcessName;
@@ -103,6 +104,7 @@ pub struct App {
pub xmrig: Arc<Mutex<Process>>, // [XMRig] process state
pub p2pool_api: Arc<Mutex<PubP2poolApi>>, // Public ready-to-print P2Pool API made by the "helper" thread
pub xmrig_api: Arc<Mutex<PubXmrigApi>>, // Public ready-to-print XMRig API made by the "helper" thread
+ pub xvb_api: Arc<Mutex<PubXvbApi>>, // Public XvB API
pub p2pool_img: Arc<Mutex<ImgP2pool>>, // A one-time snapshot of what data P2Pool started with
pub xmrig_img: Arc<Mutex<ImgXmrig>>, // A one-time snapshot of what data XMRig started with
// STDIN Buffer
@@ -181,6 +183,7 @@ impl App {
));
let p2pool_api = arc_mut!(PubP2poolApi::new());
let xmrig_api = arc_mut!(PubXmrigApi::new());
+ let xvb_api = arc_mut!(PubXvbApi::new());
let p2pool_img = arc_mut!(ImgP2pool::new());
let xmrig_img = arc_mut!(ImgXmrig::new());
@@ -243,6 +246,7 @@ impl App {
xmrig.clone(),
p2pool_api.clone(),
xmrig_api.clone(),
+ xvb_api.clone(),
p2pool_img.clone(),
xmrig_img.clone(),
arc_mut!(GupaxP2poolApi::new())
@@ -250,6 +254,7 @@ impl App {
p2pool,
xmrig,
p2pool_api,
+ xvb_api,
xmrig_api,
p2pool_img,
xmrig_img,
diff --git a/src/app/panels/middle/mod.rs b/src/app/panels/middle/mod.rs
index 6a40ea1..f881d11 100644
--- a/src/app/panels/middle/mod.rs
+++ b/src/app/panels/middle/mod.rs
@@ -143,7 +143,7 @@ path_xmr: {:#?}\n
}
Tab::Status => {
debug!("App | Entering [Status] Tab");
- crate::disk::state::Status::show(&mut self.state.status, &self.pub_sys, &self.p2pool_api, &self.xmrig_api, &self.p2pool_img, &self.xmrig_img, p2pool_is_alive, xmrig_is_alive, self.max_threads, &self.gupax_p2pool_api, &self.benchmarks, self.width, self.height, ctx, ui);
+ crate::disk::state::Status::show(&mut self.state.status, &self.pub_sys, &self.p2pool_api, &self.xmrig_api, &self.xvb_api,&self.p2pool_img, &self.xmrig_img, p2pool_is_alive, xmrig_is_alive, self.max_threads, &self.gupax_p2pool_api, &self.benchmarks, self.width, self.height, ctx, ui);
}
Tab::Gupax => {
debug!("App | Entering [Gupax] Tab");
diff --git a/src/app/panels/middle/status/mod.rs b/src/app/panels/middle/status/mod.rs
index 8c4c02b..e499f2c 100644
--- a/src/app/panels/middle/status/mod.rs
+++ b/src/app/panels/middle/status/mod.rs
@@ -21,6 +21,7 @@ use crate::{
helper::{
p2pool::{ImgP2pool, PubP2poolApi},
xmrig::{ImgXmrig, PubXmrigApi},
+ xvb::PubXvbApi,
Sys,
},
};
@@ -38,6 +39,7 @@ impl Status {
sys: &Arc<Mutex<Sys>>,
p2pool_api: &Arc<Mutex<PubP2poolApi>>,
xmrig_api: &Arc<Mutex<PubXmrigApi>>,
+ xvb_api: &Arc<Mutex<PubXvbApi>>,
p2pool_img: &Arc<Mutex<ImgP2pool>>,
xmrig_img: &Arc<Mutex<ImgXmrig>>,
p2pool_alive: bool,
@@ -59,10 +61,11 @@ impl Status {
ui,
p2pool_alive,
p2pool_api,
+ p2pool_img,
xmrig_alive,
xmrig_api,
- p2pool_img,
xmrig_img,
+ xvb_api,
max_threads,
);
//---------------------------------------------------------------------------------------------------- [P2Pool]
diff --git a/src/app/panels/middle/status/processes.rs b/src/app/panels/middle/status/processes.rs
index fe0da3c..d679da6 100644
--- a/src/app/panels/middle/status/processes.rs
+++ b/src/app/panels/middle/status/processes.rs
@@ -1,9 +1,10 @@
-use egui::Ui;
+use egui::{ScrollArea, Ui};
use std::sync::{Arc, Mutex};
use crate::disk::state::Status;
use crate::helper::p2pool::{ImgP2pool, PubP2poolApi};
use crate::helper::xmrig::{ImgXmrig, PubXmrigApi};
+use crate::helper::xvb::{PubXvbApi, XvbRound};
use crate::helper::Sys;
use crate::utils::macros::lock;
use egui::TextStyle;
@@ -21,13 +22,14 @@ impl Status {
ui: &mut egui::Ui,
p2pool_alive: bool,
p2pool_api: &Arc<Mutex<PubP2poolApi>>,
+ p2pool_img: &Arc<Mutex<ImgP2pool>>,
xmrig_alive: bool,
xmrig_api: &Arc<Mutex<PubXmrigApi>>,
- p2pool_img: &Arc<Mutex<ImgP2pool>>,
xmrig_img: &Arc<Mutex<ImgXmrig>>,
+ xvb_api: &Arc<Mutex<PubXvbApi>>,
max_threads: usize,
) {
- let width = (width / 3.0) - (SPACE * 1.666);
+ let width = (width / 4.0) - (SPACE * 1.7500);
let min_height = height - SPACE;
let height = height / 25.0;
ui.horizontal(|ui| {
@@ -54,6 +56,8 @@ impl Status {
xmrig_img,
max_threads,
);
+ // [XvB]
+ xvb(ui, min_height, width, height, xvb_api);
});
}
}
@@ -346,3 +350,139 @@ fn xmrig(
})
});
}
+
+fn xvb(ui: &mut Ui, min_height: f32, width: f32, height: f32, xvb_api: &Arc<Mutex<PubXvbApi>>) {
+ //
+ let api = lock!(xvb_api);
+ // if this field is empty, it means nothing was received from the API.
+ let enabled = !api.reward_yearly.is_empty();
+ ScrollArea::vertical().show(ui, |ui| {
+ ui.group(|ui| {
+ ui.vertical(|ui| {
+ debug!("Status Tab | Rendering [XvB]");
+ ui.set_enabled(enabled); // for now there is no API ping or /health, so we verify if the field reward_yearly is empty or not.
+ ui.set_min_height(min_height);
+ ui.add_sized(
+ [width, height],
+ Label::new(
+ RichText::new("[XvB]")
+ .color(LIGHT_GRAY)
+ .text_style(TextStyle::Name("MonospaceLarge".into())),
+ ),
+ )
+ .on_hover_text("XvB API stats")
+ .on_disabled_hover_text("No data received from XvB API");
+ // [Round Type]
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Round Type").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_ROUND_TYPE);
+ ui.add_sized([width, height], Label::new(api.round_type.to_string()));
+ // [Time Remaining]
+ ui.add_sized(
+ [width, height],
+ Label::new(
+ RichText::new("Raffle Round Time Remaining")
+ .underline()
+ .color(BONE),
+ ),
+ )
+ .on_hover_text(STATUS_XVB_TIME_REMAIN);
+ ui.add_sized(
+ [width, height],
+ Label::new(format!("{} minutes left", api.time_remain)),
+ );
+ // Donated Hashrate
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Donated Hashrate").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_DONATED_HR);
+ ui.add_sized(
+ [width, height],
+ Label::new(format!(
+ "Bonus HR\n{}kH/s\n+\n{}kH/s\ndonated by\n{} donors\n with\n{} miners",
+ api.bonus_hr, api.donate_hr, api.donate_miners, api.donate_workers
+ )),
+ );
+ // Players
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Players").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_PLAYERS);
+ ui.add_sized(
+ [width, height],
+ Label::new(format!(
+ "[Registered: {}]\n[Playing: {}]",
+ api.players, api.players_round
+ )),
+ );
+ // Winner
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Winner").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_WINNER);
+ ui.add_sized([width, height], Label::new(&api.winner));
+ // Share effort
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Share Effort").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_SHARE);
+ ui.add_sized([width, height], Label::new(format!("{}", api.share_effort)));
+ // Block reward
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Block Reward").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_BLOCK_REWARD);
+ ui.add_sized([width, height], Label::new(format!("{}", api.block_reward)));
+ //block height
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Block Height").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_BLOCK_HEIGHT);
+ ui.add_sized([width, height], Label::new(format!("{}", api.block_height)));
+ // block hash
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Block Hash").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_BLOCK_HASH);
+ ui.add_sized([width, height], Label::new(format!("{}", api.block_hash)));
+ // reward yearly
+ ui.add_sized(
+ [width, height],
+ Label::new(RichText::new("Reward Yearly").underline().color(BONE)),
+ )
+ .on_hover_text(STATUS_XVB_YEARLY);
+ if api.reward_yearly.is_empty() {
+ ui.add_sized([width, height], Label::new("No information".to_string()));
+ } else {
+ ui.add_sized(
+ [width, height],
+ Label::new(format!(
+ "{}: {} XMR\n{}: {} XMR\n{}: {} XMR\n{}: {} XMR\n{}: {} XMR",
+ XvbRound::Vip,
+ api.reward_yearly[0],
+ XvbRound::Donor,
+ api.reward_yearly[1],
+ XvbRound::DonorVip,
+ api.reward_yearly[2],
+ XvbRound::DonorWhale,
+ api.reward_yearly[3],
+ XvbRound::DonorMega,
+ api.reward_yearly[4]
+ )),
+ );
+ }
+ drop(api);
+ });
+ // by round
+ });
+ });
+}
diff --git a/src/helper/mod.rs b/src/helper/mod.rs
index 798c063..078fc07 100644
--- a/src/helper/mod.rs
+++ b/src/helper/mod.rs
@@ -47,8 +47,11 @@ use std::{
thread,
time::*,
};
+
+use self::xvb::PubXvbApi;
pub mod p2pool;
pub mod xmrig;
+pub mod xvb;
//---------------------------------------------------------------------------------------------------- Constants
// The max amount of bytes of process output we are willing to
@@ -71,10 +74,12 @@ pub struct Helper {
pub xmrig: Arc<Mutex<Process>>, // XMRig process state
pub gui_api_p2pool: Arc<Mutex<PubP2poolApi>>, // P2Pool API state (for GUI thread)
pub gui_api_xmrig: Arc<Mutex<PubXmrigApi>>, // XMRig API state (for GUI thread)
+ pub gui_api_xvb: Arc<Mutex<PubXvbApi>>, // XMRig API state (for GUI thread)
pub img_p2pool: Arc<Mutex<ImgP2pool>>, // A static "image" of the data P2Pool started with
pub img_xmrig: Arc<Mutex<ImgXmrig>>, // A static "image" of the data XMRig started with
pub_api_p2pool: Arc<Mutex<PubP2poolApi>>, // P2Pool API state (for Helper/P2Pool thread)
pub_api_xmrig: Arc<Mutex<PubXmrigApi>>, // XMRig API state (for Helper/XMRig thread)
+ pub_api_xvb: Arc<Mutex<PubXvbApi>>, // XvB API state (for Helper/XvB thread)
pub gupax_p2pool_api: Arc<Mutex<GupaxP2poolApi>>, //
}
@@ -273,6 +278,7 @@ impl Helper {
xmrig: Arc<Mutex<Process>>,
gui_api_p2pool: Arc<Mutex<PubP2poolApi>>,
gui_api_xmrig: Arc<Mutex<PubXmrigApi>>,
+ gui_api_xvb: Arc<Mutex<PubXvbApi>>,
img_p2pool: Arc<Mutex<ImgP2pool>>,
img_xmrig: Arc<Mutex<ImgXmrig>>,
gupax_p2pool_api: Arc<Mutex<GupaxP2poolApi>>,
@@ -283,11 +289,13 @@ impl Helper {
uptime: HumanTime::into_human(instant.elapsed()),
pub_api_p2pool: arc_mut!(PubP2poolApi::new()),
pub_api_xmrig: arc_mut!(PubXmrigApi::new()),
+ pub_api_xvb: arc_mut!(PubXvbApi::new()),
// These are created when initializing [App], since it needs a handle to it as well
p2pool,
xmrig,
gui_api_p2pool,
gui_api_xmrig,
+ gui_api_xvb,
img_p2pool,
img_xmrig,
gupax_p2pool_api,
@@ -402,8 +410,10 @@ impl Helper {
let pub_sys = Arc::clone(&lock.pub_sys);
let gui_api_p2pool = Arc::clone(&lock.gui_api_p2pool);
let gui_api_xmrig = Arc::clone(&lock.gui_api_xmrig);
+ let gui_api_xvb = Arc::clone(&lock.gui_api_xvb);
let pub_api_p2pool = Arc::clone(&lock.pub_api_p2pool);
let pub_api_xmrig = Arc::clone(&lock.pub_api_xmrig);
+ let pub_api_xvb = Arc::clone(&lock.pub_api_xvb);
drop(lock);
let sysinfo_cpu = sysinfo::CpuRefreshKind::everything();
@@ -423,21 +433,25 @@ impl Helper {
// 2. Lock... EVERYTHING!
let mut lock = lock!(helper);
- debug!("Helper | Locking (1/9) ... [helper]");
+ debug!("Helper | Locking (1/10) ... [helper]");
let p2pool = lock!(p2pool);
- debug!("Helper | Locking (2/9) ... [p2pool]");
+ debug!("Helper | Locking (2/10) ... [p2pool]");
let xmrig = lock!(xmrig);
- debug!("Helper | Locking (3/9) ... [xmrig]");
+ debug!("Helper | Locking (3/10) ... [xmrig]");
let mut lock_pub_sys = lock!(pub_sys);
- debug!("Helper | Locking (5/9) ... [pub_sys]");
+ debug!("Helper | Locking (4/10) ... [pub_sys]");
let mut gui_api_p2pool = lock!(gui_api_p2pool);
- debug!("Helper | Locking (6/9) ... [gui_api_p2pool]");
+ debug!("Helper | Locking (5/10) ... [gui_api_p2pool]");
let mut gui_api_xmrig = lock!(gui_api_xmrig);
- debug!("Helper | Locking (7/9) ... [gui_api_xmrig]");
+ debug!("Helper | Locking (6/10) ... [gui_api_xmrig]");
+ let mut gui_api_xvb = lock!(gui_api_xvb);
+ debug!("Helper | Locking (7/10) ... [gui_api_xvb]");
let mut pub_api_p2pool = lock!(pub_api_p2pool);
- debug!("Helper | Locking (8/9) ... [pub_api_p2pool]");
+ debug!("Helper | Locking (8/10) ... [pub_api_p2pool]");
let mut pub_api_xmrig = lock!(pub_api_xmrig);
- debug!("Helper | Locking (9/9) ... [pub_api_xmrig]");
+ debug!("Helper | Locking (9/10) ... [pub_api_xmrig]");
+ let mut pub_api_xvb = lock!(pub_api_xvb);
+ debug!("Helper | Locking (10/10) ... [pub_api_xvb]");
// Calculate Gupax's uptime always.
lock.uptime = HumanTime::into_human(lock.instant.elapsed());
// If [P2Pool] is alive...
@@ -454,6 +468,9 @@ impl Helper {
} else {
debug!("Helper | XMRig is dead! Skipping...");
}
+ // XvB API is considered always available
+ debug!("Helper | XvB is alive! Running [combine_gui_pub_api()]");
+ PubXvbApi::combine_gui_pub_api(&mut gui_api_xvb, &mut pub_api_xvb);
// 2. Selectively refresh [sysinfo] for only what we need (better performance).
sysinfo.refresh_cpu_specifics(sysinfo_cpu);
@@ -473,21 +490,25 @@ impl Helper {
// 3. Drop... (almost) EVERYTHING... IN REVERSE!
drop(lock_pub_sys);
- debug!("Helper | Unlocking (1/9) ... [pub_sys]");
+ debug!("Helper | Unlocking (1/10) ... [pub_sys]");
drop(xmrig);
- debug!("Helper | Unlocking (2/9) ... [xmrig]");
+ debug!("Helper | Unlocking (2/10) ... [xmrig]");
drop(p2pool);
- debug!("Helper | Unlocking (3/9) ... [p2pool]");
+ debug!("Helper | Unlocking (3/10) ... [p2pool]");
+ drop(pub_api_xvb);
+ debug!("Helper | Unlocking (4/10) ... [pub_api_xvb]");
drop(pub_api_xmrig);
- debug!("Helper | Unlocking (4/9) ... [pub_api_xmrig]");
+ debug!("Helper | Unlocking (5/10) ... [pub_api_xmrig]");
drop(pub_api_p2pool);
- debug!("Helper | Unlocking (5/9) ... [pub_api_p2pool]");
+ debug!("Helper | Unlocking (6/10) ... [pub_api_p2pool]");
+ drop(gui_api_xvb);
+ debug!("Helper | Unlocking (7/10) ... [gui_api_xvb]");
drop(gui_api_xmrig);
- debug!("Helper | Unlocking (6/9) ... [gui_api_xmrig]");
+ debug!("Helper | Unlocking (8/10) ... [gui_api_xmrig]");
drop(gui_api_p2pool);
- debug!("Helper | Unlocking (7/9) ... [gui_api_p2pool]");
+ debug!("Helper | Unlocking (9/10) ... [gui_api_p2pool]");
drop(lock);
- debug!("Helper | Unlocking (8/9) ... [helper]");
+ debug!("Helper | Unlocking (10/10) ... [helper]");
// 4. Calculate if we should sleep or not.
// If we should sleep, how long?
diff --git a/src/helper/xvb.rs b/src/helper/xvb.rs
new file mode 100644
index 0000000..9c0c956
--- /dev/null
+++ b/src/helper/xvb.rs
@@ -0,0 +1,162 @@
+use derive_more::Display;
+use hyper::client::HttpConnector;
+use hyper_tls::HttpsConnector;
+use log::{debug, info, warn};
+use serde::Deserialize;
+use std::{
+ sync::{Arc, Mutex},
+ thread,
+ time::Instant,
+};
+
+use crate::utils::{constants::XVB_URL_PUBLIC_API, macros::lock};
+
+use super::Helper;
+
+impl Helper {
+ pub fn start_xvb(helper: &Arc<Mutex<Self>>) {
+ let https = HttpsConnector::new();
+ let client = hyper::Client::builder().build(https);
+ let gui_api = Arc::clone(&lock!(helper).gui_api_xvb);
+ let pub_api = Arc::clone(&lock!(helper).pub_api_xvb);
+ thread::spawn(move || {
+ Self::spawn_xvb_watchdog(client, gui_api, pub_api);
+ });
+ }
+ #[tokio::main]
+ async fn spawn_xvb_watchdog(
+ client: hyper::Client<HttpsConnector<HttpConnector>>,
+ gui_api: Arc<Mutex<PubXvbApi>>,
+ pub_api: Arc<Mutex<PubXvbApi>>,
+ ) {
+ info!("XvB started");
+ // Reset stats before loop
+ *lock!(pub_api) = PubXvbApi::new();
+ *lock!(gui_api) = PubXvbApi::new();
+
+ info!("XvB | Entering watchdog mode... woof!");
+ loop {
+ // Set timer
+ let now = Instant::now();
+ debug!("XvB Watchdog | ----------- Start of loop -----------");
+ // Send an HTTP API request
+ debug!("XvB Watchdog | Attempting HTTP API request...");
+ match PubXvbApi::request_xvb_public_api(client.clone(), XVB_URL_PUBLIC_API).await {
+ Ok(new_data) => {
+ debug!("XvB Watchdog | HTTP API request OK");
+ let mut data = lock!(&pub_api);
+ *data = new_data;
+ }
+ Err(err) => {
+ warn!(
+ "XvB Watchdog | Could not send HTTP API request to: {}\n:{}",
+ XVB_URL_PUBLIC_API, err
+ );
+ }
+ }
+ // XvB Status do not need to be refreshed like others because combine_with_gui do not refresh if no data is changed.
+ let elapsed = now.elapsed().as_secs();
+ if elapsed < 59 {
+ let sleep = (60 - elapsed) as u64;
+ debug!("XvB Watchdog | END OF LOOP - Sleeping for [{}]s...", sleep);
+ std::thread::sleep(std::time::Duration::from_secs(sleep))
+ } else {
+ debug!("XMRig Watchdog | END OF LOOP - Not sleeping!");
+ }
+ }
+ }
+}
+//---------------------------------------------------------------------------------------------------- Public XvB API
+use serde_this_or_that::as_u64;
+#[derive(Debug, Clone, Default, Deserialize)]
+pub struct PubXvbApi {
+ pub time_remain: u32, // remaining time of round in minutes
+ pub bonus_hr: f64,
+ pub donate_hr: f64, // donated hr from all donors
+ pub donate_miners: u32, // numbers of donors
+ pub donate_workers: u32, // numbers of workers from donors
+ pub players: u32,
+ pub players_round: u32,
+ pub winner: String,
+ pub share_effort: String,
+ pub block_reward: String,
+ pub round_type: XvbRound,
+ #[serde(deserialize_with = "as_u64")]
+ pub block_height: u64,
+ pub block_hash: String,
+ #[serde(deserialize_with = "as_u64")]
+ pub roll_winner: u64,
+ #[serde(deserialize_with = "as_u64")]
+ pub roll_round: u64,
+ pub reward_yearly: Vec<f64>,
+}
+
+#[derive(Debug, Clone, Default, Display, Deserialize)]
+pub enum XvbRound {
+ #[default]
+ #[serde(alias = "vip")]
+ Vip,
+ #[serde(alias = "donor")]
+ Donor,
+ #[serde(alias = "donor_vip")]
+ DonorVip,
+ #[serde(alias = "donor_whale")]
+ DonorWhale,
+ #[serde(alias = "donor_mega")]
+ DonorMega,
+}
+
+impl PubXvbApi {
+ pub fn new() -> Self {
+ Self::default()
+ }
+ pub(super) fn combine_gui_pub_api(gui_api: &mut Self, pub_api: &mut Self) {
+ // update only if there is data, if no new data, pub_api fields are on default value.
+ if !pub_api.reward_yearly.is_empty() {
+ *gui_api = std::mem::take(pub_api)
+ }
+ }
+ #[inline]
+ // Send an HTTP request to XvB's API, serialize it into [Self] and return it
+ async fn request_xvb_public_api(
+ client: hyper::Client<HttpsConnector<HttpConnector>>,
+ api_uri: &str,
+ ) -> std::result::Result<Self, anyhow::Error> {
+ let request = hyper::Request::builder()
+ .method("GET")
+ .uri(api_uri)
+ .body(hyper::Body::empty())?;
+ let response =
+ tokio::time::timeout(std::time::Duration::from_secs(8), client.request(request))
+ .await?;
+ // let response = client.request(request).await;
+
+ let body = hyper::body::to_bytes(response?.body_mut()).await?;
+ Ok(serde_json::from_slice::<Self>(&body)?)
+ }
+}
+//---------------------------------------------------------------------------------------------------- TEST
+#[cfg(test)]
+mod test {
+ use std::thread;
+
+ use super::PubXvbApi;
+ use crate::utils::constants::XVB_URL_PUBLIC_API;
+ use hyper::Client;
+ use hyper_tls::HttpsConnector;
+
+ #[test]
+ fn public_api_deserialize() {
+ let https = HttpsConnector::new();
+ let client = hyper::Client::builder().build(https);
+ let new_data = thread::spawn(move || corr(client)).join().unwrap();
+ assert!(!new_data.reward_yearly.is_empty());
+ dbg!(new_data);
+ }
+ #[tokio::main]
+ async fn corr(client: Client<HttpsConnector<hyper::client::HttpConnector>>) -> PubXvbApi {
+ PubXvbApi::request_xvb_public_api(client, XVB_URL_PUBLIC_API)
+ .await
+ .unwrap()
+ }
+}
diff --git a/src/inits.rs b/src/inits.rs
index 0548b6b..45c020d 100644
--- a/src/inits.rs
+++ b/src/inits.rs
@@ -206,4 +206,7 @@ pub fn init_auto(app: &mut App) {
} else {
info!("Skipping auto-xmrig...");
}
+ // [XvB]
+ // For now, the XvB client of the API for receiving public informations is always enabled.
+ Helper::start_xvb(&app.helper);
}
diff --git a/src/utils/constants.rs b/src/utils/constants.rs
index c987bce..d70cbfc 100644
--- a/src/utils/constants.rs
+++ b/src/utils/constants.rs
@@ -181,6 +181,18 @@ pub const STATUS_XMRIG_DIFFICULTY: &str = "The current difficulty of the job XMR
pub const STATUS_XMRIG_SHARES: &str = "The amount of accepted and rejected shares";
pub const STATUS_XMRIG_POOL: &str = "The pool XMRig is currently mining to";
pub const STATUS_XMRIG_THREADS: &str = "The amount of threads XMRig is currently using";
+//--
+pub const STATUS_XVB_TIME_REMAIN: &str = "Minutes left before end of round";
+pub const STATUS_XVB_ROUND_TYPE: &str = "The current round type";
+pub const STATUS_XVB_PLAYERS: &str =
+ "Numbers of registred players and currently playing in the round";
+pub const STATUS_XVB_DONATED_HR: &str = "Hashrate donated to the raffle";
+pub const STATUS_XVB_WINNER: &str = "Current Raffle Winner";
+pub const STATUS_XVB_SHARE: &str = "Share effort";
+pub const STATUS_XVB_BLOCK_REWARD: &str = "Block reward";
+pub const STATUS_XVB_BLOCK_HEIGHT: &str = "height of the current block";
+pub const STATUS_XVB_BLOCK_HASH: &str = "hash of the block that is being worked on";
+pub const STATUS_XVB_YEARLY: &str = "Average yearly reward per round type";
// Status Submenus
pub const STATUS_SUBMENU_PROCESSES: &str =
"View the status of process related data for [Gupax|P2Pool|XMRig]";
@@ -390,6 +402,7 @@ pub const XMRIG_PATH_EMPTY: &str = "XMRig PATH is empty! To fix: goto the [G
// XvB
pub const XVB_HELP: &str = "You need to register an account by clicking on the link above to get your token with the same p2pool XMR address you use for payment.";
pub const XVB_URL: &str = "https://xmrvsbeast.com";
+pub const XVB_URL_PUBLIC_API: &str = "https://xmrvsbeast.com/p2pool/stats";
// CLI argument messages
pub const ARG_HELP: &str = r#"USAGE: ./gupax [--flag]