Switch to bundler target for wasm-pack for manifest v3

node-wasm/Cargo.toml

@@ -60,6 +60,8 @@ web-sys = { version = "0.3.70", features = [
   "RequestInit",
   "RequestMode",
   "Response",
+  "ServiceWorker",
+  "ServiceWorkerGlobalScope",
   "SharedWorker",
   "SharedWorkerGlobalScope",
   "StorageManager",
@@ -79,5 +81,5 @@ targets = ["wasm32-unknown-unknown"]
 
 # Uncomment this if you need debug symbols in release.
 # Also check workspace's `Cargo.toml`.
-#[package.metadata.wasm-pack.profile.release]
-#wasm-opt = ['-O4', '-g']
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = ['-O4', '-g']

node-wasm/js/index.d.ts

@@ -3,4 +3,3 @@
 */
 export function spawnNode(): Promise<NodeClient>;
 export * from "lumina-node-wasm";
-export default function init(): Promise<void>;

node-wasm/js/index.js

@@ -1,14 +1,12 @@
-import init, { NodeClient } from "lumina-node-wasm"
+import { NodeClient } from "lumina-node-wasm"
 
 /**
 * Spawn a worker running lumina node and get the `NodeClient` connected to it.
 */
 export async function spawnNode() {
-    await init();
     let worker = new Worker(new URL("worker.js", import.meta.url));
     let client = await new NodeClient(worker);
     return client;
 }
 
 export * from "lumina-node-wasm";
-export default init;

node-wasm/js/worker.js

@@ -1,10 +1,8 @@
-import init, { NodeWorker, NodeClient } from "lumina-node-wasm"
+import { NodeWorker, NodeClient } from "lumina-node-wasm"
 
 Error.stackTraceLimit = 99;
 
-init().then(async () => {
-    let worker = new NodeWorker(self);
-    console.log("starting worker: ", worker);
+let worker = new NodeWorker(self);
+console.log("starting worker: ", worker);
 
-    await worker.run();
-});
+worker.run();

node-wasm/src/utils.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::net::{IpAddr, Ipv4Addr};
 
 use gloo_timers::future::TimeoutFuture;
-use js_sys::Math;
+use js_sys::{Math, Promise};
 use libp2p::multiaddr::Protocol;
 use libp2p::{Multiaddr, PeerId};
 use lumina_node::network;
@@ -21,7 +21,7 @@ use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
     DedicatedWorkerGlobalScope, MessageEvent, Request, RequestInit, RequestMode, Response,
-    SharedWorker, SharedWorkerGlobalScope, Worker,
+    ServiceWorker, ServiceWorkerGlobalScope, SharedWorker, SharedWorkerGlobalScope, Worker,
 };
 
 use crate::error::{Context, Error, Result};
@@ -81,7 +81,7 @@ pub(crate) fn js_value_from_display<D: fmt::Display>(value: D) -> JsValue {
     JsValue::from(value.to_string())
 }
 
-pub(crate) trait WorkerSelf {
+trait WorkerSelf {
     type GlobalScope;
 
     fn worker_self() -> Self::GlobalScope;
@@ -112,6 +112,18 @@ impl WorkerSelf for Worker {
     }
 }
 
+impl WorkerSelf for ServiceWorker {
+    type GlobalScope = ServiceWorkerGlobalScope;
+
+    fn worker_self() -> Self::GlobalScope {
+        JsValue::from(js_sys::global()).into()
+    }
+
+    fn is_worker_type() -> bool {
+        js_sys::global().has_type::<Self::GlobalScope>()
+    }
+}
+
 /// This type is useful in cases where we want to deal with de/serialising `Result<T, E>`, with
 /// [`serde_wasm_bindgen::preserve`] where `T` is a JavaScript object (which are not serializable by
 /// Rust standards, but can be passed through unchanged via cast as they implement [`JsCast`]).
@@ -182,6 +194,9 @@ pub(crate) async fn request_storage_persistence() -> Result<(), Error> {
         Worker::worker_self().navigator().storage()
     } else if SharedWorker::is_worker_type() {
         SharedWorker::worker_self().navigator().storage()
+    } else if ServiceWorker::is_worker_type() {
+        warn!("ServiceWorker doesn't have access to StorageManager");
+        return Ok(());
     } else {
         return Err(Error::new("`navigator.storage` not found in global scope"));
     };
@@ -218,6 +233,8 @@ pub(crate) fn get_user_agent() -> Result<String, Error> {
         Ok(Worker::worker_self().navigator().user_agent()?)
     } else if SharedWorker::is_worker_type() {
         Ok(SharedWorker::worker_self().navigator().user_agent()?)
+    } else if ServiceWorker::is_worker_type() {
+        Ok(ServiceWorker::worker_self().navigator().user_agent()?)
     } else {
         Err(Error::new(
             "`navigator.user_agent` not found in global scope",
@@ -256,6 +273,12 @@ pub(crate) fn random_id() -> u32 {
     (Math::random() * f64::from(u32::MAX)).floor() as u32
 }
 
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = fetch)]
+    fn fetch_with_request(input: &Request) -> Promise;
+}
+
 async fn fetch(url: &str, opts: &RequestInit, headers: &[(&str, &str)]) -> Result<Response, Error> {
     let request = Request::new_with_str_and_init(url, opts)
         .with_context(|| format!("failed to create a request to {url}"))?;
@@ -267,15 +290,7 @@ async fn fetch(url: &str, opts: &RequestInit, headers: &[(&str, &str)]) -> Resul
             .with_context(|| format!("failed setting header: '{name}: {value}'"))?;
     }
 
-    let fetch_promise = if let Some(window) = web_sys::window() {
-        window.fetch_with_request(&request)
-    } else if Worker::is_worker_type() {
-        Worker::worker_self().fetch_with_request(&request)
-    } else if SharedWorker::is_worker_type() {
-        SharedWorker::worker_self().fetch_with_request(&request)
-    } else {
-        return Err(Error::new("`fetch` not found in global scope"));
-    };
+    let fetch_promise = fetch_with_request(&request);
 
     JsFuture::from(fetch_promise)
         .await

node-wasm/src/worker.rs

@@ -9,7 +9,7 @@ use tokio::sync::mpsc;
 use tracing::{error, info, warn};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
-use web_sys::{BroadcastChannel, SharedWorker};
+use web_sys::BroadcastChannel;
 
 use lumina_node::blockstore::IndexedDbBlockstore;
 use lumina_node::events::{EventSubscriber, NodeEventInfo};
@@ -20,7 +20,7 @@ use crate::client::WasmNodeConfig;
 use crate::commands::{NodeCommand, SingleHeaderQuery, WorkerResponse};
 use crate::error::{Context, Error, Result};
 use crate::ports::{ClientMessage, WorkerServer};
-use crate::utils::{random_id, WorkerSelf};
+use crate::utils::random_id;
 use crate::wrapper::libp2p::NetworkInfoSnapshot;
 
 #[derive(Debug, Serialize, Deserialize, Error)]
@@ -283,7 +283,7 @@ impl NodeWorkerInstance {
                 WorkerResponse::SamplingMetadata(self.get_sampling_metadata(height).await)
             }
             NodeCommand::CloseWorker => {
-                SharedWorker::worker_self().close();
+                unimplemented!("waiting for AnyWorker");
                 WorkerResponse::WorkerClosed(())
             }
             NodeCommand::InternalPing => WorkerResponse::InternalPong,

node/src/p2p.rs

@@ -1014,6 +1014,7 @@ where
 
     #[instrument(level = "trace", skip(self))]
     async fn on_kademlia_event(&mut self, ev: kad::Event) -> Result<()> {
+        info!("KAD: {ev:?}");
         match ev {
             kad::Event::RoutingUpdated {
                 peer, addresses, ..