@fedimint/core 0.1.0 → 0.1.3

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()

package/src/utils/logger.ts

@@ -23,8 +23,8 @@ export class Logger {
   }
 
   private coerceLevel(level: string): LogLevel {
-    if (logLevels.includes(level.toLocaleUpperCase() as LogLevel)) {
-      return level.toLocaleUpperCase() as LogLevel
+    if (logLevels.includes(level.toLowerCase() as LogLevel)) {
+      return level.toLowerCase() as LogLevel
     }
     return 'info'
   }

package/src/services/BalanceService.test.ts

@@ -1,26 +0,0 @@
-import { expect } from 'vitest'
-import { walletTest } from '../test/fixtures'
-
-walletTest('getBalance should be initially zero', async ({ wallet }) => {
-  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)
-})
-
-walletTest('subscribe balance', async ({ wallet }) => {
-  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/FederationService.test.ts

@@ -1,58 +0,0 @@
-import { expect } from 'vitest'
-import { walletTest } from '../test/fixtures'
-
-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/LightningService.test.ts

@@ -1,265 +0,0 @@
-import { expect } from 'vitest'
-import { keyPair } from '../test/crypto'
-import { walletTest } from '../test/fixtures'
-
-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('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 }) => {
-    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(expect.any(Array))
-  },
-)
-
-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(
-  '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: 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)
-
-    // 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.payFaucetInvoice(invoice.invoice),
-    ).resolves.toBeDefined()
-
-    // 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()
-  },
-)
-
-walletTest(
-  'subscribe_internal_pay should return state',
-  async ({ fundedWallet }) => {
-    expect(fundedWallet).toBeDefined()
-    expect(fundedWallet.isOpen()).toBe(true)
-    const initialBalance = await fundedWallet.balance.getBalance()
-    expect(initialBalance).toBeGreaterThan(0)
-    const externalInvoice = (
-      await fundedWallet.lightning.createInvoice(1, 'test invoice')
-    ).invoice
-    const payment = await fundedWallet.lightning.payInvoice(externalInvoice)
-    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)
-    expect(payment.payment_type).toHaveProperty('internal')
-    if ('internal' in payment.payment_type) {
-      const id = payment.payment_type.internal
-      await new Promise<void>((resolve, reject) => {
-        const unsubscribe = fundedWallet.lightning.subscribeInternalPayment(
-          id,
-          (state) => {
-            try {
-              expect(state).toBeDefined()
-              expect(state).toBe('funding')
-              unsubscribe()
-              resolve()
-            } catch (err) {
-              reject(err)
-            }
-          },
-        )
-      })
-    } else {
-      const id = payment.payment_type.lightning
-      await new Promise<void>((resolve, reject) => {
-        const unsubscribe = fundedWallet.lightning.subscribeLnPay(
-          id,
-          (state) => {
-            try {
-              expect(state).toBeDefined()
-              expect(state).toBe('created')
-              unsubscribe()
-              resolve()
-            } catch (err) {
-              reject(err)
-            }
-          },
-        )
-      })
-    }
-  },
-)

package/src/services/MintService.test.ts

@@ -1,74 +0,0 @@
-import { expect } from 'vitest'
-import { walletTest } from '../test/fixtures'
-
-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 throw if wallet is empty',
-  async ({ wallet }) => {
-    expect(wallet).toBeDefined()
-    expect(wallet.isOpen()).toBe(true)
-
-    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()
-})
-
-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/WalletService.test.ts

@@ -1,59 +0,0 @@
-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))
-  },
-)
-
-walletTest(
-  'generateAddress should always return an address',
-  async ({ wallet }) => {
-    expect(wallet).toBeDefined()
-    expect(wallet.isOpen()).toBe(true)
-    const response = await wallet.wallet.generateAddress()
-
-    expect(response, 'generateAddress').toEqual({
-      deposit_address: expect.any(String),
-      operation_id: expect.any(String),
-    })
-  },
-)
-
-walletTest(
-  'sendOnchain should return an operation ID after sending funds',
-  async ({ fundedWalletBeefy }) => {
-    expect(fundedWalletBeefy).toBeDefined()
-    expect(fundedWalletBeefy.isOpen()).toBe(true)
-
-    const amountSat = 100
-    const address =
-      'bcrt1qphk8q2v8he2autevdcefnnwjl4yc2hm74uuvhaa6nhrnkd3gfrwq6mnr76'
-
-    const response = await fundedWalletBeefy.wallet.sendOnchain(
-      amountSat,
-      address,
-    )
-
-    expect(response, 'send onchain').toEqual({
-      operation_id: expect.any(String),
-    })
-  },
-)