@fedimint/core-web 0.0.4 → 0.0.6

package/src/FedimintWallet.ts

@@ -6,11 +6,12 @@ import {
   FederationService,
   RecoveryService,
 } from './services'
+import { logger, type LogLevel } from './utils/logger'
 
 const DEFAULT_CLIENT_NAME = 'fm-default' as const
 
 export class FedimintWallet {
-  private client: WorkerClient
+  private _client: WorkerClient
 
   public balance: BalanceService
   public mint: MintService
@@ -18,14 +19,13 @@ export class FedimintWallet {
   public federation: FederationService
   public recovery: RecoveryService
 
-  private openPromise: Promise<void> | null = null
-  private resolveOpen: () => void = () => {}
+  private _openPromise: Promise<void> | null = null
+  private _resolveOpen: () => void = () => {}
   private _isOpen: boolean = false
 
   /**
    * Creates a new instance of FedimintWallet.
    *
-   * @description
    * This constructor initializes a FedimintWallet instance, which manages communication
    * with a Web Worker. The Web Worker is responsible for running WebAssembly code that
    * handles the core Fedimint Client operations.
@@ -53,15 +53,17 @@ export class FedimintWallet {
    * lazyWallet.open();
    */
   constructor(lazy: boolean = false) {
-    this.openPromise = new Promise((resolve) => {
-      this.resolveOpen = resolve
+    this._openPromise = new Promise((resolve) => {
+      this._resolveOpen = resolve
     })
-    this.client = new WorkerClient()
-    this.mint = new MintService(this.client)
-    this.lightning = new LightningService(this.client)
-    this.balance = new BalanceService(this.client)
-    this.federation = new FederationService(this.client)
-    this.recovery = new RecoveryService(this.client)
+    this._client = new WorkerClient()
+    this.mint = new MintService(this._client)
+    this.lightning = new LightningService(this._client)
+    this.balance = new BalanceService(this._client)
+    this.federation = new FederationService(this._client)
+    this.recovery = new RecoveryService(this._client)
+
+    logger.info('FedimintWallet instantiated')
 
     if (!lazy) {
       this.initialize()
@@ -69,24 +71,26 @@ export class FedimintWallet {
   }
 
   async initialize() {
-    await this.client.initialize()
+    logger.info('Initializing WorkerClient')
+    await this._client.initialize()
+    logger.info('WorkerClient initialized')
   }
 
   async waitForOpen() {
     if (this._isOpen) return Promise.resolve()
-    return this.openPromise
+    return this._openPromise
   }
 
   async open(clientName: string = DEFAULT_CLIENT_NAME) {
-    await this.client.initialize()
+    await this._client.initialize()
     // TODO: Determine if this should be safe or throw
     if (this._isOpen) throw new Error('The FedimintWallet is already open.')
-    const { success } = await this.client.sendSingleMessage('open', {
+    const { success } = await this._client.sendSingleMessage('open', {
       clientName,
     })
     if (success) {
       this._isOpen = !!success
-      this.resolveOpen()
+      this._resolveOpen()
     }
     return success
   }
@@ -95,19 +99,19 @@ export class FedimintWallet {
     inviteCode: string,
     clientName: string = DEFAULT_CLIENT_NAME,
   ) {
-    await this.client.initialize()
+    await this._client.initialize()
     // TODO: Determine if this should be safe or throw
     if (this._isOpen)
       throw new Error(
         'The FedimintWallet is already open. You can only call `joinFederation` on closed clients.',
       )
-    const response = await this.client.sendSingleMessage('join', {
+    const response = await this._client.sendSingleMessage('join', {
       inviteCode,
       clientName,
     })
     if (response.success) {
       this._isOpen = true
-      this.resolveOpen()
+      this._resolveOpen()
     }
   }
 
@@ -116,12 +120,21 @@ export class FedimintWallet {
    * After this call, the FedimintWallet instance should be discarded.
    */
   async cleanup() {
-    this.openPromise = null
+    this._openPromise = null
     this._isOpen = false
-    this.client.cleanup()
+    this._client.cleanup()
   }
 
   isOpen() {
     return this._isOpen
   }
+
+  /**
+   * Sets the log level for the library.
+   * @param level The desired log level ('DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE').
+   */
+  setLogLevel(level: LogLevel) {
+    logger.setLevel(level)
+    logger.info(`Log level set to ${level}.`)
+  }
 }

package/src/services/BalanceService.test.ts

@@ -0,0 +1,50 @@
+import { test, expect } from 'vitest'
+import { TestFedimintWallet } from '../test/TestFedimintWallet'
+import { beforeAll } from 'vitest'
+
+let randomTestingId: string
+let wallet: TestFedimintWallet
+
+beforeAll(async () => {
+  randomTestingId = Math.random().toString(36).substring(2, 15)
+  wallet = new TestFedimintWallet()
+  expect(wallet).toBeDefined()
+  await expect(
+    wallet.joinFederation(wallet.testing.TESTING_INVITE, randomTestingId),
+  ).resolves.toBeUndefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  // Cleanup after all tests
+  return async () => {
+    // clear up browser resources
+    await wallet.cleanup()
+    // remove the wallet db
+    indexedDB.deleteDatabase(randomTestingId)
+    // swap out the randomTestingId for a new one, to avoid raciness
+    randomTestingId = Math.random().toString(36).substring(2, 15)
+  }
+})
+
+test('getBalance should be initially zero', async () => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+  const beforeGetBalance = wallet.testing.getRequestCounter()
+  await expect(wallet.balance.getBalance()).resolves.toEqual(0)
+  expect(wallet.testing.getRequestCounter()).toBe(beforeGetBalance + 1)
+})
+
+test('subscribe balance', async () => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  const counterBefore = wallet.testing.getRequestCounter()
+  const callbacksBefore = wallet.testing.getRequestCallbackMap().size
+  const unsubscribe = await wallet.balance.subscribeBalance((balance) => {
+    expect(balance).toEqual(0)
+  })
+  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  expect(wallet.testing.getRequestCallbackMap().size).toBe(callbacksBefore + 1)
+
+  await expect(wallet.balance.getBalance()).resolves.toEqual(0)
+  expect(unsubscribe()).toBeUndefined()
+})

package/src/services/BalanceService.ts

@@ -1,12 +1,38 @@
 import { WorkerClient } from '../worker'
 
+/**
+ * Balance Service
+ *
+ * The Balance Service provides methods to interact with the balance of a Fedimint wallet.
+ */
 export class BalanceService {
   constructor(private client: WorkerClient) {}
 
+  /**
+   * Get the balance of the current wallet
+   *
+   * @example
+   * ```ts
+   * const balance = await wallet.balance.getBalance()
+   * ```
+   */
   async getBalance(): Promise<number> {
     return await this.client.rpcSingle('', 'get_balance', {})
   }
 
+  /**
+   * Subscribe to the balance of the current wallet
+   *
+   * @example
+   * ```ts
+   * const unsubscribe = wallet.balance.subscribeBalance((balance) => {
+   *  console.log(balance)
+   * })
+   *
+   * // ...Cleanup Later
+   * unsubscribe()
+   * ```
+   */
   subscribeBalance(
     onSuccess: (balance: number) => void = () => {},
     onError: (error: string) => void = () => {},

package/src/services/FederationService.test.ts

@@ -0,0 +1,58 @@
+import { expect } from 'vitest'
+import { walletTest } from '../test/setupTests'
+
+walletTest(
+  'getConfig should return the federation config',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.federation.getConfig()).resolves.toMatchObject({
+      api_endpoints: expect.any(Object),
+      broadcast_public_keys: expect.any(Object),
+      consensus_version: expect.any(Object),
+      meta: expect.any(Object),
+      modules: expect.any(Object),
+    })
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'getFederationId should return the federation id',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const federationId = await wallet.federation.getFederationId()
+    expect(federationId).toBeTypeOf('string')
+    expect(federationId).toHaveLength(64)
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'getInviteCode should return the invite code',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const inviteCode = await wallet.federation.getInviteCode(0)
+    expect(inviteCode).toBeTypeOf('string')
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'listOperations should return the list of operations',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.federation.listOperations()).resolves.toMatchObject([])
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)

package/src/services/FederationService.ts

@@ -16,16 +16,6 @@ export class FederationService {
     return await this.client.rpcSingle('', 'get_invite_code', { peer })
   }
 
-  async joinFederation(inviteCode: string, clientName: string): Promise<void> {
-    const response = await this.client.sendSingleMessage('join', {
-      inviteCode,
-      clientName,
-    })
-    if (!response.success) {
-      throw new Error('Failed to join federation')
-    }
-  }
-
   async listOperations(): Promise<JSONValue[]> {
     return await this.client.rpcSingle('', 'list_operations', {})
   }

package/src/services/LightningService.test.ts

@@ -0,0 +1,168 @@
+import { expect } from 'vitest'
+import { walletTest } from '../test/setupTests'
+
+walletTest(
+  'createInvoice should create a bolt11 invoice',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const invoice = await wallet.lightning.createInvoice(100, 'test')
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+    // 3 requests were made, one for the invoice, one for refreshing the
+    // gateway cache, one for getting the gateway info
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 3)
+
+    // Test with expiry time
+    await expect(
+      wallet.lightning.createInvoice(100, 'test', 1000, {}),
+    ).resolves.toBeDefined()
+  },
+)
+
+walletTest(
+  'listGateways should return a list of gateways',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const gateways = await wallet.lightning.listGateways()
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+    expect(gateways).toBeDefined()
+    expect(gateways).toMatchObject([
+      {
+        info: expect.any(Object),
+      },
+    ])
+  },
+)
+
+walletTest(
+  'updateGatewayCache should update the gateway cache',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.lightning.updateGatewayCache()).resolves.toBeDefined()
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest('getGateway should return a gateway', async ({ wallet }) => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  const counterBefore = wallet.testing.getRequestCounter()
+  const gateway = await wallet.lightning.getGateway()
+  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  expect(gateway).toMatchObject({
+    api: expect.any(String),
+    fees: expect.any(Object),
+    gateway_id: expect.any(String),
+    gateway_redeem_key: expect.any(String),
+    lightning_alias: expect.any(String),
+    mint_channel_id: expect.any(Number),
+    node_pub_key: expect.any(String),
+    route_hints: expect.any(Array),
+  })
+})
+
+walletTest(
+  'createInvoiceWithGateway should create a bolt11 invoice with a gateway',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const gateways = await wallet.lightning.listGateways()
+    const gateway = gateways[0]
+    expect(gateway).toBeDefined()
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const invoice = await wallet.lightning.createInvoiceWithGateway(
+      100,
+      'test',
+      null,
+      {},
+      gateway.info,
+    )
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+    await expect(
+      wallet.lightning.createInvoiceWithGateway(
+        100,
+        'test',
+        1000,
+        {},
+        gateway.info,
+      ),
+    ).resolves.toBeDefined()
+  },
+)
+
+walletTest(
+  'payInvoice should throw on insufficient funds',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const invoice = await wallet.lightning.createInvoice(100, 'test')
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    // Insufficient funds
+    try {
+      await wallet.lightning.payInvoice(invoice.invoice, {})
+      expect.unreachable('Should throw error')
+    } catch (error) {
+      expect(error).toBeDefined()
+    }
+    // 3 requests were made, one for paying the invoice, one for refreshing the
+    // gateway cache, one for getting the gateway info
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 3)
+  },
+)
+
+walletTest(
+  'payInvoice should pay a bolt11 invoice',
+  { timeout: 45000 },
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const gateways = await wallet.lightning.listGateways()
+    const gateway = gateways[0]
+    if (!gateway) {
+      expect.unreachable('Gateway not found')
+    }
+    const invoice = await wallet.lightning.createInvoice(10000, 'test')
+    await expect(
+      wallet.testing.payWithFaucet(invoice.invoice),
+    ).resolves.toBeDefined()
+    await wallet.lightning.waitForReceive(invoice.operation_id)
+    // Wait for balance to fully update
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+    const externalInvoice = await wallet.testing.getExternalInvoice(10)
+    const payment = await wallet.lightning.payInvoice(externalInvoice.pr)
+    expect(payment).toBeDefined()
+    expect(payment).toMatchObject({
+      contract_id: expect.any(String),
+      fee: expect.any(Number),
+      payment_type: expect.any(Object),
+    })
+  },
+)

package/src/services/LightningService.ts

@@ -13,7 +13,7 @@ import {
 export class LightningService {
   constructor(private client: WorkerClient) {}
 
-  async createBolt11InvoiceWithGateway(
+  async createInvoiceWithGateway(
     amount: number,
     description: string,
     expiryTime: number | null = null,
@@ -29,7 +29,7 @@ export class LightningService {
     })
   }
 
-  async createBolt11Invoice(
+  async createInvoice(
     amount: number,
     description: string,
     expiryTime: number | null = null,
@@ -46,7 +46,7 @@ export class LightningService {
     })
   }
 
-  async payBolt11InvoiceWithGateway(
+  async payInvoiceWithGateway(
     invoice: string,
     gatewayInfo: GatewayInfo,
     extraMeta: JSONObject = {},
@@ -58,12 +58,12 @@ export class LightningService {
     })
   }
 
-  async _getDefaultGatewayInfo(): Promise<LightningGateway> {
+  private async _getDefaultGatewayInfo(): Promise<LightningGateway> {
     const gateways = await this.listGateways()
     return gateways[0]
   }
 
-  async payBolt11Invoice(
+  async payInvoice(
     invoice: string,
     extraMeta: JSONObject = {},
   ): Promise<OutgoingLightningPayment> {
@@ -108,6 +108,22 @@ export class LightningService {
     return unsubscribe
   }
 
+  async waitForReceive(operationId: string): Promise<LnReceiveState> {
+    return new Promise((resolve, reject) => {
+      const unsubscribe = this.subscribeLnReceive(
+        operationId,
+        (res) => {
+          if (res === 'claimed') resolve(res)
+        },
+        reject,
+      )
+      setTimeout(() => {
+        unsubscribe()
+        reject(new Error('Timeout waiting for receive'))
+      }, 10000)
+    })
+  }
+
   async getGateway(
     gatewayId: string | null = null,
     forceInternal: boolean = false,

package/src/services/MintService.test.ts

@@ -0,0 +1,19 @@
+import { expect } from 'vitest'
+import { walletTest } from '../test/setupTests'
+
+walletTest('redeemEcash should error on invalid ecash', async ({ wallet }) => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  await expect(wallet.mint.redeemEcash('test')).rejects.toThrow()
+})
+
+walletTest(
+  'reissueExternalNotes should reissue external notes',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    await expect(wallet.mint.reissueExternalNotes('test')).rejects.toThrow()
+  },
+)

package/src/services/MintService.ts

@@ -1,5 +1,11 @@
 import { WorkerClient } from '../worker'
-import { JSONObject, JSONValue } from '../types/wallet'
+import {
+  Duration,
+  JSONObject,
+  JSONValue,
+  MintSpendNotesResponse,
+  ReissueExternalNotesState,
+} from '../types/wallet'
 
 export class MintService {
   constructor(private client: WorkerClient) {}
@@ -13,7 +19,7 @@ export class MintService {
 
   async reissueExternalNotes(
     oobNotes: string,
-    extraMeta: JSONObject,
+    extraMeta: JSONObject = {},
   ): Promise<string> {
     return await this.client.rpcSingle('mint', 'reissue_external_notes', {
       oob_notes: oobNotes,
@@ -26,12 +32,6 @@ export class MintService {
     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',
@@ -45,16 +45,36 @@ export class MintService {
 
   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,
-    })
+    // Tells the wallet to automatically try to cancel the spend if it hasn't completed
+    // after the specified number of milliseconds.
+    // If the receiver has already redeemed the notes at this time,
+    // the notes will not be cancelled
+    tryCancelAfter: number | Duration = 0,
+    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>>(
+      'mint',
+      'spend_notes',
+      {
+        min_amount: minAmount,
+        try_cancel_after: duration,
+        include_invite: includeInvite,
+        extra_meta: extraMeta,
+      },
+    )
+    const notes = res[1]
+    const operationId = res[0]
+
+    return {
+      notes,
+      operation_id: operationId,
+    }
   }
 
   async validateNotes(oobNotes: string): Promise<number> {

package/src/test/TestFedimintWallet.ts

@@ -0,0 +1,17 @@
+import { FedimintWallet } from '../FedimintWallet'
+import { WorkerClient } from '../worker/WorkerClient'
+import { TestingService } from './TestingService'
+
+export class TestFedimintWallet extends FedimintWallet {
+  public testing: TestingService
+
+  constructor() {
+    super()
+    this.testing = new TestingService(this.getWorkerClient())
+  }
+
+  // Method to expose the WorkerClient
+  getWorkerClient(): WorkerClient {
+    return this['_client']
+  }
+}