ln-service 59.4.1 → 59.6.0

package/test/chainrpc-integration/test_subscribe_to_chain_address.js

@@ -1,119 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createChainAddress} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getChainTransactions} = require('./../../');
-const {getHeight} = require('./../../');
-const {sendToChainAddress} = require('./../../');
-const {subscribeToChainAddress} = require('./../../');
-
-const count = 100;
-const defaultFee = 1e3;
-const defaultVout = 0;
-const format = 'np2wpkh';
-const interval = 1;
-const times = 1500;
-const tokens = 1e8;
-
-// Subscribing to chain transaction confirmations should trigger events
-test(`Subscribe to chain transactions`, async () => {
-  await asyncRetry({interval, times}, async () => {
-    const {kill, nodes} = await spawnLightningCluster({});
-
-    const [{chain, generate, lnd}] = nodes;
-
-    // Wait for chainrpc to be active
-    await asyncRetry({interval, times}, async () => {
-      if (!!(await getChainBalance({lnd})).chain_balance) {
-        return;
-      }
-
-      await generate({});
-
-      await getHeight({lnd});
-
-      throw new Error('ExpectedChainBalance');
-    });
-
-    let firstConf;
-    const {address} = await createChainAddress({format, lnd});
-    const startHeight = (await getHeight({lnd})).current_block_height;
-
-
-    const sub = subscribeToChainAddress({
-      lnd,
-      min_height: startHeight,
-      p2sh_address: address,
-    });
-
-    sub.on('confirmation', conf => firstConf = conf);
-    sub.on('error', err => {});
-
-    await generate({count});
-
-    await sendToChainAddress({lnd, address, tokens});
-
-    const {transactions} = await getChainTransactions({lnd});
-
-    const [{transaction}] = transactions
-      .filter(n => !n.is_confirmed)
-      .filter(n => !!n.is_outgoing);
-
-    if (!transaction) {
-      throw new Error('ExpectedTransactionInSubscribeToChainAddressResult');
-    }
-
-    // Wait for generation to be over
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      if (!firstConf) {
-        throw new Error('ExpectedSubscribeToChainAddressSeesConf');
-      }
-
-      strictEqual(firstConf.block.length, 64, 'Confirmation hash returned');
-      strictEqual(firstConf.height >= 102, true, 'Got confirmation height');
-      strictEqual(firstConf.transaction, transaction, 'Confirmation raw tx');
-
-      return;
-    });
-
-    let secondConf;
-
-    const sub2 = subscribeToChainAddress({
-      lnd,
-      min_confirmations: 6,
-      min_height: startHeight,
-      p2sh_address: address,
-    });
-
-    sub2.on('error', () => {});
-
-    sub2.on('confirmation', conf => secondConf = conf);
-
-    // Wait for generation to be over
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      if (!secondConf) {
-        throw new Error('ExpectedSubscribeToChainAddressSeesConfirmation');
-      }
-
-      strictEqual(secondConf.block.length, 64, 'Confirmation hash returned');
-      strictEqual(secondConf.height >= 102, true, 'Confirmation block height');
-      strictEqual(secondConf.transaction, transaction, '2nd conf tx returned');
-
-      return;
-    });
-
-    [sub, sub2].forEach(n => n.removeAllListeners());
-
-    await kill({});
-  });
-
-  return;
-});

package/test/chainrpc-integration/test_subscribe_to_chain_spend.js

@@ -1,116 +0,0 @@
-const {once} = require('node:events');
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createChainAddress} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getHeight} = require('./../../');
-const {getUtxos} = require('./../../');
-const {sendToChainAddress} = require('./../../');
-const {subscribeToBlocks} = require('./../../');
-const {subscribeToChainSpend} = require('./../../');
-
-const confirmationCount = 6;
-const count = 100;
-const format = 'p2wpkh';
-const interval = 1;
-const race = promises => Promise.race(promises);
-const size = 2;
-const times = 1000;
-const tokens = 1e6;
-
-// Subscribing to chain spend should push events on spend confirmations
-test(`Subscribe to chain spend`, async () => {
-  let gotAddressConf = false;
-
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target] = nodes;
-
-  const cluster = {control, target};
-
-  const {address} = await createChainAddress({lnd: target.lnd});
-  const {lnd} = control;
-
-  // Wait for chainrpc to be active
-  await control.generate({count});
-
-  const startHeight = (await getHeight({lnd})).current_block_height;
-
-  await asyncRetry({interval, times}, async () => {
-    const subBlocks = subscribeToBlocks({lnd});
-
-    const [event] = await race([
-      once(subBlocks, 'block'),
-      once(subBlocks, 'error'),
-    ]);
-
-    if (!event.height) {
-      throw new Error('ExpectedBlockEvent');
-    }
-  });
-
-  const sent = await asyncRetry({times}, async () => {
-    await control.generate({});
-
-    return await sendToChainAddress({address, lnd, tokens});
-  });
-
-  await control.generate({count: 1});
-
-  const {utxos} = await getUtxos({lnd});
-
-  const [utxo] = utxos.filter(n => n.address_format === 'p2wpkh');
-
-  await control.generate({count});
-
-  const sub = subscribeToChainSpend({
-    lnd,
-    bech32_address: utxo.address,
-    min_height: startHeight,
-    transaction_id: utxo.transaction_id,
-    transaction_vout: utxo.transaction_vout,
-  });
-
-  sub.on('error', err => {});
-
-  sub.once('confirmation', ({height, transaction, vin}) => {
-    strictEqual(!!height, true, 'Height of the confirmation is returned');
-    strictEqual(!!transaction, true, 'Raw transaction is returned');
-    strictEqual(vin !== undefined, true, 'Transaction input index returned');
-
-    return gotAddressConf = true;
-  });
-
-  const toTarget = await createChainAddress({lnd: target.lnd});
-
-  // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    try {
-      await sendToChainAddress({
-        lnd,
-        address: toTarget.address,
-        is_send_all: true,
-      });
-    } catch (err) {
-    }
-
-    // Generate to confirm the tx
-    await control.generate({count: confirmationCount});
-
-    if (!gotAddressConf) {
-      throw new Error('ExpectedSubscribeToAddressSeesConfirmation');
-    }
-
-    return;
-  });
-
-  await kill({});
-
-  strictEqual(gotAddressConf, true, 'Subscribe to address sees confirmation');
-
-  return;
-});

package/test/integration/test_add_peer.js

@@ -1,59 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {getPeers} = require('./../../');
-
-const interval = 100;
-const size = 2;
-const times = 4000;
-const timeout = 100;
-
-// Adding peers should result in a connected peer
-test(`Add a peer`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  try {
-    const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
-
-    strictEqual(
-      connectedKeys.find(n => n === target.id),
-      undefined,
-      'No peer'
-    );
-
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      await addPeer({
-        lnd,
-        timeout,
-        public_key: target.id,
-        retry_count: 1,
-        retry_delay: 1,
-        socket: target.socket,
-      });
-
-      const {peers} = await getPeers({lnd});
-
-      const connected = peers.find(n => n.public_key === target.id);
-
-      if (!connected) {
-        throw new Error('ExpectedConnectionToTarget');
-      }
-
-      strictEqual(connected.public_key, target.id, 'Connected to remote node');
-    });
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error');
-  } finally {
-    await kill({});
-  }
-
-  return;
-});

package/test/integration/test_cancel_pending_channel.js

@@ -1,46 +0,0 @@
-const test = require('node:test');
-
-const asyncEach = require('async/each');
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {cancelPendingChannel} = require('./../../');
-const {openChannels} = require('./../../');
-
-const capacity = 1e6;
-const count = 100;
-const delay = n => new Promise(resolve => setTimeout(resolve, n));
-const interval = 100;
-const race = promises => Promise.race(promises);
-const size = 2;
-const timeout = 1000 * 5;
-const times = 200;
-
-// Cancel a channel should result in no pending channels
-test(`Cancel pending channel`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  await generate({count});
-
-  const channels = [{capacity, partner_public_key: target.id}];
-
-  await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    const toCancel = await race([
-      delay(timeout),
-      openChannels({channels, lnd}),
-    ]);
-
-    const [{id}] = toCancel.pending;
-
-    await cancelPendingChannel({id, lnd});
-  });
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_close_channel.js

@@ -1,60 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {closeChannel} = require('./../../');
-
-const size = 2;
-
-// Closing a channel should close the channel
-test(`Close channel`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target] = nodes;
-
-  // Force close channel using tx id and vout
-  try {
-    const channelOpen = await setupChannel({
-      generate: control.generate,
-      lnd: control.lnd,
-      to: target,
-    });
-
-    const channelClose = await closeChannel({
-      is_force_close: true,
-      lnd: control.lnd,
-      transaction_id: channelOpen.transaction_id,
-      transaction_vout: channelOpen.transaction_vout,
-    });
-
-    strictEqual(channelClose.transaction_id.length, 64, 'Got force close id');
-    strictEqual(channelClose.transaction_vout, 0, 'Force close vout returned');
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error force closing');
-  }
-
-  // Coop close channel using the channel id
-  try {
-    const channelOpen = await setupChannel({
-      generate: control.generate,
-      lnd: control.lnd,
-      to: target,
-    });
-
-    const channelClose = await closeChannel({
-      id: channelOpen.id,
-      lnd: control.lnd,
-    });
-
-    strictEqual(channelClose.transaction_id.length, 64, 'Got coop close id');
-    strictEqual(channelClose.transaction_vout, 0, 'Got coop close tx vout');
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error coop closing');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_close_wait_pending.js

@@ -1,121 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncAuto = require('async/auto');
-const asyncRetry = require('async/retry');
-const {cancelHodlInvoice} = require('./../../');
-const {createHodlInvoice} = require('./../../');
-const {getInvoice} = require('./../../');
-const {getChannels} = require('./../../');
-const {getClosedChannels} = require('./../../');
-const {pay} = require('./../../');
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {closeChannel} = require('./../../');
-
-const interval = 100;
-const size = 2;
-const times = 1000;
-const tokens = 10;
-
-// Closing a pending payments channel should close the channel after a wait
-test(`Close channel with wait for pending`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target] = nodes;
-
-  try {
-    // Open a channel from control to target
-    const channelOpen = await setupChannel({
-      generate: control.generate,
-      lnd: control.lnd,
-      to: target,
-    });
-
-    // Create a hold invoice to create the pending state
-    const invoice = await createHodlInvoice({tokens, lnd: target.lnd});
-
-    await asyncAuto({
-      makePayment: async () => {
-        // Pay to the hold invoice
-        try {
-          await pay({lnd: control.lnd, request: invoice.request});
-        } catch (err) {
-          const [, type] = err;
-
-          // We expect that it would be canceled back
-          equal(type, 'PaymentRejectedByDestination');
-        }
-      },
-
-      // Wait for the payment to be held
-      lookForPayment: async () => {
-        await asyncRetry({interval, times}, async () => {
-          const received = await getInvoice({id: invoice.id, lnd: target.lnd});
-
-          if (!received.is_held) {
-            throw new Error('ExpectedPaymentHeld');
-          }
-        });
-      },
-
-      // Start the closing process
-      closeChannel: ['lookForPayment', async () => {
-        try {
-          await closeChannel({
-            id: channelOpen.id,
-            is_graceful_close: true,
-            lnd: control.lnd,
-          });
-        } catch (err) {
-          const [,, error] = err;
-
-          const {details} = error.err;
-
-          // LND 0.17.5 and below do not support graceful closes
-          if (details === 'cannot co-op close channel with active htlcs') {
-            throw new Error('FeatureUnsupported');
-          }
-
-          throw err;
-        }
-      }],
-
-      // Wait for channel to be in closing mode
-      confirmClosing: ['lookForPayment', async () => {
-        await asyncRetry({interval, times}, async () => {
-          const {channels} = await getChannels({lnd: control.lnd});
-
-          if (!channels.filter(n => !n.is_active).length) {
-            throw new Error('ExpectedInactiveChannels');
-          }
-        });
-      }],
-
-      // Stop the payment to void the pending state
-      cancelPayment: ['confirmClosing', async () => {
-        await cancelHodlInvoice({id: invoice.id, lnd: target.lnd});
-      }],
-
-      // Confirm that the channel closed cleanly
-      confirmClosed: ['cancelPayment', async () => {
-        await asyncRetry({interval, times}, async () => {
-          const {channels} = await getClosedChannels({lnd: control.lnd});
-
-          await control.generate({});
-
-          if (!channels.filter(n => !!n.is_cooperative_close).length) {
-            throw new Error('ExpectedCooperativelyClosedChannels');
-          }
-        });
-      }],
-    });
-  } catch (err) {
-    equal(err.message, 'FeatureUnsupported', 'Expected no error');
-  } finally {
-    await kill({});
-  }
-
-  return;
-});

package/test/integration/test_create_chain_address.js

@@ -1,63 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const {decodeBase58Address} = require('@alexbosworth/blockchain');
-const {decodeBech32Address} = require('@alexbosworth/blockchain');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createChainAddress} = require('./../../');
-
-const formats = ['np2wpkh', 'p2wpkh'];
-const p2shAddressVersion = 196;
-const p2trProgramLength = 32;
-const p2trVersion = 1;
-const pkHashByteLength = 20;
-const prefixForV1 = 'bcrt1p';
-const regtestBech32AddressHrp = 'bcrt';
-
-// Creating addresses should result in addresses
-test(`Create address results in address creation`, async () => {
-  const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
-
-  const createNewChainAddresses = formats
-    .map(async format => await createChainAddress({lnd, format}));
-
-  const [np2wpkh, p2wpkh] = await Promise.all(createNewChainAddresses);
-
-  const nativeAddress = decodeBech32Address({address: p2wpkh.address});
-  const nestedAddress = decodeBase58Address({address: np2wpkh.address});
-
-  equal(nativeAddress.program.length, pkHashByteLength, 'Native addr pkHash');
-  equal(nativeAddress.prefix, regtestBech32AddressHrp, 'Native addr prefix');
-  equal(nestedAddress.version, p2shAddressVersion, 'Nested address version');
-
-  const getUnused = formats.map(async format => {
-    return await createChainAddress({lnd, format, is_unused: true});
-  });
-
-  const [unusedNp2wpkh, unusedP2wpkh] = await Promise.all(getUnused);
-
-  equal(np2wpkh.address, unusedNp2wpkh.address, 'Nested is reused');
-  equal(p2wpkh.address, unusedP2wpkh.address, 'Native is reused');
-
-  try {
-    const {address} = await createChainAddress({lnd, format: 'p2tr'});
-
-    equal(address.startsWith(prefixForV1), true, 'A taproot address is made');
-
-    const p2trAddress = decodeBech32Address({address});
-
-    equal(p2trAddress.prefix, regtestBech32AddressHrp, 'addr has p2tr prefix');
-    equal(p2trAddress.program.length, p2trProgramLength, 'P2TR addr length');
-    equal(p2trAddress.version, p2trVersion, 'address has the P2TR version');
-  } catch (err) {
-    // LND 0.14.5 and below do not support TR addresses
-    const [code] = err;
-
-    equal(code, 501, 'Taproot addresses are unsupported');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_create_invoice.js

@@ -1,49 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createInvoice} = require('./../../');
-const {parsePaymentRequest} = require('./../../');
-
-const count = 100;
-
-// createInvoice should result in a created invoice
-test(`Create an invoice`, async () => {
-  const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
-
-  await generate({count});
-
-  try {
-    const invoice = await createInvoice({lnd});
-
-    const parsed = parsePaymentRequest({request: invoice.request});
-
-    strictEqual(invoice.chain_address, undefined, 'Address is undefined');
-    strictEqual(invoice.created_at, parsed.created_at, 'Invoice created date');
-    strictEqual(invoice.description, undefined, 'Description undefined');
-    strictEqual(invoice.id, parsed.id, 'Invoice has id');
-    strictEqual(invoice.mtokens, '0', 'Default mtokens are 0');
-    strictEqual(!!invoice.request, true, 'Invoice has request');
-    strictEqual(!!invoice.secret, true, 'Invoice returns secret');
-    strictEqual(invoice.tokens, 0, 'Default tokens are 0');
-
-    try {
-      const duplicate = await createInvoice({lnd, secret: invoice.secret});
-
-      equal(duplicate, null, 'Expected no duplicate invoice');
-    } catch (err) {
-      const [code, message] = err;
-
-      strictEqual(code, 409, 'Got expected error code');
-      strictEqual(message, 'InvoiceWithGivenHashAlreadyExists', 'Got msg');
-    }
-
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error in create invoice');
-  }
-
-  await kill({});
-
-  return;
-});