paid-services 9.2.0 → 10.0.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Versions
 
+## Version 10.0.0
+
+- `getOfferInvoice`: Add `features` to show the features of the invoice
+- `getOfferInvoice`: Add support for offers with an issuer id and no paths
+- `getOfferInvoice`: Check that an invoice for an offer without an issuer id
+    is signed by the final node of the path that the request was sent over
+
+### Breaking Changes
+
+- `getOfferInvoice`: Refuse offers with an amount in a currency
+- `getOfferInvoice`: The payer id is now a key derived by LND in key family
+    808, and `payer_key_index` is returned in place of the removed
+    `payer_secret`
+
+## 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

@@ -1,5 +1,6 @@
 const {parseInvoice} = require('invoices');
 const {parseInvoiceError} = require('invoices');
+const {parseOffer} = require('invoices');
 
 const {typeInvoiceError} = require('./constants');
 
@@ -8,7 +9,16 @@ const {typeInvoiceError} = require('./constants');
   An invoice error reply from the recipient, or an invoice that is not valid,
   that has expired, or that is not for the request, is a failed reply
 
+  An invoice for an offer without an issuer id has to be signed by the final
+  node of the `path` that the request was sent over, as BOLT 12 requires
+
   {
+    path: {
+      hops: [{
+        encrypted_data: <Encrypted Recipient Data Hex String>
+        relay_key: <Blinded Relaying Node Public Key Hex String>
+      }]
+    }
     reply: {
       type: <Reply Message Payload Record Type Number String>
       value: <Reply Message Payload Hex String>
@@ -24,13 +34,37 @@ const {typeInvoiceError} = require('./constants');
     [error]: [<Error Code Number>, <Error Message String>, <Details Object>]
     [invoice]: {
       expires_at: <Invoice Expires At ISO 8601 Date String>
+      features: [{
+        bit: <BOLT 09 Feature Bit Number>
+        is_required: <Feature Support is Required To Pay Bool>
+        type: <Feature Type 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>
+        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>
+      }]
     }
   }
 */
-module.exports = ({reply, request}) => {
+module.exports = ({path, reply, request}) => {
   // Exit early when the recipient sent back an invoice error
   if (reply.type === typeInvoiceError) {
     try {
@@ -59,6 +93,16 @@ module.exports = ({reply, request}) => {
     request: request.request,
   });
 
+  // The offer that the invoice is for is copied into the invoice
+  const offer = parseOffer({offer: invoice.offer});
+
+  // An offer without an issuer id has its invoices signed by the path ends
+  const [finalHop] = [].concat(path.hops).reverse();
+
+  if (!offer.issuer_id && invoice.node_id !== finalHop.relay_key) {
+    return {error: [503, 'ExpectedInvoiceSignedByFinalNodeOfOfferPathUsed']};
+  }
+
   if (invoice.is_expired) {
     return {error: [503, 'ExpectedUnexpiredInvoiceForOffer']};
   }
@@ -74,9 +118,11 @@ module.exports = ({reply, request}) => {
   return {
     invoice: {
       expires_at: invoice.expires_at,
+      features: invoice.features,
       id: invoice.id,
       invoice: invoice.invoice,
       mtokens: invoice.mtokens,
+      paths: invoice.paths,
     },
   };
 };

package/offers/constants.json

@@ -1,4 +1,5 @@
 {
+  "payerKeyFamily": 808,
   "typeInvoice": "66",
   "typeInvoiceError": "68",
   "typeInvoiceRequest": "64"

package/offers/get_offer_invoice.js

@@ -1,33 +1,38 @@
 const asyncAuto = require('async/auto');
-const asyncTryEach = require('async/tryEach');
+const asyncReduce = require('async/reduce');
+const {createSignedInvoiceRequest} = require('invoices');
 const {getNetwork} = require('ln-sync');
 const {getPeers} = require('ln-service');
+const {getPublicKey} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
+const {signBytes} = require('ln-service');
 
-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 {payerKeyFamily} = require('./constants');
+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;
 const isTimeout = n => isSafeInteger(n) && n > 0;
+const typeSchnorr = 'schnorr';
 
 /** Get an invoice for a BOLT 12 offer
 
   `mtokens` defaults to the offer amount, and is required when the offer has
-  no amount, or an amount in a currency. Give the `bip353_name` that the
-  offer was found with, as BOLT 12 requires.
+  no amount. An offer with an amount in a currency is not supported. Give the
+  `bip353_name` that the offer was found with, as BOLT 12 requires.
 
   The request is sent over each path of the offer in turn, waiting `timeout`
   for each, until a path gives back an invoice, or the recipient replies
-  with an invoice error, which is returned. Keep `payer_secret`, the key of
-  the payer id, to be able to prove that the request was made by the payer.
+  with an invoice error, which is returned. An offer without paths has the
+  request sent to its issuer id.
+
+  The request is signed by the `payer_id`, a new key that LND derives in key
+  family 808 at `payer_key_index`. Keep the index to be able to prove, with
+  the key derived again from the seed, that the request and the payment of
+  its invoice were made by the payer.
 
   {
     [bip353_name]: <BIP 353 Human Readable Name Offer Was Found With String>
@@ -40,12 +45,31 @@ 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>
+    features: [{
+      bit: <BOLT 09 Feature Bit Number>
+      is_required: <Feature Support is Required To Pay Bool>
+      type: <Feature Type 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>
+    payer_key_index: <Payer Id Key Index Number>
   }
 */
 module.exports = (args, cbk) => {
@@ -74,14 +98,24 @@ module.exports = (args, cbk) => {
       // Get the connected peers to start the reply path at one of them
       getPeers: ['validate', ({}, cbk) => getPeers({lnd: args.lnd}, cbk)],
 
-      // Make the signed invoice request for the offer
-      request: ['getNetwork', ({getNetwork}, cbk) => {
+      // Get a new derived key for the payer id, to derive again from the seed
+      getPayerKey: ['validate', ({}, cbk) => {
+        return getPublicKey({family: payerKeyFamily, lnd: args.lnd}, cbk);
+      }],
+
+      // Make the unsigned invoice request for the offer
+      unsigned: [
+        'getNetwork',
+        'getPayerKey',
+        ({getNetwork, getPayerKey}, cbk) =>
+      {
         try {
           return cbk(null, invoiceRequestForOffer({
             bip353_name: args.bip353_name,
             mtokens: args.mtokens,
             network: getNetwork.bitcoinjs,
             offer: args.offer,
+            payer_id: getPayerKey.public_key,
             payer_note: args.payer_note,
           }));
         } catch (err) {
@@ -89,103 +123,138 @@ module.exports = (args, cbk) => {
         }
       }],
 
+      // Sign the request with the payer id key, which never leaves LND
+      sign: ['getPayerKey', 'unsigned', ({getPayerKey, unsigned}, cbk) => {
+        return signBytes({
+          key_family: payerKeyFamily,
+          key_index: getPayerKey.index,
+          lnd: args.lnd,
+          preimage: unsigned.root,
+          tag: unsigned.tag,
+          type: typeSchnorr,
+        },
+        cbk);
+      }],
+
+      // Finish the request with its signature, to send it
+      request: ['sign', 'unsigned', ({sign, unsigned}, cbk) => {
+        try {
+          const {encoded, request} = createSignedInvoiceRequest({
+            encoded: unsigned.encoded,
+            signature: sign.signature,
+          });
+
+          return cbk(null, {encoded, request, mtokens: unsigned.mtokens});
+        } catch (err) {
+          return cbk([503, 'FailedToCreateSignedInvoiceRequest', {err}]);
+        }
+      }],
+
       // Find the introduction node of each offer path, to not reply from it
-      getPaths: ['request', ({request}, cbk) => {
+      getPaths: ['unsigned', ({unsigned}, cbk) => {
         return resolvePathIntroductions({
           lnd: args.lnd,
-          paths: request.paths,
+          paths: unsigned.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);
-            }
+          cbk);
+        },
+        cbk);
+      }],
 
-            const {error, invoice} = checkOfferInvoiceReply({
-              request,
-              reply: res.reply,
-            });
+      // The invoice the recipient answered with
+      getInvoice: ['getReplies', ({getReplies}, cbk) => {
+        const answer = getReplies.find(n => !!n.error || !!n.invoice);
 
-            // 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 when no path gave back an answer from the recipient
+        if (!answer) {
+          const failures = getReplies.filter(n => !!n.err);
 
-            // Exit early and try the next path when there is no good invoice
-            if (!!error) {
-              failures.push({err: error, is_reply: true});
+          return cbk(offerInvoiceFailure({failures}).error);
+        }
 
-              return cbk(error);
-            }
+        // Exit early when the recipient said why there is no invoice
+        if (!!answer.error) {
+          return cbk(answer.error);
+        }
 
-            return cbk(null, {invoice});
-          });
-        };
+        return cbk(null, answer.invoice);
+      }],
 
-        return asyncTryEach(getPaths.map(requestOver), (err, res) => {
-          if (!!err) {
-            return cbk(offerInvoiceFailure({failures}).error);
-          }
+      // 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);
+      }],
 
-          // Exit early when the recipient said why there is no invoice
-          if (!!res.error) {
-            return cbk(res.error);
-          }
+      // 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, res.invoice);
-        });
+        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',
+        'getPayerKey',
+        'paymentPaths',
+        'unsigned',
+        ({getInvoice, getPayerKey, paymentPaths, unsigned}, cbk) =>
+      {
         return cbk(null, {
+          description: unsigned.description,
           expires_at: getInvoice.expires_at,
+          features: getInvoice.features,
           id: getInvoice.id,
           invoice: getInvoice.invoice,
           mtokens: getInvoice.mtokens,
-          payer_id: request.payer_id,
-          payer_secret: request.payer_secret,
+          paths: paymentPaths,
+          payer_id: getPayerKey.public_key,
+          payer_key_index: getPayerKey.index,
         });
       }],
     },

package/offers/invoice_request_for_offer.js

@@ -1,30 +1,37 @@
-const {createSignedInvoiceRequest} = require('invoices');
 const {createUnsignedInvoiceRequest} = require('invoices');
-const {isPrivate} = require('tiny-secp256k1');
+const {isPoint} = require('tiny-secp256k1');
 const {parseOffer} = require('invoices');
-const {pointFromScalar} = require('tiny-secp256k1');
 
-const randomSecret = require('./random_secret');
+const issuerPath = require('./issuer_path');
 
-const bufferAsHex = buffer => buffer.toString('hex');
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isHex = n => typeof n === 'string' && /^([0-9a-f]{2})+$/i.test(n);
+const isKey = n => isHex(n) && n.length === 66 && isPoint(hexAsBuffer(n));
 const isMtokens = n => typeof n === 'string' && /^[1-9]\d*$/.test(n);
 const isName = n => typeof n === 'string' && namePattern.test(n);
-const isSecret = n => typeof n === 'string' && /^[0-9a-f]{64}$/i.test(n);
 const namePattern = /^[0-9a-zA-Z\-_.]+@[0-9a-zA-Z\-_.]+$/;
 
-/** Make a signed BOLT 12 invoice request, with a random payer key by default
+/** Make an unsigned BOLT 12 invoice request for an offer, with a payer id
+
+  `mtokens` defaults to the offer amount, and is required when the offer has
+  no amount. An offer with an amount in a currency is not supported.
 
   Give the `bip353_name` that the offer was found with, as BOLT 12 requires,
   so that the recipient knows which name was used
 
+  Sign `root` with `tag` as the tagged hash tag, with the key of `payer_id`,
+  and give the signature to `createSignedInvoiceRequest` to finish the request
+
+  The request is sent over the `paths`: the paths of the offer, or a path to
+  the issuer id of an offer that has no paths, as BOLT 12 requires
+
   {
     [bip353_name]: <BIP 353 Human Readable Name Offer Was Found With String>
     [mtokens]: <Millitokens to Pay String>
     network: <Network Name String>
     offer: <BOLT 12 Offer String>
+    payer_id: <Payer Public Key Hex String>
     [payer_note]: <Payer Note String>
-    [secret]: <Payer Secret Key Hex String>
   }
 
   @throws
@@ -32,7 +39,8 @@ const namePattern = /^[0-9a-zA-Z\-_.]+@[0-9a-zA-Z\-_.]+$/;
 
   @returns
   {
-    encoded: <Signed Invoice Request TLV Stream Hex String>
+    [description]: <Offer Description String>
+    encoded: <Unsigned Invoice Request TLV Stream Hex String>
     mtokens: <Requested Millitokens String>
     paths: [{
       hops: [{
@@ -43,9 +51,8 @@ const namePattern = /^[0-9a-zA-Z\-_.]+@[0-9a-zA-Z\-_.]+$/;
       [introduction_node]: <Introduction Node Public Key Hex String>
       key: <First Hop Path Key Public Key Hex String>
     }]
-    payer_id: <Payer Public Key Hex String>
-    payer_secret: <Payer Secret Key Hex String>
-    request: <BOLT 12 Invoice Request String>
+    root: <Merkle Root Hash To Sign Hex String>
+    tag: <Signature Tagged Hash Tag String>
   }
 */
 module.exports = args => {
@@ -61,13 +68,8 @@ module.exports = args => {
     throw new Error('ExpectedNetworkToPayOffer');
   }
 
-  if (args.secret !== undefined && !isSecret(args.secret)) {
-    throw new Error('ExpectedPayerSecretKeyToPayOffer');
-  }
-
-  // A secret that is out of the range of private keys has no public key
-  if (args.secret !== undefined && !isPrivate(hexAsBuffer(args.secret))) {
-    throw new Error('ExpectedValidPayerSecretKeyToPayOffer');
+  if (!isKey(args.payer_id)) {
+    throw new Error('ExpectedPayerIdPublicKeyToPayOffer');
   }
 
   // Exit early when the offer cannot be read
@@ -92,14 +94,9 @@ module.exports = args => {
     throw new Error('ExpectedOfferWithoutQuantityToPay');
   }
 
-  // Requests are sent over the blinded paths of the offer
-  if (!details.paths || !details.paths.length) {
-    throw new Error('ExpectedOfferWithPathsToPay');
-  }
-
-  // An amount in a currency is converted to millitokens by the payer
-  if (!!details.currency && !args.mtokens) {
-    throw new Error('ExpectedMillitokensToPayOfferWithCurrencyAmount');
+  // An amount in a currency needs an exchange rate, which is not supported
+  if (!!details.currency) {
+    throw new Error('UnsupportedCurrencyAmountInOfferToPay');
   }
 
   const amount = args.mtokens || details.mtokens;
@@ -109,39 +106,29 @@ module.exports = args => {
     throw new Error('ExpectedMillitokensToPayOfferWithoutAmount');
   }
 
-  const hasOfferAmount = !details.currency && !!details.mtokens;
-
   // An offer with an amount is paid at least that amount
-  if (hasOfferAmount && BigInt(amount) < BigInt(details.mtokens)) {
+  if (!!details.mtokens && BigInt(amount) < BigInt(details.mtokens)) {
     throw new Error('ExpectedAtLeastOfferAmountToPayOffer');
   }
 
-  const payerSecret = args.secret || randomSecret().secret;
-
-  const payerId = pointFromScalar(hexAsBuffer(payerSecret));
-
-  const payer = bufferAsHex(Buffer.from(payerId));
+  // A request is sent over the offer paths, or to the issuer id without them
+  const paths = details.paths || [issuerPath({id: details.issuer_id})];
 
   const unsigned = createUnsignedInvoiceRequest({
     bip353_name: args.bip353_name,
     mtokens: amount,
     network: args.network,
     offer: args.offer,
-    payer_id: payer,
+    payer_id: args.payer_id,
     payer_note: args.payer_note,
   });
 
-  const signed = createSignedInvoiceRequest({
-    encoded: unsigned.encoded,
-    secret: payerSecret,
-  });
-
   return {
-    encoded: signed.encoded,
+    paths,
+    description: details.description,
+    encoded: unsigned.encoded,
     mtokens: amount,
-    paths: details.paths,
-    payer_id: payer,
-    payer_secret: payerSecret,
-    request: signed.request,
+    root: unsigned.root,
+    tag: unsigned.tag,
   };
 };

package/offers/issuer_path.js

@@ -0,0 +1,28 @@
+const {blindedPathToNode} = require('bolt04');
+
+/** Make a path to send an invoice request to the issuer id of an offer
+
+  BOLT 12 sends requests for an offer without paths to its issuer id
+
+  {
+    id: <Offer Issuer Id Public Key Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    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>
+  }
+*/
+module.exports = ({id}) => {
+  const {key, path} = blindedPathToNode({hops: [id]});
+
+  return {key, hops: path, introduction_node: id};
+};

package/offers/pay_offer.js

@@ -11,8 +11,12 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
 /** Pay a BOLT 12 offer: `getOfferInvoice` and then `payOfferInvoice`
 
   `mtokens` defaults to the offer amount, and is required when the offer has
-  no amount, or an amount in a currency. Give the `bip353_name` that the
-  offer was found with, as BOLT 12 requires.
+  no amount. An offer with an amount in a currency is not supported. Give the
+  `bip353_name` that the offer was found with, as BOLT 12 requires.
+
+  The `payer_id` is a new key that LND derives in key family 808 at
+  `payer_key_index`. Keep the index to be able to prove that the request and
+  the payment were made by the payer.
 
   {
     [bip353_name]: <BIP 353 Human Readable Name Offer Was Found With String>
@@ -31,7 +35,7 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
     invoice: <BOLT 12 Invoice String>
     mtokens: <Invoice Amount Millitokens String>
     payer_id: <Payer Public Key Hex String>
-    payer_secret: <Payer Secret Key Hex String>
+    payer_key_index: <Payer Id Key Index Number>
     secret: <Payment Preimage Hex String>
   }
 */
@@ -91,7 +95,7 @@ module.exports = (args, cbk) => {
           invoice: getInvoice.invoice,
           mtokens: pay.mtokens,
           payer_id: getInvoice.payer_id,
-          payer_secret: getInvoice.payer_secret,
+          payer_key_index: getInvoice.payer_key_index,
           secret: pay.secret,
         });
       }],

package/offers/request_offer_invoice.js

@@ -0,0 +1,159 @@
+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>
+      features: [{
+        bit: <BOLT 09 Feature Bit Number>
+        is_required: <Feature Support is Required To Pay Bool>
+        type: <Feature Type 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,
+          path: args.path,
+          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": "10.0.0"
 }