From 2e0cf5c9465b08d24501f431bd2caf0b6728c117 Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Mon, 12 Aug 2024 14:49:14 +0200
Subject: [PATCH 1/6] Implemented display for cpu temperatures

---
 src-tauri/src/cpu_miner.rs                    | 27 +++++-
 src-tauri/src/main.rs                         | 23 ++++-
 src/containers/SideBar/components/Heading.tsx |  2 +-
 .../components/Settings/Card.component.tsx    | 25 ++++++
 .../components/Settings/Settings.styles.tsx   | 14 ++++
 .../components/{ => Settings}/Settings.tsx    | 83 ++++++++++++++++---
 src/store/useAppStatusStore.ts                |  1 +
 src/types/app-status.ts                       |  7 ++
 8 files changed, 164 insertions(+), 18 deletions(-)
 create mode 100644 src/containers/SideBar/components/Settings/Card.component.tsx
 create mode 100644 src/containers/SideBar/components/Settings/Settings.styles.tsx
 rename src/containers/SideBar/components/{ => Settings}/Settings.tsx (67%)

diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index 4bd333013..f5eaf973b 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -3,11 +3,11 @@ use crate::mm_proxy_manager::MmProxyManager;
 use crate::xmrig::http_api::XmrigHttpApiClient;
 use crate::xmrig_adapter::{XmrigAdapter, XmrigNodeConnection};
 use crate::{
-    CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus, CpuMinerStatus, ProgressTracker,
+    CpuCoreTemperature, CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus, CpuMinerStatus, ProgressTracker
 };
 use log::warn;
 use std::path::PathBuf;
-use sysinfo::{CpuRefreshKind, RefreshKind, System};
+use sysinfo::{Component, Components, CpuRefreshKind, RefreshKind, System};
 use tari_core::transactions::tari_amount::MicroMinotari;
 use tari_shutdown::{Shutdown, ShutdownSignal};
 use tauri::async_runtime::JoinHandle;
@@ -26,6 +26,7 @@ pub(crate) struct CpuMiner {
     watcher_task: Option<JoinHandle<Result<(), anyhow::Error>>>,
     miner_shutdown: Shutdown,
     api_client: Option<XmrigHttpApiClient>,
+    cpu_temperature_components: Components
 }
 
 impl CpuMiner {
@@ -34,6 +35,7 @@ impl CpuMiner {
             watcher_task: None,
             miner_shutdown: Shutdown::new(),
             api_client: None,
+            cpu_temperature_components: Components::new_with_refreshed_list()
         }
     }
 
@@ -156,10 +158,26 @@ impl CpuMiner {
     }
 
     pub async fn status(
-        &self,
+        &mut self,
         network_hash_rate: u64,
         block_reward: MicroMinotari,
     ) -> Result<CpuMinerStatus, anyhow::Error> {
+        
+        let components = &mut self.cpu_temperature_components;
+        components.refresh();
+
+        let cpu_components:Vec<&Component> = components.iter().filter(|component| component.label().contains("Core")).collect();
+        let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components.iter().map(|component| {
+            CpuCoreTemperature {
+                id: component.label().split(" ").last().unwrap().parse().unwrap(),
+                label: component.label().split(" ").skip(1).collect::<Vec<&str>>().join(" ").to_string(),
+                temperature: component.temperature(),
+                max_temperature: component.max(),
+            }
+        }).collect(); 
+
+        // cpu_temperatures.sort();
+
         let mut s =
             System::new_with_specifics(RefreshKind::new().with_cpu(CpuRefreshKind::everything()));
 
@@ -171,6 +189,7 @@ impl CpuMiner {
         let cpu_brand = s.cpus().get(0).map(|cpu| cpu.brand()).unwrap_or("Unknown");
 
         let cpu_usage = s.global_cpu_usage() as u32;
+        // let cpu_temperature = s.
 
         match &self.api_client {
             Some(client) => {
@@ -192,6 +211,7 @@ impl CpuMiner {
                         && xmrig_status.hashrate.total[0].unwrap() > 0.0,
                     hash_rate,
                     cpu_usage: cpu_usage as u32,
+                    cpu_temperatures,
                     cpu_brand: cpu_brand.to_string(),
                     estimated_earnings: MicroMinotari(estimated_earnings).as_u64(),
                     connection: CpuMinerConnectionStatus {
@@ -207,6 +227,7 @@ impl CpuMiner {
             None => Ok(CpuMinerStatus {
                 is_mining: false,
                 hash_rate: 0.0,
+                cpu_temperatures,
                 cpu_usage: cpu_usage as u32,
                 cpu_brand: cpu_brand.to_string(),
                 estimated_earnings: 0,
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index cdd8d4170..8318e5180 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -365,7 +365,7 @@ async fn get_applications_versions(app: tauri::AppHandle) -> Result<Applications
 // Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
 #[tauri::command]
 async fn status(state: tauri::State<'_, UniverseAppState>) -> Result<AppStatus, String> {
-    let cpu_miner = state.cpu_miner.read().await;
+    let mut cpu_miner = state.cpu_miner.write().await;
     let (_sha_hash_rate, randomx_hash_rate, block_reward, block_height, block_time, is_synced) =
         state
             .node_manager
@@ -440,11 +440,32 @@ pub struct BaseNodeStatus {
     is_synced: bool,
 }
 
+#[derive(Debug, Serialize, PartialEq, PartialOrd)]
+pub struct CpuCoreTemperature {
+    pub id : u32,
+    pub label: String,
+    pub temperature: f32,
+    pub max_temperature: f32,
+}
+
+impl Ord for CpuCoreTemperature {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.id.cmp(&other.id)
+    }
+}
+
+impl Eq for CpuCoreTemperature {
+    fn assert_receiver_is_total_eq(&self) {
+        self.id.assert_receiver_is_total_eq();
+    }
+} 
+
 #[derive(Debug, Serialize)]
 pub struct CpuMinerStatus {
     pub is_mining: bool,
     pub hash_rate: f64,
     pub cpu_usage: u32,
+    pub cpu_temperatures: Vec<CpuCoreTemperature>,
     pub cpu_brand: String,
     pub estimated_earnings: u64,
     pub connection: CpuMinerConnectionStatus,
diff --git a/src/containers/SideBar/components/Heading.tsx b/src/containers/SideBar/components/Heading.tsx
index 93861447e..5554f8fa2 100644
--- a/src/containers/SideBar/components/Heading.tsx
+++ b/src/containers/SideBar/components/Heading.tsx
@@ -1,6 +1,6 @@
 import { Stack, Typography, IconButton } from '@mui/material';
 import { CgArrowsExpandRight, CgCompressRight } from 'react-icons/cg';
-import SettingsDialog from './Settings';
+import SettingsDialog from './Settings/Settings.tsx';
 import { useUIStore } from '../../../store/useUIStore.ts';
 
 function Heading() {
diff --git a/src/containers/SideBar/components/Settings/Card.component.tsx b/src/containers/SideBar/components/Settings/Card.component.tsx
new file mode 100644
index 000000000..4df26f5a1
--- /dev/null
+++ b/src/containers/SideBar/components/Settings/Card.component.tsx
@@ -0,0 +1,25 @@
+import { Stack, Typography } from '@mui/material';
+import { CardItem } from './Settings.styles';
+
+export interface CardComponentProps {
+    heading: string;
+    labels: { labelText: string; labelValue: string }[];
+}
+
+export const CardComponent = ({ heading, labels }: CardComponentProps) => {
+    return (
+        <CardItem gap={1}>
+            <Typography variant="h6">{heading}</Typography>
+            <Stack gap={0.5}>
+                {labels.map(({ labelText, labelValue }) => (
+                    <Stack direction="row" key={labelText} gap={1}>
+                        <Typography key={labelText}>{labelText}:</Typography>
+                        <Typography sx={{ color: 'black' }} key={labelValue}>
+                            {labelValue}
+                        </Typography>
+                    </Stack>
+                ))}
+            </Stack>
+        </CardItem>
+    );
+};
diff --git a/src/containers/SideBar/components/Settings/Settings.styles.tsx b/src/containers/SideBar/components/Settings/Settings.styles.tsx
new file mode 100644
index 000000000..d27417818
--- /dev/null
+++ b/src/containers/SideBar/components/Settings/Settings.styles.tsx
@@ -0,0 +1,14 @@
+import { Box, Stack, styled } from '@mui/material';
+
+export const CardContainer = styled(Box)(({ theme }) => ({
+    display: 'grid',
+    gridTemplateColumns: '1fr 1fr',
+    gap: theme.spacing(1),
+}));
+
+export const CardItem = styled(Stack)(({ theme }) => ({
+    padding: theme.spacing(1, 1.5),
+    backgroundColor: theme.palette.background.paper,
+    borderRadius: theme.shape.borderRadius,
+    boxShadow: '0px 4px 45px 0px rgba(0, 0, 0, 0.08)',
+}));
diff --git a/src/containers/SideBar/components/Settings.tsx b/src/containers/SideBar/components/Settings/Settings.tsx
similarity index 67%
rename from src/containers/SideBar/components/Settings.tsx
rename to src/containers/SideBar/components/Settings/Settings.tsx
index e6dcc78dc..f839e51ae 100644
--- a/src/containers/SideBar/components/Settings.tsx
+++ b/src/containers/SideBar/components/Settings/Settings.tsx
@@ -15,10 +15,13 @@ import {
     Tooltip,
 } from '@mui/material';
 import { IoSettingsOutline, IoClose } from 'react-icons/io5';
-import { useGetSeedWords } from '../../../hooks/useGetSeedWords';
-import truncateString from '../../../utils/truncateString';
+import { useGetSeedWords } from '../../../../hooks/useGetSeedWords';
+import truncateString from '../../../../utils/truncateString';
 import { invoke } from '@tauri-apps/api/tauri';
-import { useGetApplicatonsVersions } from '../../../hooks/useGetApplicatonsVersions';
+import { useGetApplicatonsVersions } from '../../../../hooks/useGetApplicatonsVersions';
+import { useAppStatusStore } from '../../../../store/useAppStatusStore';
+import { CardContainer } from './Settings.styles';
+import { CardComponent } from './Card.component';
 
 const Settings: React.FC = () => {
     const { refreshVersions, applicationsVersions, mainAppVersion } =
@@ -29,6 +32,9 @@ const Settings: React.FC = () => {
     const [isCopyTooltipHidden, setIsCopyTooltipHidden] = useState(true);
     const { seedWords, getSeedWords, seedWordsFetched, seedWordsFetching } =
         useGetSeedWords();
+    const cpuTemperatures = useAppStatusStore(
+        (state) => state.cpu?.cpu_temperatures
+    );
 
     const handleClickOpen = () => setOpen(true);
     const handleClose = () => {
@@ -171,9 +177,10 @@ const Settings: React.FC = () => {
                     </Box>
                     <Divider />
                     {applicationsVersions && (
-                        <Stack spacing={1} pt={1}>
+                        <Stack spacing={1} py={1}>
                             <Stack
                                 direction="row"
+                                alignItems="center"
                                 justifyContent="space-between"
                             >
                                 <Typography variant="h5">Versions</Typography>
@@ -181,17 +188,67 @@ const Settings: React.FC = () => {
                                     Refresh Versions
                                 </Button>
                             </Stack>
-                            <Divider />
-                            <Typography>mainApp: {mainAppVersion}</Typography>
-                            {Object.entries(applicationsVersions).map(
-                                ([key, value]) => (
-                                    <Typography key={key}>
-                                        {key}: {value}
-                                    </Typography>
-                                )
-                            )}
+
+                            <CardContainer>
+                                <CardComponent
+                                    heading="Main app"
+                                    labels={[
+                                        {
+                                            labelText: 'version',
+                                            labelValue:
+                                                mainAppVersion || 'Unknown',
+                                        },
+                                    ]}
+                                />
+                                {Object.entries(applicationsVersions).map(
+                                    ([key, value]) => (
+                                        <CardComponent
+                                            key={key}
+                                            heading={key}
+                                            labels={[
+                                                {
+                                                    labelText: 'version',
+                                                    labelValue: value,
+                                                },
+                                            ]}
+                                        />
+                                    )
+                                )}
+                            </CardContainer>
                         </Stack>
                     )}
+                    <Divider />
+                    <Stack spacing={1} pt={1}>
+                        <Typography variant="h5">CPU Temperatures</Typography>
+                        {cpuTemperatures ? (
+                            <CardContainer>
+                                {cpuTemperatures.map((core) => (
+                                    <CardComponent
+                                        key={core.label}
+                                        heading={core.label}
+                                        labels={[
+                                            {
+                                                labelText:
+                                                    'Current temperature',
+                                                labelValue:
+                                                    core.temperature.toString() +
+                                                    '°C',
+                                            },
+                                            {
+                                                labelText: 'Max temperature',
+                                                labelValue:
+                                                    core.max_temperature.toString() +
+                                                    '°C',
+                                            },
+                                        ]}
+                                    />
+                                ))}
+                            </CardContainer>
+                        ) : (
+                            <Typography>No CPU Temperatures</Typography>
+                        )}
+                    </Stack>
+                    <Divider />
                     <Stack spacing={1} pt={1}>
                         <Button onClick={openLogsDirectory}>
                             Open logs directory
diff --git a/src/store/useAppStatusStore.ts b/src/store/useAppStatusStore.ts
index 443123f67..44046535e 100644
--- a/src/store/useAppStatusStore.ts
+++ b/src/store/useAppStatusStore.ts
@@ -21,6 +21,7 @@ const initialState: AppStatus = {
     mode: 'Eco',
     auto_mining: false,
     main_app_version: undefined,
+    applications_versions: undefined,
 };
 export const useAppStatusStore = create<AppStatusStoreState>()(
     persist(
diff --git a/src/types/app-status.ts b/src/types/app-status.ts
index f5dfcdc12..99b89c723 100644
--- a/src/types/app-status.ts
+++ b/src/types/app-status.ts
@@ -10,11 +10,18 @@ export interface AppStatus {
     auto_mining: boolean;
 }
 
+export interface CpuCoreTemperature {
+    label: string;
+    temperature: number;
+    max_temperature: number;
+}
+
 export interface CpuMinerStatus {
     is_mining: boolean;
     hash_rate: number;
     cpu_usage: number;
     cpu_brand: string;
+    cpu_temperatures: CpuCoreTemperature[];
     estimated_earnings: number;
     connection: CpuMinerConnectionStatus;
 }

From 3f9a04c816c9b36e5b7c0737f9f1c6e2f9117632 Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Mon, 12 Aug 2024 16:17:15 +0200
Subject: [PATCH 2/6] Working cpu temps display

---
 src-tauri/src/cpu_miner.rs | 37 +++++++++++++++++++++++++------------
 src-tauri/src/main.rs      |  4 ++--
 2 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index f5eaf973b..31387524a 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -6,6 +6,7 @@ use crate::{
     CpuCoreTemperature, CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus, CpuMinerStatus, ProgressTracker
 };
 use log::warn;
+use std::ops::Deref;
 use std::path::PathBuf;
 use sysinfo::{Component, Components, CpuRefreshKind, RefreshKind, System};
 use tari_core::transactions::tari_amount::MicroMinotari;
@@ -26,7 +27,8 @@ pub(crate) struct CpuMiner {
     watcher_task: Option<JoinHandle<Result<(), anyhow::Error>>>,
     miner_shutdown: Shutdown,
     api_client: Option<XmrigHttpApiClient>,
-    cpu_temperature_components: Components
+    cpu_temperature_components: Components,
+    cpu_temperatures: Vec<CpuCoreTemperature>,
 }
 
 impl CpuMiner {
@@ -35,7 +37,8 @@ impl CpuMiner {
             watcher_task: None,
             miner_shutdown: Shutdown::new(),
             api_client: None,
-            cpu_temperature_components: Components::new_with_refreshed_list()
+            cpu_temperature_components: Components::new_with_refreshed_list(),
+            cpu_temperatures: Vec::new(),
         }
     }
 
@@ -168,15 +171,25 @@ impl CpuMiner {
 
         let cpu_components:Vec<&Component> = components.iter().filter(|component| component.label().contains("Core")).collect();
         let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components.iter().map(|component| {
-            CpuCoreTemperature {
-                id: component.label().split(" ").last().unwrap().parse().unwrap(),
-                label: component.label().split(" ").skip(1).collect::<Vec<&str>>().join(" ").to_string(),
-                temperature: component.temperature(),
-                max_temperature: component.max(),
+                CpuCoreTemperature {
+                    id: component.label().split(" ").last().unwrap().parse().unwrap(),
+                    label: component.label().split(" ").skip(1).collect::<Vec<&str>>().join(" ").to_string(),
+                    temperature: component.temperature(),
+                    max_temperature: component.max(),
+                }
+            }).collect();
+
+        if self.cpu_temperatures.is_empty() {
+            self.cpu_temperatures = cpu_temperatures.clone()
+        }else {
+            for (i, component) in cpu_temperatures.clone().iter().enumerate() {
+                let position = self.cpu_temperatures.iter().position(|x| x.id == component.id).unwrap();
+                self.cpu_temperatures[position].temperature = component.temperature;
+                if component.temperature > self.cpu_temperatures[position].max_temperature {
+                    self.cpu_temperatures[position].max_temperature = self.cpu_temperatures[i].temperature;
+                }
             }
-        }).collect(); 
-
-        // cpu_temperatures.sort();
+        }
 
         let mut s =
             System::new_with_specifics(RefreshKind::new().with_cpu(CpuRefreshKind::everything()));
@@ -211,7 +224,7 @@ impl CpuMiner {
                         && xmrig_status.hashrate.total[0].unwrap() > 0.0,
                     hash_rate,
                     cpu_usage: cpu_usage as u32,
-                    cpu_temperatures,
+                    cpu_temperatures: self.cpu_temperatures.clone(),
                     cpu_brand: cpu_brand.to_string(),
                     estimated_earnings: MicroMinotari(estimated_earnings).as_u64(),
                     connection: CpuMinerConnectionStatus {
@@ -227,7 +240,7 @@ impl CpuMiner {
             None => Ok(CpuMinerStatus {
                 is_mining: false,
                 hash_rate: 0.0,
-                cpu_temperatures,
+                cpu_temperatures: self.cpu_temperatures.clone(),
                 cpu_usage: cpu_usage as u32,
                 cpu_brand: cpu_brand.to_string(),
                 estimated_earnings: 0,
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 8318e5180..e1d20e29f 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -440,9 +440,9 @@ pub struct BaseNodeStatus {
     is_synced: bool,
 }
 
-#[derive(Debug, Serialize, PartialEq, PartialOrd)]
+#[derive(Debug, Serialize, PartialEq, PartialOrd, Clone)]
 pub struct CpuCoreTemperature {
-    pub id : u32,
+    pub id: u32,
     pub label: String,
     pub temperature: f32,
     pub max_temperature: f32,

From f1c956705ea99101c4fa73181771237150fead99 Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Tue, 13 Aug 2024 10:57:42 +0200
Subject: [PATCH 3/6] implement temperatures for gpu

---
 src-tauri/Cargo.lock                          | 46 ++++++++++++
 src-tauri/Cargo.toml                          |  1 +
 src-tauri/src/cpu_miner.rs                    |  6 +-
 src-tauri/src/gpu_miner.rs                    | 75 +++++++++++++++++++
 src-tauri/src/main.rs                         | 62 +++++++++------
 .../SideBar/components/Settings/Settings.tsx  | 46 ++++++++++--
 src/types/app-status.ts                       | 12 +++
 7 files changed, 214 insertions(+), 34 deletions(-)
 create mode 100644 src-tauri/src/gpu_miner.rs

diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index a07d391f7..c58290f1b 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -2569,6 +2569,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "libloading"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
+dependencies = [
+ "cfg-if",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "libm"
 version = "0.2.8"
@@ -3165,6 +3175,29 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "nvml-wrapper"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c9bff0aa1d48904a1385ea2a8b97576fbdcbc9a3cfccd0d31fe978e1c4038c5"
+dependencies = [
+ "bitflags 2.6.0",
+ "libloading",
+ "nvml-wrapper-sys",
+ "static_assertions",
+ "thiserror",
+ "wrapcenum-derive",
+]
+
+[[package]]
+name = "nvml-wrapper-sys"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "698d45156f28781a4e79652b6ebe2eaa0589057d588d3aec1333f6466f13fcb5"
+dependencies = [
+ "libloading",
+]
+
 [[package]]
 name = "objc"
 version = "0.2.7"
@@ -5150,6 +5183,7 @@ dependencies = [
  "minotari_node_grpc_client",
  "minotari_wallet_grpc_client",
  "nix",
+ "nvml-wrapper",
  "open 5.3.0",
  "rand 0.8.5",
  "reqwest 0.12.5",
@@ -7268,6 +7302,18 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "wrapcenum-derive"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a76ff259533532054cfbaefb115c613203c73707017459206380f03b3b3f266e"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+]
+
 [[package]]
 name = "wry"
 version = "0.24.10"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 37b60c598..268c07fe1 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -67,6 +67,7 @@ libsqlite3-sys = { version = "0.25.1", features = ["bundled"] }
 log = "0.4.22"
 rand = "0.8.5"
 device_query = "2.1.0"
+nvml-wrapper = "0.10.0"
 
 [features]
 # This feature is used for production builds or when a dev server is not specified, DO NOT REMOVE!!
diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index 31387524a..e2e4c0e82 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -6,7 +6,6 @@ use crate::{
     CpuCoreTemperature, CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus, CpuMinerStatus, ProgressTracker
 };
 use log::warn;
-use std::ops::Deref;
 use std::path::PathBuf;
 use sysinfo::{Component, Components, CpuRefreshKind, RefreshKind, System};
 use tari_core::transactions::tari_amount::MicroMinotari;
@@ -27,7 +26,6 @@ pub(crate) struct CpuMiner {
     watcher_task: Option<JoinHandle<Result<(), anyhow::Error>>>,
     miner_shutdown: Shutdown,
     api_client: Option<XmrigHttpApiClient>,
-    cpu_temperature_components: Components,
     cpu_temperatures: Vec<CpuCoreTemperature>,
 }
 
@@ -37,7 +35,6 @@ impl CpuMiner {
             watcher_task: None,
             miner_shutdown: Shutdown::new(),
             api_client: None,
-            cpu_temperature_components: Components::new_with_refreshed_list(),
             cpu_temperatures: Vec::new(),
         }
     }
@@ -166,8 +163,7 @@ impl CpuMiner {
         block_reward: MicroMinotari,
     ) -> Result<CpuMinerStatus, anyhow::Error> {
         
-        let components = &mut self.cpu_temperature_components;
-        components.refresh();
+        let components = Components::new_with_refreshed_list();
 
         let cpu_components:Vec<&Component> = components.iter().filter(|component| component.label().contains("Core")).collect();
         let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components.iter().map(|component| {
diff --git a/src-tauri/src/gpu_miner.rs b/src-tauri/src/gpu_miner.rs
new file mode 100644
index 000000000..1542190f9
--- /dev/null
+++ b/src-tauri/src/gpu_miner.rs
@@ -0,0 +1,75 @@
+use log::info;
+use nvml_wrapper::{ enum_wrappers::device::{TemperatureSensor, TemperatureThreshold}, Nvml };
+
+use crate::{GpuMinerHardwareStatus, GpuMinerStatus};
+
+const LOG_TARGET: &str = "tari::universe::cpu_miner";
+
+pub(crate) struct GpuMiner {
+    nvml: Nvml,
+    status: GpuMinerStatus
+}
+
+impl GpuMiner {
+    pub fn new() -> Self {
+        Self {
+            nvml: Nvml::init().unwrap(),
+            status: GpuMinerStatus::from(GpuMinerStatus {hardware_statuses: Vec::new()})
+        }
+    }
+
+    pub fn start(&mut self) {
+        info!(target: LOG_TARGET, "Starting GPU miner");
+        // Start the GPU miner
+    }
+
+    pub fn stop(&mut self) {
+        info!(target: LOG_TARGET, "Stopping GPU miner");
+        // Stop the GPU miner
+    }
+
+    pub fn status(&mut self) -> GpuMinerStatus {
+
+
+        if self.status.hardware_statuses.is_empty() {
+            let devices_count = self.nvml.device_count().unwrap();
+        
+            for i in 0..devices_count {
+                let device = self.nvml.device_by_index(i).unwrap();
+
+                let uuid = device.uuid().unwrap();
+                let name = device.name().unwrap();
+                let temperature = device.temperature(TemperatureSensor::Gpu).unwrap();
+                let load = device.utilization_rates().unwrap().gpu;
+
+                self.status.hardware_statuses.push(GpuMinerHardwareStatus {
+                    uuid,
+                    name,
+                    temperature,
+                    max_temperature: temperature,
+                    load
+                });
+            }
+        }
+
+        self.status.hardware_statuses = self.status.hardware_statuses.iter().map(|status| {
+            let device = self.nvml.device_by_uuid(status.uuid.clone()).unwrap();
+
+            let temperature = device.temperature(TemperatureSensor::Gpu).unwrap();
+            let load = device.utilization_rates().unwrap().gpu;
+            let max_temperature = status.max_temperature.max(temperature);
+
+            GpuMinerHardwareStatus {
+                uuid: status.uuid.clone(),
+                name: status.name.clone(),
+                temperature,
+                max_temperature,
+                load
+            }
+        }).collect();
+
+
+        self.status.clone()
+
+    }
+}
\ No newline at end of file
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index e1d20e29f..1e2a992b8 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -2,6 +2,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod cpu_miner;
+mod gpu_miner;
 mod mm_proxy_manager;
 mod process_watcher;
 mod user_listener;
@@ -23,6 +24,7 @@ mod process_killer;
 mod wallet_adapter;
 
 use crate::cpu_miner::CpuMiner;
+use crate::gpu_miner::GpuMiner;
 use crate::internal_wallet::InternalWallet;
 use crate::mm_proxy_manager::MmProxyManager;
 use crate::node_manager::NodeManager;
@@ -366,6 +368,7 @@ async fn get_applications_versions(app: tauri::AppHandle) -> Result<Applications
 #[tauri::command]
 async fn status(state: tauri::State<'_, UniverseAppState>) -> Result<AppStatus, String> {
     let mut cpu_miner = state.cpu_miner.write().await;
+    let mut gpu_miner = state.gpu_miner.write().await;
     let (_sha_hash_rate, randomx_hash_rate, block_reward, block_height, block_time, is_synced) =
         state
             .node_manager
@@ -400,10 +403,13 @@ async fn status(state: tauri::State<'_, UniverseAppState>) -> Result<AppStatus,
         }
     };
 
+    let gpu_status = gpu_miner.status();
+
     let config_guard = state.config.read().await;
 
     Ok(AppStatus {
         cpu,
+        gpu: gpu_status,
         base_node: BaseNodeStatus {
             block_height,
             block_time,
@@ -419,6 +425,7 @@ async fn status(state: tauri::State<'_, UniverseAppState>) -> Result<AppStatus,
 pub struct AppStatus {
     // TODO: add each application version.
     cpu: CpuMinerStatus,
+    gpu: GpuMinerStatus,
     base_node: BaseNodeStatus,
     wallet_balance: WalletBalance,
     mode: MiningMode,
@@ -439,27 +446,6 @@ pub struct BaseNodeStatus {
     block_time: u64,
     is_synced: bool,
 }
-
-#[derive(Debug, Serialize, PartialEq, PartialOrd, Clone)]
-pub struct CpuCoreTemperature {
-    pub id: u32,
-    pub label: String,
-    pub temperature: f32,
-    pub max_temperature: f32,
-}
-
-impl Ord for CpuCoreTemperature {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.id.cmp(&other.id)
-    }
-}
-
-impl Eq for CpuCoreTemperature {
-    fn assert_receiver_is_total_eq(&self) {
-        self.id.assert_receiver_is_total_eq();
-    }
-} 
-
 #[derive(Debug, Serialize)]
 pub struct CpuMinerStatus {
     pub is_mining: bool,
@@ -486,10 +472,43 @@ struct CpuMinerConfig {
     tari_address: TariAddress,
 }
 
+#[derive(Debug, Serialize, PartialEq, PartialOrd, Clone)]
+pub struct CpuCoreTemperature {
+    pub id: u32,
+    pub label: String,
+    pub temperature: f32,
+    pub max_temperature: f32,
+}
+
+impl Ord for CpuCoreTemperature {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.id.cmp(&other.id)
+    }
+}
+
+impl Eq for CpuCoreTemperature {
+    fn assert_receiver_is_total_eq(&self) {
+        self.id.assert_receiver_is_total_eq();
+    }
+} 
+#[derive(Debug, Serialize,Clone)]
+struct GpuMinerStatus {
+    hardware_statuses: Vec<GpuMinerHardwareStatus>,
+}
+#[derive(Debug, Serialize, Clone)]
+struct GpuMinerHardwareStatus {
+    uuid: String,
+    temperature: u32,
+    max_temperature: u32,
+    name: String,
+    load: u32,
+}
+
 struct UniverseAppState {
     config: Arc<RwLock<AppConfig>>,
     shutdown: Shutdown,
     cpu_miner: RwLock<CpuMiner>,
+    gpu_miner: RwLock<GpuMiner>,
     cpu_miner_config: Arc<RwLock<CpuMinerConfig>>,
     user_listener: Arc<RwLock<UserListener>>,
     mm_proxy_manager: MmProxyManager,
@@ -521,6 +540,7 @@ fn main() {
         config: app_config.clone(),
         shutdown: shutdown.clone(),
         cpu_miner: CpuMiner::new().into(),
+        gpu_miner: GpuMiner::new().into(),
         cpu_miner_config: cpu_config.clone(),
         user_listener: Arc::new(RwLock::new(UserListener::new())),
         mm_proxy_manager: mm_proxy_manager.clone(),
diff --git a/src/containers/SideBar/components/Settings/Settings.tsx b/src/containers/SideBar/components/Settings/Settings.tsx
index f839e51ae..7ed83d246 100644
--- a/src/containers/SideBar/components/Settings/Settings.tsx
+++ b/src/containers/SideBar/components/Settings/Settings.tsx
@@ -36,6 +36,10 @@ const Settings: React.FC = () => {
         (state) => state.cpu?.cpu_temperatures
     );
 
+    const gpuHardwareStatuses = useAppStatusStore(
+        (state) => state.gpu?.hardware_statuses
+    );
+
     const handleClickOpen = () => setOpen(true);
     const handleClose = () => {
         setOpen(false);
@@ -219,10 +223,39 @@ const Settings: React.FC = () => {
                     )}
                     <Divider />
                     <Stack spacing={1} pt={1}>
-                        <Typography variant="h5">CPU Temperatures</Typography>
-                        {cpuTemperatures ? (
-                            <CardContainer>
-                                {cpuTemperatures.map((core) => (
+                        <Typography variant="h5">
+                            Hardware Temperatures
+                        </Typography>
+                        <CardContainer>
+                            {gpuHardwareStatuses &&
+                                gpuHardwareStatuses.map((gpu) => (
+                                    <CardComponent
+                                        key={gpu.uuid}
+                                        heading={gpu.name}
+                                        labels={[
+                                            {
+                                                labelText: 'Utilization',
+                                                labelValue:
+                                                    gpu.load.toString() + '%',
+                                            },
+                                            {
+                                                labelText:
+                                                    'Current temperature',
+                                                labelValue:
+                                                    gpu.temperature.toString() +
+                                                    '°C',
+                                            },
+                                            {
+                                                labelText: 'Max temperature',
+                                                labelValue:
+                                                    gpu.max_temperature.toString() +
+                                                    '°C',
+                                            },
+                                        ]}
+                                    />
+                                ))}
+                            {cpuTemperatures &&
+                                cpuTemperatures.map((core) => (
                                     <CardComponent
                                         key={core.label}
                                         heading={core.label}
@@ -243,10 +276,7 @@ const Settings: React.FC = () => {
                                         ]}
                                     />
                                 ))}
-                            </CardContainer>
-                        ) : (
-                            <Typography>No CPU Temperatures</Typography>
-                        )}
+                        </CardContainer>
                     </Stack>
                     <Divider />
                     <Stack spacing={1} pt={1}>
diff --git a/src/types/app-status.ts b/src/types/app-status.ts
index 99b89c723..7f80b5bfd 100644
--- a/src/types/app-status.ts
+++ b/src/types/app-status.ts
@@ -2,6 +2,7 @@ import { modeType } from '../store/types';
 
 export interface AppStatus {
     cpu?: CpuMinerStatus;
+    gpu?: GpuMinerStatus;
     base_node?: BaseNodeStatus;
     wallet_balance?: WalletBalance;
     applications_versions?: ApplicationsVersions;
@@ -10,6 +11,17 @@ export interface AppStatus {
     auto_mining: boolean;
 }
 
+export interface GpuMinerStatus {
+    hardware_statuses: GpuMinerHardwareStatus[];
+}
+
+export interface GpuMinerHardwareStatus {
+    uuid: string;
+    temperature: number;
+    max_temperature: number;
+    name: string;
+    load: number;
+}
 export interface CpuCoreTemperature {
     label: string;
     temperature: number;

From 0a3b1a65bfaaea7f2878a9aa7de9d067754c5bd0 Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Tue, 13 Aug 2024 11:09:56 +0200
Subject: [PATCH 4/6] Run cargo fmt

---
 src-tauri/src/cpu_miner.rs | 49 +++++++++++++++++++++++++----------
 src-tauri/src/gpu_miner.rs | 52 +++++++++++++++++++++-----------------
 src-tauri/src/main.rs      |  4 +--
 3 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index e2e4c0e82..e401ce093 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -3,7 +3,8 @@ use crate::mm_proxy_manager::MmProxyManager;
 use crate::xmrig::http_api::XmrigHttpApiClient;
 use crate::xmrig_adapter::{XmrigAdapter, XmrigNodeConnection};
 use crate::{
-    CpuCoreTemperature, CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus, CpuMinerStatus, ProgressTracker
+    CpuCoreTemperature, CpuMinerConfig, CpuMinerConnection, CpuMinerConnectionStatus,
+    CpuMinerStatus, ProgressTracker,
 };
 use log::warn;
 use std::path::PathBuf;
@@ -162,27 +163,47 @@ impl CpuMiner {
         network_hash_rate: u64,
         block_reward: MicroMinotari,
     ) -> Result<CpuMinerStatus, anyhow::Error> {
-        
         let components = Components::new_with_refreshed_list();
 
-        let cpu_components:Vec<&Component> = components.iter().filter(|component| component.label().contains("Core")).collect();
-        let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components.iter().map(|component| {
-                CpuCoreTemperature {
-                    id: component.label().split(" ").last().unwrap().parse().unwrap(),
-                    label: component.label().split(" ").skip(1).collect::<Vec<&str>>().join(" ").to_string(),
-                    temperature: component.temperature(),
-                    max_temperature: component.max(),
-                }
-            }).collect();
+        let cpu_components: Vec<&Component> = components
+            .iter()
+            .filter(|component| component.label().contains("Core"))
+            .collect();
+        let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components
+            .iter()
+            .map(|component| CpuCoreTemperature {
+                id: component
+                    .label()
+                    .split(" ")
+                    .last()
+                    .unwrap()
+                    .parse()
+                    .unwrap(),
+                label: component
+                    .label()
+                    .split(" ")
+                    .skip(1)
+                    .collect::<Vec<&str>>()
+                    .join(" ")
+                    .to_string(),
+                temperature: component.temperature(),
+                max_temperature: component.max(),
+            })
+            .collect();
 
         if self.cpu_temperatures.is_empty() {
             self.cpu_temperatures = cpu_temperatures.clone()
-        }else {
+        } else {
             for (i, component) in cpu_temperatures.clone().iter().enumerate() {
-                let position = self.cpu_temperatures.iter().position(|x| x.id == component.id).unwrap();
+                let position = self
+                    .cpu_temperatures
+                    .iter()
+                    .position(|x| x.id == component.id)
+                    .unwrap();
                 self.cpu_temperatures[position].temperature = component.temperature;
                 if component.temperature > self.cpu_temperatures[position].max_temperature {
-                    self.cpu_temperatures[position].max_temperature = self.cpu_temperatures[i].temperature;
+                    self.cpu_temperatures[position].max_temperature =
+                        self.cpu_temperatures[i].temperature;
                 }
             }
         }
diff --git a/src-tauri/src/gpu_miner.rs b/src-tauri/src/gpu_miner.rs
index 1542190f9..cee3d9d63 100644
--- a/src-tauri/src/gpu_miner.rs
+++ b/src-tauri/src/gpu_miner.rs
@@ -1,5 +1,8 @@
 use log::info;
-use nvml_wrapper::{ enum_wrappers::device::{TemperatureSensor, TemperatureThreshold}, Nvml };
+use nvml_wrapper::{
+    enum_wrappers::device::{TemperatureSensor, TemperatureThreshold},
+    Nvml,
+};
 
 use crate::{GpuMinerHardwareStatus, GpuMinerStatus};
 
@@ -7,14 +10,16 @@ const LOG_TARGET: &str = "tari::universe::cpu_miner";
 
 pub(crate) struct GpuMiner {
     nvml: Nvml,
-    status: GpuMinerStatus
+    status: GpuMinerStatus,
 }
 
 impl GpuMiner {
     pub fn new() -> Self {
         Self {
             nvml: Nvml::init().unwrap(),
-            status: GpuMinerStatus::from(GpuMinerStatus {hardware_statuses: Vec::new()})
+            status: GpuMinerStatus::from(GpuMinerStatus {
+                hardware_statuses: Vec::new(),
+            }),
         }
     }
 
@@ -29,11 +34,9 @@ impl GpuMiner {
     }
 
     pub fn status(&mut self) -> GpuMinerStatus {
-
-
         if self.status.hardware_statuses.is_empty() {
             let devices_count = self.nvml.device_count().unwrap();
-        
+
             for i in 0..devices_count {
                 let device = self.nvml.device_by_index(i).unwrap();
 
@@ -47,29 +50,32 @@ impl GpuMiner {
                     name,
                     temperature,
                     max_temperature: temperature,
-                    load
+                    load,
                 });
             }
         }
 
-        self.status.hardware_statuses = self.status.hardware_statuses.iter().map(|status| {
-            let device = self.nvml.device_by_uuid(status.uuid.clone()).unwrap();
+        self.status.hardware_statuses = self
+            .status
+            .hardware_statuses
+            .iter()
+            .map(|status| {
+                let device = self.nvml.device_by_uuid(status.uuid.clone()).unwrap();
 
-            let temperature = device.temperature(TemperatureSensor::Gpu).unwrap();
-            let load = device.utilization_rates().unwrap().gpu;
-            let max_temperature = status.max_temperature.max(temperature);
-
-            GpuMinerHardwareStatus {
-                uuid: status.uuid.clone(),
-                name: status.name.clone(),
-                temperature,
-                max_temperature,
-                load
-            }
-        }).collect();
+                let temperature = device.temperature(TemperatureSensor::Gpu).unwrap();
+                let load = device.utilization_rates().unwrap().gpu;
+                let max_temperature = status.max_temperature.max(temperature);
 
+                GpuMinerHardwareStatus {
+                    uuid: status.uuid.clone(),
+                    name: status.name.clone(),
+                    temperature,
+                    max_temperature,
+                    load,
+                }
+            })
+            .collect();
 
         self.status.clone()
-
     }
-}
\ No newline at end of file
+}
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 1e2a992b8..e98b19cd7 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -490,8 +490,8 @@ impl Eq for CpuCoreTemperature {
     fn assert_receiver_is_total_eq(&self) {
         self.id.assert_receiver_is_total_eq();
     }
-} 
-#[derive(Debug, Serialize,Clone)]
+}
+#[derive(Debug, Serialize, Clone)]
 struct GpuMinerStatus {
     hardware_statuses: Vec<GpuMinerHardwareStatus>,
 }

From 91c446faeebdd73f6753ee30869043863a58fa8e Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Tue, 13 Aug 2024 11:26:13 +0200
Subject: [PATCH 5/6] fix clippy and cpu order

---
 src-tauri/src/cpu_miner.rs |  2 ++
 src-tauri/src/main.rs      | 15 +++++++++++----
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index e401ce093..59fa7c78d 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -208,6 +208,8 @@ impl CpuMiner {
             }
         }
 
+        self.cpu_temperatures.sort();
+
         let mut s =
             System::new_with_specifics(RefreshKind::new().with_cpu(CpuRefreshKind::everything()));
 
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index e98b19cd7..e7eb282e9 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -472,7 +472,7 @@ struct CpuMinerConfig {
     tari_address: TariAddress,
 }
 
-#[derive(Debug, Serialize, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, Serialize, PartialEq, Clone)]
 pub struct CpuCoreTemperature {
     pub id: u32,
     pub label: String,
@@ -480,17 +480,24 @@ pub struct CpuCoreTemperature {
     pub max_temperature: f32,
 }
 
+impl Eq for CpuCoreTemperature {
+    fn assert_receiver_is_total_eq(&self) {
+        self.id.assert_receiver_is_total_eq();
+    }
+}
+
 impl Ord for CpuCoreTemperature {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.id.cmp(&other.id)
     }
 }
 
-impl Eq for CpuCoreTemperature {
-    fn assert_receiver_is_total_eq(&self) {
-        self.id.assert_receiver_is_total_eq();
+impl PartialOrd for CpuCoreTemperature {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.id.partial_cmp(&other.id)
     }
 }
+
 #[derive(Debug, Serialize, Clone)]
 struct GpuMinerStatus {
     hardware_statuses: Vec<GpuMinerHardwareStatus>,

From 73a19d8b46be20dd3fc85889482506744e5a79ff Mon Sep 17 00:00:00 2001
From: Misieq01 <bartosz2000walczak@gmail.com>
Date: Tue, 13 Aug 2024 11:29:36 +0200
Subject: [PATCH 6/6] Fix ordering

---
 src-tauri/src/cpu_miner.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src-tauri/src/cpu_miner.rs b/src-tauri/src/cpu_miner.rs
index 59fa7c78d..13da39a16 100644
--- a/src-tauri/src/cpu_miner.rs
+++ b/src-tauri/src/cpu_miner.rs
@@ -169,7 +169,8 @@ impl CpuMiner {
             .iter()
             .filter(|component| component.label().contains("Core"))
             .collect();
-        let cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components
+
+        let mut cpu_temperatures: Vec<CpuCoreTemperature> = cpu_components
             .iter()
             .map(|component| CpuCoreTemperature {
                 id: component
@@ -191,6 +192,8 @@ impl CpuMiner {
             })
             .collect();
 
+        cpu_temperatures.sort();
+
         if self.cpu_temperatures.is_empty() {
             self.cpu_temperatures = cpu_temperatures.clone()
         } else {