@fedimint/core-web 0.0.0-20250617190659

package/src/worker/worker.js

@@ -0,0 +1,167 @@
+// Web Worker for fedimint-client-wasm to run in the browser
+
+// HACK: Fixes vitest browser runner
+// TODO: remove once https://github.com/vitest-dev/vitest/pull/6569 lands in a release
+globalThis.__vitest_browser_runner__ = { wrapDynamicImport: (foo) => foo() }
+
+// dynamically imported Constructor for WasmClient
+let WasmClient = null
+// client instance
+let client = null
+
+const streamCancelMap = new Map()
+
+const handleFree = (requestId) => {
+  streamCancelMap.delete(requestId)
+}
+
+console.log('Worker - init')
+
+/**
+ * Type definitions for the worker messages
+ *
+ * @typedef {import('../types/worker').WorkerMessageType} WorkerMessageType
+ * @typedef {{
+ *  type: WorkerMessageType
+ *  payload: any
+ *  requestId: number
+ * }} WorkerMessage
+ * @param {{data: WorkerMessage}} event
+ */
+self.onmessage = async (event) => {
+  const { type, payload, requestId } = event.data
+
+  try {
+    if (type === 'init') {
+      WasmClient = (await import('@fedimint/fedimint-client-wasm-bundler'))
+        .WasmClient
+      self.postMessage({ type: 'initialized', data: {}, requestId })
+    } else if (type === 'open') {
+      const { clientName } = payload
+      client = (await WasmClient.open(clientName)) || null
+      self.postMessage({
+        type: 'open',
+        data: { success: !!client },
+        requestId,
+      })
+    } else if (type === 'join') {
+      const { inviteCode, clientName: joinClientName } = payload
+      try {
+        client = await WasmClient.join_federation(joinClientName, inviteCode)
+        self.postMessage({
+          type: 'join',
+          data: { success: !!client },
+          requestId,
+        })
+      } catch (e) {
+        self.postMessage({ type: 'error', error: e.message, requestId })
+      }
+    } else if (type === 'previewFederation') {
+      const { inviteCode } = payload
+      try {
+        client = await WasmClient.preview_federation(inviteCode)
+        const parsed = JSON.parse(client)
+        self.postMessage({
+          type: 'previewFederation',
+          data: {
+            success: !!client,
+            config: parsed.config,
+            federation_id: parsed.federation_id,
+          },
+          requestId,
+        })
+      } catch (e) {
+        self.postMessage({ type: 'error', error: e.message, requestId })
+      }
+    } else if (type === 'rpc') {
+      const { module, method, body } = payload
+      console.log('RPC received', module, method, body)
+      if (!client) {
+        self.postMessage({
+          type: 'error',
+          error: 'WasmClient not initialized',
+          requestId,
+        })
+        return
+      }
+      const rpcHandle = await client.rpc(
+        module,
+        method,
+        JSON.stringify(body),
+        (res) => {
+          console.log('RPC response', requestId, res)
+          const data = JSON.parse(res)
+          self.postMessage({ type: 'rpcResponse', requestId, ...data })
+
+          if (data.end !== undefined) {
+            // Handle stream ending
+            const handle = streamCancelMap.get(requestId)
+            handle?.free()
+          }
+        },
+      )
+      streamCancelMap.set(requestId, rpcHandle)
+    } else if (type === 'unsubscribe') {
+      const rpcHandle = streamCancelMap.get(requestId)
+      if (rpcHandle) {
+        rpcHandle.cancel()
+        rpcHandle.free()
+        streamCancelMap.delete(requestId)
+      }
+    } else if (type === 'cleanup') {
+      console.log('cleanup message received')
+      client?.free()
+      self.postMessage({
+        type: 'cleanup',
+        data: {},
+        requestId,
+      })
+      close()
+    } else if (type === 'parseInviteCode') {
+      const { inviteCode } = payload
+      try {
+        const res = WasmClient.parse_invite_code(inviteCode)
+        const parsedRes = JSON.parse(res)
+        self.postMessage({
+          type: 'parseInviteCode',
+          data: parsedRes,
+          requestId,
+        })
+      } catch (error) {
+        self.postMessage({
+          type: 'error',
+          error: `Failed to parse invite code: ${error.message}`,
+          requestId,
+        })
+      }
+    } else if (type === 'parseBolt11Invoice') {
+      const { invoiceStr } = payload
+      try {
+        const res = WasmClient.parse_bolt11_invoice(invoiceStr)
+        const parsedRes = JSON.parse(res)
+        self.postMessage({
+          type: 'parseBolt11Invoice',
+          data: parsedRes,
+          requestId,
+        })
+      } catch (error) {
+        self.postMessage({
+          type: 'error',
+          error: `Failed to parse invoice: ${error.message}`,
+          requestId,
+        })
+      }
+    } else {
+      self.postMessage({
+        type: 'error',
+        error: 'Unknown message type',
+        requestId,
+      })
+    }
+  } catch (e) {
+    console.error('ERROR', e)
+    self.postMessage({ type: 'error', error: e, requestId })
+  }
+}
+
+// self.postMessage({ type: 'init', data: {} })

package/src/worker/worker.test.ts

@@ -0,0 +1,90 @@
+import { expect } from 'vitest'
+import { TESTING_INVITE } from '../test/TestingService'
+import { JSONObject } from '../types'
+import { workerTest } from '../test/fixtures'
+
+// Waits for a message of a given type from the worker
+const waitForWorkerResponse = (
+  worker: Worker,
+  messageType: string,
+): Promise<JSONObject> => {
+  return new Promise((resolve, reject) => {
+    worker.onmessage = (event) => {
+      if (event.data.type === messageType) {
+        resolve(event.data)
+      } else if (event.data.type === 'error') {
+        reject(event.data.error)
+      }
+    }
+    worker.onerror = (error) => {
+      reject(error.message)
+    }
+  })
+}
+
+workerTest(
+  'should initialize WasmClient on init message',
+  async ({ worker }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    const response = await waitForWorkerResponse(worker, 'initialized')
+    expect(response.data).toEqual({})
+  },
+)
+
+workerTest(
+  'should return false on open for a new client',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'open',
+      requestId: 2,
+      payload: { clientName },
+    })
+    const response = await waitForWorkerResponse(worker, 'open')
+    expect(response.data).toEqual({ success: false })
+  },
+)
+
+workerTest(
+  'should error on fake federation invitation',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'join',
+      requestId: 2,
+      payload: { inviteCode: 'fakefederationinvitation', clientName },
+    })
+    try {
+      await waitForWorkerResponse(worker, 'open')
+      expect.unreachable()
+    } catch (e) {
+      expect(e).toBe('parsing failed')
+    }
+  },
+)
+
+workerTest(
+  'should handle joining a federation',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'join',
+      requestId: 2,
+      payload: { inviteCode: TESTING_INVITE, clientName },
+    })
+    const response = await waitForWorkerResponse(worker, 'join')
+    expect(response.data).toEqual({ success: true })
+  },
+)
+
+workerTest('should handle unknown message type', async ({ worker }) => {
+  worker.postMessage({ type: 'unknown', requestId: 2 })
+  const response = await waitForWorkerResponse(worker, 'error')
+  expect(response.error).toBe('Unknown message type')
+})