@fedimint/core-web 0.0.10 → 0.0.11

package/src/services/MintService.ts

@@ -6,31 +6,38 @@ import type {
   MintSpendNotesResponse,
   MSats,
   ReissueExternalNotesState,
+  SpendNotesState,
 } from '../types'
 
 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,
-    })
+  /** https://web.fedimint.org/core/FedimintWallet/MintService/redeemEcash */
+  async redeemEcash(notes: string) {
+    return await this.client.rpcSingle<string>(
+      '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,
-    })
+  async reissueExternalNotes(oobNotes: string, extraMeta: JSONObject = {}) {
+    return await this.client.rpcSingle<string>(
+      'mint',
+      'reissue_external_notes',
+      {
+        oob_notes: oobNotes,
+        extra_meta: extraMeta,
+      },
+    )
   }
 
   subscribeReissueExternalNotes(
     operationId: string,
-    onSuccess: (state: JSONValue) => void = () => {},
+    onSuccess: (state: ReissueExternalNotesState) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
     const unsubscribe = this.client.rpcStream<ReissueExternalNotesState>(
@@ -44,6 +51,7 @@ export class MintService {
     return unsubscribe
   }
 
+  /** https://web.fedimint.org/core/FedimintWallet/MintService/spendNotes */
   async spendNotes(
     amountMsats: number,
     // Tells the wallet to automatically try to cancel the spend if it hasn't completed
@@ -52,17 +60,17 @@ export class MintService {
     tryCancelAfter: number | Duration = 3600 * 24, // defaults to 1 day
     includeInvite: boolean = false,
     extraMeta: JSONValue = {},
-  ): Promise<MintSpendNotesResponse> {
+  ) {
     const duration =
       typeof tryCancelAfter === 'number'
         ? { nanos: 0, secs: tryCancelAfter }
         : tryCancelAfter
 
-    const res = await this.client.rpcSingle<Array<string>>(
+    const res = await this.client.rpcSingle<MintSpendNotesResponse>(
       'mint',
       'spend_notes',
       {
-        min_amount: amountMsats,
+        amount: amountMsats,
         try_cancel_after: duration,
         include_invite: includeInvite,
         extra_meta: extraMeta,
@@ -77,13 +85,14 @@ export class MintService {
     }
   }
 
-  async parseNotes(oobNotes: string): Promise<MSats> {
-    return await this.client.rpcSingle('mint', 'validate_notes', {
+  /** https://web.fedimint.org/core/FedimintWallet/MintService/parseEcash */
+  async parseNotes(oobNotes: string) {
+    return await this.client.rpcSingle<MSats>('mint', 'validate_notes', {
       oob_notes: oobNotes,
     })
   }
 
-  async tryCancelSpendNotes(operationId: string): Promise<void> {
+  async tryCancelSpendNotes(operationId: string) {
     await this.client.rpcSingle('mint', 'try_cancel_spend_notes', {
       operation_id: operationId,
     })
@@ -91,21 +100,19 @@ export class MintService {
 
   subscribeSpendNotes(
     operationId: string,
-    onSuccess: (state: JSONValue) => void = () => {},
+    onSuccess: (state: SpendNotesState) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
-    const unsubscribe = this.client.rpcStream(
+    return this.client.rpcStream<SpendNotesState>(
       'mint',
       'subscribe_spend_notes',
       { operation_id: operationId },
       (res) => onSuccess(res),
       onError,
     )
-
-    return unsubscribe
   }
 
-  async awaitSpendOobRefund(operationId: string): Promise<JSONValue> {
+  async awaitSpendOobRefund(operationId: string) {
     return await this.client.rpcSingle('mint', 'await_spend_oob_refund', {
       operation_id: operationId,
     })

package/src/services/RecoveryService.ts

@@ -4,23 +4,25 @@ import { WorkerClient } from '../worker'
 export class RecoveryService {
   constructor(private client: WorkerClient) {}
 
-  async hasPendingRecoveries(): Promise<boolean> {
-    return await this.client.rpcSingle('', 'has_pending_recoveries', {})
+  async hasPendingRecoveries() {
+    return await this.client.rpcSingle<boolean>(
+      '',
+      'has_pending_recoveries',
+      {},
+    )
   }
 
-  async waitForAllRecoveries(): Promise<void> {
+  async waitForAllRecoveries() {
     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<{
+  ) {
+    return this.client.rpcStream<{
       module_id: number
       progress: JSONValue
     }>('', 'subscribe_to_recovery_progress', {}, onSuccess, onError)
-
-    return unsubscribe
   }
 }

package/src/types/utils.ts

@@ -22,4 +22,8 @@ type JSONValue =
 
 type JSONObject = Record<string, JSONValue>
 
-export { Alias, Resolve, Duration, MSats, Sats, JSONValue, JSONObject }
+type Result<T, U = string> =
+  | { success: true; data?: T }
+  | { success: false; error: U }
+
+export { Alias, Resolve, Duration, MSats, Sats, JSONValue, JSONObject, Result }

package/src/types/wallet.ts

@@ -80,16 +80,18 @@ type StreamResult<T extends JSONValue> =
 
 type CancelFunction = () => void
 
-type ReissueExternalNotesState =
-  | 'Created'
-  | 'Issuing'
-  | 'Done'
-  | { Failed: { error: string } }
+type ReissueExternalNotesState = 'Created' | 'Issuing' | 'Done'
+// | { Failed: { error: string } }
 
-type MintSpendNotesResponse = {
-  notes: string
-  operation_id: string
-}
+type MintSpendNotesResponse = Array<string>
+
+type SpendNotesState =
+  | 'Created'
+  | 'UserCanceledProcessing'
+  | 'UserCanceledSuccess'
+  | 'UserCanceledFailure'
+  | 'Success'
+  | 'Refunded'
 
 export {
   LightningGateway,
@@ -108,4 +110,5 @@ export {
   CancelFunction,
   ReissueExternalNotesState,
   MintSpendNotesResponse,
+  SpendNotesState,
 }

package/src/types/worker.ts

@@ -8,6 +8,8 @@ const WorkerMessageTypes = [
   'error',
   'unsubscribe',
   'cleanup',
+  'parseInviteCode',
+  'parseBolt11Invoice',
 ] as const
 
 export type WorkerMessageType = (typeof WorkerMessageTypes)[number]

package/src/worker/WorkerClient.ts

@@ -69,8 +69,8 @@ export class WorkerClient {
   sendSingleMessage<
     Response extends JSONValue = JSONValue,
     Payload extends JSONValue = JSONValue,
-  >(type: WorkerMessageType, payload?: Payload): Promise<Response> {
-    return new Promise((resolve, reject) => {
+  >(type: WorkerMessageType, payload?: Payload) {
+    return new Promise<Response>((resolve, reject) => {
       const requestId = ++this.requestCounter
       logger.debug('WorkerClient - sendSingleMessage', requestId, type, payload)
       this.requestCallbacks.set(
@@ -179,7 +179,7 @@ export class WorkerClient {
     onEnd: () => void = () => {},
     unsubscribePromise: Promise<void>,
     // Unsubscribe function
-  ): Promise<void> {
+  ) {
     // await this.openPromise
     // if (!this.worker || !this._isOpen)
     //   throw new Error('FedimintWallet is not open')
@@ -209,13 +209,12 @@ export class WorkerClient {
     })
   }
 
-  rpcSingle<Response extends JSONValue = JSONValue>(
-    module: ModuleKind,
-    method: string,
-    body: JSONValue,
-  ): Promise<Response> {
+  rpcSingle<
+    Response extends JSONValue = JSONValue,
+    Error extends string = string,
+  >(module: ModuleKind, method: string, body: JSONValue) {
     logger.debug('WorkerClient - rpcSingle', module, method, body)
-    return new Promise((resolve, reject) => {
+    return new Promise<Response>((resolve, reject) => {
       this.rpcStream<Response>(module, method, body, resolve, reject)
     })
   }

package/src/worker/worker.js

@@ -89,6 +89,40 @@ self.onmessage = async (event) => {
         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',