paid-services 10.2.0 → 10.3.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## Version 10.3.0
+
+- `getOfferInvoice`: Add support for offer paths that start at the payer
+- `serviceSupportOffer`: Add support for reply paths that start at the node
+
 ## Version 10.2.0
 
 - `serviceSupportOffer`: Add `start` event with the support offer

package/network/constants.json

@@ -12,5 +12,7 @@
   "codeInvalidArgument": 3,
   "codePermissionDenied": 7,
   "codeUnauthenticated": 16,
-  "codeUnimplemented": 12
+  "codeUnimplemented": 12,
+  "knownHopRecordTypes": ["1", "2", "4", "6", "8", "10", "12", "14"],
+  "typePathId": "6"
 }

package/network/get_path_after_self.js

@@ -0,0 +1,222 @@
+const asyncAuto = require('async/auto');
+const {decryptBlindedPath} = require('bolt04');
+const {diffieHellmanComputeSecret} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {knownHopRecordTypes} = require('./constants');
+const {typePathId} = require('./constants');
+
+const hasPathId = records => records.some(n => n.type === typePathId);
+const hopsAfterFirst = hops => hops.slice(1);
+const idsOf = channel => [channel.id].concat(channel.other_ids);
+const {isArray} = Array;
+const isEven = type => !(BigInt(type) % BigInt(2));
+const isKnown = record => knownHopRecordTypes.includes(record.type);
+const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
+const isUnknownEven = record => !isKnown(record) && isEven(record.type);
+
+/** Get the blinded path after self, for a blinded path that starts at self
+
+  Self reads its own hop as an introduction node would. The path goes on from
+  the next node, which the hop names, or which is the peer at the other end
+  of the channel that the hop names.
+
+  As BOLT 4 asks of a node that forwards, the hop of self is not used when it
+  has an unknown even record, when it has a path id, or when it allows
+  features, since no onion message features are defined.
+
+  {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    identity: <Node Identity Public Key Hex String>
+    key: <First Hop Path Key Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    introduction_node: <Next Node Public Key Hex String>
+    key: <Next Hop Path Key Public Key Hex String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(args.hops) || !args.hops.length) {
+          return cbk([400, 'ExpectedBlindedPathHopsToGetPathAfterSelf']);
+        }
+
+        if (!isPublicKey(args.identity)) {
+          return cbk([400, 'ExpectedIdentityPublicKeyToGetPathAfterSelf']);
+        }
+
+        if (!args.key) {
+          return cbk([400, 'ExpectedPathKeyToGetPathAfterSelf']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToGetPathAfterSelf']);
+        }
+
+        return cbk();
+      },
+
+      // Compute the shared secret of the path key and the node identity key
+      getSecret: ['validate', ({}, cbk) => {
+        return diffieHellmanComputeSecret({
+          lnd: args.lnd,
+          partner_public_key: args.key,
+        },
+        cbk);
+      }],
+
+      // Decrypt the data of the hop of self to read where the path goes next
+      decrypt: ['getSecret', ({getSecret}, cbk) => {
+        const [own] = args.hops;
+
+        try {
+          return cbk(null, decryptBlindedPath({
+            encrypted: own.encrypted_data,
+            key: args.key,
+            secret: getSecret.secret,
+          }));
+        } catch (err) {
+          return cbk([503, 'FailedToDecryptOwnBlindedPathHop', {err}]);
+        }
+      }],
+
+      // Check the hop of self can be followed, as a forwarding node would
+      check: ['decrypt', ({decrypt}, cbk) => {
+        // An unknown even record cannot be ignored, so the hop cannot be used
+        if (decrypt.records.some(isUnknownEven)) {
+          return cbk([
+            400,
+            'UnexpectedUnknownRequiredRecordInOwnBlindedPathHop',
+          ]);
+        }
+
+        // No features are defined for onion messages, so a feature bit in
+        // the allowed features is an unknown feature, and the hop is not used
+        if (!!decrypt.features.length) {
+          return cbk([400, 'UnsupportedFeatureInOwnBlindedPathHop']);
+        }
+
+        // A hop with no next node or channel is the final hop of the path
+        if (!decrypt.next_node_id && !decrypt.next_channel_id) {
+          return cbk([400, 'UnexpectedBlindedPathToSelf']);
+        }
+
+        // A hop that goes on to a next node is not one with a path id record,
+        // which is present even when the path id is empty
+        if (hasPathId(decrypt.records)) {
+          return cbk([400, 'UnexpectedPathIdInOwnBlindedPathHop']);
+        }
+
+        return cbk();
+      }],
+
+      // The hops after self, which the path goes on over
+      hops: ['check', ({}, cbk) => {
+        const hops = hopsAfterFirst(args.hops);
+
+        // The next node has a hop of its own to send to
+        if (!hops.length) {
+          return cbk([400, 'ExpectedHopsAfterSelfInBlindedPath']);
+        }
+
+        return cbk(null, hops);
+      }],
+
+      // Get the channels of self when the next node is named by a channel
+      getChannels: ['decrypt', 'hops', ({decrypt}, cbk) => {
+        // Exit early when the hop names the next node
+        if (!!decrypt.next_node_id) {
+          return cbk();
+        }
+
+        return getChannels({lnd: args.lnd}, cbk);
+      }],
+
+      // Find the next channel among the channels of self
+      channel: ['decrypt', 'getChannels', ({decrypt, getChannels}, cbk) => {
+        // Exit early when the hop names the next node
+        if (!getChannels) {
+          return cbk();
+        }
+
+        const id = decrypt.next_channel_id;
+
+        // A private channel can be named by one of its aliases
+        return cbk(null, getChannels.channels.find(n => idsOf(n).includes(id)));
+      }],
+
+      // Look for the next channel in the graph when self does not list it
+      getChannel: ['channel', 'decrypt', ({channel, decrypt}, cbk) => {
+        // Exit early when the next node is already known
+        if (!!decrypt.next_node_id || !!channel) {
+          return cbk();
+        }
+
+        return getChannel({
+          id: decrypt.next_channel_id,
+          lnd: args.lnd,
+        },
+        (err, res) => {
+          // Exit early when the channel is not in the graph
+          if (!!err) {
+            return cbk([503, 'FailedToFindNextPeerInBlindedPath']);
+          }
+
+          return cbk(null, res);
+        });
+      }],
+
+      // The next node is the one that the hop names, or is across the channel
+      next: [
+        'channel',
+        'decrypt',
+        'getChannel',
+        ({channel, decrypt, getChannel}, cbk) =>
+      {
+        // Exit early when the hop names the next node
+        if (!!decrypt.next_node_id) {
+          return cbk(null, decrypt.next_node_id);
+        }
+
+        // Exit early when the channel is a channel of self
+        if (!!channel) {
+          return cbk(null, channel.partner_public_key);
+        }
+
+        const keys = getChannel.policies.map(n => n.public_key);
+
+        // The channel in the graph has to be one that self forwards over
+        if (!keys.includes(args.identity)) {
+          return cbk([503, 'FailedToFindNextPeerInBlindedPath']);
+        }
+
+        return cbk(null, keys.find(n => n !== args.identity));
+      }],
+
+      // The path goes on from the next node, with the next hop path key
+      path: ['decrypt', 'hops', 'next', ({decrypt, hops, next}, cbk) => {
+        return cbk(null, {
+          hops,
+          introduction_node: next,
+          key: decrypt.next_path_key,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'path'}, cbk));
+  });
+};

package/network/get_path_outbound.js

@@ -1,28 +1,48 @@
 const asyncAuto = require('async/auto');
+const asyncWhilst = require('async/whilst');
 const {getChannel} = require('ln-service');
+const {getIdentity} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const getMessageHops = require('./get_message_hops');
+const getPathAfterSelf = require('./get_path_after_self');
 const pathIntroduction = require('./path_introduction');
 
 const edgeChannel = edge => edge.split('x').slice(0, -1).join('x');
+const {isArray} = Array;
+const isPublicKey = n => typeof n === 'string' && /^[0-9A-F]{66}$/i.test(n);
 
-/** Get the outbound hops to reach the introduction node of a blinded path
+/** Get the outbound hops to reach the introduction node of a blinded path,
+  with the hops and the path key to send over
 
   When the introduction node is not a connected peer, the message is relayed
   along a payment route through nodes that relay onion messages
 
+  A path that starts at self is sent from the next node of the path: self
+  reads its own hops, as an introduction node would, and sends over the hops
+  after them. A path that does not start at self is sent over as it is.
+
   {
     [is_expecting_reply]: <Reply Comes Back Along the Same Nodes Bool>
     lnd: <Authenticated LND API Object>
     path: {
+      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>
     }
   }
 
   @returns via cbk or Promise
   {
+    hops: [{
+      encrypted_data: <Encrypted Recipient Data Hex String>
+      relay_key: <Blinded Relaying Node Public Key Hex String>
+    }]
+    key: <First Hop Path Key Public Key Hex String>
     outbound: [<Relaying Node Public Key Hex String>]
   }
 */
@@ -39,6 +59,21 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedBlindedPathToGetPathOutbound']);
         }
 
+        if (!isArray(args.path.hops) || !args.path.hops.length) {
+          return cbk([400, 'ExpectedBlindedPathHopsToGetPathOutbound']);
+        }
+
+        // A node introduction is compared to self as a public key
+        if (!!args.path.introduction_node) {
+          if (!isPublicKey(args.path.introduction_node)) {
+            return cbk([400, 'ExpectedIntroductionNodeKeyToGetPathOutbound']);
+          }
+        }
+
+        if (!args.path.key) {
+          return cbk([400, 'ExpectedBlindedPathKeyToGetPathOutbound']);
+        }
+
         return cbk();
       },
 
@@ -54,6 +89,11 @@ module.exports = (args, cbk) => {
         return getChannel({id, lnd: args.lnd}, cbk);
       }],
 
+      // Get the identity key of self, which the path can start at
+      getIdentity: ['validate', ({}, cbk) => {
+        return getIdentity({lnd: args.lnd}, cbk);
+      }],
+
       // Determine the introduction node of the path
       introduction: ['getChannel', ({getChannel}, cbk) => {
         try {
@@ -62,25 +102,69 @@ module.exports = (args, cbk) => {
             path: args.path,
           });
 
-          return cbk(null, introduction);
+          // Node keys are compared in lowercase, as LND gives them
+          return cbk(null, introduction.toLowerCase());
         } catch (err) {
           return cbk([400, err.message]);
         }
       }],
 
+      // Step past the hops of self while the path starts at self
+      stepped: [
+        'getIdentity',
+        'introduction',
+        ({getIdentity, introduction}, cbk) =>
+      {
+        const identity = getIdentity.public_key;
+
+        let path = {
+          hops: args.path.hops,
+          introduction_node: introduction,
+          key: args.path.key,
+        };
+
+        // Self reads its own hop as an introduction node would, and the path
+        // goes on from the next node, which can be self again
+        return asyncWhilst(
+          cbk => cbk(null, path.introduction_node === identity),
+          cbk => {
+            return getPathAfterSelf({
+              identity,
+              hops: path.hops,
+              key: path.key,
+              lnd: args.lnd,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(err);
+              }
+
+              path = res;
+
+              return cbk();
+            });
+          },
+          err => !!err ? cbk(err) : cbk(null, path)
+        );
+      }],
+
       // Get the hops to relay the message to the introduction node
-      getHops: ['introduction', ({introduction}, cbk) => {
+      getHops: ['stepped', ({stepped}, cbk) => {
         return getMessageHops({
-          destination: introduction,
+          destination: stepped.introduction_node,
           is_expecting_reply: args.is_expecting_reply,
           lnd: args.lnd,
         },
         cbk);
       }],
 
-      // The outbound hops end at the introduction node
-      outbound: ['getHops', ({getHops}, cbk) => {
-        return cbk(null, {outbound: getHops.hops});
+      // The outbound hops end at the introduction node of the path to send
+      outbound: ['getHops', 'stepped', ({getHops, stepped}, cbk) => {
+        return cbk(null, {
+          hops: stepped.hops,
+          key: stepped.key,
+          outbound: getHops.hops,
+        });
       }],
     },
     returnResult({reject, resolve, of: 'outbound'}, cbk));

package/network/request_network_reply.js

@@ -27,6 +27,9 @@ const isTimeout = n => isSafeInteger(n) && n > 0;
   than `max_reply_hops` keeps the hops nearest self, and the recipient routes
   to its start.
 
+  A path that starts at self is sent from the next node of the path, and the
+  reply path goes back from there.
+
   {
     lnd: <Authenticated LND API Object>
     [max_reply_hops]: <Maximum Reply Path Hops Count Number>
@@ -135,9 +138,9 @@ module.exports = (args, 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;
+        // The outbound hops end at the introduction node of the hops that are
+        // sent, which is the recipient itself when there is a single hop
+        const isRecipient = getOutbound.hops.length === 1;
 
         const relays = !isRecipient ? outbound : outbound.slice(0, -1);
 
@@ -258,8 +261,8 @@ module.exports = (args, cbk) => {
 
         // Send the message with a reply path back the way it goes
         const sending = sendMessage({
-          inbound: args.path.hops,
-          key: args.path.key,
+          inbound: getOutbound.hops,
+          key: getOutbound.key,
           lnd: args.lnd,
           message: args.message,
           outbound: getOutbound.outbound,

package/network/return_network_response.js

@@ -14,8 +14,8 @@ const largeOnionBytes = 32834;
 
   With `is_regular`, the response is only sent when it fits in an onion
   message of the regular size. Otherwise it has to fit in a large one. A
-  response that does not fit is a 413 error. Give the `outbound` hops to the
-  reply path when they are known.
+  response that does not fit is a 413 error. Give the `route` to the reply
+  path when it is known, as found by `getPathOutbound`.
 
   {
     [is_regular]: <Only Send In An Onion Message Of The Regular Size Bool>
@@ -33,7 +33,14 @@ const largeOnionBytes = 32834;
       [introduction_node]: <Introduction Node Public Key Hex String>
       key: <Path Key Hex String>
     }
-    [outbound]: [<Relaying Node Public Key Hex String>]
+    [route]: {
+      hops: [{
+        encrypted_data: <Encrypted Data Hex String>
+        relay_key: <Blinded Relay Key Hex String>
+      }]
+      key: <Path Key Hex String>
+      outbound: [<Relaying Node Public Key Hex String>]
+    }
   }
 
   @returns via cbk or Promise
@@ -58,23 +65,32 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
-      // Determine the outbound hops to reach the reply path
-      getOutbound: ['validate', ({}, cbk) => {
-        // Exit early when the outbound hops are already known
-        if (!!args.outbound) {
-          return cbk(null, {outbound: args.outbound});
+      // Determine the route to the reply path: the hops and key to send over
+      getRoute: ['validate', ({}, cbk) => {
+        // Exit early when the route is already known
+        if (!!args.route) {
+          return cbk(null, args.route);
         }
 
-        return getPathOutbound({lnd: args.lnd, path: args.reply}, cbk);
+        return getPathOutbound({
+          lnd: args.lnd,
+          path: {
+            hops: args.reply.inbound,
+            introduction_edge: args.reply.introduction_edge,
+            introduction_node: args.reply.introduction_node,
+            key: args.reply.key,
+          },
+        },
+        cbk);
       }],
 
       // Check that the response fits in an onion message that can be sent
-      checkSize: ['getOutbound', ({getOutbound}, cbk) => {
+      checkSize: ['getRoute', ({getRoute}, cbk) => {
         try {
           const {onion} = onionForPath({
-            inbound: args.reply.inbound,
-            key: args.reply.key,
-            outbound: getOutbound.outbound,
+            inbound: getRoute.hops,
+            key: getRoute.key,
+            outbound: getRoute.outbound,
             records: [args.message],
           });
 
@@ -99,13 +115,13 @@ module.exports = (args, cbk) => {
       }],
 
       // Send the response message through the reply path
-      send: ['checkSize', 'getOutbound', ({getOutbound}, cbk) => {
+      send: ['checkSize', 'getRoute', ({getRoute}, cbk) => {
         return sendMessage({
-          inbound: args.reply.inbound,
-          key: args.reply.key,
+          inbound: getRoute.hops,
+          key: getRoute.key,
           lnd: args.lnd,
           message: args.message,
-          outbound: getOutbound.outbound,
+          outbound: getRoute.outbound,
         },
         cbk);
       }],

package/network/service_network_messages.js

@@ -176,23 +176,32 @@ module.exports = ({delay, ids, lnd}) => {
 
     const {encrypted, key, reply} = received;
 
-    let outbound;
+    let route;
 
-    // The route to the reply path is found once for a message
-    const getOutbound = () => {
+    // The route to the reply path, the hops and key to send over and the
+    // outbound hops to reach them, is found once for a message
+    const getRoute = () => {
       // Exit early when the route was already found or is being found
-      if (!!outbound) {
-        return outbound;
+      if (!!route) {
+        return route;
       }
 
-      const lookup = getPathOutbound({lnd, path: reply});
+      const lookup = getPathOutbound({
+        lnd,
+        path: {
+          hops: reply.inbound,
+          introduction_edge: reply.introduction_edge,
+          introduction_node: reply.introduction_node,
+          key: reply.key,
+        },
+      });
 
-      outbound = lookup;
+      route = lookup;
 
       // A failed lookup is not kept, so that a later reply can try again
       lookup.catch(() => {
-        if (outbound === lookup) {
-          outbound = undefined;
+        if (route === lookup) {
+          route = undefined;
         }
       });
 
@@ -224,7 +233,7 @@ module.exports = ({delay, ids, lnd}) => {
 
       // The caller is told outside of the promise chain, so that a throw in
       // the caller is not taken as a failure to send
-      return getOutbound()
+      return getRoute()
         .then(res => {
           // Exit early when the service stopped while the route was found
           if (isStopped) {
@@ -236,7 +245,7 @@ module.exports = ({delay, ids, lnd}) => {
             lnd,
             reply,
             message: response,
-            outbound: res.outbound,
+            route: res,
           });
         })
         .then(() => setImmediate(() => done()), err => {
@@ -253,11 +262,11 @@ module.exports = ({delay, ids, lnd}) => {
 
       // The caller is told outside of the promise chain, so that it is only
       // called once, even when it throws
-      return getOutbound()
+      return getRoute()
         .then(res => regularReplyBytes({
           type,
-          inbound: reply.inbound,
-          key: reply.key,
+          inbound: res.hops,
+          key: res.key,
           outbound: res.outbound,
         }))
         .then(res => setImmediate(() => cbk(null, res)), err => {

package/offers/get_offer_invoice.js

@@ -29,11 +29,11 @@ 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. 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.
+  request sent to its issuer id. A path that starts at the payer is sent
+  from its next node. 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`, only once the request is known to be one

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.2.0"
+  "version": "10.3.0"
 }