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

package/src/services/FederationService.ts

@@ -4,19 +4,21 @@ import { WorkerClient } from '../worker'
 export class FederationService {
   constructor(private client: WorkerClient) {}
 
-  async getConfig(): Promise<JSONValue> {
+  async getConfig() {
     return await this.client.rpcSingle('', 'get_config', {})
   }
 
-  async getFederationId(): Promise<string> {
-    return await this.client.rpcSingle('', 'get_federation_id', {})
+  async getFederationId() {
+    return await this.client.rpcSingle<string>('', 'get_federation_id', {})
   }
 
-  async getInviteCode(peer: number): Promise<string | null> {
-    return await this.client.rpcSingle('', 'get_invite_code', { peer })
+  async getInviteCode(peer: number = 0) {
+    return await this.client.rpcSingle<string | null>('', 'get_invite_code', {
+      peer,
+    })
   }
 
-  async listOperations(): Promise<JSONValue[]> {
-    return await this.client.rpcSingle('', 'list_operations', {})
+  async listOperations() {
+    return await this.client.rpcSingle<JSONValue[]>('', 'list_operations', {})
   }
 }

package/src/services/LightningService.ts

@@ -3,7 +3,6 @@ import type {
   CreateBolt11Response,
   GatewayInfo,
   JSONObject,
-  JSONValue,
   LightningGateway,
   LnPayState,
   LnReceiveState,
@@ -13,21 +12,26 @@ import type {
 export class LightningService {
   constructor(private client: WorkerClient) {}
 
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/createInvoice#lightning-createinvoice */
   async createInvoice(
     amountMsats: number,
     description: string,
     expiryTime?: number, // in seconds
     gatewayInfo?: GatewayInfo,
     extraMeta?: JSONObject,
-  ): Promise<CreateBolt11Response> {
+  ) {
     const gateway = gatewayInfo ?? (await this._getDefaultGatewayInfo())
-    return await this.client.rpcSingle('ln', 'create_bolt11_invoice', {
-      amount: amountMsats,
-      description,
-      expiry_time: expiryTime ?? null,
-      extra_meta: extraMeta ?? {},
-      gateway,
-    })
+    return await this.client.rpcSingle<CreateBolt11Response>(
+      'ln',
+      'create_bolt11_invoice',
+      {
+        amount: amountMsats,
+        description,
+        expiry_time: expiryTime ?? null,
+        extra_meta: extraMeta ?? {},
+        gateway,
+      },
+    )
   }
 
   async createInvoiceTweaked(
@@ -38,9 +42,9 @@ export class LightningService {
     expiryTime?: number, // in seconds
     gatewayInfo?: GatewayInfo,
     extraMeta?: JSONObject,
-  ): Promise<CreateBolt11Response> {
+  ) {
     const gateway = gatewayInfo ?? (await this._getDefaultGatewayInfo())
-    return await this.client.rpcSingle(
+    return await this.client.rpcSingle<CreateBolt11Response>(
       'ln',
       'create_bolt11_invoice_for_user_tweaked',
       {
@@ -60,52 +64,63 @@ export class LightningService {
     tweakKey: string,
     indices: number[],
     extraMeta?: JSONObject,
-  ): Promise<string[]> {
-    return await this.client.rpcSingle('ln', 'scan_receive_for_user_tweaked', {
-      user_key: tweakKey,
-      indices,
-      extra_meta: extraMeta ?? {},
-    })
+  ) {
+    return await this.client.rpcSingle<string[]>(
+      'ln',
+      'scan_receive_for_user_tweaked',
+      {
+        user_key: tweakKey,
+        indices,
+        extra_meta: extraMeta ?? {},
+      },
+    )
   }
 
-  private async _getDefaultGatewayInfo(): Promise<GatewayInfo> {
+  private async _getDefaultGatewayInfo() {
     await this.updateGatewayCache()
     const gateways = await this.listGateways()
     return gateways[0]?.info
   }
 
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/payInvoice#lightning-payinvoice-invoice-string */
   async payInvoice(
     invoice: string,
     gatewayInfo?: GatewayInfo,
     extraMeta?: JSONObject,
-  ): Promise<OutgoingLightningPayment> {
+  ) {
     const gateway = gatewayInfo ?? (await this._getDefaultGatewayInfo())
-    return await this.client.rpcSingle('ln', 'pay_bolt11_invoice', {
-      maybe_gateway: gateway,
-      invoice,
-      extra_meta: extraMeta ?? {},
-    })
+    return await this.client.rpcSingle<OutgoingLightningPayment>(
+      'ln',
+      'pay_bolt11_invoice',
+      {
+        maybe_gateway: gateway,
+        invoice,
+        extra_meta: extraMeta ?? {},
+      },
+    )
   }
 
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/payInvoice#lightning-payinvoicesync-invoice-string */
   async payInvoiceSync(
     invoice: string,
     timeoutMs: number = 10000,
     gatewayInfo?: GatewayInfo,
     extraMeta?: JSONObject,
-  ): Promise<
-    | { success: false }
-    | {
-        success: true
-        data: { feeMsats: number; preimage: string }
-      }
-  > {
-    return new Promise(async (resolve, reject) => {
+  ) {
+    return new Promise<
+      | { success: false; error?: string }
+      | {
+          success: true
+          data: { feeMsats: number; preimage: string }
+        }
+    >(async (resolve, reject) => {
       const { contract_id, fee } = await this.payInvoice(
         invoice,
         gatewayInfo,
         extraMeta,
       )
 
+      // TODO: handle  error handling for other subscription statuses
       const unsubscribe = this.subscribeLnPay(contract_id, (res) => {
         if (typeof res !== 'string' && 'success' in res) {
           clearTimeout(timeoutId)
@@ -114,12 +129,14 @@ export class LightningService {
             success: true,
             data: { feeMsats: fee, preimage: res.success.preimage },
           })
+        } else if (typeof res !== 'string' && 'unexpected_error' in res) {
+          reject(new Error(res.unexpected_error.error_message))
         }
       })
 
       const timeoutId = setTimeout(() => {
         unsubscribe()
-        reject(new Error('Timeout waiting for pay'))
+        resolve({ success: false, error: 'Payment timeout' })
       }, timeoutMs)
     })
   }
@@ -130,46 +147,41 @@ export class LightningService {
     onSuccess: (state: LnReceiveState) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
-    const unsubscribe = this.client.rpcStream(
+    return this.client.rpcStream(
       'ln',
       'subscribe_ln_claim',
       { operation_id: operationId },
       onSuccess,
       onError,
     )
-
-    return unsubscribe
   }
 
   // TODO: Document (for external payments only)
   // TODO: Make this work for BOTH internal and external payments
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/payInvoice#lightning-payinvoice-invoice-string */
   subscribeLnPay(
     operationId: string,
     onSuccess: (state: LnPayState) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
-    const unsubscribe = this.client.rpcStream(
+    return this.client.rpcStream(
       'ln',
       'subscribe_ln_pay',
       { operation_id: operationId },
       onSuccess,
       onError,
     )
-
-    return unsubscribe
   }
 
-  async waitForPay(operationId: string): Promise<
-    | { success: false }
-    | {
-        success: true
-        data: { preimage: string }
-      }
-  > {
-    return new Promise((resolve, reject) => {
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/payInvoice#lightning-payinvoice-invoice-string */
+  async waitForPay(operationId: string) {
+    return new Promise<
+      | { success: false; error?: string }
+      | { success: true; data: { preimage: string } }
+    >((resolve, reject) => {
       let unsubscribe: () => void
       const timeoutId = setTimeout(() => {
-        reject(new Error('Timeout waiting for receive'))
+        resolve({ success: false, error: 'Waiting for receive timeout' })
       }, 15000)
 
       unsubscribe = this.subscribeLnPay(
@@ -193,28 +205,24 @@ export class LightningService {
     })
   }
 
-  // TODO: Document
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/createInvoice#lightning-createinvoice */
   subscribeLnReceive(
     operationId: string,
     onSuccess: (state: LnReceiveState) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
-    const unsubscribe = this.client.rpcStream(
+    return this.client.rpcStream(
       'ln',
       'subscribe_ln_receive',
       { operation_id: operationId },
       onSuccess,
       onError,
     )
-
-    return unsubscribe
   }
 
-  async waitForReceive(
-    operationId: string,
-    timeoutMs: number = 15000,
-  ): Promise<LnReceiveState> {
-    return new Promise((resolve, reject) => {
+  /** https://web.fedimint.org/core/FedimintWallet/LightningService/createInvoice#lightning-createinvoice */
+  async waitForReceive(operationId: string, timeoutMs: number = 15000) {
+    return new Promise<LnReceiveState>((resolve, reject) => {
       let unsubscribe: () => void
       const timeoutId = setTimeout(() => {
         reject(new Error('Timeout waiting for receive'))
@@ -241,18 +249,26 @@ export class LightningService {
   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,
-    })
+  ) {
+    return await this.client.rpcSingle<LightningGateway | null>(
+      'ln',
+      'get_gateway',
+      {
+        gateway_id: gatewayId,
+        force_internal: forceInternal,
+      },
+    )
   }
 
-  async listGateways(): Promise<LightningGateway[]> {
-    return await this.client.rpcSingle('ln', 'list_gateways', {})
+  async listGateways() {
+    return await this.client.rpcSingle<LightningGateway[]>(
+      'ln',
+      'list_gateways',
+      {},
+    )
   }
 
-  async updateGatewayCache(): Promise<JSONValue> {
+  async updateGatewayCache() {
     return await this.client.rpcSingle('ln', 'update_gateway_cache', {})
   }
 }

package/src/services/MintService.test.ts

@@ -31,3 +31,44 @@ walletTest('parseNotes should parse notes', async ({ wallet }) => {
 
   await expect(wallet.mint.reissueExternalNotes('test')).rejects.toThrow()
 })
+
+walletTest(
+  'getNotesByDenomination should return empty object if wallet is empty',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const notes = await wallet.mint.getNotesByDenomination()
+    const balance = await wallet.balance.getBalance()
+    expect(balance).toEqual(0)
+    expect(notes).toBeDefined()
+    expect(notes).toEqual({})
+  },
+)
+
+walletTest(
+  'getNotesByDenomination should get notes by denomination',
+  async ({ fundedWallet }) => {
+    expect(fundedWallet).toBeDefined()
+    expect(fundedWallet.isOpen()).toBe(true)
+
+    const notes = await fundedWallet.mint.getNotesByDenomination()
+    const balance = await fundedWallet.balance.getBalance()
+    expect(balance).toEqual(10000)
+    expect(notes).toBeDefined()
+    expect(notes).toEqual({
+      '1': 2,
+      '1024': 3,
+      '128': 2,
+      '16': 3,
+      '2': 3,
+      '2048': 2,
+      '256': 3,
+      '32': 2,
+      '4': 2,
+      '512': 3,
+      '64': 2,
+      '8': 2,
+    })
+  },
+)

package/src/services/MintService.ts

@@ -5,32 +5,40 @@ import type {
   JSONValue,
   MintSpendNotesResponse,
   MSats,
+  NoteCountByDenomination,
   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 +52,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 +61,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 +86,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,23 +101,29 @@ 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,
     })
   }
+
+  async getNotesByDenomination() {
+    return await this.client.rpcSingle<NoteCountByDenomination>(
+      'mint',
+      'note_counts_by_denomination',
+      {},
+    )
+  }
 }

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/services/WalletService.test.ts

@@ -0,0 +1,24 @@
+import { expect } from 'vitest'
+import { walletTest } from '../test/fixtures'
+import { TxOutputSummary, WalletSummary } from '../types'
+
+walletTest(
+  'getWalletSummary should return empty object if wallet is empty',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const balance = await wallet.balance.getBalance()
+    expect(balance).toEqual(0)
+
+    const summary = await wallet.wallet.getWalletSummary()
+    const expectedSummary = {
+      spendable_utxos: expect.any(Array<TxOutputSummary>),
+      unsigned_peg_out_txos: expect.any(Array<TxOutputSummary>),
+      unsigned_change_utxos: expect.any(Array<TxOutputSummary>),
+      unconfirmed_peg_out_txos: expect.any(Array<TxOutputSummary>),
+      unconfirmed_change_utxos: expect.any(Array<TxOutputSummary>),
+    } satisfies WalletSummary
+    expect(summary).toEqual(expect.objectContaining(expectedSummary))
+  },
+)

package/src/services/WalletService.ts

@@ -0,0 +1,10 @@
+import { WalletSummary } from '../types'
+import { WorkerClient } from '../worker'
+
+export class WalletService {
+  constructor(private client: WorkerClient) {}
+
+  async getWalletSummary(): Promise<WalletSummary> {
+    return await this.client.rpcSingle('wallet', 'get_wallet_summary', {})
+  }
+}

package/src/services/index.ts

@@ -3,3 +3,4 @@ export { BalanceService } from './BalanceService'
 export { LightningService } from './LightningService'
 export { RecoveryService } from './RecoveryService'
 export { FederationService } from './FederationService'
+export { WalletService } from './WalletService'

package/src/test/TestingService.ts

@@ -25,7 +25,7 @@ export class TestingService {
   }
 
   async getInviteCode() {
-    const res = await fetch('http://localhost:15243/connect-string')
+    const res = await fetch(`${import.meta.env.FAUCET}/connect-string`)
     if (res.ok) {
       return await res.text()
     } else {
@@ -34,7 +34,7 @@ export class TestingService {
   }
 
   private async getFaucetGatewayApi() {
-    const res = await fetch('http://localhost:15243/gateway-api')
+    const res = await fetch(`${import.meta.env.FAUCET}/gateway-api`)
     if (res.ok) {
       return await res.text()
     } else {
@@ -43,6 +43,7 @@ export class TestingService {
   }
 
   async getFaucetGatewayInfo() {
+    await this.lightning.updateGatewayCache()
     const gateways = await this.lightning.listGateways()
     const api = await this.getFaucetGatewayApi()
     const gateway = gateways.find((g) => g.info.api === api)
@@ -53,7 +54,7 @@ export class TestingService {
   }
 
   async payFaucetInvoice(invoice: string) {
-    const res = await fetch('http://localhost:15243/pay', {
+    const res = await fetch(`${import.meta.env.FAUCET}/pay`, {
       method: 'POST',
       body: invoice,
     })
@@ -65,7 +66,7 @@ export class TestingService {
   }
 
   async createFaucetInvoice(amount: number) {
-    const res = await fetch('http://localhost:15243/invoice', {
+    const res = await fetch(`${import.meta.env.FAUCET}/invoice`, {
       method: 'POST',
       body: amount.toString(),
     })

package/src/test/fixtures.ts

@@ -8,6 +8,7 @@ import { WorkerClient } from '../worker/WorkerClient'
 export const walletTest = test.extend<{
   wallet: TestFedimintWallet
   fundedWallet: TestFedimintWallet
+  unopenedWallet: TestFedimintWallet
 }>({
   wallet: async ({}, use) => {
     const randomTestingId = Math.random().toString(36).substring(2, 15)
@@ -36,6 +37,11 @@ export const walletTest = test.extend<{
     await wallet.fundWallet(10_000)
     await use(wallet)
   },
+  unopenedWallet: async ({}, use) => {
+    const wallet = new TestFedimintWallet()
+    await wallet.initialize()
+    await use(wallet)
+  },
 })
 
 /**

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 }