ln-service 52.14.4 → 53.0.0

package/test/chainrpc-integration/test_subscribe_to_chain_address.js

@@ -1,12 +1,16 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {chainSendTransaction} = require('./../macros');
 const {createChainAddress} = require('./../../');
 const {delay} = require('./../macros');
 const {generateBlocks} = require('./../macros');
+const {getChainBalance} = require('./../../');
+const {getChainTransactions} = require('./../../');
 const {getHeight} = require('./../../');
 const {mineTransaction} = require('./../macros');
+const {sendToChainAddress} = require('./../../');
 const {spawnLnd} = require('./../macros');
 const {subscribeToChainAddress} = require('./../../');
 const {waitForTermination} = require('./../macros');
@@ -15,102 +19,104 @@ const count = 100;
 const defaultFee = 1e3;
 const defaultVout = 0;
 const format = 'np2wpkh';
-const interval = retryCount => 50 * Math.pow(2, retryCount);
-const times = 15;
+const interval = 1;
+const times = 1500;
 const tokens = 1e8;
 
 // Subscribing to chain transaction confirmations should trigger events
 test(`Subscribe to chain transactions`, async ({end, equal, fail}) => {
-  const node = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const cert = node.chain_rpc_cert_file;
-  const host = node.listen_ip;
-  const {kill} = node;
-  const pass = node.chain_rpc_pass;
-  const port = node.chain_rpc_port;
-  const {lnd} = node;
-  const user = node.chain_rpc_user;
+  const [{chain, generate, lnd}] = nodes;
 
-  const startHeight = (await getHeight({lnd})).current_block_height;
+  // Wait for chainrpc to be active
+  await asyncRetry({interval, times}, async () => {
+    if (!!(await getChainBalance({lnd})).chain_balance) {
+      return;
+    }
 
-  const {address} = await createChainAddress({format, lnd});
+    await generate({});
 
-  // Generate some funds for LND
-  const {blocks} = await node.generate({count});
+    await getHeight({lnd});
 
-  const [block] = blocks;
+    throw new Error('ExpectedChainBalance');
+  });
 
-  const [coinbaseTransactionId] = block.transaction_ids;
+  let firstConf;
+  const {address} = await createChainAddress({format, lnd});
+  const startHeight = (await getHeight({lnd})).current_block_height;
 
-  const {transaction} = chainSendTransaction({
-    tokens,
-    destination: address,
-    fee: defaultFee,
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransactionId,
-    spend_vout: defaultVout,
-  });
+  await asyncRetry({interval, times}, async () => {
+    const sub = subscribeToChainAddress({
+      lnd,
+      min_height: startHeight,
+      p2sh_address: address,
+    });
 
-  const sub = subscribeToChainAddress({
-    lnd,
-    min_height: startHeight,
-    p2sh_address: address,
-  });
+    sub.on('confirmation', conf => firstConf = conf);
+    sub.on('error', err => {});
 
-  let firstConf;
+    await generate({count});
 
-  sub.on('confirmation', conf => firstConf = conf);
-  sub.on('error', err => {});
+    await sendToChainAddress({lnd, address, tokens});
 
-  // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    await mineTransaction({cert, host, pass, port, transaction, user});
+    const {transactions} = await getChainTransactions({lnd});
+
+    const [{transaction}] = transactions
+      .filter(n => !n.is_confirmed)
+      .filter(n => !!n.is_outgoing);
 
-    if (!firstConf) {
-      throw new Error('ExpectedSubscribeToChainAddressSeesConfirmation');
+    if (!transaction) {
+      throw new Error('ExpectedTrnasaction');
     }
 
-    equal(firstConf.block.length, 64, 'Confirmation block hash is returned');
-    equal(firstConf.height, 102, 'Confirmation block height is returned');
-    equal(firstConf.transaction, transaction, 'Confirmation raw tx returned');
+    // Wait for generation to be over
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
 
-    return;
-  });
+      if (!firstConf) {
+        throw new Error('ExpectedSubscribeToChainAddressSeesConf');
+      }
 
-  let secondConf;
+      equal(firstConf.block.length, 64, 'Confirmation block hash returned');
+      equal(firstConf.height >= 102, true, 'Got confirmation block height');
+      equal(firstConf.transaction, transaction, 'Confirmation raw tx');
 
-  const sub2 = subscribeToChainAddress({
-    lnd,
-    min_confirmations: 6,
-    min_height: startHeight,
-    p2sh_address: address,
-  });
+      return;
+    });
 
-  sub2.on('error', () => {});
+    let secondConf;
 
-  sub2.on('confirmation', conf => secondConf = conf);
+    const sub2 = subscribeToChainAddress({
+      lnd,
+      min_confirmations: 6,
+      min_height: startHeight,
+      p2sh_address: address,
+    });
 
-  // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    await mineTransaction({cert, host, pass, port, transaction, user});
+    sub2.on('error', () => {});
 
-    if (!secondConf) {
-      throw new Error('ExpectedSubscribeToChainAddressSeesMultiConfirmation');
-    }
+    sub2.on('confirmation', conf => secondConf = conf);
 
-    equal(secondConf.block.length, 64, 'Confirmation block hash is returned');
-    equal(secondConf.height, 102, 'Confirmation block height is returned');
-    equal(secondConf.transaction, transaction, 'Confirmation raw tx returned');
+    // Wait for generation to be over
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
 
-    return;
-  });
+      if (!secondConf) {
+        throw new Error('ExpectedSubscribeToChainAddressSeesConfirmation');
+      }
 
-  sub.removeAllListeners();
-  sub2.removeAllListeners();
+      equal(secondConf.block.length, 64, 'Confirmation block hash returned');
+      equal(secondConf.height >= 102, true, 'Confirmation block height');
+      equal(secondConf.transaction, transaction, '2nd conf raw tx returned');
 
-  kill();
+      return;
+    });
+
+    [sub, sub2].forEach(n => n.removeAllListeners());
+  });
 
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/chainrpc-integration/test_subscribe_to_chain_spend.js

@@ -1,40 +1,70 @@
+const {once} = require('events');
+
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createChainAddress} = require('./../../');
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
 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 = retryCount => 50 * Math.pow(2, retryCount);
-const times = 15;
+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 ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
   let gotAddressConf = false;
 
-  const {lnd} = cluster.control;
+  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;
 
-  const {address} = await createChainAddress({
-    format,
-    lnd: cluster.target.lnd,
+  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 sendToChainAddress({address, lnd, tokens});
+  const sent = await asyncRetry({times}, async () => {
+    await control.generate({});
+
+    return await sendToChainAddress({address, lnd, tokens});
+  });
 
-  await cluster.generate({count: confirmationCount, node: cluster.control});
+  await control.generate({count: 1});
 
-  const [utxo] = (await getUtxos({lnd: cluster.control.lnd})).utxos;
+  const {utxos} = await getUtxos({lnd});
+
+  const [utxo] = utxos;
+
+  await control.generate({count});
 
   const sub = subscribeToChainSpend({
     lnd,
@@ -54,7 +84,7 @@ test(`Subscribe to chain spend`, async ({end, equal}) => {
     return gotAddressConf = true;
   });
 
-  const toTarget = await createChainAddress({format, lnd: cluster.target.lnd});
+  const toTarget = await createChainAddress({lnd: target.lnd});
 
   // Wait for generation to be over
   await asyncRetry({interval, times}, async () => {
@@ -64,10 +94,11 @@ test(`Subscribe to chain spend`, async ({end, equal}) => {
         address: toTarget.address,
         is_send_all: true,
       });
-    } catch (err) {}
+    } catch (err) {
+    }
 
     // Generate to confirm the tx
-    await cluster.generate({count: 1, node: cluster.control});
+    await control.generate({count: confirmationCount});
 
     if (!gotAddressConf) {
       throw new Error('ExpectedSubscribeToAddressSeesConfirmation');
@@ -76,7 +107,7 @@ test(`Subscribe to chain spend`, async ({end, equal}) => {
     return;
   });
 
-  await cluster.kill({});
+  await kill({});
 
   equal(gotAddressConf, true, 'Subscribe to address sees confirmation');
 

package/test/{integration → extra-integration}/test_subscribe_to_rpc_requests.js

@@ -234,7 +234,7 @@ test(`Subscribe to RPC requests`, async ({end, equal, fail, strictSame}) => {
 
   spawned.kill({});
 
-  await waitForTermination({lnd});
+  await waitForTermination({lnd: spawned.lnd});
 
   return end();
 });

package/test/integration/test_add_peer.js

@@ -1,4 +1,5 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
@@ -6,37 +7,40 @@ const {createCluster} = require('./../macros');
 const {getPeers} = require('./../../');
 
 const interval = 100;
+const size = 2;
 const times = 100;
+const timeout = 1;
 
 // Adding peers should result in a connected peer
 test(`Add a peer`, async ({end, equal}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
-  const remoteNodeKey = cluster.remote.public_key;
+  const [{lnd}, target] = nodes;
 
   const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
 
-  equal(connectedKeys.find(n => n === remoteNodeKey), undefined, 'No peer');
+  equal(connectedKeys.find(n => n === target.id), undefined, 'No peer');
 
   await asyncRetry({interval, times}, async () => {
     await addPeer({
       lnd,
-      public_key: cluster.remote.public_key,
-      socket: cluster.remote.socket,
-      timeout: 1,
+      timeout,
+      public_key: target.id,
+      socket: target.socket,
     });
 
     const {peers} = await getPeers({lnd});
 
-    const connected = peers.find(n => n.public_key === remoteNodeKey);
+    const connected = peers.find(n => n.public_key === target.id);
 
-    equal(connected.public_key, remoteNodeKey, 'Connected to remote node');
+    if (!connected) {
+      throw new Error('ExpectedConnectionToTarget');
+    }
+
+    equal(connected.public_key, target.id, 'Connected to remote node');
   });
 
-  (async () => {
-    await cluster.kill({});
-  })();
+  await kill({});
 
   return end();
 });

package/test/integration/test_cancel_pending_channel.js

@@ -1,24 +1,38 @@
+const asyncEach = require('async/each');
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
+const {addPeer} = require('./../../');
 const {cancelPendingChannel} = require('./../../');
 const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
+const {getChainBalance} = require('./../../');
 const {openChannels} = require('./../../');
 
 const capacity = 1e6;
+const count = 100;
+const interval = 100;
 const race = promises => Promise.race(promises);
-const timeout = 1000 * 10;
+const size = 2;
+const timeout = 1000 * 5;
+const times = 200;
 
 // Cancel a channel should result in no pending channels
 test(`Cancel pending channel`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
 
-  const channels = [{capacity, partner_public_key: cluster.target.public_key}];
+  const {lnd} = control;
 
-  await asyncRetry({interval: 100, times: 100}, async () => {
+  await control.generate({count});
+
+  await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+  const channels = [{capacity, partner_public_key: target.id}];
+
+  await asyncRetry({interval, times}, async () => {
     const toCancel = await race([
       delay(timeout),
       openChannels({channels, lnd}),
@@ -29,7 +43,7 @@ test(`Cancel pending channel`, async ({end, equal}) => {
     await cancelPendingChannel({id, lnd});
   });
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_close_channel.js

@@ -1,24 +1,29 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {closeChannel} = require('./../../');
 const {createCluster} = require('./../macros');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
+
 // Closing a channel should close the channel
 test(`Close channel`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
 
   // Force close channel using tx id and vout
   try {
     const channelOpen = await setupChannel({
-      generate: cluster.generate,
-      lnd: cluster.control.lnd,
-      to: cluster.target,
+      generate: control.generate,
+      lnd: control.lnd,
+      to: target,
     });
 
     const channelClose = await closeChannel({
       is_force_close: true,
-      lnd: cluster.control.lnd,
+      lnd: control.lnd,
       transaction_id: channelOpen.transaction_id,
       transaction_vout: channelOpen.transaction_vout,
     });
@@ -32,14 +37,14 @@ test(`Close channel`, async ({end, equal}) => {
   // Coop close channel using the channel id
   try {
     const channelOpen = await setupChannel({
-      generate: cluster.generate,
-      lnd: cluster.control.lnd,
-      to: cluster.target,
+      generate: control.generate,
+      lnd: control.lnd,
+      to: target,
     });
 
     const channelClose = await closeChannel({
       id: channelOpen.id,
-      lnd: cluster.control.lnd,
+      lnd: control.lnd,
     });
 
     equal(channelClose.transaction_id.length, 64, 'Coop close id is returned');
@@ -48,7 +53,7 @@ test(`Close channel`, async ({end, equal}) => {
     equal(err, null, 'Expected no error coop closing');
   }
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_create_chain_address.js

@@ -1,9 +1,8 @@
 const {address} = require('bitcoinjs-lib');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createChainAddress} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const formats = ['np2wpkh', 'p2wpkh'];
 const p2shAddressVersion = 196;
@@ -12,7 +11,7 @@ const regtestBech32AddressHrp = 'bcrt';
 
 // Creating addresses should result in addresses
 test(`Create address results in address creation`, async ({end, equal}) => {
-  const {kill, lnd} = await spawnLnd({});
+  const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
   const createNewChainAddresses = formats
     .map(async format => await createChainAddress({lnd, format}));
@@ -35,9 +34,7 @@ test(`Create address results in address creation`, async ({end, equal}) => {
   equal(np2wpkh.address, unusedNp2wpkh.address, 'Nested is reused');
   equal(p2wpkh.address, unusedP2wpkh.address, 'Native is reused');
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_create_invoice.js

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