ln-service 52.14.4 → 53.0.0

package/test/integration/test_get_fee_rates.js

@@ -1,23 +1,20 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {getFeeRates} = require('./../../');
 const {setupChannel} = require('./../macros');
 
 const defaultBaseFee = 1;
 const defaultFeeRate = 1;
+const size = 2;
 
 // Getting fee rates should return the fee rates of nodes in the channel graph
 test(`Get fee rates`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, to] = nodes;
 
-  const channelOpen = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    to: cluster.target,
-  });
+  const channelOpen = await setupChannel({generate, lnd, to});
 
   const {channels} = await getFeeRates({lnd});
 
@@ -35,7 +32,7 @@ test(`Get fee rates`, async ({end, equal}) => {
   equal(channel.transaction_id, channelOpen.transaction_id, 'Channel tx id');
   equal(channel.transaction_vout, channelOpen.transaction_vout, 'Tx vout');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_forwards.js

@@ -1,7 +1,8 @@
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {delay} = require('./../macros');
 const {getForwards} = require('./../../');
@@ -9,45 +10,39 @@ const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
 const limit = 1;
+const size = 3;
 const tokens = 100;
 
 // Getting forwarded payments should return all forwarded payments
 test('Get forwards', async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  await setupChannel({
-    generate: cluster.generate,
-    lnd: cluster.control.lnd,
-    to: cluster.target,
-  });
+  const [{generate, lnd}, target, remote] = nodes;
+
+  await setupChannel({generate, lnd, to: target});
 
   await setupChannel({
-    lnd: cluster.target.lnd,
-    generate: cluster.generate,
-    generator: cluster.target,
-    to: cluster.remote,
+    lnd: target.lnd,
+    generate: target.generate,
+    to: remote,
   });
 
-  await addPeer({
-    lnd: cluster.control.lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
-  });
+  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
   await delay(2000);
 
-  for (let i = 0, lnd = cluster.remote.lnd; i < 3; i++) {
-    await pay({
-      lnd: cluster.control.lnd,
-      request: (await createInvoice({lnd, tokens: tokens + i})).request,
-    });
+  for (let i = 0, l = remote.lnd; i < 3; i++) {
+    await asyncRetry({}, async () => {
+      await delay(1000);
 
-    await delay(1000);
+      await pay({
+        lnd,
+        request: (await createInvoice({lnd: l, tokens: tokens + i})).request,
+      });
+    });
   }
 
-  const {lnd} = cluster.target;
-
-  const page1 = await getForwards({limit, lnd});
+  const page1 = await getForwards({limit, lnd: target.lnd});
 
   equal(!!page1.next, true, 'Page 1 leads to page 2');
 
@@ -62,7 +57,7 @@ test('Get forwards', async ({end, equal, strictSame}) => {
     equal(!!forward.outgoing_channel, true, 'Forward outgoing channel');
   }
 
-  const page2 = await getForwards({lnd, token: page1.next});
+  const page2 = await getForwards({lnd: target.lnd, token: page1.next});
 
   equal(!!page2.next, true, 'Page 2 leads to page 3');
 
@@ -72,7 +67,7 @@ test('Get forwards', async ({end, equal, strictSame}) => {
     equal(forward.tokens, 101, 'Second forward tokens count');
   }
 
-  const page3 = await getForwards({lnd, token: page2.next});
+  const page3 = await getForwards({lnd: target.lnd, token: page2.next});
 
   equal(!!page3.next, true, 'Page 3 leads to page 4');
 
@@ -82,47 +77,51 @@ test('Get forwards', async ({end, equal, strictSame}) => {
     equal(forward.tokens, 102, 'Third forward tokens count');
 
     // Check "before" based paging
-    const prev0 = await getForwards({limit, lnd, before: forward.created_at});
+    const prev0 = await getForwards({
+      limit,
+      before: forward.created_at,
+      lnd: target.lnd,
+    });
 
     const [firstForward] = prev0.forwards;
 
     equal(firstForward.tokens, 100, 'Previous row #1');
 
-    const prev1 = await getForwards({lnd, token: prev0.next});
+    const prev1 = await getForwards({lnd: target.lnd, token: prev0.next});
 
     const [secondForward] = prev1.forwards;
 
     equal(secondForward.tokens, 101, 'Previous row #2');
 
-    const prev2 = await getForwards({lnd, token: prev1.next});
+    const prev2 = await getForwards({lnd: target.lnd, token: prev1.next});
 
     equal(prev2.next, undefined, 'Ended paging of previous rows');
 
     // Check "after" based paging
     const after0 = await getForwards({
       limit,
-      lnd,
       before: forward.created_at,
       after: firstForward.created_at,
+      lnd: target.lnd,
     });
 
     strictSame(after0.forwards, prev0.forwards, 'After is inclusive of start');
 
-    const after1 = await getForwards({lnd, token: after0.next});
+    const after1 = await getForwards({lnd: target.lnd, token: after0.next});
 
     strictSame(after1.forwards, prev1.forwards, 'Iterating before, after');
 
-    const after2 = await getForwards({lnd, token: after1.next});
+    const after2 = await getForwards({lnd: target.lnd, token: after1.next});
 
     equal(after2.next, undefined, 'Before is non-inclusive');
   }
 
-  const page4 = await getForwards({lnd, token: page3.next});
+  const page4 = await getForwards({lnd: target.lnd, token: page3.next});
 
   equal(page4.forwards.length, [].length, 'Page 4 has no results');
   equal(page4.next, undefined, 'Page 4 leads to nowhere');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_invoice.js

@@ -1,6 +1,6 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {getHeight} = require('./../../');
 const {getInvoice} = require('./../../');
@@ -9,20 +9,16 @@ const {setupChannel} = require('./../macros');
 
 const description = 'description';
 const secret = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';
+const size = 2;
 const tokens = 42;
 
 // getInvoice results in invoice details
 test(`Get an invoice`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true})
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target] = nodes;
 
-  const channel = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    give: 1e5,
-    to: cluster.target,
-  });
+  const channel = await setupChannel({generate, lnd, give: 1e5, to: target});
 
   const created = await createInvoice({description, lnd, secret, tokens});
 
@@ -35,7 +31,7 @@ test(`Get an invoice`, async ({end, equal}) => {
   equal(invoice.secret, secret, 'Invoice secret');
   equal(invoice.tokens, tokens, 'Invoice tokens');
 
-  await pay({lnd: cluster.target.lnd, request: created.request});
+  await pay({lnd: target.lnd, request: created.request});
 
   const paid = await getInvoice({lnd, id: created.id});
 
@@ -59,7 +55,7 @@ test(`Get an invoice`, async ({end, equal}) => {
 
   equal(paid.is_confirmed, true, 'Invoice has been paid');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_invoices.js

@@ -1,55 +1,58 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
 const {getInvoices} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const limit = 1;
 
 // createInvoice should result in a created invoice
 test(`Create an invoice`, async ({end, equal}) => {
-  const {kill, lnd} = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const invoices = [
-    await createInvoice({lnd, description: '3'}),
-    await createInvoice({lnd, description: '2'}),
-    await createInvoice({lnd, description: '1'}),
-  ];
+  try {
+    const [{generate, lnd}] = nodes;
 
-  invoices.reverse();
+    const invoices = [
+      await createInvoice({lnd, description: '3'}),
+      await createInvoice({lnd, description: '2'}),
+      await createInvoice({lnd, description: '1'}),
+    ];
 
-  const firstPage = await getInvoices({limit, lnd});
+    invoices.reverse();
 
-  equal(!!firstPage.next, true, 'First page has a next token');
+    const firstPage = await getInvoices({limit, lnd});
 
-  const secondPage = await getInvoices({lnd, token: firstPage.next});
+    equal(!!firstPage.next, true, 'First page has a next token');
 
-  equal(!!secondPage.next, true, 'Second page has a next token');
+    const secondPage = await getInvoices({lnd, token: firstPage.next});
 
-  const thirdPage = await getInvoices({lnd, token: secondPage.next});
+    equal(!!secondPage.next, true, 'Second page has a next token');
 
-  equal(!!thirdPage.next, false, 'Third page has no next token');
+    const thirdPage = await getInvoices({lnd, token: secondPage.next});
 
-  const receivedInvoices = []
-    .concat(firstPage.invoices)
-    .concat(secondPage.invoices)
-    .concat(thirdPage.invoices);
+    equal(!!thirdPage.next, false, 'Third page has no next token');
 
-  receivedInvoices.forEach((invoice, i) => {
-    const expected = invoices[i];
+    const receivedInvoices = []
+      .concat(firstPage.invoices)
+      .concat(secondPage.invoices)
+      .concat(thirdPage.invoices);
 
-    equal(invoice.chain_address, expected.chain_address, 'Chain address');
-    equal(invoice.confirmed_at, expected.confirmed_at, 'Confirmed at');
-    equal(invoice.id, expected.id, 'Invoice id');
-    equal(invoice.request, expected.request, 'Payment request');
-    equal(invoice.secret, expected.secret, 'Payment secret');
-    equal(invoice.tokens, expected.tokens, 'Tokens');
-  });
+    receivedInvoices.forEach((invoice, i) => {
+      const expected = invoices[i];
 
-  kill();
+      equal(invoice.chain_address, expected.chain_address, 'Chain address');
+      equal(invoice.confirmed_at, expected.confirmed_at, 'Confirmed at');
+      equal(invoice.id, expected.id, 'Invoice id');
+      equal(invoice.request, expected.request, 'Payment request');
+      equal(invoice.secret, expected.secret, 'Payment secret');
+      equal(invoice.tokens, expected.tokens, 'Tokens');
+    });
+  } catch (err) {
+    equal(err, null, 'No error is expected');
+  }
 
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_methods.js

@@ -1,14 +1,13 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getMethods} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 // Getting LND methods should result in LND methods returned
 test(`Get LND methods`, async ({end, equal, type}) => {
-  const node = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const {kill, lnd} = node;
+  const [{lnd}] = nodes;
 
   try {
     const {methods} = await getMethods({lnd});
@@ -28,9 +27,7 @@ test(`Get LND methods`, async ({end, equal, type}) => {
     equal(message, 'ListPermissionsMethodNotSupported', 'Not supported msg');
   }
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_network_centrality.js

@@ -1,43 +1,40 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
 const {getNetworkCentrality} = require('./../../');
+const {getWalletInfo} = require('./../../');
 const {setupChannel} = require('./../macros');
 
-const interval = 1e4;
-const times = 100;
+const interval = 100;
+const size = 3;
+const times = 300;
 
 // Getting the network centrality should return the centrality scores
 test(`Get network centrality`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  await getNetworkCentrality({lnd: cluster.control.lnd});
-
-  const {control} = cluster;
-  const {remote} = cluster;
-  const {target} = cluster;
+  const [control, target, remote] = nodes;
 
   const {lnd} = control;
 
-  await setupChannel({lnd, generate: cluster.generate, to: target});
+  await setupChannel({lnd, generate: control.generate, to: target});
 
   await setupChannel({
-    generate: cluster.generate,
-    generator: target,
+    generate: target.generate,
     lnd: target.lnd,
     to: remote,
   });
 
   await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: remote.public_key, socket: remote.socket});
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
     const {nodes} = await getNetworkCentrality({lnd});
 
-    const controlScore = nodes.find(n => n.public_key === control.public_key);
-    const remoteScore = nodes.find(n => n.public_key === remote.public_key);
-    const targetScore = nodes.find(n => n.public_key === target.public_key);
+    const controlScore = nodes.find(n => n.public_key === control.id);
+    const remoteScore = nodes.find(n => n.public_key === remote.id);
+    const targetScore = nodes.find(n => n.public_key === target.id);
 
     if (!targetScore.betweenness || !targetScore.betweenness_normalized) {
       throw new Error('UnexpectedValueForTargetScoreBetweenness');
@@ -57,7 +54,7 @@ test(`Get network centrality`, async ({end, equal, strictSame}) => {
     return;
   });
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_network_graph.js

@@ -1,41 +1,38 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {getNetworkGraph} = require('./../../');
 const {getNode} = require('./../../');
 const {setupChannel} = require('./../macros');
 
 const {ceil} = Math;
 const interval = 250;
+const size = 3;
 const times = 50;
 
 // Getting the network graph should return the public nodes and connections
 test(`Get network graph`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {control} = cluster;
+  const [control, target] = nodes;
 
-  const {lnd} = control;
+  const {generate, lnd} = control;
 
-  const expectedChannel = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    to: cluster.target,
-  });
+  const expectedChannel = await setupChannel({generate, lnd, to: target});
 
   // Wait until the node shows up in the graph
   const graph = await asyncRetry({interval, times}, async () => {
     const networkGraph = await getNetworkGraph({lnd});
 
-    if (!networkGraph.nodes.find(n => n.public_key === control.public_key)) {
+    if (!networkGraph.nodes.find(n => n.public_key === control.id)) {
       throw new Error('ExpectedToFindNodeInGraph');
     }
 
     return networkGraph;
   });
 
-  const node = graph.nodes.find(n => n.public_key === control.public_key);
+  const node = graph.nodes.find(n => n.public_key === control.id);
   const [channel] = graph.channels;
 
   const nodeDetails = await getNode({lnd, public_key: node.public_key});
@@ -46,10 +43,10 @@ test(`Get network graph`, async ({end, equal, strictSame}) => {
     strictSame(chan, channel, 'Graph channel matches node details channel');
   }
 
-  equal(node.alias, control.public_key.slice(0, 20), 'Node alias is own');
+  equal(node.alias, control.id.slice(0, 20), 'Node alias is own');
   equal(node.color, '#3399ff', 'Node color is default');
-  equal(node.public_key, control.public_key, 'Node pubkey is own');
-  strictSame(node.sockets, [`127.0.0.1:${control.listen_port}`], 'Socket');
+  equal(node.public_key, control.id, 'Node pubkey is own');
+  equal(node.sockets.length, 1, 'Socket');
   equal(new Date() - new Date(node.updated_at) < 1e5, true, 'Recent update');
 
   channel.policies.forEach(policy => {
@@ -71,7 +68,7 @@ test(`Get network graph`, async ({end, equal, strictSame}) => {
   equal(channel.transaction_vout, expectedChannel.transaction_vout, 'Tx Vout');
   equal(new Date() - new Date(channel.updated_at) < 1e5, true, 'Updated at');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_network_info.js

@@ -1,12 +1,13 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getNetworkInfo} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 // Getting the network info should return basic network statistics
 test(`Get network info`, async ({end, equal}) => {
-  const {kill, lnd} = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
+
+  const [{lnd}] = nodes;
 
   const result = await getNetworkInfo({lnd});
 
@@ -18,9 +19,7 @@ test(`Get network info`, async ({end, equal}) => {
   equal(result.not_recently_updated_policy_count, 0, 'Not updated count');
   equal(result.total_capacity, 0, 'Total capacity');
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_node.js

@@ -1,7 +1,7 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
 const {getIdentity} = require('./../../');
 const {getNode} = require('./../../');
@@ -16,27 +16,20 @@ const defaultFee = 1e3;
 const defaultAliasLength = '00000000000000000000'.length;
 const feeRate = 21;
 const mtokPerTok = BigInt(1e3);
+const size = 3;
 
 // Getting a node should return the public graph node info
 test(`Get node`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {control} = cluster;
+  const [{generate, id, lnd}, target, remote] = nodes;
 
-  const {generate} = cluster;
-  const {lnd} = control;
-
-  const controlToTarget = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    to: cluster.target,
-  });
+  const controlToTarget = await setupChannel({generate, lnd, to: target});
 
   const targetToRemote = await setupChannel({
-    generate: cluster.generate,
-    generator: cluster.target,
-    lnd: cluster.target.lnd,
-    to: cluster.remote,
+    generate: target.generate,
+    lnd: target.lnd,
+    to: remote,
   });
 
   await updateRoutingFees({
@@ -48,26 +41,17 @@ test(`Get node`, async ({end, equal, strictSame}) => {
     transaction_vout: controlToTarget.transaction_vout,
   });
 
-  await addPeer({
-    lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
-  });
+  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
   await delay(3000);
 
-  const controlListenIp = cluster.control.listen_ip;
-  const controlListenPort = cluster.control.listen_port;
-
-  const controlPublicKey = (await getIdentity({lnd})).public_key;
-
-  const node = await getNode({lnd, public_key: controlPublicKey});
+  const node = await getNode({lnd, public_key: id});
 
   {
     const {channels} = await getNode({
       lnd,
       is_omitting_channels: true,
-      public_key: controlPublicKey,
+      public_key: id,
     });
 
     equal(channels.length, [].length, 'Channels are omitted')
@@ -76,7 +60,7 @@ test(`Get node`, async ({end, equal, strictSame}) => {
   if (!!node.channels.length) {
     const [{policies}] = node.channels;
 
-    const policy = policies.find(n => n.public_key === control.public_key);
+    const policy = policies.find(n => n.public_key === id);
 
     equal(BigInt(policy.base_fee_mtokens), BigInt(baseFee)*mtokPerTok, 'Base');
     equal(policy.cltv_delta, cltvDelta, 'Got expected cltv delta');
@@ -88,14 +72,14 @@ test(`Get node`, async ({end, equal, strictSame}) => {
 
   const [socket] = node.sockets;
 
-  equal(node.alias, controlPublicKey.slice(0, defaultAliasLength), 'Alias');
+  equal(node.alias, id.slice(0, defaultAliasLength), 'Alias');
   equal(node.color, '#3399ff', 'Color');
   equal(node.sockets.length, 1, 'Socket');
-  equal(socket.socket, `127.0.0.1:${controlListenPort}`, 'Ip, port');
+  equal(!!socket.socket, true, 'Ip, port');
   equal(socket.type, 'tcp', 'Socket type');
   equal(node.updated_at.length, 24, 'Update date');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });