paid-services 9.2.0 → 9.3.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## Version 9.3.0
+
+- `getOfferInvoice`: Add `description` and `paths` to show and pay the invoice
+
 ## Version 9.2.0
 
 - `getOfferInvoice`: Add method to get an invoice for a BOLT 12 offer

package/offers/check_offer_invoice_reply.js

@@ -27,6 +27,25 @@ const {typeInvoiceError} = require('./constants');
       id: <Payment Hash Hex String>
       invoice: <BOLT 12 Invoice String>
       mtokens: <Invoice Amount Millitokens String>
+      paths: [{
+        base_fee_mtokens: <Accumulated Base Fee Millitokens String>
+        cltv_delta: <Accumulated CLTV Expiry Delta Number>
+        features: [{
+          bit: <BOLT 09 Feature Bit Number>
+          is_required: <Feature Support is Required To Pay Bool>
+          type: <Feature Type String>
+        }]
+        fee_rate: <Accumulated Fee Rate Millitokens Per Million Number>
+        hops: [{
+          encrypted_data: <Encrypted Recipient Data Hex String>
+          relay_key: <Blinded Relaying Node Public Key Hex String>
+        }]
+        [introduction_edge]: <Introduction Node Edge Format Channel Id String>
+        [introduction_node]: <Introduction Node Public Key Hex String>
+        key: <First Hop Path Key Public Key Hex String>
+        max_htlc_mtokens: <Maximum HTLC Millitokens String>
+        min_htlc_mtokens: <Minimum HTLC Millitokens String>
+      }]
     }
   }
 */
@@ -77,6 +96,7 @@ module.exports = ({reply, request}) => {
       id: invoice.id,
       invoice: invoice.invoice,
       mtokens: invoice.mtokens,
+      paths: invoice.paths,
     },
   };
 };

package/offers/get_offer_invoice.js

@@ -1,18 +1,13 @@
 const asyncAuto = require('async/auto');
-const asyncTryEach = require('async/tryEach');
+const asyncReduce = require('async/reduce');
 const {getNetwork} = require('ln-sync');
 const {getPeers} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
-const checkOfferInvoiceReply = require('./check_offer_invoice_reply');
 const invoiceRequestForOffer = require('./invoice_request_for_offer');
 const offerInvoiceFailure = require('./offer_invoice_failure');
-const replyIntroduction = require('./../network/reply_introduction');
-const {requestNetworkReply} = require('./../network');
+const requestOfferInvoice = require('./request_offer_invoice');
 const {resolvePathIntroductions} = require('./../network');
-const {typeInvoice} = require('./constants');
-const {typeInvoiceError} = require('./constants');
-const {typeInvoiceRequest} = require('./constants');
 
 const {isSafeInteger} = Number;
 const defaultTimeoutMs = 30000;
@@ -40,10 +35,24 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
 
   @returns via cbk or Promise
   {
+    [description]: <Offer Description String>
     expires_at: <Invoice Expires At ISO 8601 Date String>
     id: <Payment Hash Hex String>
     invoice: <BOLT 12 Invoice String>
     mtokens: <Invoice Amount Millitokens String>
+    paths: [{
+      base_fee_mtokens: <Accumulated Base Fee Millitokens String>
+      cltv_delta: <Accumulated CLTV Expiry Delta Number>
+      fee_rate: <Accumulated Fee Rate Millitokens Per Million Number>
+      hops: [{
+        encrypted_data: <Encrypted Recipient Data Hex String>
+        relay_key: <Blinded Relaying Node Public Key Hex String>
+      }]
+      introduction_node: <Introduction Node Public Key Hex String>
+      key: <First Hop Path Key Public Key Hex String>
+      max_htlc_mtokens: <Maximum HTLC Millitokens String>
+      min_htlc_mtokens: <Minimum HTLC Millitokens String>
+    }]
     payer_id: <Payer Public Key Hex String>
     payer_secret: <Payer Secret Key Hex String>
   }
@@ -95,95 +104,101 @@ module.exports = (args, cbk) => {
           lnd: args.lnd,
           paths: request.paths,
         },
-        (err, res) => {
-          if (!!err) {
-            return cbk(err);
-          }
+        cbk);
+      }],
 
-          // Exit early when no path has a known introduction node
-          if (!res.paths.length) {
-            return cbk([503, 'FailedToFindIntroductionNodesOfOfferPaths']);
-          }
+      // The offer paths to send the request over
+      offerPaths: ['getPaths', ({getPaths}, cbk) => {
+        // Exit early when no path has a known introduction node
+        if (!getPaths.paths.length) {
+          return cbk([503, 'FailedToFindIntroductionNodesOfOfferPaths']);
+        }
 
-          return cbk(null, res.paths);
-        });
+        return cbk(null, getPaths.paths);
       }],
 
-      // Send the request over each path in turn until there is an invoice
-      getInvoice: [
-        'getPaths',
+      // Send the request over each path in turn until the recipient answers
+      getReplies: [
         'getPeers',
+        'offerPaths',
         'request',
-        ({getPaths, getPeers, request}, cbk) =>
+        ({getPeers, offerPaths, request}, cbk) =>
       {
-        const failures = [];
-
-        // Make a task to send the request over a path and check the reply
-        const requestOver = path => cbk => {
-          const {introduction} = replyIntroduction({
-            path,
-            peers: getPeers.peers,
-          });
-
-          return requestNetworkReply({
-            introduction,
+        return asyncReduce(offerPaths, [], (replies, path, cbk) => {
+          return requestOfferInvoice({
             path,
+            replies,
+            request,
             lnd: args.lnd,
-            message: {type: typeInvoiceRequest, value: request.encoded},
+            peers: getPeers.peers,
             timeout: args.timeout || defaultTimeoutMs,
-            types: [typeInvoice, typeInvoiceError],
           },
-          (err, res) => {
-            // Exit early and try the next path when there was no reply
-            if (!!err) {
-              failures.push({err});
-
-              return cbk(err);
-            }
-
-            const {error, invoice} = checkOfferInvoiceReply({
-              request,
-              reply: res.reply,
-            });
-
-            // Exit early and stop when the recipient sent an invoice error,
-            // since it got the request and said why there is no invoice
-            if (!!error && res.reply.type === typeInvoiceError) {
-              return cbk(null, {error});
-            }
-
-            // Exit early and try the next path when there is no good invoice
-            if (!!error) {
-              failures.push({err: error, is_reply: true});
-
-              return cbk(error);
-            }
-
-            return cbk(null, {invoice});
-          });
-        };
-
-        return asyncTryEach(getPaths.map(requestOver), (err, res) => {
-          if (!!err) {
-            return cbk(offerInvoiceFailure({failures}).error);
-          }
-
-          // Exit early when the recipient said why there is no invoice
-          if (!!res.error) {
-            return cbk(res.error);
-          }
-
-          return cbk(null, res.invoice);
-        });
+          cbk);
+        },
+        cbk);
+      }],
+
+      // The invoice the recipient answered with
+      getInvoice: ['getReplies', ({getReplies}, cbk) => {
+        const answer = getReplies.find(n => !!n.error || !!n.invoice);
+
+        // Exit early when no path gave back an answer from the recipient
+        if (!answer) {
+          const failures = getReplies.filter(n => !!n.err);
+
+          return cbk(offerInvoiceFailure({failures}).error);
+        }
+
+        // Exit early when the recipient said why there is no invoice
+        if (!!answer.error) {
+          return cbk(answer.error);
+        }
+
+        return cbk(null, answer.invoice);
+      }],
+
+      // Find the introduction node of each invoice path, to pay over it
+      getPaymentPaths: ['getInvoice', ({getInvoice}, cbk) => {
+        return resolvePathIntroductions({
+          lnd: args.lnd,
+          paths: getInvoice.paths,
+        },
+        cbk);
+      }],
+
+      // The payment paths to pay the invoice over
+      paymentPaths: ['getPaymentPaths', ({getPaymentPaths}, cbk) => {
+        // Exit early when no payment path has a known introduction node
+        if (!getPaymentPaths.paths.length) {
+          return cbk([503, 'FailedToFindStartOfPaymentPathsForOfferInvoice']);
+        }
+
+        return cbk(null, getPaymentPaths.paths.map(path => ({
+          base_fee_mtokens: path.base_fee_mtokens,
+          cltv_delta: path.cltv_delta,
+          fee_rate: path.fee_rate,
+          hops: path.hops,
+          introduction_node: path.introduction_node,
+          key: path.key,
+          max_htlc_mtokens: path.max_htlc_mtokens,
+          min_htlc_mtokens: path.min_htlc_mtokens,
+        })));
       }],
 
       // The invoice for the request
-      invoice: ['getInvoice', 'request', ({getInvoice, request}, cbk) => {
+      invoice: [
+        'getInvoice',
+        'paymentPaths',
+        'request',
+        ({getInvoice, paymentPaths, request}, cbk) =>
+      {
         return cbk(null, {
+          description: request.description,
           expires_at: getInvoice.expires_at,
           id: getInvoice.id,
           invoice: getInvoice.invoice,
           mtokens: getInvoice.mtokens,
+          paths: paymentPaths,
           payer_id: request.payer_id,
           payer_secret: request.payer_secret,
         });

package/offers/invoice_request_for_offer.js

@@ -32,6 +32,7 @@ const namePattern = /^[0-9a-zA-Z\-_.]+@[0-9a-zA-Z\-_.]+$/;
 
   @returns
   {
+    [description]: <Offer Description String>
     encoded: <Signed Invoice Request TLV Stream Hex String>
     mtokens: <Requested Millitokens String>
     paths: [{
@@ -137,6 +138,7 @@ module.exports = args => {
   });
 
   return {
+    description: details.description,
     encoded: signed.encoded,
     mtokens: amount,
     paths: details.paths,

package/offers/request_offer_invoice.js

@@ -0,0 +1,153 @@
+const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
+const {returnResult} = require('asyncjs-util');
+
+const checkOfferInvoiceReply = require('./check_offer_invoice_reply');
+const replyIntroduction = require('./../network/reply_introduction');
+const {requestNetworkReply} = require('./../network');
+const {typeInvoice} = require('./constants');
+const {typeInvoiceError} = require('./constants');
+const {typeInvoiceRequest} = require('./constants');
+
+const {isArray} = Array;
+const isAnswered = replies => replies.some(n => !!n.error || !!n.invoice);
+
+/** Send an invoice request over an offer path and add the reply to replies
+
+  No request is sent when the recipient already answered over another path,
+  with an invoice, or with an invoice error that says why there is no invoice.
+
+  A path that gives no reply, or a reply that is not a good invoice, is added
+  as a failure, so that the request can be sent over the next path.
+
+  {
+    lnd: <Authenticated LND API Object>
+    path: {
+      hops: [{
+        encrypted_data: <Encrypted Recipient Data Hex String>
+        relay_key: <Blinded Relaying Node Public Key Hex String>
+      }]
+      introduction_node: <Introduction Node Public Key Hex String>
+      key: <First Hop Path Key Public Key Hex String>
+    }
+    peers: [{
+      features: [{
+        bit: <BOLT 09 Feature Bit Number>
+      }]
+      public_key: <Peer Public Key Hex String>
+    }]
+    replies: [<Reply Object>]
+    request: {
+      encoded: <Signed Invoice Request TLV Stream Hex String>
+      mtokens: <Requested Millitokens String>
+      request: <BOLT 12 Invoice Request String>
+    }
+    timeout: <Wait For Reply Milliseconds Number>
+  }
+
+  @returns via cbk or Promise
+  [{
+    [err]: [<Failure Code Number>, <Failure Message String>, <Details Object>]
+    [error]: [<Error Code Number>, <Error Message String>, <Details Object>]
+    [invoice]: {
+      expires_at: <Invoice Expires At ISO 8601 Date String>
+      id: <Payment Hash Hex String>
+      invoice: <BOLT 12 Invoice String>
+      mtokens: <Invoice Amount Millitokens String>
+      paths: [<Invoice Payment Path Object>]
+    }
+    [is_reply]: <Failure Is a Recipient Reply Bool>
+  }]
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToRequestOfferInvoice']);
+        }
+
+        if (!args.path) {
+          return cbk([400, 'ExpectedOfferPathToRequestOfferInvoice']);
+        }
+
+        if (!isArray(args.peers)) {
+          return cbk([400, 'ExpectedPeersToRequestOfferInvoice']);
+        }
+
+        if (!isArray(args.replies)) {
+          return cbk([400, 'ExpectedRepliesToRequestOfferInvoice']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedInvoiceRequestToRequestOfferInvoice']);
+        }
+
+        if (!args.timeout) {
+          return cbk([400, 'ExpectedTimeoutToRequestOfferInvoice']);
+        }
+
+        return cbk();
+      },
+
+      // Send the request over the path, unless the recipient already answered
+      getReply: ['validate', asyncReflect(({}, cbk) => {
+        // Exit early when there is no need to send the request again
+        if (isAnswered(args.replies)) {
+          return cbk();
+        }
+
+        const {introduction} = replyIntroduction({
+          path: args.path,
+          peers: args.peers,
+        });
+
+        return requestNetworkReply({
+          introduction,
+          lnd: args.lnd,
+          message: {type: typeInvoiceRequest, value: args.request.encoded},
+          path: args.path,
+          timeout: args.timeout,
+          types: [typeInvoice, typeInvoiceError],
+        },
+        cbk);
+      })],
+
+      // Add the reply over the path to the replies
+      replies: ['getReply', ({getReply}, cbk) => {
+        // Exit early when the request was not sent
+        if (!getReply.error && !getReply.value) {
+          return cbk(null, args.replies);
+        }
+
+        // Exit early when there was no reply, so the next path is tried
+        if (!!getReply.error) {
+          return cbk(null, [].concat(args.replies, {err: getReply.error}));
+        }
+
+        const {reply} = getReply.value;
+
+        const {error, invoice} = checkOfferInvoiceReply({
+          reply,
+          request: args.request,
+        });
+
+        // Exit early when the recipient said why there is no invoice
+        if (!!error && reply.type === typeInvoiceError) {
+          return cbk(null, [].concat(args.replies, {error}));
+        }
+
+        const failure = {err: error, is_reply: true};
+
+        // Exit early when the reply is not a good invoice
+        if (!!error) {
+          return cbk(null, [].concat(args.replies, failure));
+        }
+
+        return cbk(null, [].concat(args.replies, {invoice}));
+      }],
+    },
+    returnResult({reject, resolve, of: 'replies'}, cbk));
+  });
+};

package/package.json

@@ -73,5 +73,5 @@
     "integration-tests": "node test/integration",
     "test": "node --experimental-test-coverage --test test/actions/*.js test/balanced/*.js test/client/*.js test/config/*.js test/network/*.js test/offers/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/service_records/*.js test/swaps/*.js test/services/*.js test/support/*.js test/trades/*.js"
   },
-  "version": "9.2.0"
+  "version": "9.3.0"
 }