align mm2_main error handling between native and WASM implementations

shamardy · shamardy · commit 57844da0e90b · 2025-03-12T18:24:47.000+02:00
diff --git a/mm2src/coins/lp_coins.rs b/mm2src/coins/lp_coins.rs
@@ -4997,7 +4997,7 @@ pub async fn delegations_info(ctx: MmArc, req: DelegationsInfo) -> Result<Json,
         DelegationsInfoDetails::Qtum => {
             let MmCoinEnum::QtumCoin(qtum) = coin else {
                 return MmError::err(StakingInfoError::InvalidPayload {
-                    reason: format!("{} is not a Qtum coin", req.coin)
+                    reason: format!("{} is not a Qtum coin", req.coin),
                 });
             };
 
@@ -5048,7 +5048,7 @@ pub async fn claim_staking_rewards(ctx: MmArc, req: ClaimStakingRewardsRequest)
 
             let MmCoinEnum::Tendermint(tendermint) = coin else {
                 return MmError::err(DelegationError::InvalidPayload {
-                    reason: format!("{} is not a Cosmos coin", req.coin)
+                    reason: format!("{} is not a Cosmos coin", req.coin),
                 });
             };
 
diff --git a/mm2src/mm2_bin_lib/src/lib.rs b/mm2src/mm2_bin_lib/src/lib.rs
@@ -108,3 +108,20 @@ async fn finalize_mm2_stop(ctx: MmArc) {
     dispatch_lp_event(ctx.clone(), StopCtxEvent.into()).await;
     let _ = ctx.stop().await;
 }
+
+#[cfg_attr(target_arch = "wasm32", derive(serde::Serialize))]
+#[derive(Clone, Debug, PartialEq, Primitive)]
+pub enum StartupErrorCode {
+    /// Operation completed successfully
+    Ok = 0,
+    /// Invalid parameters were provided to the function
+    InvalidParams = 1,
+    /// The configuration was invalid (missing required fields, etc.)
+    ConfigError = 2,
+    /// MM2 is already running
+    AlreadyRunning = 3,
+    /// MM2 initialization failed
+    InitError = 4,
+    /// Failed to spawn the MM2 process/thread
+    SpawnError = 5,
+}
diff --git a/mm2src/mm2_bin_lib/src/mm2_native_lib.rs b/mm2src/mm2_bin_lib/src/mm2_native_lib.rs
@@ -7,6 +7,7 @@ use enum_primitive_derive::Primitive;
 use gstuff::any_to_str;
 use libc::c_char;
 use mm2_core::mm_ctx::MmArc;
+use mm2_main::LpMainParams;
 use num_traits::FromPrimitive;
 use serde_json::{self as json};
 use std::ffi::{CStr, CString};
@@ -15,15 +16,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 use std::time::Duration;
 
-#[derive(Debug, PartialEq, Primitive)]
-enum MainErr {
-    Ok = 0,
-    AlreadyRuns = 1,
-    ConfIsNull = 2,
-    ConfNotUtf8 = 3,
-    CantThread = 5,
-}
-
 /// Starts the MM2 in a detached singleton thread.
 #[no_mangle]
 #[allow(clippy::missing_safety_doc)]
@@ -48,40 +40,75 @@ pub unsafe extern "C" fn mm2_main(conf: *const c_char, log_cb: extern "C" fn(lin
         }};
     }
 
-    if LP_MAIN_RUNNING.load(Ordering::Relaxed) {
-        eret!(MainErr::AlreadyRuns)
-    }
-    CTX.store(0, Ordering::Relaxed); // Remove the old context ID during restarts.
-
     if conf.is_null() {
-        eret!(MainErr::ConfIsNull)
+        eret!(StartupErrorCode::InvalidParams, "Configuration is null")
     }
-    let conf = CStr::from_ptr(conf);
-    let conf = match conf.to_str() {
+    let conf_cstr = CStr::from_ptr(conf);
+    let conf_str = match conf_cstr.to_str() {
         Ok(s) => s,
-        Err(e) => eret!(MainErr::ConfNotUtf8, e),
+        Err(e) => eret!(
+            StartupErrorCode::InvalidParams,
+            format!("Configuration is not valid UTF-8: {}", e)
+        ),
+    };
+
+    let conf: json::Value = match json::from_str(conf_str) {
+        Ok(v) => v,
+        Err(e) => eret!(
+            StartupErrorCode::ConfigError,
+            format!("Failed to parse configuration: {}", e)
+        ),
     };
-    let conf = conf.to_owned();
+
+    if LP_MAIN_RUNNING.load(Ordering::Relaxed) {
+        eret!(StartupErrorCode::AlreadyRunning, "MM2 is already running");
+    }
+
+    CTX.store(0, Ordering::Relaxed); // Remove the old context ID during restarts.
 
     register_callback(FfiCallback::with_ffi_function(log_cb));
+
     let rc = thread::Builder::new().name("lp_main".into()).spawn(move || {
         if let Err(true) = LP_MAIN_RUNNING.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) {
             log!("lp_main already started!");
             return;
         }
+
         let ctx_cb = &|ctx| CTX.store(ctx, Ordering::Relaxed);
-        match catch_unwind(move || mm2_main::run_lp_main(Some(&conf), ctx_cb, KDF_VERSION.into(), KDF_DATETIME.into()))
-        {
-            Ok(Ok(_)) => log!("run_lp_main finished"),
-            Ok(Err(err)) => log!("run_lp_main error: {}", err),
-            Err(err) => log!("run_lp_main panic: {:?}", any_to_str(&*err)),
+
+        match catch_unwind(move || {
+            let params = LpMainParams::with_conf(conf).log_filter(None);
+
+            match block_on(mm2_main::lp_main(
+                params,
+                &ctx_cb,
+                KDF_VERSION.into(),
+                KDF_DATETIME.into(),
+            )) {
+                Ok(ctx) => {
+                    if let Err(e) = block_on(mm2_main::lp_run(ctx)) {
+                        log!("MM2 runtime error: {}", e);
+                    }
+                },
+                Err(e) => log!("MM2 initialization failed: {}", e),
+            }
+        }) {
+            Ok(_) => log!("MM2 thread completed normally"),
+            Err(err) => log!("MM2 thread panicked: {:?}", any_to_str(&*err)),
         };
+
         LP_MAIN_RUNNING.store(false, Ordering::Relaxed)
     });
+
     if let Err(e) = rc {
-        eret!(MainErr::CantThread, e)
+        LP_MAIN_RUNNING.store(false, Ordering::Relaxed);
+        eret!(
+            StartupErrorCode::SpawnError,
+            format!("Failed to spawn MM2 thread: {:?}", e)
+        );
     }
-    MainErr::Ok as i8
+
+    StartupErrorCode::Ok as i8
 }
 
 /// Checks if the MM2 singleton thread is currently running or not.
@@ -177,8 +204,8 @@ pub extern "C" fn mm2_test(torch: i32, log_cb: extern "C" fn(line: *const c_char
         log!("mm2_test] Restarting MM…");
         let conf = CString::new(&conf[..]).unwrap();
         let rc = unsafe { mm2_main(conf.as_ptr(), log_cb) };
-        let rc = MainErr::from_i8(rc).unwrap();
-        if rc != MainErr::Ok {
+        let rc = StartupErrorCode::from_i8(rc).unwrap();
+        if rc != StartupErrorCode::Ok {
             log!("!mm2_main: {:?}", rc);
             return -1;
         }
diff --git a/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs b/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs
@@ -1,8 +1,5 @@
 //! Some specifics of using the [`wasm_bindgen`] library:
 //!
-//! # Currently only `Result<T, JsValue>` is allowed
-//! [tracking issue]: https://github.com/rustwasm/wasm-bindgen/issues/1004
-//!
 //! # JavaScript enums do not support methods at all
 //! [tracking issue]: https://github.com/rustwasm/wasm-bindgen/issues/1715
 //!
@@ -21,18 +18,27 @@ use mm2_rpc::data::legacy::MmVersionResponse;
 use mm2_rpc::wasm_rpc::WasmRpcResponse;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as Json;
-
-/// The errors can be thrown when using the `mm2_main` function incorrectly.
 #[wasm_bindgen]
-#[derive(Primitive)]
-pub enum Mm2MainErr {
-    AlreadyRuns = 1,
-    InvalidParams = 2,
-    NoCoinsInConf = 3,
+#[derive(Debug, Clone, Serialize)]
+struct StartupError {
+    code: StartupErrorCode,
+    message: String,
 }
 
-impl From<Mm2MainErr> for JsValue {
-    fn from(e: Mm2MainErr) -> Self { JsValue::from(e as i32) }
+#[wasm_bindgen]
+impl StartupError {
+    fn new(code: StartupErrorCode, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn code(&self) -> i8 { self.code.clone() as i8 }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String { self.message.clone() }
 }
 
 #[derive(Deserialize)]
@@ -58,7 +64,7 @@ impl From<MainParams> for LpMainParams {
 /// # Usage
 ///
 /// ```javascript
-/// import init, {mm2_main, LogLevel, Mm2MainErr} from "./path/to/mm2.js";
+/// import init, {mm2_main, LogLevel, StartupErrorCode} from "./path/to/mm2.js";
 ///
 /// const params = {
 ///     conf: { "gui":"WASMTEST", mm2:1, "passphrase":"YOUR_PASSPHRASE_HERE", "rpc_password":"test123", "coins":[{"coin":"ETH","protocol":{"type":"ETH"}}] },
@@ -68,8 +74,8 @@ impl From<MainParams> for LpMainParams {
 /// try {
 ///     mm2_main(params, handle_log);
 /// } catch (e) {
-///     switch (e) {
-///         case Mm2MainErr.AlreadyRuns:
+///     switch (e.code) {
+///         case StartupErrorCode.AlreadyRunning:
 ///             alert("MarketMaker2 already runs...");
 ///             break;
 ///         // handle other errors...
@@ -80,51 +86,70 @@ impl From<MainParams> for LpMainParams {
 /// }
 /// ```
 #[wasm_bindgen]
-pub fn mm2_main(params: JsValue, log_cb: js_sys::Function) -> Result<(), JsValue> {
+pub async fn mm2_main(params: JsValue, log_cb: js_sys::Function) -> Result<i8, JsValue> {
     let params: MainParams = match deserialize_from_js(params.clone()) {
         Ok(p) => p,
         Err(e) => {
-            console_err!("Expected 'MainParams' as the first argument, found {:?}: {}", params, e);
-            return Err(Mm2MainErr::InvalidParams.into());
+            let error = StartupError::new(
+                StartupErrorCode::InvalidParams,
+                format!("Expected 'MainParams' as the first argument, found {:?}: {}", params, e),
+            );
+            console_err!("{}", error.message());
+            return Err(error.into());
         },
     };
     if params.conf["coins"].is_null() {
-        console_err!("Config must contain 'coins' field: {:?}", params.conf);
-        return Err(Mm2MainErr::NoCoinsInConf.into());
+        let error = StartupError::new(
+            StartupErrorCode::ConfigError,
+            format!("Config must contain 'coins' field: {:?}", params.conf),
+        );
+        console_err!("{}", error.message());
+        return Err(error.into());
     }
     let params = LpMainParams::from(params);
 
     if LP_MAIN_RUNNING.load(Ordering::Relaxed) {
-        return Err(Mm2MainErr::AlreadyRuns.into());
+        let error = StartupError::new(StartupErrorCode::AlreadyRunning, "MM2 is already running");
+        console_err!("{}", error.message());
+        return Err(error.into());
     }
     CTX.store(0, Ordering::Relaxed); // Remove the old context ID during restarts.
 
     register_callback(WasmCallback::with_js_function(log_cb));
+    // Setting up a global panic hook to log panic information to the console
+    // This doesn't prevent termination of the WebAssembly instance, but ensures error details are visible
+    // We can't use catch_unwind directly with async/await in WebAssembly, so this is our best option for diagnostics
+    // If a panic occurs, the MM2 instance will terminate but the browser tab will remain responsive
     set_panic_hook();
 
-    let fut = async move {
-        if let Err(true) = LP_MAIN_RUNNING.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) {
-            console_err!("lp_main already started!");
-            return;
-        }
-        let ctx_cb = |ctx| CTX.store(ctx, Ordering::Relaxed);
-        // TODO figure out how to use catch_unwind here
-        // use futures::FutureExt;
-        // match mm2_main::lp_main(params, &ctx_cb).catch_unwind().await {
-        //     Ok(Ok(_)) => console_info!("run_lp_main finished"),
-        //     Ok(Err(err)) => console_err!("run_lp_main error: {}", err),
-        //     Err(err) => console_err!("run_lp_main panic: {:?}", any_to_str(&*err)),
-        // };
-        match mm2_main::lp_main(params, &ctx_cb, KDF_VERSION.into(), KDF_DATETIME.into()).await {
-            Ok(()) => console_info!("run_lp_main finished"),
-            Err(err) => console_err!("run_lp_main error: {}", err),
-        };
-        LP_MAIN_RUNNING.store(false, Ordering::Relaxed)
+    if let Err(true) = LP_MAIN_RUNNING.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) {
+        let error = StartupError::new(StartupErrorCode::AlreadyRunning, "lp_main already started!");
+        console_err!("{}", error.message());
+        return Err(error.into());
+    }
+
+    let ctx_cb = |ctx| CTX.store(ctx, Ordering::Relaxed);
+    let ctx = match mm2_main::lp_main(params, &ctx_cb, KDF_VERSION.into(), KDF_DATETIME.into()).await {
+        Ok(ctx) => {
+            console_info!("run_lp_main finished");
+            ctx
+        },
+        Err(err) => {
+            let error = StartupError::new(StartupErrorCode::InitError, format!("run_lp_main error: {}", err));
+            console_err!("{}", error.message());
+            LP_MAIN_RUNNING.store(false, Ordering::Relaxed);
+            return Err(error.into());
+        },
     };
 
-    // At this moment we still don't have `MmCtx` context to use its `MmCtx::abortable_system` spawner.
-    executor::spawn_local(fut);
-    Ok(())
+    executor::spawn_local(async move {
+        if let Err(e) = mm2_main::lp_run(ctx).await {
+            console_err!("MM2 runtime error: {}", e);
+        }
+        LP_MAIN_RUNNING.store(false, Ordering::Relaxed);
+    });
+
+    Ok(StartupErrorCode::Ok as i8)
 }
 
 /// Returns the MarketMaker2 instance status.
diff --git a/mm2src/mm2_main/src/lp_native_dex.rs b/mm2src/mm2_main/src/lp_native_dex.rs
@@ -20,7 +20,7 @@
 
 use bitcrypto::sha256;
 use coins::register_balance_update_handler;
-use common::executor::{SpawnFuture, Timer};
+use common::executor::SpawnFuture;
 use common::log::{info, warn};
 use crypto::{from_hw_error, CryptoCtx, HwError, HwProcessingError, HwRpcError, WithHwRpcError};
 use derive_more::Display;
@@ -49,7 +49,6 @@ use crate::lp_message_service::{init_message_service, InitMessageServiceError};
 use crate::lp_network::{lp_network_ports, p2p_event_process_loop, subscribe_to_topic, NetIdError};
 use crate::lp_ordermatch::{broadcast_maker_orders_keep_alive_loop, clean_memory_loop, init_ordermatch_context,
                            lp_ordermatch_loop, orders_kick_start, BalanceUpdateOrdermatchHandler, OrdermatchInitError};
-use crate::lp_swap;
 use crate::lp_swap::swap_kick_starts;
 use crate::lp_wallet::{initialize_wallet_passphrase, WalletInitError};
 use crate::rpc::spawn_rpc;
@@ -508,16 +507,6 @@ pub async fn lp_init(ctx: MmArc, version: String, datetime: String) -> MmInitRes
         }
     });
 
-    // In the mobile version we might depend on `lp_init` staying around until the context stops.
-    loop {
-        if ctx.is_stopping() {
-            break;
-        };
-        Timer::sleep(0.2).await
-    }
-    // Clearing up the running swaps removes any circular references that might prevent the context from being dropped.
-    lp_swap::clear_running_swaps(&ctx);
-
     Ok(())
 }
 
diff --git a/mm2src/mm2_main/src/mm2.rs b/mm2src/mm2_main/src/mm2.rs
diff --git a/mm2src/mm2_main/tests/integration_tests_common/mod.rs b/mm2src/mm2_main/tests/integration_tests_common/mod.rs
