ln-service 59.5.0 → 59.7.0

package/test/integration/test_open_channels.js

@@ -1,164 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncMap = require('async/map');
-const asyncRetry = require('async/retry');
-const {extractTransaction} = require('psbt');
-const {finalizePsbt} = require('psbt');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-const tinysecp = require('tiny-secp256k1');
-const {transactionAsPsbt} = require('psbt');
-
-const {addPeer} = require('./../../');
-const {createChainAddress} = require('./../../');
-const {fundPendingChannels} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getChainTransactions} = require('./../../');
-const {getChannel} = require('./../../');
-const {getChannels} = require('./../../');
-const {getHeight} = require('./../../');
-const {getPeers} = require('./../../');
-const {openChannels} = require('./../../');
-const {sendToChainAddresses} = require('./../../');
-
-const baseFeeMtokens = '1234';
-const capacity = 1e6;
-const count = 10;
-const defaultBaseFee = '1000';
-const interval = 20;
-const feeRate = 56;
-const maturity = 100;
-const race = promises => Promise.race(promises);
-const size = 3;
-const timeout = 250 * 10;
-const times = 2000;
-
-// Opening channels should open up channels
-test(`Open channels`, async () => {
-  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
-
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  try {
-    await generate({count: maturity});
-
-    await asyncRetry({interval, times}, async () => {
-      const lnds = [lnd, target.lnd, remote.lnd];
-
-      await generate({});
-
-      const heights = await asyncMap(lnds, async lnd => {
-        return (await getHeight({lnd})).current_block_height;
-      });
-
-      const [controlHeight, targetHeight, remoteHeight] = heights;
-
-      if (controlHeight !== targetHeight || controlHeight !== remoteHeight) {
-        throw new Error('ExpectedSyncHeights');
-      }
-    });
-
-    const chainTx = (await getChainTransactions({lnd})).transactions;
-
-    const spending = chainTx.map(({transaction}) => transaction);
-
-    const {address} = await createChainAddress({lnd});
-
-    const channels = [target, remote].map(({id}) => ({
-      capacity,
-      base_fee_mtokens: baseFeeMtokens,
-      cooperative_close_address: address,
-      fee_rate: feeRate,
-      partner_public_key: id,
-    }));
-
-    let pending;
-
-    // Wait for peers to be connected
-    await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-      await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-      if ((await getPeers({lnd})).peers.length !== channels.length) {
-        throw new Error('ExpectedConnectedPeersToOpenChannels');
-      }
-
-      return;
-    });
-
-    await asyncRetry({interval, times}, async () => {
-      pending = (await openChannels({channels, lnd})).pending;
-    });
-
-    // Normally funding would involve an un-broadcast transaction
-    const {id} = await sendToChainAddresses({lnd, send_to: pending});
-
-    await asyncRetry({interval, times}, async () => {
-      const {transactions} = await getChainTransactions({lnd});
-
-      if (!transactions.find(n => n.id === id)) {
-        throw new Error('ExpectedChainTransaction');
-      }
-
-      return;
-    });
-
-    const fundTx = (await getChainTransactions({lnd})).transactions
-      .map(({transaction}) => transaction)
-      .find(transaction => spending.find(spend => transaction !== spend));
-
-    const fundingPsbt = transactionAsPsbt({
-      ecp,
-      spending,
-      transaction: fundTx,
-    });
-
-    const {psbt} = finalizePsbt({ecp, psbt: fundingPsbt.psbt});
-
-    const reconstitutedTransaction = extractTransaction({ecp, psbt});
-
-    await fundPendingChannels({
-      lnd,
-      channels: pending.map(({id}) => id),
-      funding: psbt,
-    });
-
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const {channels} = await getChannels({lnd});
-
-      if (channels.filter(n => !!n.is_active).length !== pending.length) {
-        throw new Error('ExpectedNewChannelsCreatedAndActive');
-      }
-
-      const [channel] = channels;
-
-      strictEqual(channel.cooperative_close_address, address, 'Channel close');
-
-      const {policies} = await getChannel({lnd, id: channel.id});
-
-      const policy = policies.find(n => !!n.cltv_delta);
-
-      // LND 0.15.5 and below do not support setting fees on open
-      if (policy.base_fee_mtokens === defaultBaseFee) {
-        return;
-      }
-
-      strictEqual(policy.base_fee_mtokens, baseFeeMtokens, 'Base fee is set');
-      strictEqual(policy.fee_rate, feeRate, 'Fee rate is set');
-
-      return;
-    });
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    strictEqual(err, null, 'No error is reported');
-  }
-
-  return;
-});

package/test/integration/test_open_low_reserve.js

@@ -1,92 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {getChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-const {openChannel} = require('./../../');
-const {subscribeToOpenRequests} = require('./../../');
-
-const channelCapacityTokens = 1e6;
-const confirmationCount = 6;
-const count = 100;
-const dustLimit = 354;
-const interval = 10;
-const size = 2;
-const times = 2000;
-
-// Open a channel with a low channel reserve
-test(`Open channel but allow a minimal channel reserve`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target] = nodes;
-
-  const {id, lnd} = control;
-
-  await target.generate({count});
-
-  await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-  await asyncRetry({interval, times}, async () => {
-    const wallet = await getWalletInfo({lnd: target.lnd});
-
-    if (!wallet.is_synced_to_chain) {
-      throw new Error('ExpectedWalletSyncedToChain');
-    }
-  });
-
-  const acceptSub = subscribeToOpenRequests({lnd});
-
-  acceptSub.on('channel_request', request => {
-    request.accept({
-      min_confirmations: 1,
-      remote_csv: 999,
-      remote_reserve: 354,
-      remote_max_htlcs: 20,
-      remote_max_pending_mtokens: '200000',
-      remote_min_htlc_mtokens: '2000',
-    });
-
-    return;
-  });
-
-  try {
-    await asyncRetry({interval, times}, async () => {
-      return await openChannel({
-        lnd: target.lnd,
-        is_private: true,
-        is_allowing_minimal_reserve: true,
-        local_tokens: channelCapacityTokens,
-        partner_public_key: control.id,
-        socket: control.socket,
-      });
-    });
-  } catch (err) {
-    equal(err, null, 'Expected no error when a channel is accepted');
-  }
-
-  acceptSub.removeAllListeners();
-
-  await target.generate({count: confirmationCount});
-
-  const channel = await asyncRetry({interval, times}, async () => {
-    const [channel] = (await getChannels({lnd})).channels;
-
-    await control.generate({});
-
-    if (!channel) {
-      throw new Error('ExpectedChannelCreation');
-    }
-
-    return channel;
-  });
-
-  equal(channel.remote_reserve, dustLimit, 'Got minimal reserve value');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_open_simplified_taproot.js

@@ -1,174 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {broadcastChainTransaction} = require('./../../');
-const {fundPendingChannels} = require('./../../');
-const {fundPsbt} = require('./../../');
-const {getChannels} = require('./../../');
-const {openChannel} = require('./../../');
-const {openChannels} = require('./../../');
-const {signPsbt} = require('./../../');
-
-const channelCapacityTokens = 1e6;
-const count = 100;
-const defaultFee = 1e3;
-const description = 'description';
-const interval = 250;
-const size = 2;
-const times = 1000;
-
-// Opening a simplified taproot channel should open a simple taproot channel
-test(`Open simplified taproot channel`, async () => {
-  // Test for LND 0.16.4 or below to exit early and avoid test
-  {
-    const {kill, nodes} = await spawnLightningCluster({size});
-
-    const [{generate, id, lnd}, target] = nodes;
-
-    await generate({count});
-
-    const channelOpen = await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-      return await openChannel({
-        description,
-        lnd,
-        chain_fee_tokens_per_vbyte: defaultFee,
-        local_tokens: channelCapacityTokens,
-        partner_public_key: target.id,
-        socket: target.socket,
-      });
-    });
-
-    const channel = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const {channels} = await getChannels({lnd});
-
-      const [channel] = channels;
-
-      if (!channel) {
-        throw new Error('ExpectedChannelOpened');
-      }
-
-      return channel;
-    });
-
-    await kill({});
-
-    // Exit early when on LND 0.16.4 that do not support simplified taproot
-    if (channel.description !== description) {
-      return;
-    }
-  }
-
-  // Try opening a simplified taproot channel
-  {
-    const {kill, nodes} = await spawnLightningCluster({
-      size,
-      lnd_configuration: ['--protocol.simple-taproot-chans'],
-    });
-
-    const [{generate, id, lnd}, target] = nodes;
-
-    await generate({count});
-
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    const channelOpen = await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-      return await openChannel({
-        lnd,
-        chain_fee_tokens_per_vbyte: defaultFee,
-        is_private: true,
-        is_simplified_taproot: true,
-        local_tokens: channelCapacityTokens,
-        partner_public_key: target.id,
-        socket: target.socket,
-      });
-    });
-
-    const channel = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const {channels} = await getChannels({lnd});
-
-      const [channel] = channels;
-
-      if (!channel) {
-        throw new Error('ExpectedChannelOpened');
-      }
-
-      return channel;
-    });
-
-    equal(channel.type, 'simplified_taproot', 'Opened simplified taproot');
-
-    await kill({});
-  }
-
-  // Try opening a simplified taproot channel via PSBT funding
-  {
-    const {kill, nodes} = await spawnLightningCluster({
-      size,
-      lnd_configuration: ['--protocol.simple-taproot-chans'],
-    });
-
-    const [{generate, id, lnd}, target] = nodes;
-
-    await generate({count});
-
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    const channelOpen = await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-      return await openChannels({
-        lnd,
-        channels: [{
-          capacity: channelCapacityTokens,
-          is_private: true,
-          is_simplified_taproot: true,
-          partner_public_key: target.id,
-        }],
-      });
-    });
-
-    const funded = await fundPsbt({lnd, outputs: channelOpen.pending});
-
-    const signed = await signPsbt({lnd, psbt: funded.psbt});
-
-    await fundPendingChannels({
-      lnd,
-      channels: channelOpen.pending.map(n => n.id),
-      funding: signed.psbt,
-    });
-
-    await broadcastChainTransaction({lnd, transaction: signed.transaction});
-
-    const channel = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const {channels} = await getChannels({lnd});
-
-      const [channel] = channels;
-
-      if (!channel) {
-        throw new Error('ExpectedChannelOpened');
-      }
-
-      return channel;
-    });
-
-    equal(channel.type, 'simplified_taproot', 'Opened simplified taproot');
-
-    await kill({});
-  }
-
-  return;
-});

package/test/integration/test_open_standard_taproot.js

@@ -1,94 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {broadcastChainTransaction} = require('./../../');
-const {fundPendingChannels} = require('./../../');
-const {fundPsbt} = require('./../../');
-const {getChannels} = require('./../../');
-const {openChannel} = require('./../../');
-const {openChannels} = require('./../../');
-const {signPsbt} = require('./../../');
-
-const channelCapacityTokens = 1e6;
-const count = 100;
-const defaultFee = 1e3;
-const description = 'description';
-const interval = 250;
-const size = 2;
-const times = 1000;
-
-// Opening a standard taproot channel should open a standard taproot channel
-test(`Open standard taproot channel`, async () => {
-  // Test for LND 0.20.0 or below to exit early and avoid test
-  {
-  }
-
-  const {kill, nodes} = await spawnLightningCluster({
-    size,
-    lnd_configuration: ['--protocol.simple-taproot-chans'],
-  });
-
-  const [{generate, id, lnd}, target] = nodes;
-
-  // Try opening a standard taproot channel
-  try {
-    await generate({count});
-
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    const channelOpen = await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-      try {
-        return await openChannel({
-          lnd,
-          chain_fee_tokens_per_vbyte: defaultFee,
-          is_private: true,
-          is_standard_taproot: true,
-          local_tokens: channelCapacityTokens,
-          partner_public_key: target.id,
-          socket: target.socket,
-        });
-      } catch (err) {
-        const [code, message, details] = err;
-
-        if (!!details && details.err === 'unhandled request channel type 7') {
-          return;
-        } else {
-          throw err;
-        }
-      }
-    });
-
-    // Exit early when there is no support for standard taproot
-    if (!channelOpen) {
-      return await kill({});
-    }
-
-    const channel = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const {channels} = await getChannels({lnd});
-
-      const [channel] = channels;
-
-      if (!channel) {
-        throw new Error('ExpectedChannelOpened');
-      }
-
-      return channel;
-    });
-
-    equal(channel.type, 'standard_taproot', 'Opened standard taproot');
-  } catch (err) {
-    equal(err, null, 'Expected no error');
-  } finally {
-    await kill({});
-  }
-
-  return;
-});

package/test/integration/test_pay.js

@@ -1,149 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const {randomBytes} = require('node:crypto');
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {createInvoice} = require('./../../');
-const {decodePaymentRequest} = require('./../../');
-const {getHeight} = require('./../../');
-const {getRouteToDestination} = require('./../../');
-const {openChannel} = require('./../../');
-const {pay} = require('./../../');
-
-const confirmationCount = 6;
-const interval = 10;
-const mtokPadding = '000';
-const size = 3;
-const times = 1000;
-const tokens = 100;
-
-// Paying an invoice should settle the invoice
-test(`Pay`, async ({end, equal, strictSame}) => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  try {
-    const channel = await setupChannel({generate, lnd, to: target});
-
-    const remoteChan = await setupChannel({
-      generate: target.generate,
-      lnd: target.lnd,
-      to: remote,
-    });
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-    const commitTxFee = channel.commit_transaction_fee;
-
-    const paid = await asyncRetry({interval, times}, async () => {
-      return await pay({lnd, request: invoice.request});
-    });
-
-    strictEqual(paid.fee, 1, 'Fee paid for hop');
-    strictEqual(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
-    strictEqual(paid.id, invoice.id, 'Payment hash is equal on both sides');
-    strictEqual(paid.is_confirmed, true, 'Invoice is paid');
-    strictEqual(paid.is_outgoing, true, 'Payments are outgoing');
-    strictEqual(paid.mtokens, '101000', 'Paid mtokens');
-    strictEqual(paid.secret, invoice.secret, 'Paid for invoice secret');
-    strictEqual(paid.tokens, invoice.tokens + 1, 'Paid correct number of tok');
-
-    const height = (await getHeight({lnd})).current_block_height;
-
-    paid.hops.forEach(n => {
-      strictEqual(
-        n.timeout === height + 40 ||
-        n.timeout === height + 43 ||
-        n.timeout === height + 80,
-        true
-      );
-
-      delete n.timeout;
-
-      return;
-    });
-
-    const expectedHops = [
-      {
-        channel: channel.id,
-        fee: 1,
-        fee_mtokens: '1000',
-        forward: 100,
-        forward_mtokens: `${invoice.tokens}${mtokPadding}`,
-        public_key: target.id,
-      },
-      {
-        channel: remoteChan.id,
-        fee: 0,
-        fee_mtokens: '0',
-        forward: 100,
-        forward_mtokens: '100000',
-        public_key: remote.id,
-      },
-    ];
-
-    deepStrictEqual(paid.hops, expectedHops, 'Hops are returned');
-
-    const invoice2 = await createInvoice({lnd: remote.lnd, tokens: 100});
-
-    const {destination} = await decodePaymentRequest({
-      lnd: remote.lnd,
-      request: invoice2.request,
-    });
-
-    await generate({count: confirmationCount});
-
-    const route = await asyncRetry({interval, times}, async () => {
-      const {route} = await getRouteToDestination({
-        destination,
-        lnd,
-        payment: invoice2.payment,
-        tokens: invoice2.tokens,
-        total_mtokens: !!invoice2.payment ? invoice2.mtokens : undefined,
-      });
-
-      if (!route) {
-        throw new Error('ExpectedRouteToDestination');
-      }
-
-      return route;
-    });
-
-    // Test paying to a route, but to an id that isn't known
-    try {
-      await pay({
-        lnd,
-        path: {routes: [route], id: randomBytes(32).toString('hex')},
-      });
-    } catch (err) {
-      const [code, message] = err;
-
-      strictEqual(code, 404, 'Unknown payment hashes mean user error');
-      strictEqual(message, 'UnknownPaymentHash', 'Specifically unknown error');
-    }
-
-    // Test paying regularly to a destination
-    const directPay = await pay({
-      lnd,
-      path: {routes: [route], id: invoice2.id},
-    });
-
-    const zeroInvoice = await createInvoice({lnd: target.lnd});
-
-    await pay({lnd, request: zeroInvoice.request, mtokens: '1000'});
-  } catch (err) {
-    strictEqual(err, null, 'Not expecting an error');
-  } finally {
-    await kill({});
-  }
-
-  return;
-});