@fedimint/core-web 0.0.6 → 0.0.8

package/src/FedimintWallet.ts

@@ -1,4 +1,4 @@
-import { WorkerClient } from './worker/WorkerClient'
+import { WorkerClient } from './worker'
 import {
   BalanceService,
   MintService,
@@ -19,7 +19,7 @@ export class FedimintWallet {
   public federation: FederationService
   public recovery: RecoveryService
 
-  private _openPromise: Promise<void> | null = null
+  private _openPromise: Promise<void> | undefined = undefined
   private _resolveOpen: () => void = () => {}
   private _isOpen: boolean = false
 
@@ -85,9 +85,9 @@ export class FedimintWallet {
     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', {
-      clientName,
-    })
+    const { success } = await this._client.sendSingleMessage<{
+      success: boolean
+    }>('open', { clientName })
     if (success) {
       this._isOpen = !!success
       this._resolveOpen()
@@ -105,13 +105,19 @@ export class FedimintWallet {
       throw new Error(
         'The FedimintWallet is already open. You can only call `joinFederation` on closed clients.',
       )
-    const response = await this._client.sendSingleMessage('join', {
-      inviteCode,
-      clientName,
-    })
-    if (response.success) {
-      this._isOpen = true
-      this._resolveOpen()
+    try {
+      const response = await this._client.sendSingleMessage<{
+        success: boolean
+      }>('join', { inviteCode, clientName })
+      if (response.success) {
+        this._isOpen = true
+        this._resolveOpen()
+      }
+
+      return response.success
+    } catch (e) {
+      logger.error('Error joining federation', e)
+      return false
     }
   }
 
@@ -120,9 +126,9 @@ export class FedimintWallet {
    * After this call, the FedimintWallet instance should be discarded.
    */
   async cleanup() {
-    this._openPromise = null
+    this._openPromise = undefined
     this._isOpen = false
-    this._client.cleanup()
+    await this._client.cleanup()
   }
 
   isOpen() {

package/src/index.ts

@@ -1,22 +1,2 @@
-import { FedimintWallet } from './FedimintWallet.js'
-import {
-  LightningGateway,
-  RouteHint,
-  FeeToAmount,
-  OutgoingLightningPayment,
-  PayType,
-  LnPayState,
-  CreateBolt11Response,
-} from './types/wallet.js'
-
-export { FedimintWallet }
-
-export type {
-  LightningGateway,
-  RouteHint,
-  FeeToAmount,
-  OutgoingLightningPayment,
-  PayType,
-  LnPayState,
-  CreateBolt11Response,
-}
+export { FedimintWallet } from './FedimintWallet'
+export type * from './types'

package/src/services/BalanceService.ts

@@ -1,3 +1,4 @@
+import type { MSats } from '../types'
 import { WorkerClient } from '../worker'
 
 /**
@@ -9,19 +10,19 @@ export class BalanceService {
   constructor(private client: WorkerClient) {}
 
   /**
-   * Get the balance of the current wallet
+   * Get the balance of the current wallet in milli-satoshis (MSats)
    *
    * @example
    * ```ts
    * const balance = await wallet.balance.getBalance()
    * ```
    */
-  async getBalance(): Promise<number> {
+  async getBalance(): Promise<MSats> {
     return await this.client.rpcSingle('', 'get_balance', {})
   }
 
   /**
-   * Subscribe to the balance of the current wallet
+   * Subscribe to the balance of the current wallet in milli-satoshis (MSats)
    *
    * @example
    * ```ts
@@ -34,7 +35,7 @@ export class BalanceService {
    * ```
    */
   subscribeBalance(
-    onSuccess: (balance: number) => void = () => {},
+    onSuccess: (balance: MSats) => void = () => {},
     onError: (error: string) => void = () => {},
   ) {
     const unsubscribe = this.client.rpcStream<string>(

package/src/services/FederationService.test.ts

@@ -1,5 +1,5 @@
 import { expect } from 'vitest'
-import { walletTest } from '../test/setupTests'
+import { walletTest } from '../test/fixtures'
 
 walletTest(
   'getConfig should return the federation config',

package/src/services/FederationService.ts

@@ -1,4 +1,4 @@
-import { JSONValue } from '../types/wallet'
+import type { JSONValue } from '../types'
 import { WorkerClient } from '../worker'
 
 export class FederationService {

package/src/services/LightningService.test.ts

@@ -1,5 +1,6 @@
 import { expect } from 'vitest'
-import { walletTest } from '../test/setupTests'
+import { keyPair } from '../test/crypto'
+import { walletTest } from '../test/fixtures'
 
 walletTest(
   'createInvoice should create a bolt11 invoice',
@@ -20,11 +21,23 @@ walletTest(
 
     // Test with expiry time
     await expect(
-      wallet.lightning.createInvoice(100, 'test', 1000, {}),
+      wallet.lightning.createInvoice(100, 'test', 1000),
     ).resolves.toBeDefined()
   },
 )
 
+walletTest('createInvoice with expiry', async ({ wallet }) => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  const invoice = await wallet.lightning.createInvoice(100, 'test', 1000)
+  expect(invoice).toBeDefined()
+  expect(invoice).toMatchObject({
+    invoice: expect.any(String),
+    operation_id: expect.any(String),
+  })
+})
+
 walletTest(
   'listGateways should return a list of gateways',
   async ({ wallet }) => {
@@ -35,11 +48,7 @@ walletTest(
     const gateways = await wallet.lightning.listGateways()
     expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
     expect(gateways).toBeDefined()
-    expect(gateways).toMatchObject([
-      {
-        info: expect.any(Object),
-      },
-    ])
+    expect(gateways).toMatchObject(expect.any(Array))
   },
 )
 
@@ -74,42 +83,6 @@ walletTest('getGateway should return a gateway', async ({ wallet }) => {
   })
 })
 
-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 }) => {
@@ -126,7 +99,7 @@ walletTest(
     const counterBefore = wallet.testing.getRequestCounter()
     // Insufficient funds
     try {
-      await wallet.lightning.payInvoice(invoice.invoice, {})
+      await wallet.lightning.payInvoice(invoice.invoice)
       expect.unreachable('Should throw error')
     } catch (error) {
       expect(error).toBeDefined()
@@ -139,30 +112,97 @@ walletTest(
 
 walletTest(
   'payInvoice should pay a bolt11 invoice',
-  { timeout: 45000 },
+  { timeout: 20_000 },
+  async ({ fundedWallet }) => {
+    expect(fundedWallet).toBeDefined()
+    expect(fundedWallet.isOpen()).toBe(true)
+    const initialBalance = await fundedWallet.balance.getBalance()
+    expect(initialBalance).toBeGreaterThan(0)
+    const externalInvoice = await fundedWallet.testing.createFaucetInvoice(1)
+    const gatewayInfo = await fundedWallet.testing.getFaucetGatewayInfo()
+    const payment = await fundedWallet.lightning.payInvoice(
+      externalInvoice,
+      gatewayInfo,
+    )
+    expect(payment).toMatchObject({
+      contract_id: expect.any(String),
+      fee: expect.any(Number),
+      payment_type: expect.any(Object),
+    })
+    const finalBalance = await fundedWallet.balance.getBalance()
+    expect(finalBalance).toBeLessThan(initialBalance)
+  },
+)
+
+walletTest(
+  'createInvoiceTweaked should create a bolt11 invoice with a tweaked public key',
   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')
+    // Make an ephemeral key pair
+    const { publicKey, secretKey } = keyPair()
+    const tweak = 1
+
+    // Create an invoice paying to the tweaked public key
+    const invoice = await wallet.lightning.createInvoiceTweaked(
+      1000,
+      'test tweaked',
+      publicKey,
+      tweak,
+    )
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+  },
+)
+
+walletTest(
+  'scanReceivesForTweaks should return the operation id',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    // Make an ephemeral key pair
+    const { publicKey, secretKey } = keyPair()
+    const tweak = 1
+
+    const gatewayInfo = await wallet.testing.getFaucetGatewayInfo()
+
+    // Create an invoice paying to the tweaked public key
+    const invoice = await wallet.lightning.createInvoiceTweaked(
+      1000,
+      'test tweaked',
+      publicKey,
+      tweak,
+      undefined,
+      gatewayInfo,
+    )
     await expect(
-      wallet.testing.payWithFaucet(invoice.invoice),
+      wallet.testing.payFaucetInvoice(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),
-    })
+
+    // Scan for the receive
+    const operationIds = await wallet.lightning.scanReceivesForTweaks(
+      secretKey,
+      [tweak],
+      {},
+    )
+    expect(operationIds).toBeDefined()
+    expect(operationIds).toHaveLength(1)
+
+    // Subscribe to claiming the receive
+    const subscription = await wallet.lightning.subscribeLnClaim(
+      operationIds[0],
+      (state) => {
+        expect(state).toBeDefined()
+        expect(state).toMatchObject({
+          state: 'claimed',
+        })
+      },
+    )
+    expect(subscription).toBeDefined()
   },
 )

package/src/services/LightningService.ts

@@ -1,5 +1,5 @@
 import { WorkerClient } from '../worker'
-import {
+import type {
   CreateBolt11Response,
   GatewayInfo,
   JSONObject,
@@ -7,75 +7,103 @@ import {
   LightningGateway,
   LnPayState,
   LnReceiveState,
+  MSats,
   OutgoingLightningPayment,
-} from '../types/wallet'
+} from '../types'
 
 export class LightningService {
   constructor(private client: WorkerClient) {}
 
-  async createInvoiceWithGateway(
-    amount: number,
+  async createInvoice(
+    amount: MSats,
     description: string,
-    expiryTime: number | null = null,
-    extraMeta: JSONObject = {},
-    gatewayInfo: GatewayInfo,
-  ) {
+    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,
       description,
-      expiry_time: expiryTime,
-      extra_meta: extraMeta,
-      gateway: gatewayInfo,
+      expiry_time: expiryTime ?? null,
+      extra_meta: extraMeta ?? {},
+      gateway,
     })
   }
 
-  async createInvoice(
-    amount: number,
+  async createInvoiceTweaked(
+    amount: MSats,
     description: string,
-    expiryTime: number | null = null,
-    extraMeta: JSONObject = {},
+    tweakKey: string,
+    index: number,
+    expiryTime?: number, // in seconds
+    gatewayInfo?: GatewayInfo,
+    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,
-    })
+    const gateway = gatewayInfo ?? (await this._getDefaultGatewayInfo())
+    return await this.client.rpcSingle(
+      'ln',
+      'create_bolt11_invoice_for_user_tweaked',
+      {
+        amount,
+        description,
+        expiry_time: expiryTime ?? null,
+        user_key: tweakKey,
+        index,
+        extra_meta: extraMeta ?? {},
+        gateway,
+      },
+    )
   }
 
-  async payInvoiceWithGateway(
-    invoice: string,
-    gatewayInfo: GatewayInfo,
-    extraMeta: JSONObject = {},
-  ) {
-    return await this.client.rpcSingle('ln', 'pay_bolt11_invoice', {
-      maybe_gateway: gatewayInfo,
-      invoice,
-      extra_meta: extraMeta,
+  // Returns the operation ids of payments received to the tweaks of the user secret key
+  async scanReceivesForTweaks(
+    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 ?? {},
     })
   }
 
-  private async _getDefaultGatewayInfo(): Promise<LightningGateway> {
+  private async _getDefaultGatewayInfo(): Promise<GatewayInfo> {
+    await this.updateGatewayCache()
     const gateways = await this.listGateways()
-    return gateways[0]
+    return gateways[0]?.info
   }
 
   async payInvoice(
     invoice: string,
-    extraMeta: JSONObject = {},
+    gatewayInfo?: GatewayInfo,
+    extraMeta?: JSONObject,
   ): Promise<OutgoingLightningPayment> {
-    await this.updateGatewayCache()
-    const gateway = await this._getDefaultGatewayInfo()
+    const gateway = gatewayInfo ?? (await this._getDefaultGatewayInfo())
     return await this.client.rpcSingle('ln', 'pay_bolt11_invoice', {
-      maybe_gateway: gateway.info,
+      maybe_gateway: gateway,
       invoice,
-      extra_meta: extraMeta,
+      extra_meta: extraMeta ?? {},
     })
   }
 
+  subscribeLnClaim(
+    operationId: string,
+    onSuccess: (state: LnReceiveState) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    const unsubscribe = this.client.rpcStream(
+      'ln',
+      'subscribe_ln_claim',
+      { operation_id: operationId },
+      onSuccess,
+      onError,
+    )
+
+    return unsubscribe
+  }
+
   subscribeLnPay(
     operationId: string,
     onSuccess: (state: LnPayState) => void = () => {},
@@ -110,17 +138,26 @@ export class LightningService {
 
   async waitForReceive(operationId: string): Promise<LnReceiveState> {
     return new Promise((resolve, reject) => {
-      const unsubscribe = this.subscribeLnReceive(
+      let unsubscribe: () => void
+      const timeoutId = setTimeout(() => {
+        reject(new Error('Timeout waiting for receive'))
+      }, 15000)
+
+      unsubscribe = this.subscribeLnReceive(
         operationId,
         (res) => {
-          if (res === 'claimed') resolve(res)
+          if (res === 'claimed') {
+            clearTimeout(timeoutId)
+            unsubscribe()
+            resolve(res)
+          }
+        },
+        (error) => {
+          clearTimeout(timeoutId)
+          unsubscribe()
+          reject(error)
         },
-        reject,
       )
-      setTimeout(() => {
-        unsubscribe()
-        reject(new Error('Timeout waiting for receive'))
-      }, 10000)
     })
   }
 

package/src/services/MintService.test.ts

@@ -1,5 +1,5 @@
 import { expect } from 'vitest'
-import { walletTest } from '../test/setupTests'
+import { walletTest } from '../test/fixtures'
 
 walletTest('redeemEcash should error on invalid ecash', async ({ wallet }) => {
   expect(wallet).toBeDefined()
@@ -9,7 +9,7 @@ walletTest('redeemEcash should error on invalid ecash', async ({ wallet }) => {
 })
 
 walletTest(
-  'reissueExternalNotes should reissue external notes',
+  'reissueExternalNotes should throw if wallet is empty',
   async ({ wallet }) => {
     expect(wallet).toBeDefined()
     expect(wallet.isOpen()).toBe(true)
@@ -17,3 +17,17 @@ walletTest(
     await expect(wallet.mint.reissueExternalNotes('test')).rejects.toThrow()
   },
 )
+
+walletTest('spendNotes should throw if wallet is empty', async ({ wallet }) => {
+  expect(wallet).toBeDefined()
+  expect(wallet.isOpen()).toBe(true)
+
+  await expect(wallet.mint.spendNotes(100)).rejects.toThrow()
+})
+
+walletTest('parseNotes should parse 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,11 +1,12 @@
 import { WorkerClient } from '../worker'
-import {
+import type {
   Duration,
   JSONObject,
   JSONValue,
   MintSpendNotesResponse,
+  MSats,
   ReissueExternalNotesState,
-} from '../types/wallet'
+} from '../types'
 
 export class MintService {
   constructor(private client: WorkerClient) {}
@@ -44,12 +45,11 @@ export class MintService {
   }
 
   async spendNotes(
-    minAmount: number,
+    minAmount: MSats,
     // 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,
+    // after the specified number of seconds. If the receiver has already redeemed
+    // the notes at this time, the notes will not be cancelled.
+    tryCancelAfter: number | Duration = 3600 * 24, // defaults to 1 day
     includeInvite: boolean = false,
     extraMeta: JSONValue = {},
   ): Promise<MintSpendNotesResponse> {
@@ -77,7 +77,7 @@ export class MintService {
     }
   }
 
-  async validateNotes(oobNotes: string): Promise<number> {
+  async parseNotes(oobNotes: string): Promise<MSats> {
     return await this.client.rpcSingle('mint', 'validate_notes', {
       oob_notes: oobNotes,
     })

package/src/services/RecoveryService.ts

@@ -1,4 +1,4 @@
-import { JSONValue } from '../types/wallet'
+import type { JSONValue } from '../types'
 import { WorkerClient } from '../worker'
 
 export class RecoveryService {

package/src/test/TestFedimintWallet.ts

@@ -7,7 +7,16 @@ export class TestFedimintWallet extends FedimintWallet {
 
   constructor() {
     super()
-    this.testing = new TestingService(this.getWorkerClient())
+    this.testing = new TestingService(this.getWorkerClient(), this.lightning)
+  }
+
+  async fundWallet(amount: number) {
+    const info = await this.testing.getFaucetGatewayInfo()
+    const invoice = await this.lightning.createInvoice(amount, '', 1000, info)
+    await Promise.all([
+      this.testing.payFaucetInvoice(invoice.invoice),
+      this.lightning.waitForReceive(invoice.operation_id),
+    ])
   }
 
   // Method to expose the WorkerClient