ln-service 52.16.0 → 53.1.0

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();
 });

package/test/integration/test_decode_payment_request.js

@@ -1,10 +1,9 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
 const {getIdentity} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const tests = [
   {
@@ -23,33 +22,35 @@ const tests = [
 
 tests.forEach(({description, expected}) => {
   return test(description, async ({end, equal}) => {
-    const {kill, lnd} = await spawnLnd({});
-
-    const {request} = await createInvoice({
-      lnd,
-      cltv_delta: expected.cltv_delta,
-      description: expected.description,
-      secret: expected.secret,
-      tokens: expected.tokens,
-    });
-
-    const decoded = await decodePaymentRequest({lnd, request});
-
-    equal(decoded.chain_addresses, expected.chain_addresses, 'Chain address');
-    equal(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv delta');
-    equal(!!decoded.created_at, true, 'Created at date');
-    equal(decoded.description, expected.description, 'Decode description');
-    equal(decoded.description_hash, expected.description_hash, 'Desc hash');
-    equal(decoded.destination, (await getIdentity({lnd})).public_key, 'Pk');
-    equal(!!decoded.expires_at, true, 'Expiration date decoded');
-    equal(decoded.id, expected.id, 'Decoded payment hash');
-    equal(decoded.mtokens, expected.mtokens, 'Decode millitokens');
-    equal(decoded.safe_tokens, expected.safe_tokens, 'Decode safe amount');
-    equal(decoded.tokens, expected.tokens, 'Decode tokens amount');
-
-    kill();
-
-    await waitForTermination({lnd});
+    const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
+
+    try {
+      const {request} = await createInvoice({
+        lnd,
+        cltv_delta: expected.cltv_delta,
+        description: expected.description,
+        secret: expected.secret,
+        tokens: expected.tokens,
+      });
+
+      const decoded = await decodePaymentRequest({lnd, request});
+
+      equal(decoded.chain_addresses, expected.chain_addresses, 'Chain addr');
+      equal(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv delta');
+      equal(!!decoded.created_at, true, 'Created at date');
+      equal(decoded.description, expected.description, 'Decode description');
+      equal(decoded.description_hash, expected.description_hash, 'Desc hash');
+      equal(decoded.destination, (await getIdentity({lnd})).public_key, 'Pk');
+      equal(!!decoded.expires_at, true, 'Expiration date decoded');
+      equal(decoded.id, expected.id, 'Decoded payment hash');
+      equal(decoded.mtokens, expected.mtokens, 'Decode millitokens');
+      equal(decoded.safe_tokens, expected.safe_tokens, 'Decode safe amount');
+      equal(decoded.tokens, expected.tokens, 'Decode tokens amount');
+    } catch (err) {
+      equal(err, null, 'Expected no error');
+    }
+
+    await kill({});
 
     return end();
   });

package/test/integration/test_delete_payment.js

@@ -1,23 +1,26 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {deletePayment} = require('./../../');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
 const tokens = 100;
 
 // Deleting a payment should delete the payment record
 test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  const {lnd} = control;
 
-  const invoice = await createInvoice({tokens, lnd: cluster.target.lnd});
+  await setupChannel({lnd, generate: control.generate, to: target});
+
+  const invoice = await createInvoice({tokens, lnd: target.lnd});
 
   let paid;
 
@@ -26,7 +29,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
   } catch (err) {
     fail('Payment should be made to destination');
 
-    await cluster.kill({});
+    await kill({});
 
     return end();
   }
@@ -39,7 +42,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
   } catch (err) {
     strictSame(err, [501, 'DeletePaymentMethodNotSupported']);
 
-    await cluster.kill({});
+    await kill({});
 
     return end();
   }
@@ -48,7 +51,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
 
   equal(priorLength - wipedLength, [paid].length, 'Payment deleted');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_delete_payments.js

@@ -1,35 +1,32 @@
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {deletePayments} = require('./../../');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
+const times = 1000;
 const tokens = 100;
 
 // Deleting payments should delete all payments
 test('Delete payments', async ({afterEach, fail, end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  const {generate, lnd} = control;
 
-  const invoice = await createInvoice({tokens, lnd: cluster.target.lnd});
+  await setupChannel({generate, lnd, to: target});
 
-  let paid;
+  const invoice = await createInvoice({tokens, lnd: target.lnd});
 
-  try {
-    paid = await pay({lnd, request: invoice.request});
-  } catch (err) {
-    fail('Payment should be made to destination');
-
-    await cluster.kill({});
-
-    return end();
-  }
+  const paid = await asyncRetry({times}, async () => {
+    return await pay({lnd, request: invoice.request});
+  });
 
   const priorLength = (await getPayments({lnd})).payments.length;
 
@@ -39,7 +36,7 @@ test('Delete payments', async ({afterEach, fail, end, equal}) => {
 
   equal(priorLength - wipedLength, [paid].length, 'Payment history deleted');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_access_ids.js

@@ -1,19 +1,18 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {authenticatedLndGrpc} = require('./../../');
 const {getAccessIds} = require('./../../');
 const {grantAccess} = require('./../../');
 const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const defaultId = '0';
 const id = '1';
 
 // Getting access ids should return root macaroon ids
 test(`Get access ids`, async ({end, equal, rejects, strictSame}) => {
-  const spawned = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const {lnd, kill} = spawned;
+  const [{lnd}] = nodes;
 
   await grantAccess({id, lnd, is_ok_to_create_chain_addresses: true});
 
@@ -30,9 +29,7 @@ test(`Get access ids`, async ({end, equal, rejects, strictSame}) => {
     }
   }
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });