@fedimint/core-web 0.1.0 → 0.1.2

package/src/test/TestingService.ts

@@ -1,79 +0,0 @@
-import { LightningService } from '../services'
-import { TransportClient } from '../transport'
-
-export const TESTING_INVITE =
-  'fed11qgqrsdnhwden5te0v9cxjtt4dekxzamxw4kz6mmjvvkhydted9ukg6r9xfsnx7th0fhn26tf093juamwv4u8gtnpwpcz7qqpyz0e327ua8geceutfrcaezwt22mk6s2rdy09kg72jrcmncng2gn0kp2m5sk'
-
-// This is a testing service that allows for inspecting the internals
-// of the TransportClient. It is not intended for use in production.
-export class TestingService {
-  public TESTING_INVITE: string
-  constructor(
-    private client: TransportClient,
-    private lightning: LightningService,
-  ) {
-    // Solo Mint on mutinynet
-    this.TESTING_INVITE = TESTING_INVITE
-  }
-
-  getRequestCounter() {
-    return this.client._getRequestCounter()
-  }
-
-  getRequestCallbackMap() {
-    return this.client._getRequestCallbackMap()
-  }
-
-  async getInviteCode() {
-    const res = await fetch(`${import.meta.env.FAUCET}/connect-string`)
-    if (res.ok) {
-      return await res.text()
-    } else {
-      throw new Error(`Failed to get invite code: ${await res.text()}`)
-    }
-  }
-
-  private async getFaucetGatewayApi() {
-    const res = await fetch(`${import.meta.env.FAUCET}/gateway-api`)
-    if (res.ok) {
-      return await res.text()
-    } else {
-      throw new Error(`Failed to get gateway: ${await res.text()}`)
-    }
-  }
-
-  async getFaucetGatewayInfo() {
-    await this.lightning.updateGatewayCache()
-    const gateways = await this.lightning.listGateways()
-    const api = await this.getFaucetGatewayApi()
-    const gateway = gateways.find((g) => g.info.api === api)
-    if (!gateway) {
-      throw new Error(`Gateway not found: ${api}`)
-    }
-    return gateway.info
-  }
-
-  async payFaucetInvoice(invoice: string) {
-    const res = await fetch(`${import.meta.env.FAUCET}/pay`, {
-      method: 'POST',
-      body: invoice,
-    })
-    if (res.ok) {
-      return await res.text()
-    } else {
-      throw new Error(`Failed to pay faucet invoice: ${await res.text()}`)
-    }
-  }
-
-  async createFaucetInvoice(amount: number) {
-    const res = await fetch(`${import.meta.env.FAUCET}/invoice`, {
-      method: 'POST',
-      body: amount.toString(),
-    })
-    if (res.ok) {
-      return await res.text()
-    } else {
-      throw new Error(`Failed to generate faucet invoice: ${await res.text()}`)
-    }
-  }
-}

package/src/test/crypto.ts

@@ -1,44 +0,0 @@
-import * as secp256k1 from 'secp256k1'
-
-const randomBytes = (size: number): Uint8Array => {
-  const array = new Uint8Array(size)
-  window.crypto.getRandomValues(array)
-  return array
-}
-
-interface KeyPair {
-  secretKey: string
-  publicKey: string
-}
-
-export const keyPair = (secretKey?: Uint8Array): KeyPair => {
-  const privateKey: Uint8Array = secretKey
-    ? validatePrivateKey(secretKey)
-    : generatePrivateKey()
-
-  const publicKey = secp256k1.publicKeyCreate(privateKey)
-
-  return {
-    secretKey: Array.from(privateKey)
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join(''), // Convert Uint8Array to hex string
-    publicKey: Array.from(publicKey)
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join(''), // Convert Uint8Array to hex string
-  }
-}
-
-const validatePrivateKey = (key: Uint8Array): Uint8Array => {
-  if (!secp256k1.privateKeyVerify(key)) {
-    throw new Error('Invalid private key provided')
-  }
-  return key
-}
-
-const generatePrivateKey = (): Uint8Array => {
-  let key: Uint8Array
-  do {
-    key = randomBytes(32)
-  } while (!secp256k1.privateKeyVerify(key))
-  return key
-}

package/src/test/fixtures.test.ts

@@ -1,18 +0,0 @@
-import { expect } from 'vitest'
-import { walletTest } from './fixtures'
-
-walletTest('Fund wallet 1', async ({ fundedWallet }) => {
-  expect(fundedWallet).toBeDefined()
-})
-
-walletTest('Fund wallet 2', async ({ fundedWallet }) => {
-  expect(fundedWallet).toBeDefined()
-})
-
-walletTest('Fund wallet 3', async ({ fundedWallet }) => {
-  expect(fundedWallet).toBeDefined()
-})
-
-walletTest('Fund wallet 4', async ({ fundedWallet }) => {
-  expect(fundedWallet).toBeDefined()
-})

package/src/test/fixtures.ts

@@ -1,88 +0,0 @@
-import { expect, test } from 'vitest'
-import { TestFedimintWallet } from './TestFedimintWallet'
-import { TransportClient } from '../transport/TransportClient'
-import { WasmWorkerTransport } from '../transport/wasmTransport/WasmWorkerTransport'
-import { TestWalletDirector } from './TestWalletDirector'
-
-/**
- * Adds Fixtures for setting up and tearing down test FedimintWallet/WalletDirector instances
- */
-export const walletTest = test.extend<{
-  walletDirector: TestWalletDirector
-  wallet: TestFedimintWallet
-  fundedWallet: TestFedimintWallet
-  fundedWalletBeefy: TestFedimintWallet
-  unopenedWallet: TestFedimintWallet
-}>({
-  walletDirector: async ({}, use) => {
-    const walletDirector = new TestWalletDirector()
-    await use(walletDirector)
-  },
-  wallet: async ({ walletDirector }, use) => {
-    const randomTestingId = Math.random().toString(36).substring(2, 15)
-    const wallet = await walletDirector.createTestWallet()
-    expect(wallet).toBeDefined()
-    const inviteCode = await wallet.testing.getInviteCode()
-    await expect(
-      wallet.joinFederation(inviteCode, randomTestingId),
-    ).resolves.toBe(true)
-
-    await use(wallet)
-
-    // clear up browser resources
-    await wallet.cleanup()
-
-    // remove the wallet db
-    await new Promise((resolve) => {
-      const request = indexedDB.deleteDatabase(randomTestingId)
-      request.onsuccess = resolve
-      request.onerror = resolve
-      request.onblocked = resolve
-    })
-  },
-
-  fundedWallet: async ({ wallet }, use) => {
-    // 10K MSats
-    await wallet.fundWallet(10_000)
-    await use(wallet)
-  },
-  fundedWalletBeefy: async ({ wallet }, use) => {
-    // 1M MSats
-    await wallet.fundWallet(1_000_000)
-    await use(wallet)
-  },
-  unopenedWallet: async ({ walletDirector }, use) => {
-    const wallet = await walletDirector.createTestWallet()
-    await use(wallet)
-  },
-})
-
-/**
- * Adds Fixtures for setting up and tearing down a test Worker instance
- */
-export const workerTest = test.extend<{
-  worker: Worker
-  clientName: string
-  transportClient: TransportClient
-}>({
-  worker: async ({}, use) => {
-    const worker = new Worker(
-      new URL('../transport/wasmTransport/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)
-  },
-  transportClient: async ({}, use) => {
-    // TODO: figure out how to use a different transport in runtime depending on the test
-    // Ideally, we don't want to create separate fixtures for each transport
-    const transportClient = new TransportClient(new WasmWorkerTransport())
-    await use(transportClient)
-  },
-})

package/src/transport/TransportClient.test.ts

@@ -1,6 +0,0 @@
-import { expect } from 'vitest'
-import { workerTest } from '../test/fixtures'
-
-workerTest('should initialize', async ({ transportClient }) => {
-  expect(transportClient).toBeDefined()
-})

package/src/transport/TransportClient.ts

@@ -1,251 +0,0 @@
-import type {
-  CancelFunction,
-  JSONValue,
-  ModuleKind,
-  StreamError,
-  StreamResult,
-  TransportMessageType,
-} from '../types'
-import { Logger } from '../utils/logger'
-import type { Transport, TransportMessage } from '../types/transport'
-
-/**
- * Handles communication with a generic transport.
- * Must be instantiated with a platform-specific transport. (wasm for web, react native, etc.)
- */
-export class TransportClient {
-  // Generic Transport. Can be wasm, react native, node, etc.
-  private readonly transport: Transport
-  private requestCounter = 0
-  private requestCallbacks = new Map<number, (value: any) => void>()
-  private initPromise: Promise<boolean> | undefined = undefined
-  logger: Logger
-
-  /**
-   * @summary Constructor for the TransportClient
-   * @param transport - The platform-specific transport to use. (wasm for web, react native, etc.)
-   */
-  constructor(transport: Transport) {
-    this.transport = transport
-    this.logger = new Logger(transport.logger)
-    this.transport.setMessageHandler(this.handleTransportMessage)
-    this.transport.setErrorHandler(this.handleTransportError)
-    this.logger.info('TransportClient instantiated')
-    this.logger.debug('TransportClient transport', transport)
-  }
-
-  // Idempotent setup - Loads the wasm module
-  initialize() {
-    if (this.initPromise) return this.initPromise
-    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)
-  }
-
-  private handleTransportError = (error: unknown) => {
-    this.logger.error('TransportClient error', error)
-  }
-
-  private handleTransportMessage = (message: TransportMessage) => {
-    const { type, requestId, ...data } = message
-    if (type === 'log') {
-      this.handleLogMessage(message)
-    }
-    const streamCallback =
-      requestId !== undefined ? this.requestCallbacks.get(requestId) : undefined
-    // TODO: Handle errors... maybe have another callbacks list for errors?
-    this.logger.debug('TransportClient - handleTransportMessage', message)
-    if (streamCallback) {
-      streamCallback(data) // {data: something} OR {error: something}
-    } else if (requestId !== undefined) {
-      this.logger.warn(
-        'TransportClient - handleTransportMessage - received message with no callback',
-        requestId,
-        message,
-      )
-    }
-  }
-
-  // TODO: Handle errors... maybe have another callbacks list for errors?
-  // TODO: Handle timeouts
-  // TODO: Handle multiple errors
-
-  sendSingleMessage<
-    Response extends JSONValue = JSONValue,
-    Payload extends JSONValue = JSONValue,
-  >(type: TransportMessageType, payload?: Payload) {
-    return new Promise<Response>((resolve, reject) => {
-      const requestId = ++this.requestCounter
-      this.logger.debug(
-        'TransportClient - sendSingleMessage',
-        requestId,
-        type,
-        payload,
-      )
-      this.requestCallbacks.set(
-        requestId,
-        (response: StreamResult<Response>) => {
-          this.requestCallbacks.delete(requestId)
-          this.logger.debug(
-            'TransportClient - sendSingleMessage - response',
-            requestId,
-            response,
-          )
-          if (response.data) resolve(response.data)
-          else if (response.error) reject(response.error)
-          else
-            this.logger.warn(
-              'TransportClient - sendSingleMessage - malformed response',
-              requestId,
-              response,
-            )
-        },
-      )
-      this.transport.postMessage({ type, payload, requestId })
-    })
-  }
-
-  /**
-   * @summary Initiates an RPC stream with the specified module and method.
-   *
-   * @description
-   * This function sets up an RPC stream by sending a request to a worker and
-   * handling responses asynchronously. It ensures that unsubscription is handled
-   * correctly, even if the unsubscribe function is called before the subscription
-   * is fully established, by deferring the unsubscription attempt using `setTimeout`.
-   *
-   * The function operates in a non-blocking manner, leveraging Promises to manage
-   * asynchronous operations and callbacks to handle responses.
-   *
-   *
-   * @template Response - The expected type of the successful response.
-   * @template Body - The type of the request body.
-   * @param module - The module kind to interact with.
-   * @param method - The method name to invoke on the module.
-   * @param body - The request payload.
-   * @param onSuccess - Callback invoked with the response data on success.
-   * @param onError - Callback invoked with error information if an error occurs.
-   * @param onEnd - Optional callback invoked when the stream ends.
-   * @returns A function that can be called to cancel the subscription.
-   *
-   */
-  rpcStream<
-    Response extends JSONValue = JSONValue,
-    Body extends JSONValue = JSONValue,
-  >(
-    module: ModuleKind,
-    method: string,
-    body: Body,
-    onSuccess: (res: Response) => void,
-    onError: (res: StreamError['error']) => void,
-    onEnd: () => void = () => {},
-  ): CancelFunction {
-    const requestId = ++this.requestCounter
-    this.logger.debug(
-      'TransportClient - rpcStream',
-      requestId,
-      module,
-      method,
-      body,
-    )
-    let unsubscribe: (value: void) => void = () => {}
-    let isSubscribed = false
-
-    const unsubscribePromise = new Promise<void>((resolve) => {
-      unsubscribe = () => {
-        if (isSubscribed) {
-          // If already subscribed, resolve immediately to trigger unsubscription
-          resolve()
-        } else {
-          // If not yet subscribed, defer the unsubscribe attempt to the next event loop tick
-          // This ensures that subscription setup has time to complete
-          setTimeout(() => unsubscribe(), 0)
-        }
-      }
-    })
-
-    // Initiate the inner RPC stream setup asynchronously
-    this._rpcStreamInner(
-      requestId,
-      module,
-      method,
-      body,
-      onSuccess,
-      onError,
-      onEnd,
-      unsubscribePromise,
-    ).then(() => {
-      isSubscribed = true
-    })
-
-    return unsubscribe
-  }
-
-  private async _rpcStreamInner<
-    Response extends JSONValue = JSONValue,
-    Body extends JSONValue = JSONValue,
-  >(
-    requestId: number,
-    module: ModuleKind,
-    method: string,
-    body: Body,
-    onSuccess: (res: Response) => void,
-    onError: (res: StreamError['error']) => void,
-    onEnd: () => void = () => {},
-    unsubscribePromise: Promise<void>,
-    // Unsubscribe function
-  ) {
-    this.requestCallbacks.set(requestId, (response: StreamResult<Response>) => {
-      if (response.error !== undefined) {
-        onError(response.error)
-      } else if (response.data !== undefined) {
-        onSuccess(response.data)
-      } else if (response.end !== undefined) {
-        this.requestCallbacks.delete(requestId)
-        onEnd()
-      }
-    })
-    this.transport.postMessage({
-      type: 'rpc',
-      payload: { module, method, body },
-      requestId,
-    })
-
-    unsubscribePromise.then(() => {
-      this.transport.postMessage({
-        type: 'unsubscribe',
-        requestId,
-      })
-      this.requestCallbacks.delete(requestId)
-    })
-  }
-
-  rpcSingle<
-    Response extends JSONValue = JSONValue,
-    Error extends string = string,
-  >(module: ModuleKind, method: string, body: JSONValue) {
-    this.logger.debug('TransportClient - rpcSingle', module, method, body)
-    return new Promise<Response>((resolve, reject) => {
-      this.rpcStream<Response>(module, method, body, resolve, reject)
-    })
-  }
-
-  async cleanup() {
-    await this.sendSingleMessage('cleanup')
-    this.requestCounter = 0
-    this.initPromise = undefined
-    this.requestCallbacks.clear()
-  }
-
-  // For Testing
-  _getRequestCounter() {
-    return this.requestCounter
-  }
-  _getRequestCallbackMap() {
-    return this.requestCallbacks
-  }
-}

package/src/transport/index.ts

@@ -1,2 +0,0 @@
-export { TransportClient } from './TransportClient'
-export { WasmWorkerTransport } from './wasmTransport/WasmWorkerTransport'

package/src/transport/wasmTransport/WasmWorkerTransport.ts

@@ -1,39 +0,0 @@
-import type {
-  Transport,
-  TransportErrorHandler,
-  TransportLogger,
-  TransportMessageHandler,
-  TransportRequest,
-} from '../../types/transport'
-
-export class WasmWorkerTransport implements Transport {
-  private messageHandler: TransportMessageHandler = () => {}
-  private errorHandler: TransportErrorHandler = () => {}
-  private readonly worker: Worker
-
-  logger: TransportLogger = console
-
-  constructor() {
-    this.worker = new Worker(new URL('./worker.js', import.meta.url), {
-      type: 'module',
-    })
-    this.worker.onmessage = (event: MessageEvent) => {
-      this.messageHandler(event.data)
-    }
-    this.worker.onerror = (event: ErrorEvent) => {
-      this.errorHandler(event)
-    }
-  }
-
-  postMessage(message: TransportRequest) {
-    this.worker.postMessage(message)
-  }
-
-  setMessageHandler(handler: TransportMessageHandler) {
-    this.messageHandler = handler
-  }
-
-  setErrorHandler(handler: TransportErrorHandler) {
-    this.errorHandler = handler
-  }
-}

package/src/transport/wasmTransport/worker.js

@@ -1,167 +0,0 @@
-// Web Worker for fedimint-client-wasm to run in the browser
-
-// HACK: Fixes vitest browser runner
-// TODO: remove once https://github.com/vitest-dev/vitest/pull/6569 lands in a release
-globalThis.__vitest_browser_runner__ = { wrapDynamicImport: (foo) => foo() }
-
-// dynamically imported Constructor for WasmClient
-let WasmClient = null
-// client instance
-let client = null
-
-const streamCancelMap = new Map()
-
-const handleFree = (requestId) => {
-  streamCancelMap.delete(requestId)
-}
-
-console.log('Worker - init')
-
-/**
- * Type definitions for the worker messages
- *
- * @typedef {import('../../types/transport').TransportMessageType} WorkerMessageType
- * @typedef {{
- *  type: WorkerMessageType
- *  payload: any
- *  requestId: number
- * }} WorkerMessage
- * @param {{data: WorkerMessage}} event
- */
-self.onmessage = async (event) => {
-  const { type, payload, requestId } = event.data
-
-  try {
-    if (type === 'init') {
-      WasmClient = (await import('@fedimint/fedimint-client-wasm-bundler'))
-        .WasmClient
-      self.postMessage({ type: 'initialized', data: {}, requestId })
-    } else if (type === 'open') {
-      const { clientName } = payload
-      client = (await WasmClient.open(clientName)) || null
-      self.postMessage({
-        type: 'open',
-        data: { success: !!client },
-        requestId,
-      })
-    } else if (type === 'join') {
-      const { inviteCode, clientName: joinClientName } = payload
-      try {
-        client = await WasmClient.join_federation(joinClientName, inviteCode)
-        self.postMessage({
-          type: 'join',
-          data: { success: !!client },
-          requestId,
-        })
-      } catch (e) {
-        self.postMessage({ type: 'error', error: e.message, requestId })
-      }
-    } else if (type === 'previewFederation') {
-      const { inviteCode } = payload
-      try {
-        client = await WasmClient.preview_federation(inviteCode)
-        const parsed = JSON.parse(client)
-        self.postMessage({
-          type: 'previewFederation',
-          data: {
-            success: !!client,
-            config: parsed.config,
-            federation_id: parsed.federation_id,
-          },
-          requestId,
-        })
-      } catch (e) {
-        self.postMessage({ type: 'error', error: e.message, requestId })
-      }
-    } else if (type === 'rpc') {
-      const { module, method, body } = payload
-      console.log('RPC received', module, method, body)
-      if (!client) {
-        self.postMessage({
-          type: 'error',
-          error: 'WasmClient not initialized',
-          requestId,
-        })
-        return
-      }
-      const rpcHandle = await client.rpc(
-        module,
-        method,
-        JSON.stringify(body),
-        (res) => {
-          console.log('RPC response', requestId, res)
-          const data = JSON.parse(res)
-          self.postMessage({ type: 'rpcResponse', requestId, ...data })
-
-          if (data.end !== undefined) {
-            // Handle stream ending
-            const handle = streamCancelMap.get(requestId)
-            handle?.free()
-          }
-        },
-      )
-      streamCancelMap.set(requestId, rpcHandle)
-    } else if (type === 'unsubscribe') {
-      const rpcHandle = streamCancelMap.get(requestId)
-      if (rpcHandle) {
-        rpcHandle.cancel()
-        rpcHandle.free()
-        streamCancelMap.delete(requestId)
-      }
-    } else if (type === 'cleanup') {
-      console.log('cleanup message received')
-      client?.free()
-      self.postMessage({
-        type: 'cleanup',
-        data: {},
-        requestId,
-      })
-      close()
-    } else if (type === 'parseInviteCode') {
-      const { inviteCode } = payload
-      try {
-        const res = WasmClient.parse_invite_code(inviteCode)
-        const parsedRes = JSON.parse(res)
-        self.postMessage({
-          type: 'parseInviteCode',
-          data: parsedRes,
-          requestId,
-        })
-      } catch (error) {
-        self.postMessage({
-          type: 'error',
-          error: `Failed to parse invite code: ${error.message}`,
-          requestId,
-        })
-      }
-    } else if (type === 'parseBolt11Invoice') {
-      const { invoiceStr } = payload
-      try {
-        const res = WasmClient.parse_bolt11_invoice(invoiceStr)
-        const parsedRes = JSON.parse(res)
-        self.postMessage({
-          type: 'parseBolt11Invoice',
-          data: parsedRes,
-          requestId,
-        })
-      } catch (error) {
-        self.postMessage({
-          type: 'error',
-          error: `Failed to parse invoice: ${error.message}`,
-          requestId,
-        })
-      }
-    } else {
-      self.postMessage({
-        type: 'error',
-        error: 'Unknown message type',
-        requestId,
-      })
-    }
-  } catch (e) {
-    console.error('ERROR', e)
-    self.postMessage({ type: 'error', error: e, requestId })
-  }
-}
-
-// self.postMessage({ type: 'init', data: {} })