@fedimint/core-web 0.0.3 → 0.0.5

package/src/types/wallet.ts

@@ -47,22 +47,22 @@ type PayType = {
 }
 
 type LnPayState =
-  | 'Created'
-  | 'Canceled'
-  | { Funded: { block_height: number } }
-  | { WaitingForRefund: { error_reason: string } }
-  | 'AwaitingChange'
+  | 'created'
+  | 'canceled'
+  | { funded: { block_height: number } }
+  | { waiting_for_refund: { error_reason: string } }
+  | 'awaiting_change'
   | { Success: { preimage: string } }
-  | { Refunded: { gateway_error: string } }
-  | { UnexpectedError: { error_message: string } }
+  | { refunded: { gateway_error: string } }
+  | { unexpected_error: { error_message: string } }
 
 type LnReceiveState =
-  | 'Created'
-  | { WaitingForPayment: { invoice: string; timeout: number } }
-  | { Canceled: { reason: string } }
-  | 'Funded'
-  | 'AwaitingFunds'
-  | 'Claimed'
+  | 'created'
+  | { waiting_for_payment: { invoice: string; timeout: number } }
+  | { canceled: { reason: string } }
+  | 'funded'
+  | 'awaiting_funds'
+  | 'claimed'
 
 type CreateBolt11Response = {
   operation_id: string
@@ -94,6 +94,12 @@ type StreamResult<T extends JSONValue> =
 
 type CancelFunction = () => void
 
+type ReissueExternalNotesState =
+  | 'Created'
+  | 'Issuing'
+  | 'Done'
+  | { Failed: { error: string } }
+
 export {
   JSONValue,
   JSONObject,
@@ -111,4 +117,5 @@ export {
   StreamResult,
   ModuleKind,
   CancelFunction,
+  ReissueExternalNotesState,
 }

package/src/utils/logger.ts

@@ -0,0 +1,61 @@
+const logLevels = ['debug', 'info', 'warn', 'error', 'none'] as const
+export type LogLevel = (typeof logLevels)[number]
+
+export class Logger {
+  private level: LogLevel
+
+  constructor(level: LogLevel = 'none') {
+    this.level = level
+  }
+
+  setLevel(level: LogLevel) {
+    this.level = level
+  }
+
+  coerceLevel(level: string): LogLevel {
+    if (logLevels.includes(level.toLocaleUpperCase() as LogLevel)) {
+      return level.toLocaleUpperCase() as LogLevel
+    }
+    return 'info'
+  }
+
+  log(level: string, message: string, ...args: any[]) {
+    const logLevel = this.coerceLevel(level)
+    if (!this.shouldLog(logLevel)) {
+      return
+    }
+    const consoleFn = console[logLevel]
+    consoleFn(`[${logLevel.toUpperCase()}] ${message}`, ...args)
+  }
+
+  debug(message: string, ...args: any[]) {
+    this.log('debug', message, ...args)
+  }
+
+  info(message: string, ...args: any[]) {
+    this.log('info', message, ...args)
+  }
+
+  warn(message: string, ...args: any[]) {
+    this.log('warn', message, ...args)
+  }
+
+  error(message: string, ...args: any[]) {
+    this.log('error', message, ...args)
+  }
+
+  private shouldLog(
+    messageLevel: LogLevel,
+  ): messageLevel is Exclude<LogLevel, 'none'> {
+    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'none']
+    const messageLevelIndex = levels.indexOf(messageLevel)
+    const currentLevelIndex = levels.indexOf(this.level)
+    return (
+      currentLevelIndex <= messageLevelIndex &&
+      this.level !== 'none' &&
+      messageLevel !== 'none'
+    )
+  }
+}
+
+export const logger = new Logger()

package/src/worker/WorkerClient.ts

@@ -0,0 +1,229 @@
+import {
+  CancelFunction,
+  JSONValue,
+  ModuleKind,
+  StreamError,
+  StreamResult,
+} from '../types/wallet'
+import { logger } from '../utils/logger'
+
+// Handles communication with the wasm worker
+// TODO: Move rpc stream management to a separate "SubscriptionManager" class
+export class WorkerClient {
+  private worker: Worker
+  private requestCounter = 0
+  private requestCallbacks = new Map<number, (value: any) => void>()
+  private initPromise: Promise<void> | null = null
+
+  constructor() {
+    // Must create the URL inside the constructor for vite
+    this.worker = new Worker(new URL('./worker.js', import.meta.url), {
+      type: 'module',
+    })
+    this.worker.onmessage = this.handleWorkerMessage.bind(this)
+    this.worker.onerror = this.handleWorkerError.bind(this)
+    logger.info('WorkerClient instantiated')
+    logger.debug('WorkerClient', this.worker)
+  }
+
+  // Idempotent setup - Loads the wasm module
+  initialize() {
+    if (this.initPromise) return this.initPromise
+    this.initPromise = this.sendSingleMessage('init')
+    return this.initPromise
+  }
+
+  private handleWorkerLogs(event: MessageEvent) {
+    const { type, level, message, ...data } = event.data
+    logger.log(level, message, ...data)
+  }
+
+  private handleWorkerError(event: ErrorEvent) {
+    logger.error('Worker error', event)
+  }
+
+  private handleWorkerMessage(event: MessageEvent) {
+    const { type, requestId, ...data } = event.data
+    if (type === 'log') {
+      this.handleWorkerLogs(event.data)
+    }
+    const streamCallback = this.requestCallbacks.get(requestId)
+    // TODO: Handle errors... maybe have another callbacks list for errors?
+    logger.debug('WorkerClient - handleWorkerMessage', event.data)
+    if (streamCallback) {
+      streamCallback(data) // {data: something} OR {error: something}
+    } else {
+      logger.warn(
+        'WorkerClient - handleWorkerMessage - received message with no callback',
+        requestId,
+        event.data,
+      )
+    }
+  }
+
+  // TODO: Handle errors... maybe have another callbacks list for errors?
+  // TODO: Handle timeouts
+  // TODO: Handle multiple errors
+
+  sendSingleMessage(type: string, payload?: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const requestId = ++this.requestCounter
+      logger.debug('WorkerClient - sendSingleMessage', requestId, type, payload)
+      this.requestCallbacks.set(requestId, (response) => {
+        this.requestCallbacks.delete(requestId)
+        logger.debug(
+          'WorkerClient - sendSingleMessage - response',
+          requestId,
+          response,
+        )
+        if (response.data) resolve(response.data)
+        else if (response.error) reject(response.error)
+        else
+          logger.warn(
+            'WorkerClient - sendSingleMessage - malformed response',
+            requestId,
+            response,
+          )
+      })
+      this.worker.postMessage({ type, payload, requestId })
+    })
+  }
+
+  /**
+   * @summary Initiates an RPC stream with the specified module and method.
+   *
+   * @description
+   * This function sets up an RPC stream by sending a request to a worker and
+   * handling responses asynchronously. It ensures that unsubscription is handled
+   * correctly, even if the unsubscribe function is called before the subscription
+   * is fully established, by deferring the unsubscription attempt using `setTimeout`.
+   *
+   * The function operates in a non-blocking manner, leveraging Promises to manage
+   * asynchronous operations and callbacks to handle responses.
+   *
+   *
+   * @template Response - The expected type of the successful response.
+   * @template Body - The type of the request body.
+   * @param module - The module kind to interact with.
+   * @param method - The method name to invoke on the module.
+   * @param body - The request payload.
+   * @param onSuccess - Callback invoked with the response data on success.
+   * @param onError - Callback invoked with error information if an error occurs.
+   * @param onEnd - Optional callback invoked when the stream ends.
+   * @returns A function that can be called to cancel the subscription.
+   *
+   */
+  rpcStream<
+    Response extends JSONValue = JSONValue,
+    Body extends JSONValue = JSONValue,
+  >(
+    module: ModuleKind,
+    method: string,
+    body: Body,
+    onSuccess: (res: Response) => void,
+    onError: (res: StreamError['error']) => void,
+    onEnd: () => void = () => {},
+  ): CancelFunction {
+    const requestId = ++this.requestCounter
+    logger.debug('WorkerClient - rpcStream', requestId, module, method, body)
+    let unsubscribe: (value: void) => void = () => {}
+    let isSubscribed = false
+
+    const unsubscribePromise = new Promise<void>((resolve) => {
+      unsubscribe = () => {
+        if (isSubscribed) {
+          // If already subscribed, resolve immediately to trigger unsubscription
+          resolve()
+        } else {
+          // If not yet subscribed, defer the unsubscribe attempt to the next event loop tick
+          // This ensures that subscription setup has time to complete
+          setTimeout(() => unsubscribe(), 0)
+        }
+      }
+    })
+
+    // Initiate the inner RPC stream setup asynchronously
+    this._rpcStreamInner(
+      requestId,
+      module,
+      method,
+      body,
+      onSuccess,
+      onError,
+      onEnd,
+      unsubscribePromise,
+    ).then(() => {
+      isSubscribed = true
+    })
+
+    return unsubscribe
+  }
+
+  private async _rpcStreamInner<
+    Response extends JSONValue = JSONValue,
+    Body extends JSONValue = JSONValue,
+  >(
+    requestId: number,
+    module: ModuleKind,
+    method: string,
+    body: Body,
+    onSuccess: (res: Response) => void,
+    onError: (res: StreamError['error']) => void,
+    onEnd: () => void = () => {},
+    unsubscribePromise: Promise<void>,
+    // Unsubscribe function
+  ): Promise<void> {
+    // await this.openPromise
+    // if (!this.worker || !this._isOpen)
+    //   throw new Error('FedimintWallet is not open')
+
+    this.requestCallbacks.set(requestId, (response: StreamResult<Response>) => {
+      if (response.error !== undefined) {
+        onError(response.error)
+      } else if (response.data !== undefined) {
+        onSuccess(response.data)
+      } else if (response.end !== undefined) {
+        this.requestCallbacks.delete(requestId)
+        onEnd()
+      }
+    })
+    this.worker.postMessage({
+      type: 'rpc',
+      payload: { module, method, body },
+      requestId,
+    })
+
+    unsubscribePromise.then(() => {
+      this.worker?.postMessage({
+        type: 'unsubscribe',
+        requestId,
+      })
+      this.requestCallbacks.delete(requestId)
+    })
+  }
+
+  rpcSingle<Response extends JSONValue = JSONValue>(
+    module: ModuleKind,
+    method: string,
+    body: JSONValue,
+  ): Promise<Response> {
+    logger.debug('WorkerClient - rpcSingle', module, method, body)
+    return new Promise((resolve, reject) => {
+      this.rpcStream<Response>(module, method, body, resolve, reject)
+    })
+  }
+
+  cleanup() {
+    this.worker.terminate()
+    this.initPromise = null
+    this.requestCallbacks.clear()
+  }
+
+  // For Testing
+  _getRequestCounter() {
+    return this.requestCounter
+  }
+  _getRequestCallbackMap() {
+    return this.requestCallbacks
+  }
+}

package/src/worker/index.ts

@@ -0,0 +1 @@
+export { WorkerClient } from './WorkerClient'

package/src/worker/worker.js

@@ -0,0 +1,96 @@
+// 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')
+
+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 === '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 {
+      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 { JSONObject } from '../types/wallet'
+import { TESTING_INVITE } from '../test/TestingService'
+import { workerTest } from '../test/setupTests'
+
+// 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')
+})

package/node_modules/fedimint-client-wasm/fedimint_client_wasm.d.ts

@@ -1,49 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
- */
-export class RpcHandle {
-  free(): void
-  /**
-   */
-  cancel(): void
-}
-/**
- */
-export class WasmClient {
-  free(): void
-  /**
-   * Open fedimint client with already joined federation.
-   *
-   * After you have joined a federation, you can reopen the fedimint client
-   * with same client_name. Opening client with same name at same time is
-   * not supported. You can close the current client by calling
-   * `client.free()`. NOTE: The client will remain active until all the
-   * running rpc calls have finished.
-   * @param {string} client_name
-   * @returns {Promise<WasmClient | undefined>}
-   */
-  static open(client_name: string): Promise<WasmClient | undefined>
-  /**
-   * Open a fedimint client by join a federation.
-   * @param {string} client_name
-   * @param {string} invite_code
-   * @returns {Promise<WasmClient>}
-   */
-  static join_federation(
-    client_name: string,
-    invite_code: string,
-  ): Promise<WasmClient>
-  /**
-   * Call a fedimint client rpc the responses are returned using `cb`
-   * callback. Each rpc call *can* return multiple responses by calling
-   * `cb` multiple times. The returned RpcHandle can be used to cancel the
-   * operation.
-   * @param {string} module
-   * @param {string} method
-   * @param {string} payload
-   * @param {Function} cb
-   * @returns {RpcHandle}
-   */
-  rpc(module: string, method: string, payload: string, cb: Function): RpcHandle
-}

package/node_modules/fedimint-client-wasm/fedimint_client_wasm.js

@@ -1,4 +0,0 @@
-import * as wasm from './fedimint_client_wasm_bg.wasm'
-import { __wbg_set_wasm } from './fedimint_client_wasm_bg.js'
-__wbg_set_wasm(wasm)
-export * from './fedimint_client_wasm_bg.js'