paid-services 9.3.0 → 10.1.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Versions
 
+## Version 10.1.0
+
+- `createSupportOffer`: Add `introduction` to start the created offer path at
+    a connected peer, for a node that is connected only by private channels
+- `getOfferInvoice`: Check the offer before deriving the payer key, so that a
+    refused offer does not use up a payer key index
+- `payOfferInvoice`: Refuse invoices that require multi-part payment
+
+## 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

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,6 +34,11 @@ 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>
@@ -49,7 +64,7 @@ const {typeInvoiceError} = require('./constants');
     }
   }
 */
-module.exports = ({reply, request}) => {
+module.exports = ({path, reply, request}) => {
   // Exit early when the recipient sent back an invoice error
   if (reply.type === typeInvoiceError) {
     try {
@@ -78,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']};
   }
@@ -93,6 +118,7 @@ module.exports = ({reply, request}) => {
   return {
     invoice: {
       expires_at: invoice.expires_at,
+      features: invoice.features,
       id: invoice.id,
       invoice: invoice.invoice,
       mtokens: invoice.mtokens,

package/offers/constants.json

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

package/offers/get_offer_invoice.js

@@ -1,28 +1,42 @@
 const asyncAuto = require('async/auto');
 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 {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
+const {signBytes} = require('ln-service');
 
 const invoiceRequestForOffer = require('./invoice_request_for_offer');
 const offerInvoiceFailure = require('./offer_invoice_failure');
+const {payerKeyFamily} = require('./constants');
 const requestOfferInvoice = require('./request_offer_invoice');
 const {resolvePathIntroductions} = require('./../network');
 
 const {isSafeInteger} = Number;
+const bufferAsHex = buffer => Buffer.from(buffer).toString('hex');
 const defaultTimeoutMs = 30000;
 const isTimeout = n => isSafeInteger(n) && n > 0;
+const placeholderPayerId = bufferAsHex(pointFromScalar(Buffer.alloc(32, 1)));
+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`, only once the request is known to be one
+  that can be made, so that a refused request uses no 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>
@@ -37,6 +51,11 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
   {
     [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>
@@ -54,7 +73,7 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
       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) => {
@@ -83,14 +102,16 @@ 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) => {
+      // Make the request with a placeholder payer id, to check that it can be
+      // made before a payer key is derived for it
+      checkRequest: ['getNetwork', ({getNetwork}, cbk) => {
         try {
           return cbk(null, invoiceRequestForOffer({
             bip353_name: args.bip353_name,
             mtokens: args.mtokens,
             network: getNetwork.bitcoinjs,
             offer: args.offer,
+            payer_id: placeholderPayerId,
             payer_note: args.payer_note,
           }));
         } catch (err) {
@@ -99,10 +120,10 @@ module.exports = (args, cbk) => {
       }],
 
       // Find the introduction node of each offer path, to not reply from it
-      getPaths: ['request', ({request}, cbk) => {
+      getPaths: ['checkRequest', ({checkRequest}, cbk) => {
         return resolvePathIntroductions({
           lnd: args.lnd,
-          paths: request.paths,
+          paths: checkRequest.paths,
         },
         cbk);
       }],
@@ -117,6 +138,58 @@ module.exports = (args, cbk) => {
         return cbk(null, getPaths.paths);
       }],
 
+      // Get a new derived key for the payer id, to derive again from the seed
+      getPayerKey: ['offerPaths', ({}, cbk) => {
+        return getPublicKey({family: payerKeyFamily, lnd: args.lnd}, cbk);
+      }],
+
+      // Make the unsigned invoice request for the offer with the payer id
+      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) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // 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}]);
+        }
+      }],
+
       // Send the request over each path in turn until the recipient answers
       getReplies: [
         'getPeers',
@@ -188,19 +261,21 @@ module.exports = (args, cbk) => {
       // The invoice for the request
       invoice: [
         'getInvoice',
+        'getPayerKey',
         'paymentPaths',
-        'request',
-        ({getInvoice, paymentPaths, request}, cbk) =>
+        'unsigned',
+        ({getInvoice, getPayerKey, paymentPaths, unsigned}, cbk) =>
       {
         return cbk(null, {
-          description: request.description,
+          description: unsigned.description,
           expires_at: getInvoice.expires_at,
+          features: getInvoice.features,
           id: getInvoice.id,
           invoice: getInvoice.invoice,
           mtokens: getInvoice.mtokens,
           paths: paymentPaths,
-          payer_id: request.payer_id,
-          payer_secret: request.payer_secret,
+          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
@@ -33,7 +40,7 @@ const namePattern = /^[0-9a-zA-Z\-_.]+@[0-9a-zA-Z\-_.]+$/;
   @returns
   {
     [description]: <Offer Description String>
-    encoded: <Signed Invoice Request TLV Stream Hex String>
+    encoded: <Unsigned Invoice Request TLV Stream Hex String>
     mtokens: <Requested Millitokens String>
     paths: [{
       hops: [{
@@ -44,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 => {
@@ -62,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
@@ -93,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;
@@ -110,40 +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 {
+    paths,
     description: details.description,
-    encoded: signed.encoded,
+    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/pay_offer_invoice.js

@@ -7,13 +7,18 @@ const {returnResult} = require('asyncjs-util');
 
 const {resolvePathIntroductions} = require('./../network');
 
+const hasBit = (features, bit) => !!features.find(n => n.bit === bit);
 const isMtokens = n => typeof n === 'string' && /^\d+$/.test(n);
+const requiredMppBit = 16;
 
 /** Pay a BOLT 12 invoice over its blinded payment paths
 
   The invoice is not checked against an offer. Pay an invoice from
   `getOfferInvoice`, which checks that it is for the offer and amount asked.
 
+  The invoice is paid over one route, so an invoice that requires multi-part
+  payment is not supported.
+
   {
     invoice: <BOLT 12 Invoice String>
     lnd: <Authenticated LND API Object>
@@ -71,6 +76,11 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedInvoiceForNodeNetworkToPay']);
         }
 
+        // BOLT 12 pays over multiple paths when the invoice requires MPP
+        if (hasBit(details.features, requiredMppBit)) {
+          return cbk([400, 'UnsupportedMultiPartPaymentRequiredToPayInvoice']);
+        }
+
         if (!details.paths.length) {
           return cbk([400, 'ExpectedPaymentPathsInInvoiceToPay']);
         }

package/offers/request_offer_invoice.js

@@ -51,6 +51,11 @@ const isAnswered = replies => replies.some(n => !!n.error || !!n.invoice);
     [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>
@@ -130,6 +135,7 @@ module.exports = (args, cbk) => {
 
         const {error, invoice} = checkOfferInvoiceReply({
           reply,
+          path: args.path,
           request: args.request,
         });
 

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.3.0"
+  "version": "10.1.0"
 }

package/support/create_support_offer.js

@@ -28,6 +28,7 @@ const bufferAsHex = buffer => Buffer.from(buffer).toString('hex');
 const isHex = n => typeof n === 'string' && /^([0-9a-f]{2})+$/i.test(n);
 const isLimit = n => n === undefined || (isSafeInteger(n) && n > 0);
 const isPathId = n => isHex(n) && n.length / 2 >= minPathIdBytes;
+const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
 const isSequence = n => n === undefined || (isSafeInteger(n) && n >= 0);
 const isServiceId = n => isHex(n) && n.length / 2 === serviceIdBytes;
 
@@ -38,8 +39,12 @@ const isServiceId = n => isHex(n) && n.length / 2 === serviceIdBytes;
 
   The offer has blinded paths to self. Give `paths` made to self, each with
   the `id` given to self in its final hop, at least 16 random bytes kept
-  private, to keep the node private. Otherwise a path that starts at self is
-  created. Keep the offer small, with one path, so that its invoices fit in
+  private, to keep the node private. Otherwise a path is created that starts
+  at a connected `introduction` peer, or at self when none is given. A node
+  with only private channels gives an `introduction` peer that has public
+  channels and relays onion messages, since BOLT 12 requires paths from
+  publicly reachable nodes in the offer of a node connected only by private
+  channels. Keep the offer small, with one path, so that its invoices fit in
   onion messages of the regular size.
 
   The offer has its own issuer id, a derived key that is not linked to the
@@ -63,6 +68,7 @@ const isServiceId = n => isHex(n) && n.length / 2 === serviceIdBytes;
 
   {
     [description]: <Offer Description String>
+    [introduction]: <Introduction Peer Public Key Hex String>
     [issuer]: <Issuer Identifier String>
     [issuer_record]: <Use Issuer Id of Support Record Hex String>
     lnd: <Authenticated LND API Object>
@@ -126,6 +132,15 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedArrayOfPathsForSupportOffer']);
         }
 
+        if (!!args.introduction && !isPublicKey(args.introduction)) {
+          return cbk([400, 'ExpectedIntroductionPublicKeyForSupportOffer']);
+        }
+
+        // An introduction peer starts a created path, not a given path
+        if (!!args.introduction && !!args.paths) {
+          return cbk([400, 'ExpectedEitherIntroductionPeerOrGivenPaths']);
+        }
+
         if (!!args.suggested_mtokens && !!args.suggested_amounts) {
           return cbk([400, 'ExpectedEitherSuggestedMtokensOrAmounts']);
         }
@@ -275,7 +290,11 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
-        return createNetworkPath({lnd: args.lnd}, cbk);
+        return createNetworkPath({
+          introduction: args.introduction,
+          lnd: args.lnd,
+        },
+        cbk);
       }],
 
       // Create the offer