@fedimint/core 0.1.1 → 0.1.3

package/src/FedimintWallet.ts

@@ -8,7 +8,9 @@ import {
   WalletService,
 } from './services'
 
-const DEFAULT_CLIENT_NAME = 'fm-default' as const
+// The Rpc requires exactly 36 length uuid strings
+// This is temporary until we have a proper client management system
+const DEFAULT_CLIENT_NAME = 'dd5135b2-c228-41b7-a4f9-3b6e7afe3088' as const
 
 export class FedimintWallet {
   public balance: BalanceService
@@ -48,16 +50,19 @@ export class FedimintWallet {
    * lazyWallet.initialize();
    * lazyWallet.open();
    */
-  constructor(private _client: TransportClient) {
+  constructor(
+    private _client: TransportClient,
+    private _clientName: string = DEFAULT_CLIENT_NAME,
+  ) {
     this._openPromise = new Promise((resolve) => {
       this._resolveOpen = resolve
     })
-    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.wallet = new WalletService(this._client)
+    this.mint = new MintService(this._client, this._clientName)
+    this.lightning = new LightningService(this._client, this._clientName)
+    this.balance = new BalanceService(this._client, this._clientName)
+    this.federation = new FederationService(this._client, this._clientName)
+    this.recovery = new RecoveryService(this._client, this._clientName)
+    this.wallet = new WalletService(this._client, this._clientName)
   }
 
   async waitForOpen() {
@@ -68,14 +73,17 @@ export class FedimintWallet {
   async open(clientName: string = DEFAULT_CLIENT_NAME) {
     // 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<{
-      success: boolean
-    }>('open', { clientName })
-    if (success) {
-      this._isOpen = !!success
+    try {
+      await this._client.sendSingleMessage('open_client', {
+        client_name: clientName,
+      })
+      this._isOpen = true
       this._resolveOpen()
+      return true
+    } catch (e) {
+      this._client.logger.error('Error opening client', e)
+      throw e
     }
-    return success
   }
 
   async joinFederation(
@@ -88,15 +96,15 @@ export class FedimintWallet {
         'The FedimintWallet is already open. You can only call `joinFederation` on closed clients.',
       )
     try {
-      const response = await this._client.sendSingleMessage<{
-        success: boolean
-      }>('join', { inviteCode, clientName })
-      if (response.success) {
-        this._isOpen = true
-        this._resolveOpen()
-      }
+      await this._client.sendSingleMessage('join_federation', {
+        invite_code: inviteCode,
+        client_name: clientName,
+        force_recover: false,
+      })
+      this._isOpen = true
+      this._resolveOpen()
 
-      return response.success
+      return true
     } catch (e) {
       this._client.logger.error('Error joining federation', e)
       return false

package/src/WalletDirector.ts

@@ -45,7 +45,7 @@ export class WalletDirector {
     const response = this._client.sendSingleMessage<{
       config: FederationConfig
       federation_id: string
-    }>('previewFederation', { inviteCode })
+    }>('preview_federation', { invite_code: inviteCode })
     return response
   }
 
@@ -83,7 +83,7 @@ export class WalletDirector {
       type: string
       data: JSONValue
       requestId: number
-    }>('parseInviteCode', { inviteCode })
+    }>('parse_invite_code', { inviteCode })
     return response
   }
 
@@ -113,7 +113,42 @@ export class WalletDirector {
       type: string
       data: JSONValue
       requestId: number
-    }>('parseBolt11Invoice', { invoiceStr })
+    }>('parse_bolt11_invoice', { invoiceStr })
     return response
   }
+
+  /**
+   * Generates and sets a new mnemonic phrase.
+   * @returns {Promise<string[]>} A promise that resolves to the generated mnemonic phrase.
+   */
+  async generateMnemonic(): Promise<string[]> {
+    const result = await this._client.sendSingleMessage<{ mnemonic: string[] }>(
+      'generate_mnemonic',
+    )
+    return result.mnemonic
+  }
+
+  /**
+   * Retrieves the current mnemonic phrase.
+   * @returns {Promise<string[]>} A promise that resolves to the current mnemonic phrase.
+   */
+  async getMnemonic(): Promise<string[]> {
+    const result = await this._client.sendSingleMessage<{ mnemonic: string[] }>(
+      'get_mnemonic',
+    )
+    return result.mnemonic
+  }
+
+  /**
+   * Sets the mnemonic phrase.
+   * @param {string[]} words - The mnemonic words to set.
+   * @returns {Promise<boolean>} A promise that resolves to true if the mnemonic was set successfully.
+   */
+  async setMnemonic(words: string[]): Promise<boolean> {
+    const result = await this._client.sendSingleMessage<{ success: boolean }>(
+      'set_mnemonic',
+      { words },
+    )
+    return result.success
+  }
 }

package/src/services/BalanceService.ts

@@ -6,11 +6,19 @@ import { TransportClient } from '../transport'
  * The Balance Service provides methods to interact with the balance of a Fedimint wallet.
  */
 export class BalanceService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   /** https://web.fedimint.org/core/FedimintWallet/BalanceService/getBalance */
   async getBalance() {
-    return await this.client.rpcSingle<number>('', 'get_balance', {})
+    return await this.client.rpcSingle<number>(
+      '',
+      'get_balance',
+      {},
+      this.clientName,
+    )
   }
 
   /** https://web.fedimint.org/core/FedimintWallet/BalanceService/subscribeBalance */
@@ -22,6 +30,7 @@ export class BalanceService {
       '',
       'subscribe_balance_changes',
       {},
+      this.clientName,
       (res) => onSuccess(parseInt(res)),
       onError,
     )

package/src/services/FederationService.ts

@@ -12,20 +12,33 @@ import type {
 import { TransportClient } from '../transport'
 
 export class FederationService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   async getConfig() {
-    return await this.client.rpcSingle('', 'get_config', {})
+    return await this.client.rpcSingle('', 'get_config', {}, this.clientName)
   }
 
   async getFederationId() {
-    return await this.client.rpcSingle<string>('', 'get_federation_id', {})
+    return await this.client.rpcSingle<string>(
+      '',
+      'get_federation_id',
+      {},
+      this.clientName,
+    )
   }
 
   async getInviteCode(peer: number = 0) {
-    return await this.client.rpcSingle<string | null>('', 'get_invite_code', {
-      peer,
-    })
+    return await this.client.rpcSingle<string | null>(
+      '',
+      'get_invite_code',
+      {
+        peer,
+      },
+      this.clientName,
+    )
   }
 
   async listOperations(
@@ -39,6 +52,7 @@ export class FederationService {
         limit: limit ?? null,
         last_seen: last_seen ?? null,
       },
+      this.clientName,
     )
   }
 
@@ -47,6 +61,7 @@ export class FederationService {
       '',
       'get_operation',
       { operation_id: operationId },
+      this.clientName,
     )
   }
 

package/src/services/LightningService.ts

@@ -11,7 +11,10 @@ import type {
 } from '../types'
 
 export class LightningService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   /** https://web.fedimint.org/core/FedimintWallet/LightningService/createInvoice#lightning-createinvoice */
   async createInvoice(
@@ -32,6 +35,7 @@ export class LightningService {
         extra_meta: extraMeta ?? {},
         gateway,
       },
+      this.clientName,
     )
   }
 
@@ -57,6 +61,7 @@ export class LightningService {
         extra_meta: extraMeta ?? {},
         gateway,
       },
+      this.clientName,
     )
   }
 
@@ -74,6 +79,7 @@ export class LightningService {
         indices,
         extra_meta: extraMeta ?? {},
       },
+      this.clientName,
     )
   }
 
@@ -98,6 +104,7 @@ export class LightningService {
         invoice,
         extra_meta: extraMeta ?? {},
       },
+      this.clientName,
     )
   }
 
@@ -151,6 +158,7 @@ export class LightningService {
       'ln',
       'subscribe_internal_pay',
       { operation_id: operation_id },
+      this.clientName,
       onSuccess,
       onError,
     )
@@ -166,6 +174,7 @@ export class LightningService {
       'ln',
       'subscribe_ln_claim',
       { operation_id: operationId },
+      this.clientName,
       onSuccess,
       onError,
     )
@@ -183,6 +192,7 @@ export class LightningService {
       'ln',
       'subscribe_ln_pay',
       { operation_id: operationId },
+      this.clientName,
       onSuccess,
       onError,
     )
@@ -230,6 +240,7 @@ export class LightningService {
       'ln',
       'subscribe_ln_receive',
       { operation_id: operationId },
+      this.clientName,
       onSuccess,
       onError,
     )
@@ -272,6 +283,7 @@ export class LightningService {
         gateway_id: gatewayId,
         force_internal: forceInternal,
       },
+      this.clientName,
     )
   }
 
@@ -280,10 +292,16 @@ export class LightningService {
       'ln',
       'list_gateways',
       {},
+      this.clientName,
     )
   }
 
   async updateGatewayCache() {
-    return await this.client.rpcSingle('ln', 'update_gateway_cache', {})
+    return await this.client.rpcSingle(
+      'ln',
+      'update_gateway_cache',
+      {},
+      this.clientName,
+    )
   }
 }

package/src/services/MintService.ts

@@ -11,7 +11,10 @@ import type {
 } from '../types'
 
 export class MintService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   /** https://web.fedimint.org/core/FedimintWallet/MintService/redeemEcash */
   async redeemEcash(notes: string) {
@@ -22,6 +25,7 @@ export class MintService {
         oob_notes: notes, // "out of band notes"
         extra_meta: null,
       },
+      this.clientName,
     )
   }
 
@@ -33,6 +37,7 @@ export class MintService {
         oob_notes: oobNotes,
         extra_meta: extraMeta,
       },
+      this.clientName,
     )
   }
 
@@ -45,6 +50,7 @@ export class MintService {
       'mint',
       'subscribe_reissue_external_notes',
       { operation_id: operationId },
+      this.clientName,
       onSuccess,
       onError,
     )
@@ -76,6 +82,7 @@ export class MintService {
         include_invite: includeInvite,
         extra_meta: extraMeta,
       },
+      this.clientName,
     )
     const notes = res[1]
     const operationId = res[0]
@@ -88,15 +95,25 @@ export class MintService {
 
   /** https://web.fedimint.org/core/FedimintWallet/MintService/parseEcash */
   async parseNotes(oobNotes: string) {
-    return await this.client.rpcSingle<MSats>('mint', 'validate_notes', {
-      oob_notes: oobNotes,
-    })
+    return await this.client.rpcSingle<MSats>(
+      'mint',
+      'validate_notes',
+      {
+        oob_notes: oobNotes,
+      },
+      this.clientName,
+    )
   }
 
   async tryCancelSpendNotes(operationId: string) {
-    await this.client.rpcSingle('mint', 'try_cancel_spend_notes', {
-      operation_id: operationId,
-    })
+    await this.client.rpcSingle(
+      'mint',
+      'try_cancel_spend_notes',
+      {
+        operation_id: operationId,
+      },
+      this.clientName,
+    )
   }
 
   subscribeSpendNotes(
@@ -108,15 +125,21 @@ export class MintService {
       'mint',
       'subscribe_spend_notes',
       { operation_id: operationId },
+      this.clientName,
       (res) => onSuccess(res),
       onError,
     )
   }
 
   async awaitSpendOobRefund(operationId: string) {
-    return await this.client.rpcSingle('mint', 'await_spend_oob_refund', {
-      operation_id: operationId,
-    })
+    return await this.client.rpcSingle(
+      'mint',
+      'await_spend_oob_refund',
+      {
+        operation_id: operationId,
+      },
+      this.clientName,
+    )
   }
 
   async getNotesByDenomination() {
@@ -124,6 +147,7 @@ export class MintService {
       'mint',
       'note_counts_by_denomination',
       {},
+      this.clientName,
     )
   }
 }

package/src/services/RecoveryService.ts

@@ -2,18 +2,27 @@ import type { JSONValue } from '../types'
 import { TransportClient } from '../transport'
 
 export class RecoveryService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   async hasPendingRecoveries() {
     return await this.client.rpcSingle<boolean>(
       '',
       'has_pending_recoveries',
       {},
+      this.clientName,
     )
   }
 
   async waitForAllRecoveries() {
-    await this.client.rpcSingle('', 'wait_for_all_recoveries', {})
+    await this.client.rpcSingle(
+      '',
+      'wait_for_all_recoveries',
+      {},
+      this.clientName,
+    )
   }
 
   subscribeToRecoveryProgress(
@@ -23,6 +32,13 @@ export class RecoveryService {
     return this.client.rpcStream<{
       module_id: number
       progress: JSONValue
-    }>('', 'subscribe_to_recovery_progress', {}, onSuccess, onError)
+    }>(
+      '',
+      'subscribe_to_recovery_progress',
+      {},
+      this.clientName,
+      onSuccess,
+      onError,
+    )
   }
 }

package/src/services/WalletService.ts

@@ -7,10 +7,18 @@ import {
 import { TransportClient } from '../transport'
 
 export class WalletService {
-  constructor(private client: TransportClient) {}
+  constructor(
+    private client: TransportClient,
+    private clientName: string,
+  ) {}
 
   async getWalletSummary(): Promise<WalletSummary> {
-    return await this.client.rpcSingle('wallet', 'get_wallet_summary', {})
+    return await this.client.rpcSingle(
+      'wallet',
+      'get_wallet_summary',
+      {},
+      this.clientName,
+    )
   }
 
   async generateAddress(extraMeta: JSONValue = {}) {
@@ -20,6 +28,7 @@ export class WalletService {
       {
         extra_meta: extraMeta,
       },
+      this.clientName,
     )
   }
 
@@ -28,11 +37,16 @@ export class WalletService {
     address: string,
     extraMeta: JSONValue = {},
   ): Promise<{ operation_id: string }> {
-    return await this.client.rpcSingle('wallet', 'peg_out', {
-      amount_sat: amountSat,
-      destination_address: address,
-      extra_meta: extraMeta,
-    })
+    return await this.client.rpcSingle(
+      'wallet',
+      'peg_out',
+      {
+        amount_sat: amountSat,
+        destination_address: address,
+        extra_meta: extraMeta,
+      },
+      this.clientName,
+    )
   }
   subscribeDeposit(
     operation_id: string,
@@ -43,6 +57,7 @@ export class WalletService {
       'ln',
       'subscribe_deposit',
       { operation_id: operation_id },
+      this.clientName,
       onSuccess,
       onError,
     )

package/src/transport/TransportClient.ts

@@ -38,36 +38,58 @@ export class TransportClient {
   }
 
   // Idempotent setup - Loads the wasm module
-  initialize() {
+  initialize(): Promise<boolean>
+  initialize(testFilename: string): Promise<boolean>
+  initialize(testFilename?: string): Promise<boolean> {
     if (this.initPromise) return this.initPromise
-    this.initPromise = this.sendSingleMessage('init')
+    if (testFilename) {
+      this.initPromise = this.sendSingleMessage('init', {
+        filename: testFilename,
+      })
+    } else {
+      this.initPromise = this.sendSingleMessage('init')
+    }
     return this.initPromise
   }
 
   private handleLogMessage(message: TransportMessage) {
-    const { type, level, message: logMessage, ...data } = message
-    this.logger.info(String(level), String(logMessage), data)
+    const { type, level = 'debug', message: logMessage, ...data } = message
+    this.logger.log(String(level), `Transport Log: ${String(logMessage)}`, data)
   }
 
   private handleTransportError = (error: unknown) => {
-    this.logger.error('TransportClient error', error)
+    this.logger.warn(
+      'TransportClient error',
+      JSON.stringify(error, [
+        'message',
+        'arguments',
+        'type',
+        'name',
+        'request_id',
+      ]),
+    )
   }
 
   private handleTransportMessage = (message: TransportMessage) => {
-    const { type, requestId, ...data } = message
+    const { type, request_id, ...data } = message
     if (type === 'log') {
       this.handleLogMessage(message)
     }
+
     const streamCallback =
-      requestId !== undefined ? this.requestCallbacks.get(requestId) : undefined
+      request_id !== undefined
+        ? this.requestCallbacks.get(request_id)
+        : undefined
     // TODO: Handle errors... maybe have another callbacks list for errors?
-    this.logger.debug('TransportClient - handleTransportMessage', message)
     if (streamCallback) {
+      this.logger.debug(
+        'TransportClient - handleTransportMessage - callback',
+        message,
+      )
       streamCallback(data) // {data: something} OR {error: something}
-    } else if (requestId !== undefined) {
+    } else if (request_id !== undefined && type !== 'end') {
       this.logger.warn(
         'TransportClient - handleTransportMessage - received message with no callback',
-        requestId,
         message,
       )
     }
@@ -98,7 +120,7 @@ export class TransportClient {
             requestId,
             response,
           )
-          if (response.data) resolve(response.data)
+          if (response.data !== undefined) resolve(response.data)
           else if (response.error) reject(response.error)
           else
             this.logger.warn(
@@ -143,6 +165,7 @@ export class TransportClient {
     module: ModuleKind,
     method: string,
     body: Body,
+    clientName: string,
     onSuccess: (res: Response) => void,
     onError: (res: StreamError['error']) => void,
     onEnd: () => void = () => {},
@@ -154,6 +177,7 @@ export class TransportClient {
       module,
       method,
       body,
+      clientName,
     )
     let unsubscribe: (value: void) => void = () => {}
     let isSubscribed = false
@@ -177,6 +201,7 @@ export class TransportClient {
       module,
       method,
       body,
+      clientName,
       onSuccess,
       onError,
       onEnd,
@@ -196,6 +221,7 @@ export class TransportClient {
     module: ModuleKind,
     method: string,
     body: Body,
+    clientName: string,
     onSuccess: (res: Response) => void,
     onError: (res: StreamError['error']) => void,
     onEnd: () => void = () => {},
@@ -213,14 +239,15 @@ export class TransportClient {
       }
     })
     this.transport.postMessage({
-      type: 'rpc',
-      payload: { module, method, body },
+      type: 'client_rpc',
+      payload: { client_name: clientName, module, method, payload: body },
       requestId,
     })
 
     unsubscribePromise.then(() => {
       this.transport.postMessage({
-        type: 'unsubscribe',
+        type: 'cancel_rpc',
+        payload: { cancel_request_id: requestId },
         requestId,
       })
       this.requestCallbacks.delete(requestId)
@@ -230,15 +257,28 @@ export class TransportClient {
   rpcSingle<
     Response extends JSONValue = JSONValue,
     Error extends string = string,
-  >(module: ModuleKind, method: string, body: JSONValue) {
+  >(
+    module: ModuleKind,
+    method: string,
+    body: JSONValue,
+    clientName: string,
+  ): Promise<Response> {
     this.logger.debug('TransportClient - rpcSingle', module, method, body)
     return new Promise<Response>((resolve, reject) => {
-      this.rpcStream<Response>(module, method, body, resolve, reject)
+      this.rpcStream<Response>(
+        module,
+        method,
+        body,
+        clientName,
+        resolve,
+        reject,
+      )
     })
   }
 
   async cleanup() {
-    await this.sendSingleMessage('cleanup')
+    const res = await this.sendSingleMessage('cleanup')
+    this.logger.info('TransportClient - cleanup', res)
     this.requestCounter = 0
     this.initPromise = undefined
     this.requestCallbacks.clear()