@fedimint/core-web 0.0.2 → 0.0.4

package/src/services/LightningService.ts

@@ -0,0 +1,128 @@
+import { WorkerClient } from '../worker'
+import {
+  CreateBolt11Response,
+  GatewayInfo,
+  JSONObject,
+  JSONValue,
+  LightningGateway,
+  LnPayState,
+  LnReceiveState,
+  OutgoingLightningPayment,
+} from '../types/wallet'
+
+export class LightningService {
+  constructor(private client: WorkerClient) {}
+
+  async createBolt11InvoiceWithGateway(
+    amount: number,
+    description: string,
+    expiryTime: number | null = null,
+    extraMeta: JSONObject = {},
+    gatewayInfo: GatewayInfo,
+  ) {
+    return await this.client.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 = {},
+  ): Promise<CreateBolt11Response> {
+    await this.updateGatewayCache()
+    const gateway = await this._getDefaultGatewayInfo()
+    return await this.client.rpcSingle('ln', 'create_bolt11_invoice', {
+      amount,
+      description,
+      expiry_time: expiryTime,
+      extra_meta: extraMeta,
+      gateway: gateway.info,
+    })
+  }
+
+  async payBolt11InvoiceWithGateway(
+    invoice: string,
+    gatewayInfo: GatewayInfo,
+    extraMeta: JSONObject = {},
+  ) {
+    return await this.client.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,
+    extraMeta: JSONObject = {},
+  ): Promise<OutgoingLightningPayment> {
+    await this.updateGatewayCache()
+    const gateway = await this._getDefaultGatewayInfo()
+    return await this.client.rpcSingle('ln', 'pay_bolt11_invoice', {
+      maybe_gateway: gateway.info,
+      invoice,
+      extra_meta: extraMeta,
+    })
+  }
+
+  subscribeLnPay(
+    operationId: string,
+    onSuccess: (state: LnPayState) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    const unsubscribe = this.client.rpcStream(
+      'ln',
+      'subscribe_ln_pay',
+      { operation_id: operationId },
+      onSuccess,
+      onError,
+    )
+
+    return unsubscribe
+  }
+
+  subscribeLnReceive(
+    operationId: string,
+    onSuccess: (state: LnReceiveState) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    const unsubscribe = this.client.rpcStream(
+      'ln',
+      'subscribe_ln_receive',
+      { operation_id: operationId },
+      onSuccess,
+      onError,
+    )
+
+    return unsubscribe
+  }
+
+  async getGateway(
+    gatewayId: string | null = null,
+    forceInternal: boolean = false,
+  ): Promise<LightningGateway | null> {
+    return await this.client.rpcSingle('ln', 'get_gateway', {
+      gateway_id: gatewayId,
+      force_internal: forceInternal,
+    })
+  }
+
+  async listGateways(): Promise<LightningGateway[]> {
+    return await this.client.rpcSingle('ln', 'list_gateways', {})
+  }
+
+  async updateGatewayCache(): Promise<JSONValue> {
+    return await this.client.rpcSingle('ln', 'update_gateway_cache', {})
+  }
+}

package/src/services/MintService.ts

@@ -0,0 +1,93 @@
+import { WorkerClient } from '../worker'
+import { JSONObject, JSONValue } from '../types/wallet'
+
+export class MintService {
+  constructor(private client: WorkerClient) {}
+
+  async redeemEcash(notes: string): Promise<void> {
+    await this.client.rpcSingle('mint', 'reissue_external_notes', {
+      oob_notes: notes, // "out of band notes"
+      extra_meta: null,
+    })
+  }
+
+  async reissueExternalNotes(
+    oobNotes: string,
+    extraMeta: JSONObject,
+  ): Promise<string> {
+    return await this.client.rpcSingle('mint', 'reissue_external_notes', {
+      oob_notes: oobNotes,
+      extra_meta: extraMeta,
+    })
+  }
+
+  subscribeReissueExternalNotes(
+    operationId: string,
+    onSuccess: (state: JSONValue) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    type ReissueExternalNotesState =
+      | 'Created'
+      | 'Issuing'
+      | 'Done'
+      | { Failed: { error: string } }
+
+    const unsubscribe = this.client.rpcStream<ReissueExternalNotesState>(
+      'mint',
+      'subscribe_reissue_external_notes',
+      { operation_id: operationId },
+      onSuccess,
+      onError,
+    )
+
+    return unsubscribe
+  }
+
+  async spendNotes(
+    minAmount: number,
+    tryCancelAfter: number,
+    includeInvite: boolean,
+    extraMeta: JSONValue,
+  ): Promise<JSONValue> {
+    return await this.client.rpcSingle('mint', 'spend_notes', {
+      min_amount: minAmount,
+      try_cancel_after: tryCancelAfter,
+      include_invite: includeInvite,
+      extra_meta: extraMeta,
+    })
+  }
+
+  async validateNotes(oobNotes: string): Promise<number> {
+    return await this.client.rpcSingle('mint', 'validate_notes', {
+      oob_notes: oobNotes,
+    })
+  }
+
+  async tryCancelSpendNotes(operationId: string): Promise<void> {
+    await this.client.rpcSingle('mint', 'try_cancel_spend_notes', {
+      operation_id: operationId,
+    })
+  }
+
+  subscribeSpendNotes(
+    operationId: string,
+    onSuccess: (state: JSONValue) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    const unsubscribe = this.client.rpcStream(
+      'mint',
+      'subscribe_spend_notes',
+      { operation_id: operationId },
+      (res) => onSuccess(res),
+      onError,
+    )
+
+    return unsubscribe
+  }
+
+  async awaitSpendOobRefund(operationId: string): Promise<JSONValue> {
+    return await this.client.rpcSingle('mint', 'await_spend_oob_refund', {
+      operation_id: operationId,
+    })
+  }
+}

package/src/services/RecoveryService.ts

@@ -0,0 +1,26 @@
+import { JSONValue } from '../types/wallet'
+import { WorkerClient } from '../worker'
+
+export class RecoveryService {
+  constructor(private client: WorkerClient) {}
+
+  async hasPendingRecoveries(): Promise<boolean> {
+    return await this.client.rpcSingle('', 'has_pending_recoveries', {})
+  }
+
+  async waitForAllRecoveries(): Promise<void> {
+    await this.client.rpcSingle('', 'wait_for_all_recoveries', {})
+  }
+
+  subscribeToRecoveryProgress(
+    onSuccess: (progress: { module_id: number; progress: JSONValue }) => void,
+    onError: (error: string) => void,
+  ): () => void {
+    const unsubscribe = this.client.rpcStream<{
+      module_id: number
+      progress: JSONValue
+    }>('', 'subscribe_to_recovery_progress', {}, onSuccess, onError)
+
+    return unsubscribe
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,5 @@
+export { MintService } from './MintService'
+export { BalanceService } from './BalanceService'
+export { LightningService } from './LightningService'
+export { RecoveryService } from './RecoveryService'
+export { FederationService } from './FederationService'

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/WorkerClient.ts

@@ -0,0 +1,190 @@
+import {
+  CancelFunction,
+  JSONValue,
+  ModuleKind,
+  StreamError,
+  StreamResult,
+} from '../types/wallet'
+
+// 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)
+  }
+
+  // Idempotent setup - Loads the wasm module
+  initialize() {
+    if (this.initPromise) return this.initPromise
+    this.initPromise = this.sendSingleMessage('init')
+    return this.initPromise
+  }
+
+  private handleWorkerError(event: ErrorEvent) {
+    console.error('Worker error', JSON.stringify(event))
+  }
+
+  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}
+    }
+  }
+
+  // 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
+      this.requestCallbacks.set(requestId, (response) => {
+        this.requestCallbacks.delete(requestId)
+        if (response.data) resolve(response.data)
+        else if (response.error) reject(response.error)
+      })
+      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
+
+    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> {
+    return new Promise((resolve, reject) => {
+      this.rpcStream<Response>(module, method, body, resolve, reject)
+    })
+  }
+
+  cleanup() {
+    this.worker.terminate()
+    this.initPromise = null
+    this.requestCallbacks.clear()
+  }
+}

package/src/worker/index.ts

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

package/src/worker/worker.js

@@ -0,0 +1,85 @@
+// Web Worker for fedimint-client-wasm to run in the browser
+
+// HACK: Fixes vitest browser runner
+globalThis.__vitest_browser_runner__ = { wrapDynamicImport: (foo) => foo() }
+
+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/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
+    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,
+    })
+  }
+}
+
+self.postMessage({ type: 'init', data: {} })

package/dist/wasm.worker.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=wasm.worker.d.ts.map

package/dist/wasm.worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wasm.worker.d.ts","sourceRoot":"","sources":["../src/wasm.worker.ts"],"names":[],"mappings":""}

package/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

package/src/wasm.worker.ts

@@ -1,41 +0,0 @@
-// import init, { InitOutput, WasmClient } from '../wasm/fedimint_client_wasm.js'
-
-// let client: WasmClient | undefined
-
-// async function workerInit() {
-//   await init(new URL('@fedi/common/wasm/fedi_wasm_bg.wasm', import.meta.url))
-// }
-
-// const initPromise = workerInit().catch((error) =>
-//   postMessage({ error: String(error) }),
-// )
-
-// async function rpcRequest(method: string, data: string): Promise<string> {
-//   await initPromise
-//   return await fedimint_rpc(method, data)
-// }
-
-// const handleMessage = async (token: string, method: string, data: string) => {
-//   if (method === 'open') {
-//     await initPromise
-//     client = await WasmClient.open(data)
-//     if (client !== undefined) {
-//       postMessage({ token, result: true })
-//     } else {
-//       postMessage({ token, result: false })
-//     }
-//   } else if (method === 'join_federation') {
-//     await initPromise
-//     const result = await WasmClient.join_federation(data)
-//     postMessage({ token, result })
-//   }
-// }
-
-// // Handles worker.postMessage calls
-// addEventListener('message', (e) => {
-//   const { token, method, data } = e.data
-//   handleMessage(token, method, data)
-//   // rpcRequest(method, data)
-//   //   .then((result) => postMessage({ token, result }))
-//   //   .catch((error) => postMessage({ error: String(error) }))
-// })