@fedimint/core 0.1.0 → 0.1.1

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