@fedimint/core-web 0.1.0 → 0.1.2

package/src/services/FederationService.ts

@@ -1,216 +0,0 @@
-import type {
-  EcashTransaction,
-  LightningTransaction,
-  LnVariant,
-  MintVariant,
-  OperationKey,
-  OperationLog,
-  Transactions,
-  WalletTransaction,
-  WalletVariant,
-} from '../types'
-import { TransportClient } from '../transport'
-
-export class FederationService {
-  constructor(private client: TransportClient) {}
-
-  async getConfig() {
-    return await this.client.rpcSingle('', 'get_config', {})
-  }
-
-  async getFederationId() {
-    return await this.client.rpcSingle<string>('', 'get_federation_id', {})
-  }
-
-  async getInviteCode(peer: number = 0) {
-    return await this.client.rpcSingle<string | null>('', 'get_invite_code', {
-      peer,
-    })
-  }
-
-  async listOperations(
-    limit?: number,
-    last_seen?: OperationKey,
-  ): Promise<[OperationKey, OperationLog][]> {
-    return await this.client.rpcSingle<[OperationKey, OperationLog][]>(
-      '',
-      'list_operations',
-      {
-        limit: limit ?? null,
-        last_seen: last_seen ?? null,
-      },
-    )
-  }
-
-  async getOperation(operationId: string) {
-    return await this.client.rpcSingle<OperationLog | null>(
-      '',
-      'get_operation',
-      { operation_id: operationId },
-    )
-  }
-
-  async listTransactions(
-    limit?: number,
-    last_seen?: OperationKey,
-  ): Promise<Transactions[]> {
-    const operations = await this.listOperations(limit, last_seen)
-    return operations
-      .filter(
-        (item): item is [OperationKey, OperationLog] =>
-          Array.isArray(item) && item.length === 2,
-      )
-      .filter(([_, op]) => {
-        const { operation_module_kind, meta } = op
-        const variant = meta.variant
-        return (
-          (operation_module_kind === 'ln' &&
-            ((variant as LnVariant).pay || (variant as LnVariant).receive)) ||
-          (operation_module_kind === 'mint' &&
-            ((variant as MintVariant).spend_o_o_b ||
-              (variant as MintVariant).reissuance)) ||
-          (operation_module_kind === 'wallet' &&
-            ((variant as WalletVariant).deposit ||
-              (variant as WalletVariant).withdraw))
-        )
-      })
-      .map(([key, op]) => {
-        const timestamp = key.creation_time
-          ? Math.round(
-              key.creation_time.secs_since_epoch * 1000 +
-                key.creation_time.nanos_since_epoch / 1_000_000,
-            )
-          : 0
-        const operationId = key.operation_id
-        const kind = op.operation_module_kind as 'ln' | 'mint' | 'wallet'
-        const meta = op.meta
-        const variant = meta.variant
-
-        let outcome: string | undefined
-        if (op.outcome && op.outcome.outcome) {
-          if (typeof op.outcome.outcome === 'string') {
-            outcome = op.outcome.outcome
-          } else if (
-            typeof op.outcome.outcome === 'object' &&
-            op.outcome.outcome !== null
-          ) {
-            if ('success' in op.outcome.outcome) outcome = 'success'
-            else if ('canceled' in op.outcome.outcome) outcome = 'canceled'
-            else if ('claimed' in op.outcome.outcome) outcome = 'claimed'
-            else if ('funded' in op.outcome.outcome) outcome = 'funded'
-            else if ('awaiting_funds' in op.outcome.outcome)
-              outcome = 'awaiting_funds'
-            else if ('unexpected_error' in op.outcome.outcome)
-              outcome = 'unexpected_error'
-            else if ('created' in op.outcome.outcome) outcome = 'created'
-            else if ('waiting_for_refund' in op.outcome.outcome)
-              outcome = 'canceled'
-            else if ('awaiting_change' in op.outcome.outcome)
-              outcome = 'pending'
-            else if ('refunded' in op.outcome.outcome) outcome = 'refunded'
-            else if ('waiting_for_payment' in op.outcome.outcome)
-              outcome = 'awaiting_funds'
-            else if ('Created' in op.outcome.outcome) outcome = 'Created'
-            else if ('Success' in op.outcome.outcome) outcome = 'Success'
-            else if ('Refunded' in op.outcome.outcome) outcome = 'Refunded'
-            else if ('UserCanceledProcessing' in op.outcome.outcome)
-              outcome = 'UserCanceledProcessing'
-            else if ('UserCanceledSuccess' in op.outcome.outcome)
-              outcome = 'UserCanceledSuccess'
-            else if ('UserCanceledFailure' in op.outcome.outcome)
-              outcome = 'UserCanceledFailure'
-            else if ('WaitingForTransaction' in op.outcome.outcome)
-              outcome = 'pending'
-            else if ('WaitingForConfirmation' in op.outcome.outcome)
-              outcome = 'pending'
-            else if ('Confirmed' in op.outcome.outcome) outcome = 'Confirmed'
-            else if ('Claimed' in op.outcome.outcome) outcome = 'Claimed'
-            else if ('Failed' in op.outcome.outcome) outcome = 'Failed'
-          }
-        }
-
-        if (kind === 'ln') {
-          const isPay = !!(variant as LnVariant).pay
-          const txId =
-            (variant as LnVariant).pay?.out_point.txid ||
-            (variant as LnVariant).receive?.out_point.txid ||
-            ''
-          const type = (variant as LnVariant).pay ? 'send' : 'receive'
-          const invoice =
-            (variant as LnVariant).pay?.invoice ||
-            (variant as LnVariant).receive?.invoice ||
-            ''
-          const gateway =
-            (variant as LnVariant).pay?.gateway_id ||
-            (variant as LnVariant).receive?.gateway_id ||
-            ''
-          const fee = (variant as LnVariant).pay?.fee
-          const internalPay = (variant as LnVariant).pay?.is_internal_payment
-          const preimage =
-            isPay &&
-            op.outcome?.outcome &&
-            typeof op.outcome.outcome === 'object' &&
-            'success' in op.outcome.outcome
-              ? op.outcome.outcome.success.preimage
-              : undefined
-
-          return {
-            timestamp,
-            operationId,
-            kind,
-            txId,
-            type,
-            invoice,
-            internalPay,
-            fee,
-            gateway,
-            outcome: outcome as LightningTransaction['outcome'],
-          } as LightningTransaction
-        } else if (kind === 'mint') {
-          const txId = (variant as MintVariant).reissuance?.txid
-          const type = (variant as MintVariant).reissuance
-            ? 'reissue'
-            : 'spend_oob'
-          const amountMsats = meta.amount
-          const notes = (variant as MintVariant).spend_o_o_b?.oob_notes
-
-          return {
-            timestamp,
-            type,
-            txId,
-            outcome: outcome as EcashTransaction['outcome'],
-            operationId,
-            amountMsats,
-            notes,
-            kind,
-          } as EcashTransaction
-        } else if (kind === 'wallet') {
-          const type = (variant as WalletVariant).deposit
-            ? 'deposit'
-            : 'withdraw'
-          const address =
-            (variant as WalletVariant).deposit?.address ||
-            (variant as WalletVariant).withdraw?.address ||
-            ''
-          const feeRate = (variant as WalletVariant).withdraw?.fee.fee_rate
-            .sats_per_kvb
-          const amountMsats =
-            (variant as WalletVariant).withdraw?.amountMsats || 0
-
-          return {
-            timestamp,
-            type,
-            onchainAddress: address,
-            fee: feeRate || 0,
-            amountMsats,
-            outcome,
-            kind,
-            operationId,
-          } as WalletTransaction
-        }
-      })
-      .filter(
-        (transaction): transaction is Transactions => transaction !== undefined,
-      )
-  }
-}

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)
-            }
-          },
-        )
-      })
-    }
-  },
-)