@fedimint/core-web 0.0.3 → 0.0.5

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

@@ -0,0 +1,22 @@
+import { JSONValue } from '../types/wallet'
+import { WorkerClient } from '../worker'
+
+export class FederationService {
+  constructor(private client: WorkerClient) {}
+
+  async getConfig(): Promise<JSONValue> {
+    return await this.client.rpcSingle('', 'get_config', {})
+  }
+
+  async getFederationId(): Promise<string> {
+    return await this.client.rpcSingle('', 'get_federation_id', {})
+  }
+
+  async getInviteCode(peer: number): Promise<string | null> {
+    return await this.client.rpcSingle('', 'get_invite_code', { peer })
+  }
+
+  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

@@ -0,0 +1,144 @@
+import { WorkerClient } from '../worker'
+import {
+  CreateBolt11Response,
+  GatewayInfo,
+  JSONObject,
+  JSONValue,
+  LightningGateway,
+  LnPayState,
+  LnReceiveState,
+  OutgoingLightningPayment,
+} from '../types/wallet'
+
+export class LightningService {
+  constructor(private client: WorkerClient) {}
+
+  async createInvoiceWithGateway(
+    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 createInvoice(
+    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 payInvoiceWithGateway(
+    invoice: string,
+    gatewayInfo: GatewayInfo,
+    extraMeta: JSONObject = {},
+  ) {
+    return await this.client.rpcSingle('ln', 'pay_bolt11_invoice', {
+      maybe_gateway: gatewayInfo,
+      invoice,
+      extra_meta: extraMeta,
+    })
+  }
+
+  private async _getDefaultGatewayInfo(): Promise<LightningGateway> {
+    const gateways = await this.listGateways()
+    return gateways[0]
+  }
+
+  async payInvoice(
+    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 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,
+  ): 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.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

@@ -0,0 +1,96 @@
+import { WorkerClient } from '../worker'
+import {
+  JSONObject,
+  JSONValue,
+  ReissueExternalNotesState,
+} 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 = () => {},
+  ) {
+    const unsubscribe = this.client.rpcStream<ReissueExternalNotesState>(
+      'mint',
+      'subscribe_reissue_external_notes',
+      { operation_id: operationId },
+      onSuccess,
+      onError,
+    )
+
+    return unsubscribe
+  }
+
+  async spendNotes(
+    minAmount: number,
+    // 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 = 0,
+    includeInvite: boolean = false,
+    extraMeta: JSONValue = {},
+  ): Promise<JSONValue> {
+    console.error('tryCancelAfter', tryCancelAfter)
+    return await this.client.rpcSingle('mint', 'spend_notes', {
+      min_amount: minAmount,
+      try_cancel_after: null,
+      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/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']
+  }
+}

package/src/test/TestingService.ts

@@ -0,0 +1,59 @@
+import { WorkerClient } from '../worker'
+
+export const TESTING_INVITE =
+  'fed11qgqrsdnhwden5te0v9cxjtt4dekxzamxw4kz6mmjvvkhydted9ukg6r9xfsnx7th0fhn26tf093juamwv4u8gtnpwpcz7qqpyz0e327ua8geceutfrcaezwt22mk6s2rdy09kg72jrcmncng2gn0kp2m5sk'
+
+// This is a testing service that allows for inspecting the internals
+// of the WorkerClient. It is not intended for use in production.
+export class TestingService {
+  public TESTING_INVITE: string
+  constructor(private client: WorkerClient) {
+    // Solo Mint on mutinynet
+    this.TESTING_INVITE = TESTING_INVITE
+  }
+
+  getRequestCounter() {
+    return this.client._getRequestCounter()
+  }
+
+  getRequestCallbackMap() {
+    return this.client._getRequestCallbackMap()
+  }
+
+  async payWithFaucet(invoice: string) {
+    try {
+      const response = await fetch(
+        `https://faucet.mutinynet.com/api/lnurlw/callback?k1=k1&pr=${invoice}`,
+      )
+
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! Failed to pay invoice. status: ${response.status}`,
+        )
+      }
+
+      return await response.json()
+    } catch (error) {
+      console.error('Error paying with faucet', error)
+      throw error
+    }
+  }
+
+  async getExternalInvoice(amount: number) {
+    try {
+      const response = await fetch(
+        `https://lnurl-staging.mutinywallet.com/lnurlp/refund/callback?amount=${amount}`,
+      )
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! Failed to get external invoice. status: ${response.status}`,
+        )
+      }
+
+      return await response.json()
+    } catch (error) {
+      console.error('Error getting external invoice', error)
+      throw error
+    }
+  }
+}

package/src/test/setupTests.ts

@@ -0,0 +1,43 @@
+import { expect, test } from 'vitest'
+import { TestFedimintWallet } from './TestFedimintWallet'
+
+/**
+ * Adds Fixtures for setting up and tearing down a test FedimintWallet instance
+ */
+export const walletTest = test.extend<{ wallet: TestFedimintWallet }>({
+  wallet: async ({}, use) => {
+    const randomTestingId = Math.random().toString(36).substring(2, 15)
+    const wallet = new TestFedimintWallet()
+    expect(wallet).toBeDefined()
+
+    await expect(
+      wallet.joinFederation(wallet.testing.TESTING_INVITE, randomTestingId),
+    ).resolves.toBeUndefined()
+    await use(wallet)
+
+    // clear up browser resources
+    await wallet.cleanup()
+    // remove the wallet db
+    indexedDB.deleteDatabase(randomTestingId)
+  },
+})
+
+/**
+ * Adds Fixtures for setting up and tearing down a test Worker instance
+ */
+export const workerTest = test.extend<{
+  worker: Worker
+  clientName: string
+}>({
+  worker: async ({}, use) => {
+    const worker = new Worker(new URL('../worker/worker.js', import.meta.url), {
+      type: 'module',
+    })
+    await use(worker)
+    worker.terminate()
+  },
+  clientName: async ({}, use) => {
+    const randomTestingId = Math.random().toString(36).substring(2, 15)
+    await use(randomTestingId)
+  },
+})