@fedimint/core-web 0.1.0 → 0.1.2

package/src/transport/wasmTransport/worker.test.ts

@@ -1,90 +0,0 @@
-import { expect } from 'vitest'
-import { TESTING_INVITE } from '../../test/TestingService'
-import { JSONObject } from '../../types'
-import { workerTest } from '../../test/fixtures'
-
-// Waits for a message of a given type from the worker
-const waitForWorkerResponse = (
-  worker: Worker,
-  messageType: string,
-): Promise<JSONObject> => {
-  return new Promise((resolve, reject) => {
-    worker.onmessage = (event) => {
-      if (event.data.type === messageType) {
-        resolve(event.data)
-      } else if (event.data.type === 'error') {
-        reject(event.data.error)
-      }
-    }
-    worker.onerror = (error) => {
-      reject(error.message)
-    }
-  })
-}
-
-workerTest(
-  'should initialize WasmClient on init message',
-  async ({ worker }) => {
-    worker.postMessage({ type: 'init', requestId: 1 })
-    const response = await waitForWorkerResponse(worker, 'initialized')
-    expect(response.data).toEqual({})
-  },
-)
-
-workerTest(
-  'should return false on open for a new client',
-  async ({ worker, clientName }) => {
-    worker.postMessage({ type: 'init', requestId: 1 })
-    await waitForWorkerResponse(worker, 'initialized')
-
-    worker.postMessage({
-      type: 'open',
-      requestId: 2,
-      payload: { clientName },
-    })
-    const response = await waitForWorkerResponse(worker, 'open')
-    expect(response.data).toEqual({ success: false })
-  },
-)
-
-workerTest(
-  'should error on fake federation invitation',
-  async ({ worker, clientName }) => {
-    worker.postMessage({ type: 'init', requestId: 1 })
-    await waitForWorkerResponse(worker, 'initialized')
-
-    worker.postMessage({
-      type: 'join',
-      requestId: 2,
-      payload: { inviteCode: 'fakefederationinvitation', clientName },
-    })
-    try {
-      await waitForWorkerResponse(worker, 'open')
-      expect.unreachable()
-    } catch (e) {
-      expect(e).toBe('parsing failed')
-    }
-  },
-)
-
-workerTest(
-  'should handle joining a federation',
-  async ({ worker, clientName }) => {
-    worker.postMessage({ type: 'init', requestId: 1 })
-    await waitForWorkerResponse(worker, 'initialized')
-
-    worker.postMessage({
-      type: 'join',
-      requestId: 2,
-      payload: { inviteCode: TESTING_INVITE, clientName },
-    })
-    const response = await waitForWorkerResponse(worker, 'join')
-    expect(response.data).toEqual({ success: true })
-  },
-)
-
-workerTest('should handle unknown message type', async ({ worker }) => {
-  worker.postMessage({ type: 'unknown', requestId: 2 })
-  const response = await waitForWorkerResponse(worker, 'error')
-  expect(response.error).toBe('Unknown message type')
-})

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from './wallet'
-export * from './utils'
-export * from './transport'

package/src/types/transport.ts

@@ -1,54 +0,0 @@
-import type { JSONValue } from './utils'
-
-const TransportMessageTypes = [
-  'init',
-  'initialized',
-  'rpc',
-  'log',
-  'open',
-  'join',
-  'error',
-  'unsubscribe',
-  'cleanup',
-  'parseInviteCode',
-  'parseBolt11Invoice',
-  'previewFederation',
-] as const
-
-export type TransportMessageType = (typeof TransportMessageTypes)[number]
-
-export type TransportRequest = {
-  type: TransportMessageType
-  requestId?: number
-  payload?: JSONValue
-}
-
-export type TransportMessage = {
-  type: TransportMessageType | string
-  requestId?: number
-} & Record<string, unknown>
-
-export type TransportMessageHandler = (message: TransportMessage) => void
-
-export type TransportErrorHandler = (error: unknown) => void
-
-/**
- * Generic Transport interface for communicating with a specific
- * target of the FedimintClient. Can be Wasm, React Native, Node, etc.
- */
-export interface Transport {
-  postMessage(message: TransportRequest): void
-  setMessageHandler(handler: TransportMessageHandler): void
-  setErrorHandler(handler: TransportErrorHandler): void
-  logger: TransportLogger
-}
-
-/**
- * Generic logger interface based on browser console.log
- */
-export type TransportLogger = {
-  debug(message: string, ...args: any[]): void
-  info(message: string, ...args: any[]): void
-  warn(message: string, ...args: any[]): void
-  error(message: string, ...args: any[]): void
-}

package/src/types/utils.ts

@@ -1,29 +0,0 @@
-type Alias<T> = T & {}
-type Resolve<T> = T & unknown
-
-type Seconds = Alias<number>
-type Nanos = Alias<number>
-
-type Duration = {
-  nanos: Nanos
-  secs: Seconds
-}
-
-type MSats = Alias<number>
-type Sats = Alias<number>
-
-type JSONValue =
-  | string
-  | number
-  | boolean
-  | null
-  | { [key: string]: JSONValue }
-  | JSONValue[]
-
-type JSONObject = Record<string, JSONValue>
-
-type Result<T, U = string> =
-  | { success: true; data?: T }
-  | { success: false; error: U }
-
-export { Alias, Resolve, Duration, MSats, Sats, JSONValue, JSONObject, Result }

package/src/types/wallet.ts

@@ -1,298 +0,0 @@
-import { MSats, Duration, JSONValue, JSONObject } from './utils'
-
-const MODULE_KINDS = ['', 'ln', 'mint', 'wallet'] as const
-type ModuleKind = (typeof MODULE_KINDS)[number]
-
-// TODO: Define the structure of FederationConfig
-type FederationConfig = JSONObject
-
-type GatewayInfo = {
-  gateway_id: string
-  api: string
-  node_pub_key: string
-  federation_index: number
-  route_hints: RouteHint[]
-  fees: FeeToAmount
-}
-type LightningGateway = {
-  info: GatewayInfo
-  vetted: boolean
-  ttl: Duration
-}
-
-type RouteHint = {
-  // TODO: Define the structure of RouteHint
-}
-
-type FeeToAmount = {
-  // TODO: Define the structure of FeeToAmount
-}
-
-type OutgoingLightningPayment = {
-  payment_type: PayType
-  contract_id: string
-  fee: MSats
-}
-
-type PayType = { lightning: string } | { internal: string }
-
-type LnPayState =
-  | 'created'
-  | 'canceled'
-  | { funded: { block_height: number } }
-  | { waiting_for_refund: { error_reason: string } }
-  | 'awaiting_change'
-  | { success: { preimage: string } }
-  | { refunded: { gateway_error: string } }
-  | { unexpected_error: { error_message: string } }
-
-type LnReceiveState =
-  | 'created'
-  | { waiting_for_payment: { invoice: string; timeout: number } }
-  | { canceled: { reason: string } }
-  | 'funded'
-  | 'awaiting_funds'
-  | 'claimed'
-
-type LnInternalPayState =
-  | 'funding'
-  | { preimage: string }
-  | { refund_success: { out_points: BtcOutPoint[]; error: string } }
-  | { refund_error: { error_message: string; error: string } }
-  | { funding_failed: { error: string } }
-  | { unexpected_error: string }
-
-type CreateBolt11Response = {
-  operation_id: string
-  invoice: string
-}
-
-type StreamError = {
-  error: string
-  data: never
-  end: never
-}
-
-type StreamSuccess<T extends JSONValue> = {
-  data: T
-  error: never
-  end: never
-}
-
-type StreamEnd = {
-  end: string
-  data: never
-  error: never
-}
-
-type StreamResult<T extends JSONValue> =
-  | StreamSuccess<T>
-  | StreamError
-  | StreamEnd
-
-type CancelFunction = () => void
-
-type ReissueExternalNotesState = 'Created' | 'Issuing' | 'Done'
-// | { Failed: { error: string } }
-
-type MintSpendNotesResponse = Array<string>
-
-type SpendNotesState =
-  | 'Created'
-  | 'UserCanceledProcessing'
-  | 'UserCanceledSuccess'
-  | 'UserCanceledFailure'
-  | 'Success'
-  | 'Refunded'
-
-type TxOutputSummary = {
-  outpoint: {
-    txid: string
-    vout: number
-  }
-  amount: number
-}
-
-type BtcOutPoint = {
-  txid: string
-  vout: number
-}
-
-type WalletDepositState =
-  | 'WaitingForTransaction'
-  | {
-      WaitingForConfirmation: {
-        btc_deposited: number
-        btc_out_point: BtcOutPoint
-      }
-    }
-  | { Confirmed: { btc_deposited: number; btc_out_point: BtcOutPoint } }
-  | { Claimed: { btc_deposited: number; btc_out_point: BtcOutPoint } }
-  | { Failed: string }
-
-type WalletSummary = {
-  spendable_utxos: TxOutputSummary[]
-  unsigned_peg_out_txos: TxOutputSummary[]
-  unsigned_change_utxos: TxOutputSummary[]
-  // TODO: fix typo in rust
-  unconfirmed_peg_out_txos: TxOutputSummary[]
-  unconfirmed_change_utxos: TxOutputSummary[]
-}
-
-type LnVariant = {
-  pay?: {
-    gateway_id: string
-    invoice: string
-    fee: number
-    is_internal_payment: boolean
-    out_point: {
-      out_idx: number
-      txid: string
-    }
-  }
-  receive?: {
-    gateway_id: string
-    invoice: string
-    out_point: {
-      out_idx: number
-      txid: string
-    }
-  }
-}
-
-type MintVariant = {
-  spend_o_o_b?: {
-    requested_amount: number
-    oob_notes: string
-  }
-  reissuance?: {
-    txid: string
-  }
-}
-
-type WalletVariant = {
-  deposit?: {
-    address: string
-    tweak_idx: number
-  }
-  withdraw?: {
-    address: string
-    amountMsats: number
-    fee: {
-      fee_rate: {
-        sats_per_kvb: number
-      }
-      total_weight: number
-    }
-  }
-}
-
-type OperationKey = {
-  creation_time: { nanos_since_epoch: number; secs_since_epoch: number }
-  operation_id: string
-}
-type OperationMeta = {
-  amount: number
-  extra_meta: JSONObject
-  variant: LnVariant | MintVariant | WalletVariant
-}
-
-type OperationLog = {
-  meta: OperationMeta
-  operation_module_kind: string
-  outcome: {
-    outcome: LnPayState | LnReceiveState | SpendNotesState | WalletDepositState
-  }
-}
-
-type BaseTransactions = {
-  timestamp: number
-  operationId: string
-  kind: 'ln' | 'mint' | 'wallet'
-}
-
-type LightningTransaction = BaseTransactions & {
-  type: 'send' | 'receive'
-  invoice: string
-  outcome:
-    | 'created'
-    | 'canceled'
-    | 'claimed'
-    | 'pending'
-    | 'success'
-    | 'funded'
-    | 'awaiting_funds'
-    | 'unexpected_error'
-  gateway: string
-  fee?: number
-  internalPay?: boolean
-  preimage?: string
-  txId: string
-}
-
-type EcashTransaction = BaseTransactions & {
-  type: 'spend_oob' | 'reissue'
-  amountMsats: number
-  outcome?: SpendNotesState | ReissueExternalNotesState
-  notes?: string
-  txId?: string
-}
-
-type WalletTransaction = BaseTransactions & {
-  type: 'withdraw' | 'deposit'
-  onchainAddress: string
-  amountMsats: number
-  fee: number
-  outcome?:
-    | 'WaitingForTransaction'
-    | 'WaitingForConfirmation'
-    | 'Confirmed'
-    | 'Claimed'
-    | 'Failed'
-}
-
-type Transactions = LightningTransaction | EcashTransaction | WalletTransaction
-
-/** Keys are powers of 2 */
-type NoteCountByDenomination = Record<number, number>
-
-type GenerateAddressResponse = {
-  deposit_address: string
-  operation_id: string
-}
-
-export {
-  LightningGateway,
-  FederationConfig,
-  RouteHint,
-  FeeToAmount,
-  OutgoingLightningPayment,
-  PayType,
-  LnPayState,
-  LnReceiveState,
-  CreateBolt11Response,
-  GatewayInfo,
-  StreamError,
-  StreamSuccess,
-  StreamResult,
-  ModuleKind,
-  CancelFunction,
-  LnInternalPayState,
-  ReissueExternalNotesState,
-  MintSpendNotesResponse,
-  SpendNotesState,
-  WalletSummary,
-  TxOutputSummary,
-  NoteCountByDenomination,
-  GenerateAddressResponse,
-  OperationKey,
-  OperationLog,
-  LnVariant,
-  MintVariant,
-  WalletVariant,
-  LightningTransaction,
-  EcashTransaction,
-  WalletTransaction,
-  Transactions,
-  WalletDepositState,
-}

package/src/utils/logger.ts

@@ -1,69 +0,0 @@
-import { TransportLogger } from '../types/transport'
-
-const logLevels = ['debug', 'info', 'warn', 'error', 'none'] as const
-export type LogLevel = (typeof logLevels)[number]
-
-export class Logger {
-  private level: LogLevel
-  private logger: TransportLogger
-
-  /**
-   * Generic Logger for a given environment.
-   *
-   * @param _logger - The transport's logger to use. (console for web, react native, etc.)
-   * @param level - The log level to use. (debug, info, warn, error, none)
-   */
-  constructor(_logger: TransportLogger = console, level: LogLevel = 'none') {
-    this.logger = _logger
-    this.level = level
-  }
-
-  setLevel(level: LogLevel) {
-    this.level = level
-  }
-
-  private coerceLevel(level: string): LogLevel {
-    if (logLevels.includes(level.toLocaleUpperCase() as LogLevel)) {
-      return level.toLocaleUpperCase() as LogLevel
-    }
-    return 'info'
-  }
-
-  log(level: string, message: string, ...args: any[]) {
-    const logLevel = this.coerceLevel(level)
-    if (!this.shouldLog(logLevel)) {
-      return
-    }
-    const consoleFn = this.logger[logLevel]
-    consoleFn(`[${logLevel.toUpperCase()}] ${message}`, ...args)
-  }
-
-  debug(message: string, ...args: any[]) {
-    this.log('debug', message, ...args)
-  }
-
-  info(message: string, ...args: any[]) {
-    this.log('info', message, ...args)
-  }
-
-  warn(message: string, ...args: any[]) {
-    this.log('warn', message, ...args)
-  }
-
-  error(message: string, ...args: any[]) {
-    this.log('error', message, ...args)
-  }
-
-  private shouldLog(
-    messageLevel: LogLevel,
-  ): messageLevel is Exclude<LogLevel, 'none'> {
-    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'none']
-    const messageLevelIndex = levels.indexOf(messageLevel)
-    const currentLevelIndex = levels.indexOf(this.level)
-    return (
-      currentLevelIndex <= messageLevelIndex &&
-      this.level !== 'none' &&
-      messageLevel !== 'none'
-    )
-  }
-}