@fedimint/core-web 0.0.10 → 0.1.0-alex-cache-wasm-build

package/src/types/wallet.ts

@@ -1,7 +1,11 @@
-import { MSats, Duration, JSONValue } from './utils'
+import { MSats, Duration, JSONValue, JSONObject } from './utils'
 
-const MODULE_KINDS = ['', 'ln', 'mint'] as const
+const MODULE_KINDS = ['', 'ln', 'mint', 'wallet'] as const
 type ModuleKind = (typeof MODULE_KINDS)[number]
+
+// TODO: Define the structure of FederationConfig
+type FederationConfig = JSONObject
+
 type GatewayInfo = {
   gateway_id: string
   api: string
@@ -80,19 +84,41 @@ type StreamResult<T extends JSONValue> =
 
 type CancelFunction = () => void
 
-type ReissueExternalNotesState =
+type ReissueExternalNotesState = 'Created' | 'Issuing' | 'Done'
+// | { Failed: { error: string } }
+
+type MintSpendNotesResponse = Array<string>
+
+type SpendNotesState =
   | 'Created'
-  | 'Issuing'
-  | 'Done'
-  | { Failed: { error: string } }
+  | 'UserCanceledProcessing'
+  | 'UserCanceledSuccess'
+  | 'UserCanceledFailure'
+  | 'Success'
+  | 'Refunded'
+
+type TxOutputSummary = {
+  outpoint: {
+    txid: string
+    vout: number
+  }
+  amount: number
+}
 
-type MintSpendNotesResponse = {
-  notes: string
-  operation_id: string
+type WalletSummary = {
+  spendable_utxos: TxOutputSummary[]
+  unsigned_peg_out_txos: TxOutputSummary[]
+  unsigned_change_utxos: TxOutputSummary[]
+  unconfirmed_peg_out_txos: TxOutputSummary[]
+  unconfirmed_change_utxos: TxOutputSummary[]
 }
 
+/** Keys are powers of 2 */
+type NoteCountByDenomination = Record<number, number>
+
 export {
   LightningGateway,
+  FederationConfig,
   RouteHint,
   FeeToAmount,
   OutgoingLightningPayment,
@@ -108,4 +134,8 @@ export {
   CancelFunction,
   ReissueExternalNotesState,
   MintSpendNotesResponse,
+  SpendNotesState,
+  WalletSummary,
+  TxOutputSummary,
+  NoteCountByDenomination,
 }

package/src/types/worker.ts

@@ -8,6 +8,9 @@ const WorkerMessageTypes = [
   'error',
   'unsubscribe',
   'cleanup',
+  'parseInviteCode',
+  'parseBolt11Invoice',
+  'previewFederation',
 ] 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

@@ -17,6 +17,17 @@ const handleFree = (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
 
@@ -45,6 +56,23 @@ self.onmessage = async (event) => {
       } 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)
@@ -89,6 +117,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',