ln-service 53.6.0 → 53.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 53.7.0
+
+- `payViaRoutes`, `subscribeToPayViaRoutes`: Add support for relay messages
+
 ## 53.6.0
 
 - `partiallySignPsbt`: Add method to add a partial signature to a PSBT

package/README.md

@@ -2530,7 +2530,7 @@ LND 0.11.1 and below do not return `last_reconnected` or `reconnection_rate`
         }]
         is_inbound: <Is Inbound Peer Bool>
         [is_sync_peer]: <Is Syncing Graph Data Bool>
-        [last_reconnected]: <Peer Last Reconnected At ISO 8601 Date String>
+        [last_reconnection]: <Peer Last Reconnected At ISO 8601 Date String>
         ping_time: <Ping Latency Milliseconds Number>
         public_key: <Node Identity Public Key String>
         [reconnection_rate]: <Count of Reconnections Over Time Number>
@@ -3706,6 +3706,10 @@ Requires `offchain:write` permission
           fee_mtokens: <Fee Millitokens String>
           forward: <Forward Tokens Number>
           forward_mtokens: <Forward Millitokens String>
+          [messages]: [{
+            type: <Message Type Number String>
+            value: <Message Raw Value Hex Encoded String>
+          }]
           [public_key]: <Public Key Hex String>
           timeout: <Timeout Block Height Number>
         }]
@@ -5692,6 +5696,10 @@ Requires `offchain:write` permission
           fee_mtokens: <Fee Millitokens String>
           forward: <Forward Tokens Number>
           forward_mtokens: <Forward Millitokens String>
+          [messages]: [{
+            type: <Message Type Number String>
+            value: <Message Raw Value Hex Encoded String>
+          }]
           public_key: <Public Key Hex String>
           timeout: <Timeout Block Height Number>
         }]

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.17.2",
     "invoices": "2.0.3",
-    "lightning": "5.4.1",
+    "lightning": "5.6.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.4.2"
@@ -26,7 +26,7 @@
     "bitcoinjs-lib": "6.0.1",
     "bn.js": "5.2.0",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.2.1",
+    "ln-docker-daemons": "2.2.3",
     "portfinder": "1.0.28",
     "psbt": "1.1.11",
     "rimraf": "3.0.2",
@@ -65,5 +65,5 @@
     "integration-test-0.12.0": "DOCKER_LND_VERSION=v0.12.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/autopilotrpc-integration/*.js test/chainrpc-integration/*.js test/integration/*.js test/invoicesrpc-integration/*.js test/routerrpc-integration/*.js test/signerrpc-integration/*.js test/tower_clientrpc-integration/*.js test/tower_serverrpc-integration/*.js test/walletrpc-integration/*.js"
   },
-  "version": "53.6.0"
+  "version": "53.7.0"
 }

package/test/integration/test_add_peer.js

@@ -17,30 +17,34 @@ test(`Add a peer`, async ({end, equal}) => {
 
   const [{lnd}, target] = nodes;
 
-  const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
+  try {
+    const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
 
-  equal(connectedKeys.find(n => n === target.id), undefined, 'No peer');
+    equal(connectedKeys.find(n => n === target.id), undefined, 'No peer');
 
-  await asyncRetry({interval, times}, async () => {
-    await addPeer({
-      lnd,
-      timeout,
-      public_key: target.id,
-      socket: target.socket,
-    });
-
-    const {peers} = await getPeers({lnd});
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd,
+        timeout,
+        public_key: target.id,
+        socket: target.socket,
+      });
 
-    const connected = peers.find(n => n.public_key === target.id);
+      const {peers} = await getPeers({lnd});
 
-    if (!connected) {
-      throw new Error('ExpectedConnectionToTarget');
-    }
+      const connected = peers.find(n => n.public_key === target.id);
 
-    equal(connected.public_key, target.id, 'Connected to remote node');
-  });
+      if (!connected) {
+        throw new Error('ExpectedConnectionToTarget');
+      }
 
-  await kill({});
+      equal(connected.public_key, target.id, 'Connected to remote node');
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/integration/test_get_failed_payments.js

@@ -28,128 +28,132 @@ test('Get failed payments', async ({end, equal, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const {address} = await createChainAddress({lnd: remote.lnd});
-
-  await generate({count});
-
-  // Send coins to remote so that it can accept the channel
-  await sendToChainAddress({lnd, address, tokens: channelCapacityTokens});
-
-  // Generate to confirm the tx
-  await generate({count: confirmationCount});
-  await remote.generate({count: confirmationCount});
-
-  await setupChannel({
-    generate,
-    lnd,
-    capacity: channelCapacityTokens + channelCapacityTokens,
-    to: target,
-  });
-
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    generator: target,
-    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});
-
-  const bigInvoice = await createInvoice({
-    tokens: (channelCapacityTokens / 2) + (channelCapacityTokens / 4),
-    lnd: remote.lnd,
-  });
-
   try {
-    await pay({lnd, request: bigInvoice.request});
-  } catch (err) {
-  }
-
-  // Create a new channel to increase total edge liquidity
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    generator: target,
-    to: remote,
-  });
-
-  await deleteForwardingReputations({lnd});
-
-  await asyncRetry({times}, async () => {
-    await pay({lnd, request: invoice.request});
-  });
-
-  {
-    const {payments} = await getFailedPayments({lnd});
-
-    const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
-
-    equal(payment.destination, remote.id, 'Payment to');
-    equal(payment.confirmed_at, undefined, 'No confirmation date');
-    equal(!!payment.created_at, true, 'Got payment created date');
-    equal(payment.fee, undefined, 'No fee when not paid');
-    equal(payment.fee_mtokens, undefined, 'No fee mtokens when not paid');
-    equal(!!payment.id, true, 'Got a payment id');
-    equal(!!payment.index, true, 'Got payment index');
-    equal(payment.is_confirmed, false, 'Failed payment is not confirmed');
-    equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-    equal(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
-    equal(payment.request, bigInvoice.request, 'Probe has a request');
-    equal(payment.secret, undefined, 'Failed has no secret');
-    equal(payment.safe_fee, undefined, 'Failed has no fee');
-    equal(payment.safe_tokens, bigInvoice.tokens, 'Failed has safe tokens');
-    equal(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
-
-    const gotFailed = await getPayment({lnd, id: payment.id});
-
-    strictSame(
-      gotFailed,
-      {
-        failed: {
-          is_insufficient_balance: false,
-          is_invalid_payment: false,
-          is_pathfinding_timeout: false,
-          is_route_not_found: true,
+    const {address} = await createChainAddress({lnd: remote.lnd});
+
+    await generate({count});
+
+    // Send coins to remote so that it can accept the channel
+    await sendToChainAddress({lnd, address, tokens: channelCapacityTokens});
+
+    // Generate to confirm the tx
+    await generate({count: confirmationCount});
+    await remote.generate({count: confirmationCount});
+
+    await setupChannel({
+      generate,
+      lnd,
+      capacity: channelCapacityTokens + channelCapacityTokens,
+      to: target,
+    });
+
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      generator: target,
+      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});
+
+    const bigInvoice = await createInvoice({
+      tokens: (channelCapacityTokens / 2) + (channelCapacityTokens / 4),
+      lnd: remote.lnd,
+    });
+
+    try {
+      await pay({lnd, request: bigInvoice.request});
+    } catch (err) {
+    }
+
+    // Create a new channel to increase total edge liquidity
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      generator: target,
+      to: remote,
+    });
+
+    await deleteForwardingReputations({lnd});
+
+    await asyncRetry({times}, async () => {
+      await pay({lnd, request: invoice.request});
+    });
+
+    {
+      const {payments} = await getFailedPayments({lnd});
+
+      const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
+
+      equal(payment.destination, remote.id, 'Payment to');
+      equal(payment.confirmed_at, undefined, 'No confirmation date');
+      equal(!!payment.created_at, true, 'Got payment created date');
+      equal(payment.fee, undefined, 'No fee when not paid');
+      equal(payment.fee_mtokens, undefined, 'No fee mtokens when not paid');
+      equal(!!payment.id, true, 'Got a payment id');
+      equal(!!payment.index, true, 'Got payment index');
+      equal(payment.is_confirmed, false, 'Failed payment is not confirmed');
+      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
+      equal(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
+      equal(payment.request, bigInvoice.request, 'Probe has a request');
+      equal(payment.secret, undefined, 'Failed has no secret');
+      equal(payment.safe_fee, undefined, 'Failed has no fee');
+      equal(payment.safe_tokens, bigInvoice.tokens, 'Failed has safe tokens');
+      equal(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
+
+      const gotFailed = await getPayment({lnd, id: payment.id});
+
+      strictSame(
+        gotFailed,
+        {
+          failed: {
+            is_insufficient_balance: false,
+            is_invalid_payment: false,
+            is_pathfinding_timeout: false,
+            is_route_not_found: true,
+          },
+          is_confirmed: false,
+          is_failed: true,
+          is_pending: false,
+          payment: undefined,
+          pending: undefined,
         },
-        is_confirmed: false,
-        is_failed: true,
-        is_pending: false,
-        payment: undefined,
-        pending: undefined,
-      },
-      'Got failed state'
-    );
-  }
-
-  {
-    const {payments} = await getPayments({lnd});
-
-    const [payment] = payments;
-
-    equal(payment.destination, remote.id, 'Paid to');
-    equal(!!payment.confirmed_at, true, 'Got confirmation date');
-    equal(!!payment.created_at, true, 'Got payment start date');
-    equal(payment.fee, 1, 'Got fee paid');
-    equal(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
-    strictSame(payment.hops, [target.id], 'Got hops');
-    equal(!!payment.id, true, 'Got a payment id');
-    equal(!!payment.index, true, 'Got payment index');
-    equal(payment.is_confirmed, true, 'Failed payment is not confirmed');
-    equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-    equal(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
-    equal(payment.request, invoice.request, 'Payment has a request');
-    equal(!!payment.secret, true, 'Failed has no secret');
-    equal(payment.safe_fee, 2, 'Failed has no fee');
-    equal(payment.safe_tokens, invoice.tokens, 'Failed has safe tokens');
-    equal(payment.tokens, invoice.tokens, 'Failed has tokens');
+        'Got failed state'
+      );
+    }
+
+    {
+      const {payments} = await getPayments({lnd});
+
+      const [payment] = payments;
+
+      equal(payment.destination, remote.id, 'Paid to');
+      equal(!!payment.confirmed_at, true, 'Got confirmation date');
+      equal(!!payment.created_at, true, 'Got payment start date');
+      equal(payment.fee, 1, 'Got fee paid');
+      equal(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
+      strictSame(payment.hops, [target.id], 'Got hops');
+      equal(!!payment.id, true, 'Got a payment id');
+      equal(!!payment.index, true, 'Got payment index');
+      equal(payment.is_confirmed, true, 'Failed payment is not confirmed');
+      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
+      equal(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
+      equal(payment.request, invoice.request, 'Payment has a request');
+      equal(!!payment.secret, true, 'Failed has no secret');
+      equal(payment.safe_fee, 2, 'Failed has no fee');
+      equal(payment.safe_tokens, invoice.tokens, 'Failed has safe tokens');
+      equal(payment.tokens, invoice.tokens, 'Failed has tokens');
+    }
+  } catch (err) {
+    strictSame(err, null, 'Expected no error');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });

package/test/integration/test_get_node.js

@@ -24,62 +24,66 @@ test(`Get node`, async ({end, equal, strictSame}) => {
 
   const [{generate, id, lnd}, target, remote] = nodes;
 
-  const controlToTarget = await setupChannel({generate, lnd, to: target});
+  try {
+    const controlToTarget = await setupChannel({generate, lnd, to: target});
 
-  const targetToRemote = await setupChannel({
-    generate: target.generate,
-    lnd: target.lnd,
-    to: remote,
-  });
+    const targetToRemote = await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
+    });
 
-  await updateRoutingFees({
-    lnd,
-    base_fee_tokens: baseFee,
-    cltv_delta: cltvDelta,
-    fee_rate: feeRate,
-    transaction_id: controlToTarget.transaction_id,
-    transaction_vout: controlToTarget.transaction_vout,
-  });
+    await updateRoutingFees({
+      lnd,
+      base_fee_tokens: baseFee,
+      cltv_delta: cltvDelta,
+      fee_rate: feeRate,
+      transaction_id: controlToTarget.transaction_id,
+      transaction_vout: controlToTarget.transaction_vout,
+    });
 
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-  await delay(3000);
+    await delay(3000);
 
-  const node = await getNode({lnd, public_key: id});
+    const node = await getNode({lnd, public_key: id});
 
-  {
-    const {channels} = await getNode({
-      lnd,
-      is_omitting_channels: true,
-      public_key: id,
-    });
+    {
+      const {channels} = await getNode({
+        lnd,
+        is_omitting_channels: true,
+        public_key: id,
+      });
 
-    equal(channels.length, [].length, 'Channels are omitted')
-  }
-
-  if (!!node.channels.length) {
-    const [{policies}] = node.channels;
+      equal(channels.length, [].length, 'Channels are omitted')
+    }
 
-    const policy = policies.find(n => n.public_key === id);
+    if (!!node.channels.length) {
+      const [{policies}] = node.channels;
 
-    equal(BigInt(policy.base_fee_mtokens), BigInt(baseFee)*mtokPerTok, 'Base');
-    equal(policy.cltv_delta, cltvDelta, 'Got expected cltv delta');
-    equal(policy.fee_rate, feeRate, 'Got expected fee rate');
-    equal(policy.is_disabled, false, 'Channel is not disabled');
-    equal(policy.max_htlc_mtokens, '990000000', 'Max HTLC mtokens returned');
-    equal(policy.min_htlc_mtokens, '1000', 'Min HTLC mtokens returned');
-  }
+      const policy = policies.find(n => n.public_key === id);
 
-  const [socket] = node.sockets;
+      equal(BigInt(policy.base_fee_mtokens), BigInt(baseFee)*mtokPerTok, 'bf');
+      equal(policy.cltv_delta, cltvDelta, 'Got expected cltv delta');
+      equal(policy.fee_rate, feeRate, 'Got expected fee rate');
+      equal(policy.is_disabled, false, 'Channel is not disabled');
+      equal(policy.max_htlc_mtokens, '990000000', 'Max HTLC mtokens returned');
+      equal(policy.min_htlc_mtokens, '1000', 'Min HTLC mtokens returned');
+    }
 
-  equal(node.alias, id.slice(0, defaultAliasLength), 'Alias');
-  equal(node.color, '#3399ff', 'Color');
-  equal(node.sockets.length, 1, 'Socket');
-  equal(!!socket.socket, true, 'Ip, port');
-  equal(socket.type, 'tcp', 'Socket type');
-  equal(node.updated_at.length, 24, 'Update date');
+    const [socket] = node.sockets;
 
-  await kill({});
+    equal(node.alias, id.slice(0, defaultAliasLength), 'Alias');
+    equal(node.color, '#3399ff', 'Color');
+    equal(node.sockets.length, 1, 'Socket');
+    equal(!!socket.socket, true, 'Ip, port');
+    equal(socket.type, 'tcp', 'Socket type');
+    equal(node.updated_at.length, 24, 'Update date');
+  } catch (err) {
+    strictSame(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/integration/test_get_wallet_info.js

@@ -1,11 +1,14 @@
+const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getWalletInfo} = require('./../../');
 
 const initHeight = 1;
+const interval = 10;
 const pubKeyHexLength = Buffer.alloc(33).toString('hex').length;
 const regtestChainId = '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f';
+const times = 1000;
 const walletInfoType = 'wallet';
 
 // Getting the wallet info should return info about the wallet
@@ -16,6 +19,14 @@ test(`Get wallet info`, async ({end, equal, strictSame}) => {
 
   const result = await getWalletInfo({lnd});
 
+  await asyncRetry({interval, times}, async () => {
+    if (result.current_block_height === initHeight) {
+      return;
+    }
+
+    throw new Error('ExpectedBlockHeightAtInitHeight');
+  });
+
   equal(result.active_channels_count, 0, 'Expected channels count');
   equal(!!result.alias, true, 'Expected alias');
   strictSame(result.chains, [regtestChainId], 'Got chains');

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/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,11 +62,25 @@ 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,
+    });
+  });
+
+  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 getRouteThroughHops({

package/test/routerrpc-integration/test_pay_via_routes.js

@@ -18,6 +18,7 @@ const {openChannel} = require('./../../');
 const {payViaRoutes} = require('./../../');
 const {routeFromChannels} = require('./../../');
 const {setupChannel} = require('./../macros');
+const {subscribeToForwardRequests} = require('./../../');
 const {waitForChannel} = require('./../macros');
 const {waitForPendingChannel} = require('./../macros');
 const {waitForRoute} = require('./../macros');
@@ -27,6 +28,7 @@ const confirmationCount = 6;
 const defaultFee = 1e3;
 const defaultVout = 0;
 const interval = 10;
+const intermediateRecord = {type: '65536', value: '5678'};
 const mtokPadding = '000';
 const regtestChain = '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206';
 const reserveRatio = 0.99;
@@ -39,7 +41,7 @@ const tokens = 100;
 const txIdHexLength = 32 * 2;
 
 // Paying via routes should successfully pay via routes
-test(`Pay via routes`, async ({end, equal}) => {
+test(`Pay via routes`, async ({end, equal, strictSame}) => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;
@@ -170,10 +172,26 @@ test(`Pay via routes`, async ({end, equal}) => {
     equal(lowFeeErrMessage, 'FeeInsufficient', 'Low fee returns low fee msg');
   }
 
+  const [hopToTarget] = route.hops;
+
+  hopToTarget.messages = [intermediateRecord];
+
   route.messages = [{type: tlvType, value: tlvValue}];
 
+  const sub = subscribeToForwardRequests({lnd: target.lnd});
+
+  const forwardMessages = [];
+
+  sub.on('forward_request', request => {
+    request.messages.forEach(message => forwardMessages.push(message));
+
+    return request.accept();
+  });
+
   const payment = await payViaRoutes({id, lnd, routes: [route]});
 
+  strictSame(forwardMessages, [intermediateRecord], 'Got intermediate record');
+
   equal(payment.confirmed_at > start, true, 'Paid has confirm date');
 
   const paidInvoice = await getInvoice({id, lnd: remote.lnd});

package/test/routerrpc-integration/test_subscribe_to_forward_requests.js

@@ -20,8 +20,8 @@ const {waitForRoute} = require('./../macros');
 const size = 3;
 const tokens = 100;
 
-// Paying an invoice should settle the invoice
-test(`Pay via payment request`, async ({end, equal, rejects, strictSame}) => {
+// Subscribing to forward requests should intercept forwards
+test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;