paid-services 10.0.0 → 10.2.0

package/CHANGELOG.md

@@ -1,18 +1,22 @@
 # Versions
 
+## Version 10.2.0
+
+- `serviceSupportOffer`: Add `start` event with the support offer
+
+## Version 10.1.0
+
+- `createSupportOffer`: Add `introduction` to start the created offer path
+
 ## 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`
+- `getOfferInvoice`: Seed derived `payer_key_index` replaces `payer_secret`
 
 ## Version 9.3.0
 

package/network/constants.json

@@ -0,0 +1,16 @@
+{
+  "accessDeniedMessages": [
+    "^cannot determine data format of binary-encoded macaroon",
+    "^empty macaroon data",
+    "^expected 1 macaroon",
+    "^invalid ID$",
+    "^permission denied$",
+    "^unknown macaroon version",
+    "^unmarshal v[12]",
+    "^verification failed"
+  ],
+  "codeInvalidArgument": 3,
+  "codePermissionDenied": 7,
+  "codeUnauthenticated": 16,
+  "codeUnimplemented": 12
+}

package/network/get_message_hops.js

@@ -1,7 +1,9 @@
 const asyncAuto = require('async/auto');
 const asyncRetry = require('async/retry');
+const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getPeers} = require('ln-service');
+const {getWalletInfo} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const getRelayingRoute = require('./get_relaying_route');
@@ -19,8 +21,19 @@ const onlyChannelsBits = [66, 67];
   payment route found from the destination to self, through nodes that relay
   messages.
 
+  When a reply is expected back along the same nodes, and self only takes
+  messages from peers with a channel, a connected destination is only sent to
+  directly when it has a channel with self, since the reply comes back from
+  it.
+
+  The route is found over the channels that are known, the channels of the
+  public graph and the channels of self, so a destination that can only be
+  reached through unannounced channels of other nodes, as when self is only
+  connected through a peer that is itself private, is not supported.
+
   {
     destination: <Destination Node Public Key Hex String>
+    [is_expecting_reply]: <Reply Comes Back Along the Same Nodes Bool>
     lnd: <Authenticated LND API Object>
   }
 
@@ -29,17 +42,17 @@ const onlyChannelsBits = [66, 67];
     hops: [<Message Hop Public Key Hex String>]
   }
 */
-module.exports = ({destination, lnd}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
         // The destination key is a string so that it can be compared
-        if (!destination || typeof destination !== 'string') {
+        if (!args.destination || typeof args.destination !== 'string') {
           return cbk([400, 'ExpectedDestinationToGetMessageHops']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedLndToGetMessageHops']);
         }
 
@@ -47,26 +60,67 @@ module.exports = ({destination, lnd}, cbk) => {
       },
 
       // Node keys are compared in lowercase, as LND gives them
-      key: ['validate', ({}, cbk) => cbk(null, destination.toLowerCase())],
+      key: ['validate', ({}, cbk) => {
+        return cbk(null, args.destination.toLowerCase());
+      }],
 
       // Get the connected peers
-      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
+      getPeers: ['validate', ({}, cbk) => getPeers({lnd: args.lnd}, cbk)],
 
-      // A connected destination is sent to directly unless it needs a channel
-      isDirect: ['getPeers', 'key', ({getPeers, key}, cbk) => {
+      // A connected destination is a direct hop unless it needs a channel
+      isPeer: ['getPeers', 'key', ({getPeers, key}, cbk) => {
         const peer = getPeers.peers.find(n => n.public_key === key);
 
         return cbk(null, !!peer && !hasBit(peer.features, onlyChannelsBits));
       }],
 
+      // Get the features of self when a reply comes back from the destination
+      getFeatures: ['isPeer', ({isPeer}, cbk) => {
+        // Exit early when the destination is not sent to directly anyway
+        if (!isPeer || !args.is_expecting_reply) {
+          return cbk();
+        }
+
+        return getWalletInfo({lnd: args.lnd}, cbk);
+      }],
+
+      // Get the channels with the destination when the reply needs a channel
+      getChannels: ['getFeatures', 'key', ({getFeatures, key}, cbk) => {
+        // Exit early when self takes messages from peers without a channel
+        if (!getFeatures || !hasBit(getFeatures.features, onlyChannelsBits)) {
+          return cbk();
+        }
+
+        return getChannels({lnd: args.lnd, partner_public_key: key}, cbk);
+      }],
+
+      // A connected destination also has a channel when the reply needs one
+      isDirect: ['getChannels', 'isPeer', ({getChannels, isPeer}, cbk) => {
+        // Exit early when the channels were not needed
+        if (!getChannels) {
+          return cbk(null, isPeer);
+        }
+
+        return cbk(null, !!getChannels.channels.length);
+      }],
+
       // Get the identity key of self, which routes are found back to
-      getIdentity: ['isDirect', ({isDirect}, cbk) => {
+      getIdentity: [
+        'getFeatures',
+        'isDirect',
+        ({getFeatures, isDirect}, cbk) =>
+      {
         // Exit early when the destination is sent to directly
         if (isDirect) {
           return cbk();
         }
 
-        return getIdentity({lnd}, cbk);
+        // Exit early when the identity key came with the features
+        if (!!getFeatures) {
+          return cbk(null, {public_key: getFeatures.public_key});
+        }
+
+        return getIdentity({lnd: args.lnd}, cbk);
       }],
 
       // Find a series of nodes to relay the message
@@ -95,9 +149,9 @@ module.exports = ({destination, lnd}, cbk) => {
         return asyncRetry({errorFilter: isRetry, times: maxAttempts}, cbk => {
           return getRelayingRoute({
             ignore,
-            lnd,
             source,
             destination: key,
+            lnd: args.lnd,
             peers: getPeers.peers,
           },
           (err, res) => {

package/network/get_path_outbound.js

@@ -13,6 +13,7 @@ const edgeChannel = edge => edge.split('x').slice(0, -1).join('x');
   along a payment route through nodes that relay onion messages
 
   {
+    [is_expecting_reply]: <Reply Comes Back Along the Same Nodes Bool>
     lnd: <Authenticated LND API Object>
     path: {
       [introduction_edge]: <Introduction Node Edge Format Channel Id String>
@@ -25,16 +26,16 @@ const edgeChannel = edge => edge.split('x').slice(0, -1).join('x');
     outbound: [<Relaying Node Public Key Hex String>]
   }
 */
-module.exports = ({lnd, path}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedLndToGetPathOutbound']);
         }
 
-        if (!path) {
+        if (!args.path) {
           return cbk([400, 'ExpectedBlindedPathToGetPathOutbound']);
         }
 
@@ -44,21 +45,21 @@ module.exports = ({lnd, path}, cbk) => {
       // Get the channel of the introduction edge
       getChannel: ['validate', ({}, cbk) => {
         // Exit early when the introduction is a node and not an edge
-        if (!path.introduction_edge) {
+        if (!args.path.introduction_edge) {
           return cbk();
         }
 
-        const id = edgeChannel(path.introduction_edge);
+        const id = edgeChannel(args.path.introduction_edge);
 
-        return getChannel({id, lnd}, cbk);
+        return getChannel({id, lnd: args.lnd}, cbk);
       }],
 
       // Determine the introduction node of the path
       introduction: ['getChannel', ({getChannel}, cbk) => {
         try {
           const {introduction} = pathIntroduction({
-            path,
             channel: getChannel,
+            path: args.path,
           });
 
           return cbk(null, introduction);
@@ -69,7 +70,12 @@ module.exports = ({lnd, path}, cbk) => {
 
       // Get the hops to relay the message to the introduction node
       getHops: ['introduction', ({introduction}, cbk) => {
-        return getMessageHops({lnd, destination: introduction}, cbk);
+        return getMessageHops({
+          destination: introduction,
+          is_expecting_reply: args.is_expecting_reply,
+          lnd: args.lnd,
+        },
+        cbk);
       }],
 
       // The outbound hops end at the introduction node

package/network/make_network_request.js

@@ -17,7 +17,8 @@ const peerRequestType = 32768;
 const typeNetworkRequest = '32769';
 
 /** Make a network request over onion messages, sent over a blinded path of
-  the destination, with the response returned over a reply path to self
+  the destination, with the response returned over a reply path back along
+  the route of the request
 
   The request fails when no response arrives within the `timeout`.
 

package/network/request_network_reply.js

@@ -9,6 +9,7 @@ const getPathOutbound = require('./get_path_outbound');
 
 const defaultTimeoutMs = 1000 * 30;
 const {isArray} = Array;
+const isHops = n => isSafeInteger(n) && n > 0;
 const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
 const {isSafeInteger} = Number;
 const isTimeout = n => isSafeInteger(n) && n > 0;
@@ -16,13 +17,19 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
 /** Send an onion message over a blinded path and wait for its reply
 
   The reply is the first message of one of the reply `types` that arrives on
-  the reply path of the message, which starts at self or at a connected
-  `introduction` peer. The request fails when no reply arrives within the
-  `timeout`.
+  the reply path of the message. The request fails when no reply arrives
+  within the `timeout`.
+
+  The reply path goes back along the route of the message, through the nodes
+  that relayed it, ending at self, so that the recipient can reach it. When
+  self only takes messages from peers with a channel, the message goes out
+  over a channel, so that the reply comes back over one. A reply path of more
+  than `max_reply_hops` keeps the hops nearest self, and the recipient routes
+  to its start.
 
   {
-    [introduction]: <Reply Path Introduction Peer Public Key Hex String>
     lnd: <Authenticated LND API Object>
+    [max_reply_hops]: <Maximum Reply Path Hops Count Number>
     message: {
       type: <Message Payload Record Type Number String>
       value: <Message Payload Hex String>
@@ -90,8 +97,8 @@ module.exports = (args, cbk) => {
           }
         }
 
-        if (!!args.introduction && !isPublicKey(args.introduction)) {
-          return cbk([400, 'ExpectedReplyIntroductionToRequestNetworkReply']);
+        if (args.max_reply_hops !== undefined && !isHops(args.max_reply_hops)) {
+          return cbk([400, 'ExpectedMaximumReplyHopsToRequestNetworkReply']);
         }
 
         if (args.timeout !== undefined && !isTimeout(args.timeout)) {
@@ -112,7 +119,38 @@ module.exports = (args, cbk) => {
 
       // Determine the outbound hops to reach the path introduction node
       getOutbound: ['validate', ({}, cbk) => {
-        return getPathOutbound({lnd: args.lnd, path: args.path}, cbk);
+        return getPathOutbound({
+          is_expecting_reply: true,
+          lnd: args.lnd,
+          path: args.path,
+        },
+        cbk);
+      }],
+
+      // The reply path goes back the way the message went, ending at self
+      replyPath: [
+        'getIdentity',
+        'getOutbound',
+        ({getIdentity, getOutbound}, cbk) =>
+      {
+        const {outbound} = getOutbound;
+
+        // The outbound hops end at the introduction node of the path, which
+        // is the recipient itself when the path has a single hop
+        const isRecipient = args.path.hops.length === 1;
+
+        const relays = !isRecipient ? outbound : outbound.slice(0, -1);
+
+        const hops = [].concat(relays).reverse().concat(getIdentity.public_key);
+
+        // Exit early when the reply path has no more hops than allowed
+        if (!args.max_reply_hops || hops.length <= args.max_reply_hops) {
+          return cbk(null, {hops});
+        }
+
+        // The hops nearest self are kept, which the recipient cannot find on
+        // its own, and it routes to the start of the reply path
+        return cbk(null, {hops: hops.slice(-args.max_reply_hops)});
       }],
 
       // Listen to incoming onion messages
@@ -131,10 +169,10 @@ module.exports = (args, cbk) => {
 
       // Send the message and wait for the reply
       request: [
-        'getIdentity',
         'getOutbound',
+        'replyPath',
         'subscribe',
-        ({getIdentity, getOutbound, subscribe}, cbk) =>
+        ({getOutbound, replyPath, subscribe}, cbk) =>
       {
         let isFinished = false;
         let timer;
@@ -218,17 +256,14 @@ module.exports = (args, cbk) => {
           });
         });
 
-        // Keys are used in lowercase, as LND gives them
-        const introduction = (args.introduction || String()).toLowerCase();
-
-        // Send the message with a reply path back to self
+        // Send the message with a reply path back the way it goes
         const sending = sendMessage({
           inbound: args.path.hops,
           key: args.path.key,
           lnd: args.lnd,
           message: args.message,
           outbound: getOutbound.outbound,
-          reply: [introduction, getIdentity.public_key].filter(n => !!n),
+          reply: replyPath.hops,
         });
 
         return sending.catch(err => finished(err));

package/network/service_network_messages.js

@@ -4,11 +4,17 @@ const getPathId = require('./get_path_id');
 const getPathOutbound = require('./get_path_outbound');
 const regularReplyBytes = require('./regular_reply_bytes');
 const returnNetworkResponse = require('./return_network_response');
+const subscriptionRejectionError = require('./subscription_rejection_error');
 
+const defaultDelayMs = 1000 * 30;
+const endedError = [503, 'NetworkMessagesSubscriptionEnded'];
 const failedReplyBytes = err => [400, 'FailedToGetRegularReplyBytes', {err}];
 const {isArray} = Array;
+const isDelay = n => isSafeInteger(n) && n > 0;
 const isHex = n => typeof n === 'string' && /^([0-9a-f]{2})+$/i.test(n);
 const isLargeOnion = onion => !!onion && onion.length / 2 === largeOnionBytes;
+const {isSafeInteger} = Number;
+const isUnsupported = err => isArray(err) && err[0] === 501;
 const largeOnionBytes = 32834;
 const stoppedError = [503, 'ServiceStoppedBeforeReplyWasSent'];
 
@@ -24,12 +30,16 @@ const stoppedError = [503, 'ServiceStoppedBeforeReplyWasSent'];
   message of the regular size. `reply_bytes` gives the most bytes of such a
   reply that fit, or -1 when no reply fits.
 
-  The `end` listener is called when the stream of messages stops, after the
-  `error` listener when it fails. After the service stops, a reply that was
+  When the stream of messages fails or ends, the `error` listener is told and
+  the stream is subscribed to again after `delay`, keeping the message
+  listeners. The `end` listener is called, after the `error` listener, only
+  when subscribing again cannot help: LND without onion messages, or a
+  subscription that LND rejects. After the service stops, a reply that was
   being prepared is not sent, its callback is given an error, and nothing is
   reported to the error listener.
 
   {
+    [delay]: <Subscribe Again After Delay Milliseconds Number> // Default: 30000
     [ids]: [<Accepted Path Identifier Hex String>]
     lnd: <Authenticated LND API Object>
   }
@@ -81,7 +91,11 @@ const stoppedError = [503, 'ServiceStoppedBeforeReplyWasSent'];
         bytes: <Most Reply Payload Bytes For Regular Size, -1 For None Number>
       }
 */
-module.exports = ({ids, lnd}) => {
+module.exports = ({delay, ids, lnd}) => {
+  if (delay !== undefined && !isDelay(delay)) {
+    throw new Error('ExpectedDelayMillisecondsToServiceNetworkMessages');
+  }
+
   if (!!ids && !isArray(ids)) {
     throw new Error('ExpectedArrayOfPathIdsToServiceNetworkMessages');
   }
@@ -95,11 +109,12 @@ module.exports = ({ids, lnd}) => {
 
   const listeners = {};
   const service = {end: () => {}, error: () => {}};
-  const sub = subscribeToMessages({lnd});
 
   let isStopped = false;
+  let sub;
+  let timer;
 
-  // Stop listening, and tell the caller, when the messages stream stops
+  // Stop listening, and tell the caller, when subscribing again cannot help
   const ended = err => {
     // Exit early when the service was already stopped
     if (isStopped) {
@@ -111,18 +126,42 @@ module.exports = ({ids, lnd}) => {
     // Removing the listeners cancels the subscription
     sub.removeAllListeners();
 
-    if (!!err) {
-      service.error(err);
-    }
+    service.error(err);
 
     return service.end();
   };
 
-  // The stream can close normally, or fail
-  sub.on('end', () => ended());
-  sub.on('error', err => ended(err));
+  // Subscribe again after the stream fails, keeping the message listeners
+  const failed = err => {
+    // Exit early when the service was already stopped
+    if (isStopped) {
+      return;
+    }
+
+    // Removing the listeners cancels the subscription, and a stream that
+    // sends an end after its error is not heard, so it is subscribed to
+    // again once
+    sub.removeAllListeners();
+
+    // The wait to subscribe again starts before the error listener is told,
+    // so that a listener that stops the service calls it off
+    timer = setTimeout(() => {
+      timer = undefined;
+
+      // Subscribing can throw, when there is nothing to subscribe with
+      try {
+        return subscribe();
+      } catch (err) {
+        return ended([503, 'FailedToSubscribeToNetworkMessages', {err}]);
+      }
+    },
+    delay || defaultDelayMs);
+
+    return service.error(err);
+  };
 
-  sub.on('message_received', received => {
+  // Handle a message that arrived on the stream
+  const onMessage = received => {
     const {message} = received;
 
     // Exit early when there is no message payload
@@ -262,7 +301,35 @@ module.exports = ({ids, lnd}) => {
         reply_bytes: !reply ? undefined : replyBytes,
       });
     });
-  });
+  };
+
+  // Subscribe to the stream of messages
+  const subscribe = () => {
+    sub = subscribeToMessages({lnd});
+
+    // The stream can close normally, which is subscribed to again
+    sub.on('end', () => failed(endedError));
+
+    sub.on('error', err => {
+      // LND without onion messages has no stream to subscribe to again
+      if (isUnsupported(err)) {
+        return ended(err);
+      }
+
+      const {error} = subscriptionRejectionError({err});
+
+      // A rejected subscription would be rejected again
+      if (!!error) {
+        return ended(error);
+      }
+
+      return failed([503, 'NetworkMessagesSubscriptionFailed', {err}]);
+    });
+
+    sub.on('message_received', onMessage);
+  };
+
+  subscribe();
 
   return {
     end: cbk => service.end = cbk,
@@ -272,6 +339,9 @@ module.exports = ({ids, lnd}) => {
     stop: ({}) => {
       isStopped = true;
 
+      // Subscribing again is called off when it is being waited for
+      clearTimeout(timer);
+
       return sub.removeAllListeners();
     },
   };

package/network/service_network_requests.js

@@ -18,6 +18,10 @@ const typeNetworkRequest = '32769';
   response does not fit, the error is reported to the `error` listener and a
   `[413, 'ResponseTooLarge']` failure is sent in its place.
 
+  When the stream of messages fails, the `error` listener is told and the
+  stream is subscribed to again, as `serviceNetworkMessages` does, so the
+  `end` listener is only called when subscribing again cannot help.
+
   {
     [ids]: [<Accepted Path Identifier Hex String>]
     lnd: <Authenticated LND API Object>

package/network/subscription_rejection_error.js

@@ -0,0 +1,49 @@
+const {accessDeniedMessages} = require('./constants');
+const {codeInvalidArgument} = require('./constants');
+const {codePermissionDenied} = require('./constants');
+const {codeUnauthenticated} = require('./constants');
+const {codeUnimplemented} = require('./constants');
+
+const accessDeniedCodes = [codePermissionDenied, codeUnauthenticated];
+const deniedMessages = accessDeniedMessages.map(n => new RegExp(n));
+const rejectionCodes = [codeInvalidArgument, codeUnimplemented];
+
+/** Derive the error for a messages subscription that LND rejected
+
+  A rejected subscription is not recovered by subscribing again. This is
+  judged the way that the invoices subscription of ln-service judges it.
+
+  {
+    [err]: {
+      [code]: <gRPC Status Code Number>
+      [details]: <gRPC Status Details String>
+    }
+  }
+
+  @returns
+  {
+    [error]: <Subscription Rejected Error Array>
+  }
+*/
+module.exports = ({err}) => {
+  // Exit early when there is no error to derive a rejection from
+  if (!err) {
+    return {};
+  }
+
+  // LND denies access with a gRPC status code, or with a message about a
+  // missing, unreadable, expired, locked, or insufficiently permissioned
+  // macaroon
+  const isDeniedCode = accessDeniedCodes.includes(err.code);
+  const isDeniedMessage = deniedMessages.some(n => n.test(err.details));
+
+  if (isDeniedCode || isDeniedMessage) {
+    return {error: [403, 'PermissionDeniedToSubscribeToMessages', {err}]};
+  }
+
+  if (rejectionCodes.includes(err.code)) {
+    return {error: [503, 'SubscriptionToMessagesRejected', {err}]};
+  }
+
+  return {};
+};

package/offers/get_offer_invoice.js

@@ -2,8 +2,8 @@ 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');
 
@@ -14,8 +14,10 @@ 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
@@ -27,12 +29,17 @@ const typeSchnorr = 'schnorr';
   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. An offer without paths has the
-  request sent to its issuer id.
+  request sent to its issuer id. The reply path of a request goes back along
+  its route, so that the recipient can reach it. The route to the start of a
+  path is found over the public graph and the channels of the payer, so a
+  payer that is only connected through a peer that is itself private is not
+  supported.
 
   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.
+  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>
@@ -95,15 +102,48 @@ module.exports = (args, cbk) => {
       // Get the network of the node to pay the offer on
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
-      // Get the connected peers to start the reply path at one of them
-      getPeers: ['validate', ({}, cbk) => getPeers({lnd: args.lnd}, 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) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Find the introduction node of each offer path to send the request to
+      getPaths: ['checkRequest', ({checkRequest}, cbk) => {
+        return resolvePathIntroductions({
+          lnd: args.lnd,
+          paths: checkRequest.paths,
+        },
+        cbk);
+      }],
+
+      // 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, getPaths.paths);
+      }],
 
       // Get a new derived key for the payer id, to derive again from the seed
-      getPayerKey: ['validate', ({}, cbk) => {
+      getPayerKey: ['offerPaths', ({}, cbk) => {
         return getPublicKey({family: payerKeyFamily, lnd: args.lnd}, cbk);
       }],
 
-      // Make the unsigned invoice request for the offer
+      // Make the unsigned invoice request for the offer with the payer id
       unsigned: [
         'getNetwork',
         'getPayerKey',
@@ -150,39 +190,14 @@ module.exports = (args, cbk) => {
         }
       }],
 
-      // Find the introduction node of each offer path, to not reply from it
-      getPaths: ['unsigned', ({unsigned}, cbk) => {
-        return resolvePathIntroductions({
-          lnd: args.lnd,
-          paths: unsigned.paths,
-        },
-        cbk);
-      }],
-
-      // 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, getPaths.paths);
-      }],
-
       // Send the request over each path in turn until the recipient answers
-      getReplies: [
-        'getPeers',
-        'offerPaths',
-        'request',
-        ({getPeers, offerPaths, request}, cbk) =>
-      {
+      getReplies: ['offerPaths', 'request', ({offerPaths, request}, cbk) => {
         return asyncReduce(offerPaths, [], (replies, path, cbk) => {
           return requestOfferInvoice({
             path,
             replies,
             request,
             lnd: args.lnd,
-            peers: getPeers.peers,
             timeout: args.timeout || defaultTimeoutMs,
           },
           cbk);

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

@@ -3,7 +3,6 @@ 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');
@@ -20,6 +19,8 @@ const isAnswered = replies => replies.some(n => !!n.error || !!n.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.
 
+  The reply path goes back along the route of the request.
+
   {
     lnd: <Authenticated LND API Object>
     path: {
@@ -30,12 +31,6 @@ const isAnswered = replies => replies.some(n => !!n.error || !!n.invoice);
       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>
@@ -77,10 +72,6 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedOfferPathToRequestOfferInvoice']);
         }
 
-        if (!isArray(args.peers)) {
-          return cbk([400, 'ExpectedPeersToRequestOfferInvoice']);
-        }
-
         if (!isArray(args.replies)) {
           return cbk([400, 'ExpectedRepliesToRequestOfferInvoice']);
         }
@@ -103,13 +94,7 @@ module.exports = (args, cbk) => {
           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,

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": "10.0.0"
+  "version": "10.2.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

package/support/get_support_menu.js

@@ -1,6 +1,5 @@
 const asyncAuto = require('async/auto');
 const {getNetwork} = require('ln-sync');
-const {getPeers} = require('ln-service');
 const {parseInvoiceError} = require('invoices');
 const {parseOffer} = require('invoices');
 const {returnResult} = require('asyncjs-util');
@@ -10,10 +9,10 @@ const decodeSupportMenu = require('./decode_support_menu');
 const {defaultMenuTimeoutMs} = require('./constants');
 const isReplyTooLarge = require('./is_reply_too_large');
 const isSupportOffer = require('./is_support_offer');
+const {maxReplyHops} = require('./constants');
 const menuOffers = require('./menu_offers');
 const offerBitcoinNetwork = require('./offer_bitcoin_network');
 const offerSuggestedAmounts = require('./offer_suggested_amounts');
-const replyIntroduction = require('./../network/reply_introduction');
 const {requestNetworkReply} = require('./../network');
 const {resolvePathIntroductions} = require('./../network');
 const {typeInvoice} = require('./constants');
@@ -34,8 +33,9 @@ const isTimeout = n => n === undefined || (isSafeInteger(n) && n > 0);
   into pages. The first page is page zero, and each page says how many pages
   there are. The request is a signed invoice request with the menu request
   record, sent over the first path of the offer with a payer id that is only
-  used once, and the reply path starts at a connected peer that relays onion
-  messages when there is one. A reply without a page means the menu is not
+  used once, and the reply path goes back along the route of the request,
+  keeping the hops nearest the payer when it has more than the eight hops
+  that a recipient answers. A reply without a page means the menu is not
   supported, and an invoice sent back is not paid.
 
   A page is only used when it is signed by the support offer issuer id, has
@@ -160,9 +160,6 @@ module.exports = (args, cbk) => {
       // Get the network of the node to check offers are for it
       getNetwork: ['details', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
-      // Get the connected peers to start the reply path at one of them
-      getPeers: ['details', ({}, cbk) => getPeers({lnd: args.lnd}, cbk)],
-
       // Check the offer is for the network of the node
       checkNetwork: ['details', 'getNetwork', ({getNetwork}, cbk) => {
         const {network} = offerBitcoinNetwork({offer: args.offer});
@@ -174,7 +171,7 @@ module.exports = (args, cbk) => {
         return cbk();
       }],
 
-      // Find the introduction node of the first path, to not reply from it
+      // Find the introduction node of the first path to send the request to
       getPath: ['details', ({details}, cbk) => {
         const [path] = details.paths;
 
@@ -196,15 +193,6 @@ module.exports = (args, cbk) => {
         });
       }],
 
-      // Select a peer that relays onion messages to start the reply path
-      introduction: ['getPath', 'getPeers', ({getPath, getPeers}, cbk) => {
-        const {peers} = getPeers;
-
-        const {introduction} = replyIntroduction({path: getPath, peers});
-
-        return cbk(null, introduction);
-      }],
-
       // Make a signed invoice request that asks for the page
       message: ['checkNetwork', ({}, cbk) => {
         try {
@@ -221,16 +209,11 @@ module.exports = (args, cbk) => {
       }],
 
       // Send the request and wait for the reply
-      getReply: [
-        'getPath',
-        'introduction',
-        'message',
-        ({getPath, introduction, message}, cbk) =>
-      {
+      getReply: ['getPath', 'message', ({getPath, message}, cbk) => {
         return requestNetworkReply({
-          introduction,
           message,
           lnd: args.lnd,
+          max_reply_hops: maxReplyHops,
           path: getPath,
           timeout: args.timeout || defaultMenuTimeoutMs,
           types: [typeInvoice, typeInvoiceError],

package/support/service_support_offer.js

@@ -74,6 +74,8 @@ const typeRequestAmount = '82';
   checked to be a support offer of a supported version, and its signing key
   is checked to be the offer issuer id. When a check fails, or the related
   offers cannot be made into menus, an error is emitted and the service ends.
+  When the checks pass, the `start` listener is given the offer, so that a
+  service resumed from its record can show the offer again.
 
   Requests that did not arrive on an offer path are ignored. Invalid requests
   on an offer path are sent an invoice error. A request that is sent again is
@@ -115,6 +117,11 @@ const typeRequestAmount = '82';
   stops the handling of requests that are being handled, so nothing more is
   sent.
 
+  The service gets through a disconnection from LND, like LND restarting:
+  the error is emitted, onion messages are subscribed to again after a
+  delay, and invoices paid in the meantime are still reported. The service
+  ends when LND rejects a subscription, or does not have onion messages.
+
   {
     lnd: <Authenticated LND API Object>
     record: <Support Service Record Hex String>
@@ -140,10 +147,17 @@ const typeRequestAmount = '82';
     invoice: <Add an Invoice Sent Listener Function>
     invoice_error: <Add an Invoice Error Sent Listener Function>
     menu: <Add a Menu Sent Listener Function>
+    start: <Add a Service Started Listener Function>
     stop: <Stop Listening Function> ({}) => {};
     supporter: <Add a Supporter Paid Listener Function>
   }
 
+    start:
+    @returns via cbk
+    {
+      offer: <BOLT 12 Support Offer String>
+    }
+
     supporter:
     @returns via cbk
     {
@@ -269,6 +283,7 @@ module.exports = args => {
     invoice: () => {},
     invoice_error: () => {},
     menu: () => {},
+    start: () => {},
   };
   const waiting = [];
 
@@ -284,6 +299,11 @@ module.exports = args => {
   // Tell a listener about an event apart from the code that found it, so
   // that a listener that throws cannot stop the service or crash it
   const emit = (event, details) => process.nextTick(() => {
+    // Exit early when the service stopped before it could say it started
+    if (event === 'start' && isStopped) {
+      return;
+    }
+
     try {
       return service[event](details);
     } catch (err) {
@@ -512,14 +532,26 @@ module.exports = args => {
   (err, res) => {
     isChecked = true;
 
+    // Exit early when the service stopped or failed while the record was
+    // checked, so that it does not start
+    if (isStopped) {
+      return;
+    }
+
     if (!!err) {
-      failed(err);
-    } else {
-      state = res.state;
+      return failed(err);
     }
 
-    // Requests that arrived while the record was checked are handled now
-    return waiting.splice(0).forEach(handle => handle());
+    state = res.state;
+
+    // The service has started, and the offer can be shown again
+    emit('start', {offer: state.offer});
+
+    // Requests that arrived while the record was checked are handled now,
+    // after the start listener is told
+    return process.nextTick(() => {
+      return waiting.splice(0).forEach(handle => handle());
+    });
   }));
 
   invoicesSub.on('error', err => failed(err));
@@ -1020,6 +1052,7 @@ module.exports = args => {
     invoice: cbk => service.invoice = cbk,
     invoice_error: cbk => service.invoice_error = cbk,
     menu: cbk => service.menu = cbk,
+    start: cbk => service.start = cbk,
     stop: ({}) => {
       isStopped = true;
 

package/network/reply_introduction.js

@@ -1,44 +0,0 @@
-const {randomInt} = require('node:crypto');
-
-const onionMessagesBits = [38, 39];
-
-/** Select a connected peer to start a reply path at
-
-  The peer has to relay onion messages, and is not the start of the path that
-  the request is sent over. A random peer is selected from those that can be
-  used, and there is no peer when none can be used.
-
-  {
-    path: {
-      [introduction_node]: <Request Path Introduction Public Key Hex String>
-    }
-    peers: [{
-      features: [{
-        bit: <BOLT 09 Feature Bit Number>
-      }]
-      public_key: <Peer Public Key Hex String>
-    }]
-  }
-
-  @returns
-  {
-    [introduction]: <Reply Path Introduction Peer Public Key Hex String>
-  }
-*/
-module.exports = ({path, peers}) => {
-  const relays = peers.filter(peer => {
-    // The start of the request path is not used for the reply path
-    if (peer.public_key === path.introduction_node) {
-      return false;
-    }
-
-    return !!peer.features.find(n => onionMessagesBits.includes(n.bit));
-  });
-
-  // Exit early when there is no peer to start the reply path at
-  if (!relays.length) {
-    return {};
-  }
-
-  return {introduction: relays[randomInt(relays.length)].public_key};
-};