ln-service 53.6.0 → 53.7.3

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');
@@ -25,140 +24,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_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_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});