@fedimint/core-web 0.0.2 → 0.0.3

package/node_modules/fedimint-client-wasm/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "fedimint-client-wasm",
+  "type": "module",
+  "collaborators": [
+    "The Fedimint Developers"
+  ],
+  "description": "fedimint client for wasm",
+  "version": "0.5.0-alpha",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fedimint/fedimint"
+  },
+  "files": [
+    "fedimint_client_wasm_bg.wasm",
+    "fedimint_client_wasm.js",
+    "fedimint_client_wasm_bg.js",
+    "fedimint_client_wasm.d.ts"
+  ],
+  "main": "fedimint_client_wasm.js",
+  "types": "fedimint_client_wasm.d.ts",
+  "sideEffects": [
+    "./fedimint_client_wasm.js",
+    "./snippets/*"
+  ]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fedimint/core-web",
   "description": "Library for building web apps with a fedimint client",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/fedimint/fedimint-web-sdk.git",
@@ -9,20 +9,25 @@
   },
   "files": [
     "dist",
-    "wasm",
-    "src"
+    "src",
+    "wasm"
   ],
   "sideEffects": false,
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "dependencies": {
+    "fedimint-client-wasm": "file:./wasm"
+  },
+  "bundledDependencies": [
+    "fedimint-client-wasm"
+  ],
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
-    "@rollup/plugin-wasm": "^6.2.2",
     "@types/node": "^20.14.8",
-    "@web/rollup-plugin-import-meta-assets": "^2.2.1",
     "rollup": "^4.21.2",
+    "rollup-plugin-typescript2": "^0.36.0",
     "tslib": "^2.7.0",
     "typescript": "^5.2.2"
   },

package/src/FedimintWallet.ts

@@ -1,4 +1,3 @@
-import init, { RpcHandle, WasmClient } from '../wasm/fedimint_client_wasm.js'
 import {
   JSONValue,
   JSONObject,
@@ -10,42 +9,87 @@ import {
   StreamError,
   CreateBolt11Response,
   ModuleKind,
-} from './types/wallet.js'
+  GatewayInfo,
+  CancelFunction,
+} from './types/wallet'
 
 const DEFAULT_CLIENT_NAME = 'fm-default' as const
 
 export class FedimintWallet {
-  private _fed: WasmClient | null = null
+  private worker: Worker | null = null
   private initPromise: Promise<void> | null = null
-  private openPromise: Promise<void> | null = null
+  private openPromise: Promise<void>
   private resolveOpen: () => void = () => {}
+  private _isOpen: boolean = false
+  private requestCounter: number = 0
+  private requestCallbacks: Map<number, (value: any) => void> = new Map()
 
-  constructor(lazy: boolean = false) {
-    if (lazy) return
-    this.initialize()
+  constructor(lazy: boolean = false, open: boolean = true) {
     this.openPromise = new Promise((resolve) => {
       this.resolveOpen = resolve
     })
+    if (lazy) return
+    this.initialize()
+  }
+
+  async waitForOpen() {
+    if (this._isOpen) return
+    return this.openPromise
+  }
+
+  private getNextRequestId(): number {
+    return ++this.requestCounter
+  }
+
+  // Sends a single message and deletes the request callback
+  // The first response
+  private sendSingleMessage(type: string, payload?: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const requestId = this.getNextRequestId()
+      this.requestCallbacks.set(requestId, (data) => {
+        this.requestCallbacks.delete(requestId)
+        if (data.data) resolve(data.data)
+        else if (data.error) reject(data.error)
+      })
+      try {
+        this.worker!.postMessage({ type, payload, requestId })
+      } catch (e) {
+        reject(e)
+      }
+    })
   }
 
   // Setup
-  async initialize() {
+  initialize() {
     if (this.initPromise) return this.initPromise
-    // this.worker = new Worker(new URL('./wasm.worker.ts', import.meta.url))
-    this.initPromise = init().then(() => {
-      console.trace('Fedimint Client Wasm Initialization complete')
-    })
+    this.worker = new Worker(new URL('./worker.js', import.meta.url))
+    this.worker.onmessage = this.handleWorkerMessage.bind(this)
+    this.initPromise = this.sendSingleMessage('init')
     return this.initPromise
   }
 
+  private handleWorkerMessage(event: MessageEvent) {
+    const { type, requestId, ...data } = event.data
+    const streamCallback = this.requestCallbacks.get(requestId)
+    // TODO: Handle errors... maybe have another callbacks list for errors?
+    if (streamCallback) {
+      streamCallback(data) // {data: something} OR {error: something}
+    }
+  }
+
   async open(clientName: string = DEFAULT_CLIENT_NAME) {
     await this.initialize()
-    const wasm = await WasmClient.open(clientName)
-
-    if (wasm === undefined) return false
-    this._fed = wasm
-    this.resolveOpen()
-    return true
+    // TODO: Determine if this should be safe or throw
+    if (this._isOpen)
+      throw new Error(
+        'The FedimintWallet is already open. You can only call `FedimintWallet.open on closed clients.`',
+      )
+    const { success } = await this.sendSingleMessage('open', { clientName })
+    if (success) {
+      this._isOpen = !!success
+      this.resolveOpen()
+    }
+    return success
   }
 
   async joinFederation(
@@ -53,12 +97,43 @@ export class FedimintWallet {
     clientName: string = DEFAULT_CLIENT_NAME,
   ) {
     await this.initialize()
-    this._fed = await WasmClient.join_federation(clientName, inviteCode)
-    this.resolveOpen()
+    // TODO: Determine if this should be safe or throw
+    if (this._isOpen)
+      throw new Error(
+        'Failed to Join Federation. You have already joined a federation, and you can only join one federation per wallet.',
+      )
+    const response = await this.sendSingleMessage('join', {
+      inviteCode,
+      clientName,
+    })
+    if (response.success) this._isOpen = true
   }
 
-  // RPC
-  private async _rpcStream<
+  /**
+   * @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.
+   *
+   */
+  private _rpcStream<
     Response extends JSONValue = JSONValue,
     Body extends JSONValue = JSONValue,
   >(
@@ -67,42 +142,94 @@ export class FedimintWallet {
     body: Body,
     onSuccess: (res: Response) => void,
     onError: (res: StreamError['error']) => void,
-  ): Promise<RpcHandle> {
-    await this.openPromise
-    if (!this._fed) throw new Error('FedimintWallet is not open')
-    const unsubscribe = await this._fed.rpc(
-      module,
-      method,
-      JSON.stringify(body),
-      (res: string) => {
-        // TODO: Validate the response?
-        const parsed = JSON.parse(res) as StreamResult<Response>
-        if (parsed.error) {
-          onError(parsed.error)
+    onEnd: () => void = () => {},
+  ): CancelFunction {
+    const requestId = this.getNextRequestId()
+
+    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 {
-          onSuccess(parsed.data)
+          // 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(() => {
+      console.trace('UNSUBSCRIBING', requestId)
+      this.worker?.postMessage({
+        type: 'unsubscribe',
+        requestId,
+      })
+      this.requestCallbacks.delete(requestId)
+    })
+  }
+
   private async _rpcSingle<Response extends JSONValue = JSONValue>(
     module: ModuleKind,
     method: string,
     body: JSONValue,
   ): Promise<Response> {
     return new Promise((resolve, reject) => {
-      if (!this._fed) return reject('FedimintWallet is not open')
-      this._fed.rpc(module, method, JSON.stringify(body), (res: string) => {
-        // TODO: Validate the response?
-        const parsed = JSON.parse(res) as StreamResult<Response>
-        if (parsed.error) {
-          reject(parsed.error)
-        } else {
-          resolve(parsed.data)
-        }
-      })
+      this._rpcStream<Response>(module, method, body, resolve, reject)
     })
   }
 
@@ -148,12 +275,7 @@ export class FedimintWallet {
       onError,
     )
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   async spendNotes(
@@ -195,12 +317,7 @@ export class FedimintWallet {
       onError,
     )
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   async awaitSpendOobRefund(operationId: string): Promise<JSONValue> {
@@ -214,13 +331,14 @@ export class FedimintWallet {
    * After this call, the FedimintWallet instance should be discarded.
    */
   async cleanup() {
-    await this._fed?.free()
-    this._fed = null
-    this.openPromise = null
+    this.worker?.terminate()
+    this.worker = null
+    this.openPromise = Promise.resolve()
+    this.requestCallbacks.clear()
   }
 
   isOpen() {
-    return this._fed !== null
+    return this.worker !== null && this._isOpen
   }
 
   async getConfig(): Promise<JSONValue> {
@@ -261,12 +379,7 @@ export class FedimintWallet {
       onError,
     )
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   subscribeToRecoveryProgress(
@@ -281,39 +394,69 @@ export class FedimintWallet {
       progress: JSONValue
     }>('', 'subscribe_to_recovery_progress', {}, onSuccess, onError)
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   // Lightning Network module methods
 
+  async createBolt11InvoiceWithGateway(
+    amount: number,
+    description: string,
+    expiryTime: number | null = null,
+    extraMeta: JSONObject = {},
+    gatewayInfo: GatewayInfo,
+  ) {
+    return await this._rpcSingle('ln', 'create_bolt11_invoice', {
+      amount,
+      description,
+      expiry_time: expiryTime,
+      extra_meta: extraMeta,
+      gateway: gatewayInfo,
+    })
+  }
+
   async createBolt11Invoice(
     amount: number,
     description: string,
     expiryTime: number | null = null,
     extraMeta: JSONObject = {},
-    gateway: LightningGateway | null = null,
   ): Promise<CreateBolt11Response> {
+    await this.updateGatewayCache()
+    const gateway = await this._getDefaultGatewayInfo()
     return await this._rpcSingle('ln', 'create_bolt11_invoice', {
       amount,
       description,
       expiry_time: expiryTime,
       extra_meta: extraMeta,
-      gateway,
+      gateway: gateway.info,
     })
   }
 
+  async payBolt11InvoiceWithGateway(
+    invoice: string,
+    gatewayInfo: GatewayInfo,
+    extraMeta: JSONObject = {},
+  ) {
+    return await this._rpcSingle('ln', 'pay_bolt11_invoice', {
+      maybe_gateway: gatewayInfo,
+      invoice,
+      extra_meta: extraMeta,
+    })
+  }
+
+  async _getDefaultGatewayInfo(): Promise<LightningGateway> {
+    const gateways = await this.listGateways()
+    return gateways[0]
+  }
+
   async payBolt11Invoice(
     invoice: string,
-    maybeGateway: LightningGateway | null = null,
     extraMeta: JSONObject = {},
   ): Promise<OutgoingLightningPayment> {
+    await this.updateGatewayCache()
+    const gateway = await this._getDefaultGatewayInfo()
     return await this._rpcSingle('ln', 'pay_bolt11_invoice', {
-      maybe_gateway: maybeGateway,
+      maybe_gateway: gateway.info,
       invoice,
       extra_meta: extraMeta,
     })
@@ -332,12 +475,7 @@ export class FedimintWallet {
       onError,
     )
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   subscribeLnReceive(
@@ -353,12 +491,7 @@ export class FedimintWallet {
       onError,
     )
 
-    return () => {
-      unsubscribe.then((unsub) => {
-        unsub.cancel()
-        unsub.free()
-      })
-    }
+    return unsubscribe
   }
 
   async getGateway(
@@ -376,6 +509,7 @@ export class FedimintWallet {
   }
 
   async updateGatewayCache(): Promise<void> {
+    console.trace('Updating gateway cache')
     await this._rpcSingle('ln', 'update_gateway_cache', {})
   }
 }

package/src/types/wallet.ts

@@ -10,7 +10,7 @@ type JSONValue =
 
 type JSONObject = Record<string, JSONValue>
 
-type LightningGateway = {
+type GatewayInfo = {
   gateway_id: string
   api: string
   node_pub_key: string
@@ -18,6 +18,14 @@ type LightningGateway = {
   route_hints: RouteHint[]
   fees: FeeToAmount
 }
+type LightningGateway = {
+  info: GatewayInfo
+  vetted: boolean
+  ttl: {
+    nanos: number
+    secs: number
+  }
+}
 
 type RouteHint = {
   // TODO: Define the structure of RouteHint
@@ -64,14 +72,27 @@ type CreateBolt11Response = {
 type StreamError = {
   error: string
   data: never
+  end: never
 }
 
 type StreamSuccess<T extends JSONValue> = {
   data: T
   error: never
+  end: never
+}
+
+type StreamEnd = {
+  end: string
+  data: never
+  error: never
 }
 
-type StreamResult<T extends JSONValue> = StreamSuccess<T> | StreamError
+type StreamResult<T extends JSONValue> =
+  | StreamSuccess<T>
+  | StreamError
+  | StreamEnd
+
+type CancelFunction = () => void
 
 export {
   JSONValue,
@@ -84,8 +105,10 @@ export {
   LnPayState,
   LnReceiveState,
   CreateBolt11Response,
+  GatewayInfo,
   StreamError,
   StreamSuccess,
   StreamResult,
   ModuleKind,
+  CancelFunction,
 }

package/src/worker.js

@@ -0,0 +1,80 @@
+// import { WasmClient } from '../wasm/fedimint_client_wasm.js'
+// import { WasmClient } from 'fedimint-client-wasm'
+// import wasm from '../wasm/fedimint_client_wasm_bg.wasm'
+
+let WasmClient = null
+let client = null
+
+const streamCancelMap = new Map()
+
+const handleFree = (requestId) => {
+  streamCancelMap.delete(requestId)
+}
+
+self.onmessage = async (event) => {
+  const { type, payload, requestId } = event.data
+
+  if (type === 'init') {
+    WasmClient = (await import('fedimint-client-wasm')).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
+    if (!client) {
+      self.postMessage({
+        type: 'error',
+        error: 'WasmClient not initialized',
+        requestId,
+      })
+      return
+    }
+    const rpcHandle = await client.rpc(
+      module,
+      method,
+      JSON.stringify(body),
+      (res) => {
+        const data = JSON.parse(res)
+        self.postMessage({ type: 'rpcResponse', requestId, ...data })
+
+        if (data.end === undefined) return
+
+        // 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,
+    })
+  }
+}