@fedimint/core-web 0.0.11 → 0.1.0

package/src/services/FederationService.ts

@@ -1,8 +1,18 @@
-import type { JSONValue } from '../types'
-import { WorkerClient } from '../worker'
+import type {
+  EcashTransaction,
+  LightningTransaction,
+  LnVariant,
+  MintVariant,
+  OperationKey,
+  OperationLog,
+  Transactions,
+  WalletTransaction,
+  WalletVariant,
+} from '../types'
+import { TransportClient } from '../transport'
 
 export class FederationService {
-  constructor(private client: WorkerClient) {}
+  constructor(private client: TransportClient) {}
 
   async getConfig() {
     return await this.client.rpcSingle('', 'get_config', {})
@@ -18,7 +28,189 @@ export class FederationService {
     })
   }
 
-  async listOperations() {
-    return await this.client.rpcSingle<JSONValue[]>('', 'list_operations', {})
+  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

@@ -206,3 +206,60 @@ walletTest(
     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/LightningService.ts

@@ -1,16 +1,17 @@
-import { WorkerClient } from '../worker'
+import { TransportClient } from '../transport'
 import type {
   CreateBolt11Response,
   GatewayInfo,
   JSONObject,
   LightningGateway,
+  LnInternalPayState,
   LnPayState,
   LnReceiveState,
   OutgoingLightningPayment,
 } from '../types'
 
 export class LightningService {
-  constructor(private client: WorkerClient) {}
+  constructor(private client: TransportClient) {}
 
   /** https://web.fedimint.org/core/FedimintWallet/LightningService/createInvoice#lightning-createinvoice */
   async createInvoice(
@@ -141,6 +142,20 @@ export class LightningService {
     })
   }
 
+  subscribeInternalPayment(
+    operation_id: string,
+    onSuccess: (state: LnInternalPayState) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    return this.client.rpcStream(
+      'ln',
+      'subscribe_internal_pay',
+      { operation_id: operation_id },
+      onSuccess,
+      onError,
+    )
+  }
+
   // TODO: Document
   subscribeLnClaim(
     operationId: string,

package/src/services/MintService.test.ts

@@ -31,3 +31,44 @@ walletTest('parseNotes should parse notes', async ({ wallet }) => {
 
   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/MintService.ts

@@ -1,16 +1,17 @@
-import { WorkerClient } from '../worker'
+import { TransportClient } from '../transport'
 import type {
   Duration,
   JSONObject,
   JSONValue,
   MintSpendNotesResponse,
   MSats,
+  NoteCountByDenomination,
   ReissueExternalNotesState,
   SpendNotesState,
 } from '../types'
 
 export class MintService {
-  constructor(private client: WorkerClient) {}
+  constructor(private client: TransportClient) {}
 
   /** https://web.fedimint.org/core/FedimintWallet/MintService/redeemEcash */
   async redeemEcash(notes: string) {
@@ -117,4 +118,12 @@ export class MintService {
       operation_id: operationId,
     })
   }
+
+  async getNotesByDenomination() {
+    return await this.client.rpcSingle<NoteCountByDenomination>(
+      'mint',
+      'note_counts_by_denomination',
+      {},
+    )
+  }
 }

package/src/services/RecoveryService.ts

@@ -1,8 +1,8 @@
 import type { JSONValue } from '../types'
-import { WorkerClient } from '../worker'
+import { TransportClient } from '../transport'
 
 export class RecoveryService {
-  constructor(private client: WorkerClient) {}
+  constructor(private client: TransportClient) {}
 
   async hasPendingRecoveries() {
     return await this.client.rpcSingle<boolean>(

package/src/services/WalletService.test.ts

@@ -0,0 +1,59 @@
+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),
+    })
+  },
+)

package/src/services/WalletService.ts

@@ -0,0 +1,50 @@
+import {
+  JSONValue,
+  WalletSummary,
+  GenerateAddressResponse,
+  WalletDepositState,
+} from '../types'
+import { TransportClient } from '../transport'
+
+export class WalletService {
+  constructor(private client: TransportClient) {}
+
+  async getWalletSummary(): Promise<WalletSummary> {
+    return await this.client.rpcSingle('wallet', 'get_wallet_summary', {})
+  }
+
+  async generateAddress(extraMeta: JSONValue = {}) {
+    return await this.client.rpcSingle<GenerateAddressResponse>(
+      'wallet',
+      'peg_in',
+      {
+        extra_meta: extraMeta,
+      },
+    )
+  }
+
+  async sendOnchain(
+    amountSat: number,
+    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,
+    })
+  }
+  subscribeDeposit(
+    operation_id: string,
+    onSuccess: (state: WalletDepositState) => void = () => {},
+    onError: (error: string) => void = () => {},
+  ) {
+    return this.client.rpcStream(
+      'ln',
+      'subscribe_deposit',
+      { operation_id: operation_id },
+      onSuccess,
+      onError,
+    )
+  }
+}

package/src/services/index.ts

@@ -3,3 +3,4 @@ export { BalanceService } from './BalanceService'
 export { LightningService } from './LightningService'
 export { RecoveryService } from './RecoveryService'
 export { FederationService } from './FederationService'
+export { WalletService } from './WalletService'

package/src/test/TestFedimintWallet.ts

@@ -1,26 +1,31 @@
 import { FedimintWallet } from '../FedimintWallet'
-import { WorkerClient } from '../worker/WorkerClient'
+import { TransportClient } from '../transport/TransportClient'
 import { TestingService } from './TestingService'
 
 export class TestFedimintWallet extends FedimintWallet {
   public testing: TestingService
 
-  constructor() {
-    super()
-    this.testing = new TestingService(this.getWorkerClient(), this.lightning)
+  constructor(_client: TransportClient) {
+    super(_client)
+    this.testing = new TestingService(_client, this.lightning)
   }
 
-  async fundWallet(amount: number) {
+  async fundWallet(amountMSats: number) {
     const info = await this.testing.getFaucetGatewayInfo()
-    const invoice = await this.lightning.createInvoice(amount, '', 1000, info)
+    const invoice = await this.lightning.createInvoice(
+      amountMSats,
+      '',
+      1000,
+      info,
+    )
     await Promise.all([
       this.testing.payFaucetInvoice(invoice.invoice),
       this.lightning.waitForReceive(invoice.operation_id),
     ])
   }
 
-  // Method to expose the WorkerClient
-  getWorkerClient(): WorkerClient {
+  // Method to expose the TransportClient
+  getTransportClient(): TransportClient {
     return this['_client']
   }
 }

package/src/test/TestWalletDirector.ts

@@ -0,0 +1,14 @@
+import { WasmWorkerTransport } from '../transport/wasmTransport/WasmWorkerTransport'
+import { Transport } from '../types'
+import { WalletDirector } from '../WalletDirector'
+import { TestFedimintWallet } from './TestFedimintWallet'
+
+export class TestWalletDirector extends WalletDirector {
+  constructor(client: Transport = new WasmWorkerTransport()) {
+    super(client)
+  }
+  async createTestWallet() {
+    await this._client.initialize()
+    return new TestFedimintWallet(this._client)
+  }
+}

package/src/test/TestingService.ts

@@ -1,15 +1,15 @@
 import { LightningService } from '../services'
-import { WorkerClient } from '../worker'
+import { TransportClient } from '../transport'
 
 export const TESTING_INVITE =
   'fed11qgqrsdnhwden5te0v9cxjtt4dekxzamxw4kz6mmjvvkhydted9ukg6r9xfsnx7th0fhn26tf093juamwv4u8gtnpwpcz7qqpyz0e327ua8geceutfrcaezwt22mk6s2rdy09kg72jrcmncng2gn0kp2m5sk'
 
 // This is a testing service that allows for inspecting the internals
-// of the WorkerClient. It is not intended for use in production.
+// of the TransportClient. It is not intended for use in production.
 export class TestingService {
   public TESTING_INVITE: string
   constructor(
-    private client: WorkerClient,
+    private client: TransportClient,
     private lightning: LightningService,
   ) {
     // Solo Mint on mutinynet
@@ -25,7 +25,7 @@ export class TestingService {
   }
 
   async getInviteCode() {
-    const res = await fetch('http://localhost:15243/connect-string')
+    const res = await fetch(`${import.meta.env.FAUCET}/connect-string`)
     if (res.ok) {
       return await res.text()
     } else {
@@ -34,7 +34,7 @@ export class TestingService {
   }
 
   private async getFaucetGatewayApi() {
-    const res = await fetch('http://localhost:15243/gateway-api')
+    const res = await fetch(`${import.meta.env.FAUCET}/gateway-api`)
     if (res.ok) {
       return await res.text()
     } else {
@@ -43,6 +43,7 @@ export class TestingService {
   }
 
   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)
@@ -53,7 +54,7 @@ export class TestingService {
   }
 
   async payFaucetInvoice(invoice: string) {
-    const res = await fetch('http://localhost:15243/pay', {
+    const res = await fetch(`${import.meta.env.FAUCET}/pay`, {
       method: 'POST',
       body: invoice,
     })
@@ -65,7 +66,7 @@ export class TestingService {
   }
 
   async createFaucetInvoice(amount: number) {
-    const res = await fetch('http://localhost:15243/invoice', {
+    const res = await fetch(`${import.meta.env.FAUCET}/invoice`, {
       method: 'POST',
       body: amount.toString(),
     })