ln-service 53.7.1 → 53.7.2

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_route_through_hops.js

@@ -83,14 +83,16 @@ test(`Get route through hops`, async ({end, equal, strictSame}) => {
     }
   });
 
-  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,
+  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]});

package/test/routerrpc-integration/test_pay_via_payment_details.js

@@ -25,140 +25,148 @@ test(`Pay`, async ({end, equal, rejects, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const channel = await setupChannel({lnd, generate, to: target});
-
-  const remoteChan = await setupChannel({
-    generate: target.generate,
-    lnd: target.lnd,
-    to: remote,
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  const height = (await getHeight({lnd})).current_block_height;
-  const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-  const {features} = await decodePaymentRequest({
-    lnd,
-    request: invoice.request,
-  });
-
-  const expectedHops = [
-    {
-      channel: channel.id,
-      channel_capacity: 1000000,
-      fee: 1,
-      fee_mtokens: '1000',
-      forward: invoice.tokens,
-      forward_mtokens: (BigInt(invoice.tokens) * BigInt(1e3)).toString(),
-      public_key: target.id,
-    },
-    {
-      channel: remoteChan.id,
-      channel_capacity: 1000000,
-      fee: 0,
-      fee_mtokens: '0',
-      forward: invoice.tokens,
-      forward_mtokens: '100000',
-      public_key: remote.id,
-    },
-  ];
-
-  await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
-
   try {
-    const paid = await payViaPaymentDetails({
-      features,
-      lnd,
-      destination: remote.id,
-      payment: invoice.payment,
-      tokens: invoice.tokens,
-    });
-  } catch (err) {
-    strictSame(err, [503, 'PaymentRejectedByDestination']);
-  }
+    const channel = await setupChannel({lnd, generate, to: target});
 
-  try {
-    const tooSoonCltv = await payViaPaymentDetails({
-      features,
-      lnd,
-      destination: remote.id,
-      id: invoice.id,
-      max_timeout_height: height + 46,
-      payment: invoice.payment,
-      tokens: invoice.tokens,
+    const remoteChan = await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
     });
 
-    equal(tooSoonCltv, null, 'Should not be able to pay a too soon CLTV');
-  } catch (err) {
-    strictSame(err, [503, 'PaymentPathfindingFailedToFindPossibleRoute'], 'Fail');
-  }
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-  try {
-    const paid = await payViaPaymentDetails({
-      features,
+    const height = (await getHeight({lnd})).current_block_height;
+    const invoice = await createInvoice({tokens, lnd: remote.lnd});
+
+    const {features} = await decodePaymentRequest({
       lnd,
-      destination: remote.id,
-      id: invoice.id,
-      max_timeout_height: height + 90,
-      messages: [{type: tlvType, value: tlvData}],
-      payment: invoice.payment,
-      tokens: invoice.tokens,
+      request: invoice.request,
     });
 
-    equal(paid.confirmed_at > start, true, 'Confirm date was received');
-    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;
+    const expectedHops = [
+      {
+        channel: channel.id,
+        channel_capacity: 1000000,
+        fee: 1,
+        fee_mtokens: '1000',
+        forward: invoice.tokens,
+        forward_mtokens: (BigInt(invoice.tokens) * BigInt(1e3)).toString(),
+        public_key: target.id,
+      },
+      {
+        channel: remoteChan.id,
+        channel_capacity: 1000000,
+        fee: 0,
+        fee_mtokens: '0',
+        forward: invoice.tokens,
+        forward_mtokens: '100000',
+        public_key: remote.id,
+      },
+    ];
+
+    await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
+
+    try {
+      const paid = await payViaPaymentDetails({
+        features,
+        lnd,
+        destination: remote.id,
+        payment: invoice.payment,
+        tokens: invoice.tokens,
+      });
+    } catch (err) {
+      strictSame(err, [503, 'PaymentRejectedByDestination']);
+    }
 
-      return;
-    });
+    try {
+      const tooSoonCltv = await payViaPaymentDetails({
+        features,
+        lnd,
+        destination: remote.id,
+        id: invoice.id,
+        max_timeout_height: height + 46,
+        payment: invoice.payment,
+        tokens: invoice.tokens,
+      });
+
+      equal(tooSoonCltv, null, 'Should not be able to pay a too soon CLTV');
+    } catch (err) {
+      strictSame(
+        err,
+        [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
+        'Fail'
+      );
+    }
 
-    strictSame(paid.hops, expectedHops, 'Hops are returned');
-  } catch (err) {
-    equal(err, null, 'No error is thrown when payment is attempted');
-  }
+    try {
+      const paid = await payViaPaymentDetails({
+        features,
+        lnd,
+        destination: remote.id,
+        id: invoice.id,
+        max_timeout_height: height + 90,
+        messages: [{type: tlvType, value: tlvData}],
+        payment: invoice.payment,
+        tokens: invoice.tokens,
+      });
+
+      equal(paid.confirmed_at > start, true, 'Confirm date was received');
+      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;
+      });
+
+      strictSame(paid.hops, expectedHops, 'Hops are returned');
+    } catch (err) {
+      equal(err, null, 'No error is thrown when payment is attempted');
+    }
 
-  {
-    const {payments} = await getInvoice({id: invoice.id, lnd: remote.lnd});
+    {
+      const {payments} = await getInvoice({id: invoice.id, lnd: remote.lnd});
 
-    if (!!payments) {
-      const [payment] = payments;
+      if (!!payments) {
+        const [payment] = payments;
 
-      if (!!payment && !!payment.messages.length) {
-        const [message] = payment.messages;
+        if (!!payment && !!payment.messages.length) {
+          const [message] = payment.messages;
 
-        equal(message.type, tlvType, 'Got TLV type');
-        equal(message.value, tlvData, 'Got TLV value');
+          equal(message.type, tlvType, 'Got TLV type');
+          equal(message.value, tlvData, 'Got TLV value');
+        }
       }
     }
-  }
 
-  {
-    const {invoices} = await getInvoices({lnd: remote.lnd});
+    {
+      const {invoices} = await getInvoices({lnd: remote.lnd});
 
-    const [{payments}] = invoices;
+      const [{payments}] = invoices;
 
-    if (!!payments.length) {
-      const [payment] = payments;
+      if (!!payments.length) {
+        const [payment] = payments;
 
-      if (!!payment && !!payment.messages.length) {
-        const [message] = payment.messages;
+        if (!!payment && !!payment.messages.length) {
+          const [message] = payment.messages;
 
-        equal(message.type, tlvType, 'Got TLV type');
-        equal(message.value, tlvData, 'Got TLV value');
+          equal(message.type, tlvType, 'Got TLV type');
+          equal(message.value, tlvData, 'Got TLV value');
+        }
       }
     }
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });

package/test/routerrpc-integration/test_probe_for_route.js

@@ -34,96 +34,100 @@ test('Probe for route', async ({end, equal, strictSame}) => {
   // Send coins to remote so that it can accept a channel
   await remote.generate({count});
 
-  await setupChannel({
-    generate,
-    lnd,
-    capacity: channelCapacityTokens + channelCapacityTokens,
-    to: target,
-  });
-
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    give: Math.round(channelCapacityTokens / 2),
-    to: remote,
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-  await delay(1000);
-
   try {
-    await probeForRoute({
+    await setupChannel({
+      generate,
       lnd,
-      destination: remote.id,
-      is_ignoring_past_failures: true,
-      tokens: invoice.tokens,
+      capacity: channelCapacityTokens + channelCapacityTokens,
+      to: target,
     });
-  } catch (err) {
-    const [code, message, {failure}] = err;
 
-    equal(code, 503, 'Failed to find route');
-    equal(message, 'RoutingFailure', 'Hit a routing failure');
-    equal(failure.reason, 'TemporaryChannelFailure', 'Temporary failure');
-  }
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      give: Math.round(channelCapacityTokens / 2),
+      to: remote,
+    });
 
-  const {version} = await getWalletVersion({lnd});
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-  const [, minor] = (version || '').split('.');
+    const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
-  if (!version || parseInt(minor) > 13) {
-    const {payments} = await getFailedPayments({lnd});
+    await delay(1000);
 
-    strictSame(payments, [], 'Probes do not leave a failed state behind');
-  }
+    try {
+      await probeForRoute({
+        lnd,
+        destination: remote.id,
+        is_ignoring_past_failures: true,
+        tokens: invoice.tokens,
+      });
+    } catch (err) {
+      const [code, message, {failure}] = err;
 
-  // Create a new channel to increase total edge liquidity
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    to: remote,
-  });
+      equal(code, 503, 'Failed to find route');
+      equal(message, 'RoutingFailure', 'Hit a routing failure');
+      equal(failure.reason, 'TemporaryChannelFailure', 'Temporary failure');
+    }
 
-  await deleteForwardingReputations({lnd});
+    const {version} = await getWalletVersion({lnd});
 
-  await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
+    const [, minor] = (version || '').split('.');
 
-  try {
-    const {route} = await probeForRoute({
-      lnd,
-      destination: remote.id,
-      payment: invoice.payment,
-      tokens: invoice.tokens,
-      total_mtokens: !!invoice.payment ? invoice.mtokens : undefined,
-    });
+    if (!version || parseInt(minor) > 13) {
+      const {payments} = await getFailedPayments({lnd});
 
-    if (!route) {
-      throw new Error('ExpectedRouteFromProbe');
+      strictSame(payments, [], 'Probes do not leave a failed state behind');
     }
 
-    equal(route.fee, 1, 'Found route fee');
-    equal(route.fee_mtokens, '1500', 'Found route fee mtokens');
-    strictSame(route.hops.length, 2, 'Found route hops returned');
-    equal(route.mtokens, '500001500', 'Found route mtokens');
-    equal(route.timeout >= 400, true, 'Found route timeout');
-    equal(route.tokens, 500001, 'Found route tokens');
-
-    const {secret} = await payViaRoutes({
-      lnd,
-      id: invoice.id,
-      routes: [route],
+    // Create a new channel to increase total edge liquidity
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      to: remote,
     });
 
-    equal(secret, invoice.secret, 'Route works');
+    await deleteForwardingReputations({lnd});
+
+    await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
+
+    try {
+      const {route} = await probeForRoute({
+        lnd,
+        destination: remote.id,
+        payment: invoice.payment,
+        tokens: invoice.tokens,
+        total_mtokens: !!invoice.payment ? invoice.mtokens : undefined,
+      });
+
+      if (!route) {
+        throw new Error('ExpectedRouteFromProbe');
+      }
+
+      equal(route.fee, 1, 'Found route fee');
+      equal(route.fee_mtokens, '1500', 'Found route fee mtokens');
+      strictSame(route.hops.length, 2, 'Found route hops returned');
+      equal(route.mtokens, '500001500', 'Found route mtokens');
+      equal(route.timeout >= 400, true, 'Found route timeout');
+      equal(route.tokens, 500001, 'Found route tokens');
+
+      const {secret} = await payViaRoutes({
+        lnd,
+        id: invoice.id,
+        routes: [route],
+      });
+
+      equal(secret, invoice.secret, 'Route works');
+    } catch (err) {
+      equal(err, null, 'No error when probing for route');
+    }
   } catch (err) {
-    equal(err, null, 'No error when probing for route');
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });