feat(wasm): Run Lumina in a Shared Worker

node-wasm/Cargo.toml

@@ -31,15 +31,15 @@ lumina-node = { workspace = true }
 
 anyhow = "1.0.86"
 console_error_panic_hook = "0.1.7"
-enum-as-inner = "0.6"
-futures = "0.3"
-gloo-timers = "0.3"
-instant = "0.1"
+enum-as-inner = "0.6.0"
+futures = "0.3.30"
+gloo-timers = "0.3.0"
+instant = "0.1.13"
 js-sys = "0.3.69"
 serde = { version = "1.0.203", features = ["derive"] }
 serde-wasm-bindgen = "0.6.5"
 serde_repr = "0.1.19"
-thiserror = "1.0"
+thiserror = "1.0.61"
 time = { version = "0.3.36", features = ["wasm-bindgen"] }
 tokio = { version = "1.38.0", features = ["sync"] }
 tracing = "0.1.40"
@@ -53,12 +53,13 @@ web-sys = { version = "0.3.69", features = [
   "DedicatedWorkerGlobalScope",
   "MessageEvent",
   "MessagePort",
+  "Navigator",
   "SharedWorker",
   "SharedWorkerGlobalScope",
   "Worker",
   "WorkerGlobalScope",
   "WorkerOptions",
-  "WorkerType"
+  "WorkerType",
 ] }
 
 [package.metadata.docs.rs]

node-wasm/src/node.rs

@@ -5,19 +5,18 @@ use libp2p::identity::Keypair;
 use libp2p::multiaddr::Protocol;
 use serde::{Deserialize, Serialize};
 use serde_wasm_bindgen::to_value;
-use tracing::info;
 use wasm_bindgen::prelude::*;
-use web_sys::{BroadcastChannel, SharedWorker, Worker, WorkerOptions, WorkerType};
+use web_sys::BroadcastChannel;
 
 use lumina_node::blockstore::IndexedDbBlockstore;
 use lumina_node::network::{canonical_network_bootnodes, network_genesis, network_id};
 use lumina_node::node::NodeConfig;
 use lumina_node::store::IndexedDbStore;
 
 use crate::error::{Context, Result};
-use crate::utils::{is_chrome, js_value_from_display, JsValueToJsError, Network};
+use crate::utils::{is_chrome, js_value_from_display, Network};
 use crate::worker::commands::{CheckableResponseExt, NodeCommand, SingleHeaderQuery};
-use crate::worker::{worker_script_url, WorkerClient};
+use crate::worker::{worker_script_url, AnyWorker, WorkerClient};
 use crate::wrapper::libp2p::NetworkInfoSnapshot;
 
 const LUMINA_WORKER_NAME: &str = "lumina";
@@ -65,32 +64,27 @@ impl NodeDriver {
     #[wasm_bindgen(constructor)]
     pub async fn new(worker_type: Option<NodeWorkerKind>) -> Result<NodeDriver> {
         let url = worker_script_url();
-        let mut opts = WorkerOptions::new();
-        opts.type_(WorkerType::Module);
-        opts.name(LUMINA_WORKER_NAME);
 
-        let default_worker_type = if is_chrome() {
+        // For chrome we default to running in a dedicated Worker because:
+        // 1. Chrome Android does not support SharedWorkers at all
+        // 2. On desktop Chrome, if tab running lumina is reloaded, it fails to re-connect to
+        //    previous worker instance and doesn't create a new one, leaving it in non functioning
+        //    limbo
+        let default_worker_type = if is_chrome().unwrap_or(false) {
             NodeWorkerKind::Dedicated
         } else {
             NodeWorkerKind::Shared
         };
 
-        let client = match worker_type.unwrap_or(default_worker_type) {
-            NodeWorkerKind::Shared => {
-                info!("Starting SharedWorker");
-                let worker = SharedWorker::new_with_worker_options(&url, &opts)
-                    .to_error("could not create SharedWorker")?;
-                WorkerClient::from(worker)
-            }
-            NodeWorkerKind::Dedicated => {
-                info!("Starting Worker");
-                let worker =
-                    Worker::new_with_options(&url, &opts).to_error("could not create Worker")?;
-                WorkerClient::from(worker)
-            }
-        };
+        let worker = AnyWorker::new(
+            worker_type.unwrap_or(default_worker_type),
+            &url,
+            LUMINA_WORKER_NAME,
+        )?;
 
-        Ok(Self { client })
+        Ok(Self {
+            client: WorkerClient::new(worker),
+        })
     }
 
     /// Check whether Lumina is currently running

node-wasm/src/utils.rs

@@ -1,7 +1,6 @@
 //! Various utilities for interacting with node from wasm.
 use std::fmt::{self, Debug};
 
-use js_sys::JsString;
 use lumina_node::network;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
@@ -13,10 +12,7 @@ use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::prelude::*;
 use tracing_web::{performance_layer, MakeConsoleWriter};
 use wasm_bindgen::prelude::*;
-use web_sys::{
-    window, Crypto, DedicatedWorkerGlobalScope, SharedWorker, SharedWorkerGlobalScope, Worker,
-    WorkerGlobalScope,
-};
+use web_sys::{Crypto, DedicatedWorkerGlobalScope, SharedWorker, SharedWorkerGlobalScope, Worker};
 
 use crate::error::{Context, Error, Result};
 
@@ -83,27 +79,6 @@ pub(crate) fn to_jsvalue_or_undefined<T: Serialize>(value: &T) -> JsValue {
     to_value(value).unwrap_or(JsValue::UNDEFINED)
 }
 
-pub(crate) trait JsValueToJsError<T> {
-    fn to_error<C>(self, context_fn: C) -> Result<T, JsError>
-    where
-        C: fmt::Display + Send + Sync + 'static;
-}
-
-impl<T> JsValueToJsError<T> for std::result::Result<T, JsValue> {
-    fn to_error<C>(self, context: C) -> Result<T, JsError>
-    where
-        C: fmt::Display + Send + Sync + 'static,
-    {
-        self.map_err(|e| {
-            let error_str = match e.dyn_ref::<JsString>() {
-                Some(s) => format!("{context}: {s}"),
-                None => format!("{context}"),
-            };
-            JsError::new(&error_str)
-        })
-    }
-}
-
 pub(crate) trait WorkerSelf {
     type GlobalScope;
 
@@ -188,23 +163,14 @@ const CHROME_USER_AGENT_DETECTION_STR: &str = "Chrome/";
 // currently there's issue with SharedWorkers on Chrome, where restarting lumina's worker
 // causes all network connections to fail. Until that's resolved detect chrome and apply
 // a workaround.
-pub(crate) fn is_chrome() -> bool {
-    let mut user_agent = None;
-    if let Some(window) = window() {
-        user_agent = Some(window.navigator().user_agent());
-    };
-    if let Some(worker_scope) = JsValue::from(js_sys::global()).dyn_ref::<WorkerGlobalScope>() {
-        user_agent = Some(worker_scope.navigator().user_agent());
-    }
-
-    if let Some(user_agent) = user_agent {
-        user_agent
-            .as_deref()
-            .unwrap_or("")
-            .contains(CHROME_USER_AGENT_DETECTION_STR)
-    } else {
-        false
-    }
+pub(crate) fn is_chrome() -> Result<bool, Error> {
+    js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("navigator"))
+        .context("failed to get `navigator` from global object")?
+        .dyn_into::<web_sys::Navigator>()
+        .context("`navigator` is not instanceof `Navigator`")?
+        .user_agent()
+        .context("could not get UserAgent from Navigator")
+        .map(|user_agent| user_agent.contains(CHROME_USER_AGENT_DETECTION_STR))
 }
 
 pub(crate) fn get_crypto() -> Result<Crypto, Error> {

node-wasm/src/worker.rs

@@ -28,7 +28,7 @@ use crate::wrapper::libp2p::NetworkInfoSnapshot;
 mod channel;
 pub(crate) mod commands;
 
-pub(crate) use channel::WorkerClient;
+pub(crate) use channel::{AnyWorker, WorkerClient};
 
 const WORKER_MESSAGE_SERVER_INCOMING_QUEUE_LENGTH: usize = 64;