feat(log): handle errors

locales/en/errors.json

@@ -9,7 +9,7 @@
   "failed-to-find-tapplet-version": "Failed to find tapplet version",
   "failed-to-obtain-permission-token-lock": "Failed to obtain permission token lock",
   "failed-to-obtain-auth-token-lock": "Failed to obtain auth token lock",
-  "provider-call-failed-for-method": "Provider call failed for method {{ method }} with params {{ params }}",
+  "failed-to-call-provider": "Provider call failed for method {{ method }} with params {{ params }}",
   "failed-to-obtain-local-address": "Failed to obtain local address",
   "failed-to-start-tapplet-server": "Failed to start tapplet server",
   "tapplet-server-already-running": "Tapplet server already running",

locales/pl/errors.json

@@ -9,7 +9,7 @@
   "failed-to-find-tapplet-version": "Nie udało się znaleźć wersji tapplet'u",
   "failed-to-obtain-permission-token-lock": "Nie udało się uzyskać blokady tokena uprawnień",
   "failed-to-obtain-auth-token-lock": "Nie udało się uzyskać blokady tokena autoryzacji",
-  "provider-call-failed-for-method": "Wywołanie provider'a nie powiodło się dla metody {{ method }} z parametrami {{ params }}",
+  "failed-to-call-provider": "Wywołanie provider'a nie powiodło się dla metody {{ method }} z parametrami {{ params }}",
   "failed-to-obtain-local-address": "Nie udało się uzyskać lokalnego adresu",
   "failed-to-start-tapplet-server": "Nie udało się uruchomić serwera tapplet'u",
   "tapplet-server-already-running": "Serwer tapplet'u już działa",

src-tauri/src/commands.rs

@@ -21,7 +21,8 @@ use crate::{
   },
   download_utils::{ download_file_with_retries, extract },
   error::{
-    Error::{ self, FailedToObtainPermissionTokenLock, JsonParsingError, RequestError, TappletServerError },
+    Error::{ self, IOError, FailedToObtainPermissionTokenLock, JsonParsingError, RequestError, TappletServerError },
+    IOError::*,
     RequestError::*,
     TappletServerError::*,
   },
@@ -110,13 +111,17 @@ pub async fn call_wallet(
 ) -> Result<serde_json::Value, Error> {
   let permission_token = tokens.permission
     .lock()
+    .inspect_err(|e| error!(target: LOG_TARGET, "❌ Error at call_wallet: {:?}", e))
     .map_err(|_| FailedToObtainPermissionTokenLock)?
     .clone();
-  let req_params: serde_json::Value = serde_json::from_str(&params).map_err(|e| JsonParsingError(e))?;
-
+  let req_params: serde_json::Value = serde_json
+    ::from_str(&params)
+    .inspect_err(|e| error!(target: LOG_TARGET, "❌ Error at call_wallet: {:?}", e))
+    .map_err(|e| JsonParsingError(e))?;
   match make_request(Some(permission_token), method, req_params).await {
     Ok(res) => Ok(res),
     Err(e) => {
+      error!(target: LOG_TARGET,"❌ Error at call_wallet: {:?}", e);
       return Err(Error::RequestFailed { message: e.to_string() });
     }
   }
@@ -143,14 +148,16 @@ pub async fn launch_tapplet(
 
   // Extract the tapplet archieve each time before launching
   // This way make sure that local files have not been replaced and are not malicious
-  let _ = extract(&file_path, &tapplet_path.clone()).await;
+  let _ = extract(&file_path, &tapplet_path.clone()).await
+    .inspect_err(|e| error!(target: LOG_TARGET, "❌ Error extracting file: {:?}", e))
+    .map_err(|_| { IOError(FailedToUnpackFile { path: tapplet_path.to_string_lossy().to_string() }) })?;
   //TODO should compare integrity field with the one stored in db or from github manifest?
   match check_files_and_validate_checksum(tapp_version, tapplet_path.clone()) {
     Ok(is_valid) => {
-      info!(target: LOG_TARGET,"Checksum validated without error. Is valid?: {:?}", is_valid);
+      info!(target: LOG_TARGET,"✅ Checksum validation successfully with test result: {:?}", is_valid);
     }
     Err(e) => {
-      error!(target: LOG_TARGET,"Error validating checksum: {:?}", e);
+      error!(target: LOG_TARGET,"❌ Error validating checksum: {:?}", e);
       return Err(e.into());
     }
   }
@@ -228,14 +235,16 @@ pub async fn download_and_extract_tapp(
   });
   handle.await?.map_err(|_| Error::RequestError(FailedToDownload { url: tapp_version.registry_url.clone() }))?;
 
-  let _ = extract(&file_path, &tapplet_path.clone()).await;
+  let _ = extract(&file_path, &tapplet_path.clone()).await.inspect_err(
+    |e| error!(target: LOG_TARGET, "❌ Error extracting file: {:?}", e)
+  );
   //TODO should compare integrity field with the one stored in db or from github manifest?
   match check_files_and_validate_checksum(tapp_version, tapplet_path.clone()) {
     Ok(is_valid) => {
-      info!(target: LOG_TARGET,"Checksum validated without error. Is valid?: {:?}", is_valid);
+      info!(target: LOG_TARGET,"✅ Checksum validation successfully with test result: {:?}", is_valid);
     }
     Err(e) => {
-      error!(target: LOG_TARGET,"Error validating checksum: {:?}", e);
+      error!(target: LOG_TARGET,"🚨 Error validating checksum: {:?}", e);
       return Err(e.into());
     }
   }
@@ -460,6 +469,6 @@ pub fn delete_dev_tapplet(dev_tapplet_id: i32, db_connection: State<'_, Database
 pub fn open_log_dir(app_handle: tauri::AppHandle) {
   let log_dir = app_handle.path().app_log_dir().expect("Could not get log dir");
   if let Err(e) = open::that(log_dir) {
-    error!(target: LOG_TARGET, "Could not open log dir: {:?}", e);
+    error!(target: LOG_TARGET, "❌ Could not open log dir: {:?}", e);
   }
 }

src-tauri/src/download_utils.rs

@@ -12,6 +12,7 @@ use tokio::fs::{ File, OpenOptions };
 use tokio::io::{ AsyncWriteExt, BufReader };
 use tokio::time::sleep;
 use tokio_util::compat::{ TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt };
+use log::error;
 
 use crate::progress_tracker::ProgressTracker;
 
@@ -99,10 +100,12 @@ pub async fn extract(file_path: &Path, dest_dir: &Path) -> Result<(), anyhow::Er
           extract_zip(file_path, dest_dir).await?;
         }
         _ => {
+          error!(target: LOG_TARGET, "❌ Extract file error: Unsupported file extension",);
           return Err(anyhow::anyhow!("Unsupported file extension"));
         }
       }
     None => {
+      error!(target: LOG_TARGET, "❌ Extract file error: File has no extension",);
       return Err(anyhow::anyhow!("File has no extension"));
     }
   }

src-tauri/src/error.rs

@@ -13,7 +13,7 @@ pub enum Error {
   #[error("failed-to-find-tapplet-version")] VersionNotFound,
   #[error("failed-to-obtain-permission-token-lock")] FailedToObtainPermissionTokenLock,
   #[error("failed-to-obtain-auth-token-lock")] FailedToObtainAuthTokenLock,
-  #[error("provider-call-failed-for-method | method-{method} & params-{params}")] ProviderError {
+  #[error("failed-to-call-provider | method-{method} & params-{params}")] ProviderError {
     method: String,
     params: String,
   },

src-tauri/src/lib.rs

@@ -69,11 +69,11 @@ async fn try_get_tokens() -> (String, String) {
   loop {
     match permission_token().await {
       Ok(tokens) => {
-        info!(target: LOG_TARGET, "permission token ok {:?}", tokens);
+        info!(target: LOG_TARGET, "✅ WALLET DAEMON permission token found: {:?}", tokens);
         return tokens;
       }
       Err(e) => {
-        warn!(target: LOG_TARGET, "permission token ERR {:?}", e);
+        warn!(target: LOG_TARGET, "❌ Wallet Daemon permission token error: {:?}", e);
         sleep(Duration::from_millis(500));
         continue;
       }
@@ -105,7 +105,6 @@ fn setup_tari_universe(app: &mut tauri::App) -> Result<(), Box<dyn std::error::E
   let tokens = app.state::<Tokens>();
   let handle = tauri::async_runtime::spawn(try_get_tokens());
   let (permission_token, auth_token) = tauri::async_runtime::block_on(handle)?;
-  info!(target: LOG_TARGET, "permission token found {:?}", permission_token);
   tokens.permission
     .lock()
     .map_err(|_| error::Error::FailedToObtainPermissionTokenLock)?
@@ -121,7 +120,7 @@ fn setup_tari_universe(app: &mut tauri::App) -> Result<(), Box<dyn std::error::E
   let handle_start = tauri::async_runtime::spawn(async move { start(tapplet_assets_path).await });
   let (addr, cancel_token) = tauri::async_runtime::block_on(handle_start)?.unwrap();
   app.manage(AssetServer { addr, cancel_token });
-  info!(target: LOG_TARGET, "Tari Universe setup completed successfully");
+  info!(target: LOG_TARGET, "🚀 Tari Universe setup completed successfully");
 
   Ok(())
 }

src-tauri/src/progress_tracker.rs

@@ -64,28 +64,28 @@ impl ProgressTrackerInner {
   }
 
   pub fn update(&self, title: String, title_params: Option<HashMap<String, String>>, progress: u64) {
-    debug!(target: LOG_TARGET, "Progress: {}% {}", progress, title);
+    debug!(target: LOG_TARGET, "⏳️️ Progress: {}% {}", progress, title);
     self.window
       .emit("message", SetupStatusEvent {
         event_type: "download_status".to_string(),
         title,
         title_params,
         progress: progress as f64,
       })
-      .inspect_err(|e| error!(target: LOG_TARGET, "Could not emit event 'message': {:?}", e))
+      .inspect_err(|e| error!(target: LOG_TARGET, "❌ Could not emit event 'message': {:?}", e))
       .ok();
   }
 
   pub fn update_with_next_max(&self, title: String, title_params: Option<HashMap<String, String>>, progress: u64) {
-    debug!(target: LOG_TARGET, "Progress: {}% {}", progress, title);
+    debug!(target: LOG_TARGET, "⏳️️ Progress: {}% {}", progress, title);
     self.window
       .emit("message", SetupStatusEvent {
         event_type: "setup_status".to_string(),
         title,
         title_params,
         progress: ((self.min as f64) + ((self.next_max - self.min) as f64) * ((progress as f64) / 100.0)) / 100.0,
       })
-      .inspect_err(|e| error!(target: LOG_TARGET, "Could not emit event 'message': {:?}", e))
+      .inspect_err(|e| error!(target: LOG_TARGET, "❌ Could not emit event 'message': {:?}", e))
       .ok();
   }
 }

src-tauri/src/rpc.rs

@@ -15,10 +15,11 @@ use tari_wallet_daemon_client::{
   ComponentAddressOrName,
 };
 use tauri_plugin_http::reqwest::{ self, header::{ AUTHORIZATION, CONTENT_TYPE } };
-
+use log::{ error, info };
 use crate::error::Error;
 
 const JSON_CONNECT_ADDRESS: &str = "127.0.0.1:18010"; // TODO use db to get endpoint
+const LOG_TARGET: &str = "tari::dan::wallet_daemon";
 
 pub async fn permission_token() -> Result<(String, String), anyhow::Error> {
   let req_params = AuthLoginRequest {
@@ -48,8 +49,7 @@ pub async fn account_create(account_name: Option<String>, permissions_token: Str
     key_id: None,
     max_fee: None,
   };
-  let resp = make_request(Some(permissions_token), "accounts.create".to_string(), create_acc_params).await?;
-
+  let _resp = make_request(Some(permissions_token), "accounts.create".to_string(), create_acc_params).await?;
   Ok(())
 }
 
@@ -109,7 +109,13 @@ pub async fn make_request<T: Serialize>(
   }
   let resp = builder.json(&body).send().await?.json::<JsonRpcResponse>().await?;
   match resp.result {
-    JsonRpcAnswer::Result(result) => Ok(result),
-    JsonRpcAnswer::Error(error) => Err(anyhow::Error::msg(error.to_string())),
+    JsonRpcAnswer::Result(result) => {
+      info!(target: LOG_TARGET, "👁️‍🗨️ JSON rpc request result: {:?}", result);
+      Ok(result)
+    }
+    JsonRpcAnswer::Error(error) => {
+      error!(target: LOG_TARGET, "🚨 JSON rpc request error: {:?}", error);
+      Err(anyhow::Error::msg(error.to_string()))
+    }
   }
 }

src-tauri/src/tapplet_installer.rs

@@ -49,7 +49,7 @@ pub fn get_tapp_download_path(
     .path()
     .app_data_dir()
     .unwrap_or_else(|e| {
-      error!(target: LOG_TARGET, "Failed to get app dir: {}", e);
+      error!(target: LOG_TARGET, "❌ Failed to get app dir: {}", e);
       PathBuf::from("")
     })
     .to_path_buf();
@@ -84,9 +84,9 @@ async fn download_file(url: &str, dest: PathBuf) -> Result<(), Error> {
       file.write_all(&chunk).map_err(|_| IOError(FailedToWriteFile { path: path.clone() }))?;
     }
   } else if response.status().is_server_error() {
-    println!("Download server error! Status: {:?}", response.status());
+    error!(target: LOG_TARGET, "❌ Download server error! Status: {:?}", response.status());
   } else {
-    println!("Download failed. Something else happened. Status: {:?}", response);
+    error!(target: LOG_TARGET, "❌ Download failed! Unknown status. Server response: {:?}", response);
   }
 
   Ok(())

src-tauri/src/tapplet_server.rs

@@ -1,5 +1,5 @@
 use axum::Router;
-use log::info;
+use log::{ error, info };
 use std::{ net::SocketAddr, path::PathBuf };
 use tokio::select;
 use tokio_util::sync::CancellationToken;
@@ -24,17 +24,20 @@ pub async fn serve(app: Router, port: u16) -> Result<(String, CancellationToken)
   let addr = SocketAddr::from(([127, 0, 0, 1], port));
   let listener = tokio::net::TcpListener
     ::bind(addr).await
+    .inspect_err(|e| error!(target: LOG_TARGET, "❌ Failed to bind port server error: {:?}", e))
     .map_err(|_| TappletServerError(BindPortError { port: addr.to_string() }))?;
   let address = listener
     .local_addr()
+    .inspect_err(|e| error!(target: LOG_TARGET, "❌ Failed to obtain local address error: {:?}", e))
     .map_err(|_| TappletServerError(FailedToObtainLocalAddress))?
     .to_string();
 
   tauri::async_runtime::spawn(async move { axum
       ::serve(listener, app)
       .with_graceful_shutdown(shutdown_signal(cancel_token_clone)).await
+      .inspect_err(|e| error!(target: LOG_TARGET, "❌ Failed to start server error: {:?}", e))
       .map_err(|_| TappletServerError(FailedToStart)) });
-  info!(target: LOG_TARGET, "Tapplet start process completed successfully");
+  info!(target: LOG_TARGET, "🚀 Tapplet start process completed successfully");
 
   Ok((address, cancel_token))
 }

src-tauri/src/wallet_daemon.rs

@@ -47,7 +47,7 @@ pub async fn start_wallet_daemon(
   let shutdown = Shutdown::new();
   let shutdown_signal = shutdown.to_signal();
 
-  info!(target: LOG_TARGET, "Wallet daemon configuration completed successfully");
+  info!(target: LOG_TARGET, "🚀 Wallet daemon configuration completed successfully");
 
   run_tari_dan_wallet_daemon(config, shutdown_signal).await
 }

src/components/ErrorSnackBar.tsx

@@ -9,23 +9,35 @@ import React from "react"
 import { Language } from "../i18initializer"
 
 const ERROR_KEY_SEPARATOR = "|"
-const ERROR_CONTEXT_VAULE_SEPARATOR = "&"
 
 export const resolveBackendErrorMessage = (
   translator: TFunction<"errors", undefined>,
   error: string,
   lng: Language
-) => {
-  const [translationKey, context] = error.split(ERROR_KEY_SEPARATOR)
-  const contextValues: Record<string, string> = context
-    .split(ERROR_CONTEXT_VAULE_SEPARATOR)
-    .reduce<Record<string, string>>((acc, item) => {
-      const [key, value] = item.split("-")
-      acc[key.trim()] = value.trim()
-      return acc
-    }, {})
-
-  return translator(translationKey.trim(), { ...contextValues, lng })
+): string => {
+  const parts = error.split(ERROR_KEY_SEPARATOR)
+
+  if (parts.length < 2) {
+    return translator(error.trim(), { lng })
+  }
+
+  // Extract the nested error name
+  const nestedErrorPart = parts[1].trim() // Get the second part
+  const translationKey = nestedErrorPart.split("-").slice(1).join("-") // Extract everything after 'message-'
+
+  // Extract the method and params from the remaining part
+  const context = parts.slice(2).join(ERROR_KEY_SEPARATOR) // Join the remaining parts back
+  const methodMatch = context.match(/method-([a-zA-Z0-9._]+)/)
+  const paramsMatch = context.match(/params-(.*)/)
+
+  const method = methodMatch ? methodMatch[1] : "unknown method"
+  const params = paramsMatch ? JSON.parse(paramsMatch[1]) : {}
+
+  const formattedParams = JSON.stringify(params, null, 2)
+    .replace(/"([^"]+)":/g, "$1:") // Remove quotes from keys
+    .replace(/"([^"]+)"/g, "$1") // Remove quotes from string value
+
+  return translator(translationKey.trim(), { method, params: formattedParams, lng })
 }
 
 export const ErrorSnackBar = () => {
@@ -42,7 +54,7 @@ export const ErrorSnackBar = () => {
     if (message && message.includes(ERROR_KEY_SEPARATOR)) {
       return resolveBackendErrorMessage(t, message, currentLanguage)
     }
-    return message
+    return t(message)
   }, [message, currentLanguage])
 
   return (

src/components/TransactionConfirmationModal.tsx

@@ -11,13 +11,17 @@ import { BalanceUpdateView } from "./BalanceUpdate"
 import { useTranslation } from "react-i18next"
 import { ErrorSource } from "../store/error/error.types"
 import { CallFunction, CallMethod } from "@tari-project/tarijs/dist/builders/types/Instruction"
+import { resolveBackendErrorMessage } from "./ErrorSnackBar"
+import { metadataSelector } from "../store/metadata/metadata.selector"
 
 const selectSimulationById = (state: RootState, id?: number) => (id ? simulationsSelectors.selectById(state, id) : null)
 
 export const TransactionConfirmationModal: React.FC = () => {
   const { t } = useTranslation(["components", "common"])
   const transaction = useSelector(transactionSelector.getPendingTransaction)
   const simulation = useSelector((state: RootState) => selectSimulationById(state, transaction?.id))
+  const currentLanguage = useSelector(metadataSelector.selectCurrentLanguage)
+
   const dispatch = useDispatch()
 
   const handleClose = async () => {
@@ -93,7 +97,8 @@ export const TransactionConfirmationModal: React.FC = () => {
         </DialogContentText>
         {simulation?.status == "failure" && (
           <DialogContentText>
-            {t("simulation-error-msg", { ns: "components" })}: {simulation?.errorMsg}
+            {t("simulation-error-msg", { ns: "components" })}:{" "}
+            {resolveBackendErrorMessage(t, simulation?.errorMsg, currentLanguage)}
           </DialogContentText>
         )}
         <DialogContentText>

src/components/Wallet.tsx

@@ -83,7 +83,7 @@ export const Wallet: React.FC = () => {
       </Typography>
       <Box display="flex" flexDirection="column" gap={2} alignItems="center" py={4}>
         <SelectAccount onSubmit={handleCreateAccount} accountsList={accountsList} />
-        <Paper variant="outlined" elevation={0} sx={{ padding: 1, borderRadius: 2, width: "50%" }}>
+        <Paper variant="outlined" elevation={0} sx={{ padding: 1, borderRadius: 2, width: "auto", minWidth: 200 }}>
           <Stack direction="column" justifyContent="flex-end">
             <Typography variant="caption" textAlign="left">{`Name: ${currentAccount?.account.name}`}</Typography>
             <Typography variant="caption" textAlign="left">{`${t("address", {

src/store/provider/provider.action.ts

@@ -58,7 +58,6 @@ export const initializeAction = () => ({
 
       handleMessage = async (event: MessageEvent<TransactionEvent>) => {
         if (!event?.data?.args || !event?.data?.methodName) {
-          dispatch(errorActions.showError({ message: "no-data-in-event", errorSource: ErrorSource.FRONTEND }))
           return
         }
         if (!event.source) {

src/store/transaction/transaction.types.ts

@@ -7,7 +7,6 @@ export type TUProviderMethod = Exclude<keyof TUInternalProvider, "runOne">
 
 export type Transaction = {
   methodName: TUProviderMethod
-  // args: any[]
   args: SubmitTransactionRequest[]
   id: number
   submit: () => void