ln-service 53.7.2 → 53.7.3

package/test/routerrpc-integration/test_delete_forwarding_reputations.js

@@ -1,3 +1,4 @@
+const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
@@ -5,12 +6,17 @@ const {addPeer} = require('./../../');
 const {createInvoice} = require('./../../');
 const {deleteForwardingReputations} = require('./../../');
 const {getForwardingReputations} = require('./../../');
+const {getNetworkGraph} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {probeForRoute} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');
 
+const flatten = arr => [].concat(...arr);
+const interval = 10;
 const size = 3;
+const times = 1000;
+const tlvOnionBit = 14;
 const tokens = 1e6 / 2;
 
 // Deleting forwarding reputations should eliminate forwarding reputations
@@ -19,45 +25,73 @@ test('Delete forwarding reputations', async ({end, equal}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const controlToTargetChan = await setupChannel({generate, lnd, to: target});
+  try {
+    const controlToTargetChan = await setupChannel({
+      generate,
+      lnd,
+      to: target,
+    });
 
-  const targetToRemoteChan = await setupChannel({
-    generate: target.generate,
-    lnd: target.lnd,
-    to: remote,
-  });
+    const targetToRemoteChan = await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
+    });
 
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-  const {id, request} = await createInvoice({tokens, lnd: remote.lnd});
+    const {id, request} = await createInvoice({tokens, lnd: remote.lnd});
 
-  await waitForRoute({lnd, tokens, destination: remote.id});
+    await asyncRetry({interval, times}, async () => {
+      const {channels, nodes} = await getNetworkGraph({lnd});
 
-  try {
-    await payViaPaymentRequest({lnd, request});
-  } catch (err) {
-    equal(err, null, 'Expected no error paying payment request');
-  }
+      const limitedFeatures = nodes.find(node => {
+        return !node.features.find(n => n.bit === tlvOnionBit);
+      });
 
-  try {
-    await probeForRoute({lnd, tokens, destination: remote.id});
-  } catch (err) {}
+      const policies = flatten(channels.map(n => n.policies));
 
-  {
-    const {nodes} = await getForwardingReputations({lnd});
+      const cltvDeltas = policies.map(n => n.cltv_delta);
 
-    equal(nodes.length, 2, 'Reputations should exist');
-  }
+      if (!!cltvDeltas.filter(n => !n).length) {
+        throw new Error('ExpectedAllChannelPolicies');
+      }
 
-  await deleteForwardingReputations({lnd});
+      if (!!limitedFeatures) {
+        throw new Error('NetworkGraphSyncIncomplete');
+      }
+    });
 
-  {
-    const {nodes} = await getForwardingReputations({lnd});
+    await waitForRoute({lnd, tokens, destination: remote.id});
 
-    equal(nodes.length, [].length, 'Reputations should be wiped');
-  }
+    try {
+      await payViaPaymentRequest({lnd, request});
+    } catch (err) {
+      equal(err, null, 'Expected no error paying payment request');
+    }
 
-  await kill({});
+    try {
+      await probeForRoute({lnd, tokens, destination: remote.id});
+    } catch (err) {}
+
+    {
+      const {nodes} = await getForwardingReputations({lnd});
+
+      equal(nodes.length, 2, 'Reputations should exist');
+    }
+
+    await deleteForwardingReputations({lnd});
+
+    {
+      const {nodes} = await getForwardingReputations({lnd});
+
+      equal(nodes.length, [].length, 'Reputations should be wiped');
+    }
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/routerrpc-integration/test_get_forwarding_reputations.js

@@ -5,7 +5,7 @@ const {test} = require('@alexbosworth/tap');
 const {addPeer} = require('./../../');
 const {getChannels} = require('./../../');
 const {getForwardingReputations} = require('./../../');
-const {payViaRoutes} = require('./../../');
+const {getNetworkGraph} = require('./../../');
 const {probeForRoute} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');
@@ -15,9 +15,12 @@ const channelCapacityTokens = 1e6;
 const confirmationCount = 20;
 const defaultFee = 1e3;
 const defaultOdds = 950000;
+const flatten = arr => [].concat(...arr);
 const interval = 10;
+const maturity = 100;
 const size = 3;
 const times = 2000;
+const tlvOnionBit = 14;
 const tokens = 1e6 / 2;
 
 // Getting forwarding reputations should return reputations
@@ -26,9 +29,9 @@ test('Get forwarding reputations', async ({end, equal}) => {
 
   const [{generate, id, lnd}, target, remote] = cluster.nodes;
 
-  await generate({count: 100});
-
   try {
+    await generate({count: maturity});
+
     // Create a channel from the control to the target node
     await setupChannel({
       generate,
@@ -45,22 +48,47 @@ test('Get forwarding reputations', async ({end, equal}) => {
     });
 
     await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+      const {channels, nodes} = await getNetworkGraph({lnd});
+
+      const limitedFeatures = nodes.find(node => {
+        return !node.features.find(n => n.bit === tlvOnionBit);
+      });
+
+      const policies = flatten(channels.map(n => n.policies));
+
+      const cltvDeltas = policies.map(n => n.cltv_delta);
+
+      if (!!cltvDeltas.filter(n => !n).length) {
+        throw new Error('ExpectedAllChannelPolicies');
+      }
+
+      if (!!limitedFeatures) {
+        throw new Error('NetworkGraphSyncIncomplete');
+      }
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      await addPeer({
+        lnd,
+        public_key: remote.id,
+        socket: remote.socket,
+        retry_count: 1,
+        retry_delay: 1,
+        timeout: 1,
+      });
 
       const {channels} = await getChannels({lnd: remote.lnd});
 
       await waitForRoute({lnd, tokens, destination: remote.id});
 
-      try {
-        const res = await probeForRoute({
-          lnd,
-          tokens,
-          destination: remote.id,
-          is_ignoring_past_failures: true,
-        });
-      } catch (err) {
-        equal(err, null, 'Expected no error probing');
-      }
+      await probeForRoute({
+        lnd,
+        tokens,
+        destination: remote.id,
+        is_ignoring_past_failures: true,
+      });
 
       const {nodes} = await getForwardingReputations({lnd});
 

package/test/routerrpc-integration/test_get_route_through_hops.js

@@ -12,16 +12,18 @@ const {getNetworkGraph} = require('./../../');
 const {getRouteThroughHops} = require('./../../');
 const {getRouteToDestination} = require('./../../');
 const {getWalletInfo} = require('./../../');
-const {getWalletVersion} = require('./../../');
 const {payViaRoutes} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');
 
 const confirmationCount = 6;
+const flatten = arr => [].concat(...arr);
 const interval = 10;
+const maturity = 100;
 const messages = [{type: '1000000', value: '01'}];
 const size = 3;
 const times = 1000;
+const tlvOnionBit = 14;
 const tokens = 100;
 
 // Getting a route through hops should result in a route through specified hops
@@ -30,8 +32,7 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  await target.generate({count: 100});
-  await remote.generate({count: 100});
+  await target.generate({count: maturity});
 
   const controlToTargetChan = await setupChannel({generate, lnd, to: target});
 
@@ -53,6 +54,26 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
     }
   });
 
+  await asyncRetry({interval, times}, async () => {
+    const {channels, nodes} = await getNetworkGraph({lnd});
+
+    const limitedFeatures = nodes.find(node => {
+      return !node.features.find(n => n.bit === tlvOnionBit);
+    });
+
+    const policies = flatten(channels.map(n => n.policies));
+
+    const cltvDeltas = policies.map(n => n.cltv_delta);
+
+    if (!!cltvDeltas.filter(n => !n).length) {
+      throw new Error('ExpectedAllChannelPolicies');
+    }
+
+    if (!!limitedFeatures) {
+      throw new Error('NetworkGraphSyncIncomplete');
+    }
+  });
+
   const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
   const {id} = invoice;
@@ -71,18 +92,6 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
     });
   });
 
-  await asyncRetry({interval, times}, async () => {
-    const {nodes} = await getNetworkGraph({lnd});
-
-    const limitedFeatures = nodes.find(node => {
-      return !node.features.find(n => n.bit === 14);
-    });
-
-    if (!!limitedFeatures) {
-      throw new Error('NetworkGraphSyncIncomplete');
-    }
-  });
-
   const res = await asyncRetry({interval, times}, async () => {
     return await getRouteThroughHops({
       lnd,

package/test/routerrpc-integration/test_multipath_payment.js

@@ -4,7 +4,6 @@ const {test} = require('@alexbosworth/tap');
 const {createInvoice} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getRouteToDestination} = require('./../../');
-const {getWalletVersion} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {payViaRoutes} = require('./../../');

package/test/routerrpc-integration/test_pay_via_payment_details.js

@@ -8,7 +8,6 @@ const {delay} = require('./../macros');
 const {getHeight} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getInvoices} = require('./../../');
-const {getWalletVersion} = require('./../../');
 const {payViaPaymentDetails} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');

package/test/routerrpc-integration/test_pay_via_payment_request.js

@@ -22,99 +22,111 @@ test(`Pay via payment request`, async ({end, equal, rejects, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const channel = await setupChannel({generate, lnd, to: target});
-
-  // Make sure that an error is returned when there is no route
   try {
-    const {request} = await createInvoice({tokens, lnd: remote.lnd});
+    await generate({count: 100});
 
-    await rejects(
-      payViaPaymentRequest({lnd, request}),
-      [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
-      'A payment with no route returns an error'
-    );
-  } catch (err) {
-    equal(err, null, 'Expected no error creating invoice');
-  }
+    const channel = await setupChannel({generate, lnd, to: target});
 
-  const remoteChan = await setupChannel({
-    lnd: target.lnd,
-    generate: target.generate,
-    to: remote,
-  });
+    // Make sure that an error is returned when there is no route
+    try {
+      const {request} = await createInvoice({tokens, lnd: remote.lnd});
 
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  await waitForRoute({lnd, tokens, destination: remote.id});
+      await rejects(
+        payViaPaymentRequest({lnd, request}),
+        [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
+        'A payment with no route returns an error'
+      );
+    } catch (err) {
+      equal(err, null, 'Expected no error creating invoice');
+    }
 
-  // When a route exists, payment is successful
-  try {
-    const commitTxFee = channel.commit_transaction_fee;
-    const height = (await getWalletInfo({lnd})).current_block_height;
-    const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-    const paid = await payViaPaymentRequest({
-      lnd,
-      max_timeout_height: height + 40 + 43,
-      messages: [{type: tlvType, value: tlvValue}],
-      request: invoice.request,
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
     });
 
-    equal(paid.confirmed_at > start, true, 'Got confirmation date');
-    equal(paid.fee, 1, 'Fee tokens paid');
-    equal(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
-    equal(paid.id, invoice.id, 'Payment hash is equal on both sides');
-    equal(paid.mtokens, '101000', 'Paid mtokens');
-    equal(paid.secret, invoice.secret, 'Paid for invoice secret');
-
-    paid.hops.forEach(n => {
-      equal(n.timeout === height + 40 || n.timeout === height + 43, true);
-
-      delete n.timeout;
-
-      return;
+    const remoteChan = await setupChannel({
+      lnd: target.lnd,
+      generate: target.generate,
+      to: remote,
     });
 
-    const expectedHops = [
-      {
-        channel: channel.id,
-        channel_capacity: 1000000,
-        fee: 1,
-        fee_mtokens: '1000',
-        forward: 100,
-        forward_mtokens: invoice.mtokens,
-        public_key: target.id,
-      },
-      {
-        channel: remoteChan.id,
-        channel_capacity: 1000000,
-        fee: 0,
-        fee_mtokens: '0',
-        forward: 100,
-        forward_mtokens: '100000',
-        public_key: remote.id,
-      },
-    ];
-
-    strictSame(paid.hops, expectedHops, 'Hops are returned');
-
-    const {payments} = await getInvoice({id: paid.id, lnd: remote.lnd});
-
-    if (!!payments.length) {
-      const [payment] = payments;
-
-      if (!!payment.messages.length) {
-        const [message] = payment.messages;
-
-        equal(message.type, tlvType, 'Got TLV message type');
-        equal(message.value, tlvValue, 'Got TLV message value');
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+    await waitForRoute({lnd, tokens, destination: remote.id});
+
+    // When a route exists, payment is successful
+    try {
+      const commitTxFee = channel.commit_transaction_fee;
+      const height = (await getWalletInfo({lnd})).current_block_height;
+      const invoice = await createInvoice({tokens, lnd: remote.lnd});
+
+      const paid = await payViaPaymentRequest({
+        lnd,
+        max_timeout_height: height + 40 + 43,
+        messages: [{type: tlvType, value: tlvValue}],
+        request: invoice.request,
+      });
+
+      equal(paid.confirmed_at > start, true, 'Got confirmation date');
+      equal(paid.fee, 1, 'Fee tokens paid');
+      equal(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
+      equal(paid.id, invoice.id, 'Payment hash is equal on both sides');
+      equal(paid.mtokens, '101000', 'Paid mtokens');
+      equal(paid.secret, invoice.secret, 'Paid for invoice secret');
+
+      paid.hops.forEach(n => {
+        equal(n.timeout === height + 40 || n.timeout === height + 43, true);
+
+        delete n.timeout;
+
+        return;
+      });
+
+      const expectedHops = [
+        {
+          channel: channel.id,
+          channel_capacity: 1000000,
+          fee: 1,
+          fee_mtokens: '1000',
+          forward: 100,
+          forward_mtokens: invoice.mtokens,
+          public_key: target.id,
+        },
+        {
+          channel: remoteChan.id,
+          channel_capacity: 1000000,
+          fee: 0,
+          fee_mtokens: '0',
+          forward: 100,
+          forward_mtokens: '100000',
+          public_key: remote.id,
+        },
+      ];
+
+      strictSame(paid.hops, expectedHops, 'Hops are returned');
+
+      const {payments} = await getInvoice({id: paid.id, lnd: remote.lnd});
+
+      if (!!payments.length) {
+        const [payment] = payments;
+
+        if (!!payment.messages.length) {
+          const [message] = payment.messages;
+
+          equal(message.type, tlvType, 'Got TLV message type');
+          equal(message.value, tlvValue, 'Got TLV message value');
+        }
       }
+    } catch (err) {
+      equal(err, null, 'Expected no error paying payment request');
     }
   } catch (err) {
-    equal(err, null, 'Expected no error paying payment request');
+    equal(err, 'Expected no errors');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });

package/test/routerrpc-integration/test_probe_for_route.js

@@ -31,10 +31,12 @@ test('Probe for route', async ({end, equal, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  // Send coins to remote so that it can accept a channel
-  await remote.generate({count});
-
   try {
+    // Send coins to remote so that it can accept a channel
+    await remote.generate({count});
+
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
     await setupChannel({
       generate,
       lnd,
@@ -50,8 +52,6 @@ test('Probe for route', async ({end, equal, strictSame}) => {
       to: remote,
     });
 
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
     const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
     await delay(1000);

package/test/routerrpc-integration/test_subscribe_to_forward_requests.js

@@ -10,7 +10,6 @@ const {deleteForwardingReputations} = require('./../../');
 const {getHeight} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getPayment} = require('./../../');
-const {getWalletVersion} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {subscribeToForwardRequests} = require('./../../');
 const {subscribeToPayViaRequest} = require('./../../');

package/test/routerrpc-integration/test_subscribe_to_forwards.js

@@ -17,7 +17,7 @@ const {subscribeToForwards} = require('./../../');
 const anchorsFeatureBit = 23;
 const interval = 10;
 const size = 3;
-const times = 100;
+const times = 1000;
 const tokens = 100;
 
 // Subscribing to forwards should show forwarding events
@@ -41,7 +41,16 @@ test('Subscribe to forwards', async ({end, equal, rejects, strictSame}) => {
       to: remote,
     });
 
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd,
+        public_key: remote.id,
+        retry_count: 1,
+        retry_delay: 1,
+        socket: remote.socket,
+        timeout: 1000,
+      });
+    });
 
     await delay(3000);
 

package/test/routerrpc-integration/test_subscribe_to_past_payments.js

@@ -2,11 +2,8 @@ const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {addPeer} = require('./../../');
 const {createInvoice} = require('./../../');
 const {delay} = require('./../macros');
-const {getChannels} = require('./../../');
-const {getHeight} = require('./../../');
 const {getPayment} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {setupChannel} = require('./../macros');

package/test/tower_clientrpc-integration/test_get_connected_watchtowers.js

@@ -1,12 +1,9 @@
 const {test} = require('@alexbosworth/tap');
 
-const {closeChannel} = require('./../../');
 const {connectWatchtower} = require('./../../');
-const {createInvoice} = require('./../../');
 const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
 const {disconnectWatchtower} = require('./../../');
-const {getChannels} = require('./../../');
 const {getConnectedWatchtowers} = require('./../../');
 const {getTowerServerInfo} = require('./../../');
 const {openChannel} = require('./../../');