ln-service 53.5.2 → 53.7.2

package/test/integration/test_subscribe_to_channels.js

@@ -16,7 +16,7 @@ const defaultFee = 1e3;
 const giveTokens = 1e5;
 const interval = 100;
 const size = 2;
-const times = 20;
+const times = 200;
 
 // Subscribing to channels should trigger channel events
 test('Subscribe to channels', async ({end, equal, fail}) => {

package/test/integration/test_subscribe_to_peer_messages.js

@@ -16,98 +16,104 @@ test(`Subscribe to peer messages`, async ({end, equal, strictSame}) => {
 
   const [{lnd}, target, remote] = nodes;
 
-  await addPeer({
-    lnd,
-    public_key: target.id,
-    socket: target.socket,
-  });
-
-  await addPeer({
-    lnd: target.lnd,
-    public_key: remote.id,
-    socket: remote.socket,
-  });
-
   try {
-    await sendMessageToPeer({
+    await addPeer({
       lnd,
-      message: Buffer.from('message').toString('hex'),
       public_key: target.id,
+      socket: target.socket,
+    });
+
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
     });
-  } catch (err) {
-    const [code] = err;
 
-    // Send message to peer is not supported on LND 0.13.4 or lower
-    if (code === 501) {
-      await kill({});
+    try {
+      await sendMessageToPeer({
+        lnd,
+        message: Buffer.from('message').toString('hex'),
+        public_key: target.id,
+      });
+    } catch (err) {
+      const [code] = err;
 
-      return end();
+      // Send message to peer is not supported on LND 0.13.4 or lower
+      if (code === 501) {
+        await kill({});
+
+        return end();
+      }
     }
-  }
 
-  const messages = [];
-  const targetSub = subscribeToPeerMessages({lnd: target.lnd});
-  const remoteSub = subscribeToPeerMessages({lnd: remote.lnd});
-  const targetMessages = [];
+    const messages = [];
+    const targetSub = subscribeToPeerMessages({lnd: target.lnd});
+    const remoteSub = subscribeToPeerMessages({lnd: remote.lnd});
+    const targetMessages = [];
 
-  remoteSub.on('message_received', message => messages.push(message));
+    remoteSub.on('message_received', message => messages.push(message));
 
-  targetSub.on('message_received', async ({message, type}) => {
-    targetMessages.push(message);
+    targetSub.on('message_received', async ({message, type}) => {
+      targetMessages.push(message);
 
-    if (type !== 40805) {
-      return;
-    }
+      if (type !== 40805) {
+        return;
+      }
+
+      // Wait for message to appear
+      return await asyncRetry({interval, times}, async () => {
+      // Relay message from control to remote
+        await sendMessageToPeer({
+          message,
+          type,
+          lnd: target.lnd,
+          public_key: remote.id,
+        });
+
+        if (!messages.length) {
+          throw new Error('ExpectedMessage');
+        }
+      });
+    });
 
     // Wait for message to appear
-    return await asyncRetry({interval, times}, async () => {
-    // Relay message from control to remote
+    await asyncRetry({interval, times}, async () => {
+      // Control send a message to target peer
       await sendMessageToPeer({
-        message,
-        type,
-        lnd: target.lnd,
-        public_key: remote.id,
+        lnd,
+        message: Buffer.from('message to remote').toString('hex'),
+        public_key: target.id,
+        type: 40805,
       });
 
-      if (!messages.length) {
-        throw new Error('ExpectedMessage');
+      if (!targetMessages.length) {
+        throw new Error('ExpectedTargetMessageReceived');
       }
     });
-  });
 
-  // Wait for message to appear
-  await asyncRetry({interval, times}, async () => {
-    // Control send a message to target peer
-    await sendMessageToPeer({
-      lnd,
-      message: Buffer.from('message to remote').toString('hex'),
-      public_key: target.id,
-      type: 40805,
+    // Wait for message to appear
+    await asyncRetry({interval, times}, async () => {
+      if (!messages.length) {
+        throw new Error('ExpectedMessage');
+      }
     });
 
-    if (!targetMessages.length) {
-      throw new Error('ExpectedTargetMessageReceived');
-    }
-  });
-
-  // Wait for message to appear
-  await asyncRetry({interval, times}, async () => {
-    if (!messages.length) {
-      throw new Error('ExpectedMessage');
-    }
-  });
-
-  strictSame(
-    messages,
-    [{
-      message: Buffer.from('message to remote').toString('hex'),
-      public_key: target.id,
-      type: 40805,
-    }],
-    'Message successfully relayed through target'
-  );
-
-  await kill({});
+    const [message] = messages;
+
+    strictSame(
+      message,
+      {
+        message: Buffer.from('message to remote').toString('hex'),
+        public_key: target.id,
+        type: 40805,
+      },
+      'Message successfully relayed through target'
+    );
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/integration/test_subscribe_to_peers.js

@@ -20,36 +20,40 @@ test(`Subscribe to peers`, async ({end, equal}) => {
 
   const [{generate, lnd}, target] = nodes;
 
-  const sub = subscribeToPeers({lnd});
+  try {
+    const sub = subscribeToPeers({lnd});
 
-  sub.on('error', () => {});
+    sub.on('error', () => {});
 
-  await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-  });
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: target.id, socket: target.socket});
+    });
 
-  const disconnect = removePeer({lnd, public_key: target.id});
-  const receiveDisconnect = once(sub, 'disconnected');
+    const disconnect = removePeer({lnd, public_key: target.id});
+    const receiveDisconnect = once(sub, 'disconnected');
 
-  const [disconectMessage] = await all([receiveDisconnect, disconnect]);
+    const [disconectMessage] = await all([receiveDisconnect, disconnect]);
 
-  const [disconnected] = disconectMessage;
+    const [disconnected] = disconectMessage;
 
-  equal(disconnected.public_key, target.id, 'Got d/c event');
+    equal(disconnected.public_key, target.id, 'Got d/c event');
 
-  const connect = asyncRetry({interval, times}, async () => {
-    return addPeer({lnd, public_key: target.id, socket: target.socket});
-  });
+    const connect = asyncRetry({interval, times}, async () => {
+      return addPeer({lnd, public_key: target.id, socket: target.socket});
+    });
 
-  const receiveConnectMessage = once(sub, 'connected');
+    const receiveConnectMessage = once(sub, 'connected');
 
-  const [connectMessage] = await all([receiveConnectMessage, connect]);
+    const [connectMessage] = await all([receiveConnectMessage, connect]);
 
-  const [connected] = connectMessage;
+    const [connected] = connectMessage;
 
-  equal(connected.public_key, target.id, 'Got connected');
-
-  await kill({});
+    equal(connected.public_key, target.id, 'Got connected');
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/routerrpc-integration/test_get_forwarding_reputations.js

@@ -26,66 +26,70 @@ test('Get forwarding reputations', async ({end, equal}) => {
 
   const [{generate, id, lnd}, target, remote] = cluster.nodes;
 
-  await generate({count: 400});
-
-  // Create a channel from the control to the target node
-  await setupChannel({
-    generate,
-    lnd,
-    capacity: channelCapacityTokens * 2,
-    to: target,
-  });
-
-  const targetToRemoteChan = await setupChannel({
-    generate: target.generate,
-    give: Math.round(channelCapacityTokens / 2),
-    lnd: target.lnd,
-    to: remote,
-  });
-
-  await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    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');
-    }
-
-    const {nodes} = await getForwardingReputations({lnd});
-
-    const [node] = nodes;
-
-    if (!node) {
-      throw new Error('ExpectedForwardingNode');
-    }
-
-    equal(!!node.public_key, true, 'Temp fail node added');
-
-    const [peer] = node.peers;
-
-    if (!peer) {
-      throw new Error('ExpectedNodePeer');
-    }
-
-    if (!peer.last_failed_forward_at) {
-      throw new Error('ExpectedLastFailTimeReturned');
-    }
-
-    equal(!!peer.last_failed_forward_at, true, 'Last fail time returned');
-    equal(!!peer.to_public_key, true, 'Got peer pub key');
-  });
-
-  await cluster.kill({});
+  await generate({count: 100});
+
+  try {
+    // Create a channel from the control to the target node
+    await setupChannel({
+      generate,
+      lnd,
+      capacity: channelCapacityTokens * 2,
+      to: target,
+    });
+
+    const targetToRemoteChan = await setupChannel({
+      generate: target.generate,
+      give: Math.round(channelCapacityTokens / 2),
+      lnd: target.lnd,
+      to: remote,
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+      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');
+      }
+
+      const {nodes} = await getForwardingReputations({lnd});
+
+      const [node] = nodes;
+
+      if (!node) {
+        throw new Error('ExpectedForwardingNode');
+      }
+
+      equal(!!node.public_key, true, 'Temp fail node added');
+
+      const [peer] = node.peers;
+
+      if (!peer) {
+        throw new Error('ExpectedNodePeer');
+      }
+
+      if (!peer.last_failed_forward_at) {
+        throw new Error('ExpectedLastFailTimeReturned');
+      }
+
+      equal(!!peer.last_failed_forward_at, true, 'Last fail time returned');
+      equal(!!peer.to_public_key, true, 'Got peer pub key');
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await cluster.kill({});
+  }
 
   return end();
 });

package/test/routerrpc-integration/test_get_route_confidence.js

@@ -17,41 +17,45 @@ test('Get route confidence', async ({end, equal}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  // Create a channel from the control to the target node
-  await setupChannel({
-    generate,
-    lnd,
-    capacity: channelCapacityTokens * 2,
-    to: target,
-  });
-
-  // Create a too-small channel from target to remote
-  await setupChannel({
-    generate: target.generate,
-    give: Math.round(channelCapacityTokens / 2),
-    lnd: target.lnd,
-    to: remote,
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  const destination = remote.id;
-
-  // Allow time for graph sync to complete
-  const {routes} = await waitForRoute({destination, lnd, tokens});
-
-  // Run into a failure to inform future pathfinding
   try {
-    await probeForRoute({destination, lnd, tokens});
-  } catch (err) {}
-
-  const [{hops}] = routes;
-
-  const {confidence} = await getRouteConfidence({lnd, hops});
-
-  equal((confidence / 1e6) < 0.1, true, 'Due to fail, odds of success = low');
-
-  await kill({});
+    // Create a channel from the control to the target node
+    await setupChannel({
+      generate,
+      lnd,
+      capacity: channelCapacityTokens * 2,
+      to: target,
+    });
+
+    // Create a too-small channel from target to remote
+    await setupChannel({
+      generate: target.generate,
+      give: Math.round(channelCapacityTokens / 2),
+      lnd: target.lnd,
+      to: remote,
+    });
+
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+    const destination = remote.id;
+
+    // Allow time for graph sync to complete
+    const {routes} = await waitForRoute({destination, lnd, tokens});
+
+    // Run into a failure to inform future pathfinding
+    try {
+      await probeForRoute({destination, lnd, tokens});
+    } catch (err) {}
+
+    const [{hops}] = routes;
+
+    const {confidence} = await getRouteConfidence({lnd, hops});
+
+    equal((confidence / 1e6) < 0.1, true, 'Due to fail, odds of success low');
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/routerrpc-integration/test_get_route_through_hops.js

@@ -8,6 +8,7 @@ const {addPeer} = require('./../../');
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
 const {getInvoice} = require('./../../');
+const {getNetworkGraph} = require('./../../');
 const {getRouteThroughHops} = require('./../../');
 const {getRouteToDestination} = require('./../../');
 const {getWalletInfo} = require('./../../');
@@ -17,8 +18,10 @@ const {setupChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');
 
 const confirmationCount = 6;
+const interval = 10;
 const messages = [{type: '1000000', value: '01'}];
 const size = 3;
+const times = 1000;
 const tokens = 100;
 
 // Getting a route through hops should result in a route through specified hops
@@ -40,7 +43,7 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
 
   await target.generate({count: confirmationCount});
 
-  await asyncRetry({interval: 10, times: 1000}, async () => {
+  await asyncRetry({interval, times}, async () => {
     const wallet = await getWalletInfo({lnd: remote.lnd});
 
     await addPeer({lnd, public_key: remote.id, socket: remote.socket});
@@ -59,21 +62,37 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
 
   await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
 
-  const {route} = await getRouteToDestination({
-    lnd,
-    cltv_delta: decodedRequest.cltv_delta,
-    destination: decodedRequest.destination,
-    tokens: invoice.tokens,
+  const {route} = await asyncRetry({interval, times}, async () => {
+    return await getRouteToDestination({
+      lnd,
+      cltv_delta: decodedRequest.cltv_delta,
+      destination: decodedRequest.destination,
+      tokens: invoice.tokens,
+    });
   });
 
-  const res = await getRouteThroughHops({
-    lnd,
-    messages,
-    cltv_delta: decodedRequest.cltv_delta + 6,
-    mtokens: (BigInt(invoice.tokens) * BigInt(1e3)).toString(),
-    payment: decodedRequest.payment,
-    public_keys: route.hops.map(n => n.public_key),
-    total_mtokens: invoice.mtokens,
+  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,
+      messages,
+      cltv_delta: decodedRequest.cltv_delta + 6,
+      mtokens: (BigInt(invoice.tokens) * BigInt(1e3)).toString(),
+      payment: decodedRequest.payment,
+      public_keys: route.hops.map(n => n.public_key),
+      total_mtokens: invoice.mtokens,
+    });
   });
 
   await payViaRoutes({lnd, id: invoice.id, routes: [res.route]});