balanceofsatoshis 23.1.12 → 23.2.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Versions
 
+## 23.2.0
+
+- `invoice`: Add `--encrypted-hints` to hide the node behind blinded paths in
+    the payment request
+- `invoice`: Add `--select-hints` with `--encrypted-hints` to choose the
+    blinded path outwards from a peer to an introduction node
+- `invoice`: Add `--virtual-fee-rate` with selected `--encrypted-hints` to
+    charge a receiver fee on the blinded path
+- `pay`, `probe`: Add support for payment requests with blinded paths
+
 ## 23.1.12
 
 - Add support for LND 0.21.3

package/bos

@@ -1147,7 +1147,11 @@ prog
   .help('--virtual invoices cannot be used with payers who probe before pay')
   .help('Only one --virtual invoice can be active at a time')
   .help('--reject-on-amount-increase can only be used with --virtual invoices')
+  .help('--encrypted-hints hides the node with blinded paths, needs an amount')
+  .help('--encrypted-hints with --select-hints picks the path outwards by hop')
+  .help('--virtual-fee-rate with selected --encrypted-hints is a receiver fee')
   .argument('[amount]', 'Amount for invoice', STRING, '0')
+  .option('--encrypted-hints', 'Use blinded paths instead of hop hints')
   .option('--for <description>', 'What is the invoice requesting payment for')
   .option('--hours <expires_in>', 'Hours invoice is valid for', INT)
   .option('--include-hints', 'Include the default set of hop hint channels')
@@ -1157,7 +1161,7 @@ prog
   .option('--reject-on-amount-increase', 'Reject if required amount increases')
   .option('--select-hints', 'Select hop hints to be added to the request')
   .option('--virtual', 'Request payment over a virtual channel')
-  .option('--virtual-fee-rate <pm>', 'Fee rate to use on virtual channel', INT)
+  .option('--virtual-fee-rate <pm>', 'Receiver fee rate on virtual/path', INT)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1167,6 +1171,7 @@ prog
           ask: await commands.interrogate({}),
           description: options.for,
           expires_in: options.hours,
+          is_encrypting_hints: options.encryptedHints || undefined,
           is_hinting: options.includeHints || undefined,
           is_including_qr: !!options.qr || undefined,
           is_rejecting_option: !!options.rejectOnAmountIncrease || undefined,
@@ -1551,6 +1556,7 @@ prog
 
   // Pay a payment request, probing first
   .command('pay', 'Pay a payment request, probing first')
+  .help('Blinded path requests are probed to the introduction node, 1 path')
   .argument('<request>', 'Payment Request')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
   .option('--avoid-high-fee-routes', 'Avoid evaluating too-high fee routes')
@@ -1670,6 +1676,7 @@ prog
   // Determine if a payment request is sendable
   .command('probe', 'Check if a payment request is sendable')
   .help('Simulate paying a payment request without actually paying it')
+  .help('Blinded path requests are probed to the introduction node, 1 path')
   .argument('<to>', 'Payment request or node public key')
   .argument('[amount]', 'Amount to probe, default: request amount')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)

package/chain/closing_fees.js

@@ -1,6 +1,5 @@
-const {Transaction} = require('bitcoinjs-lib');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 
-const {fromHex} = Transaction;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
 
 /** Calculate channel closing fees paid
@@ -40,7 +39,9 @@ module.exports = args => {
   }
 
   // Calculate the value of the outputs in the tx that spends the capacity
-  const outValue = sumOf(fromHex(closer.transaction).outs.map(n => n.value));
+  const {outputs} = componentsOfTransaction({transaction: closer.transaction});
+
+  const outValue = sumOf(outputs.map(n => n.tokens));
 
   const fees = []
     .concat(args.capacity - outValue)

package/chain/fund_transaction.js

@@ -246,7 +246,12 @@ module.exports = (args, cbk) => {
         try {
           const outputs = args.addresses.map((address, i) => {
             const amount = args.amounts[i];
-            const variables = {max: getMax.max_tokens};
+            const variables = {};
+
+            // The max variable is only defined when a maximum is calculated
+            if (getMax.max_tokens !== undefined) {
+              variables.max = getMax.max_tokens;
+            }
 
             return {address, tokens: parseAmount({amount, variables}).tokens};
           });

package/display/describe_route.js

@@ -10,8 +10,10 @@ const describeConfidence = require('./describe_confidence');
 const formatFeeRate = require('./format_fee_rate');
 
 const aliasColor = n => !!n ? greenBright(n) : '';
+const blindedChannel = 'blinded';
 const effectiveFeeRate = (n, m) => Number(BigInt(1e6) * BigInt(n) / BigInt(m));
 const flatten = arr => [].concat(...arr);
+const isBlindedHop = hop => !!hop.encrypted_data && !hop.path_key;
 const isEmoji = /(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC69\uDC6E\uDC70-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD18-\uDD1C\uDD1E\uDD1F\uDD26\uDD30-\uDD39\uDD3D\uDD3E\uDDD1-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])?|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDEEB\uDEEC\uDEF4-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u2660\u2663\u2665\u2666\u2668\u267B\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEF8]|\uD83E[\uDD10-\uDD3A\uDD3C-\uDD3E\uDD40-\uDD45\uDD47-\uDD4C\uDD50-\uDD6B\uDD80-\uDD97\uDDC0\uDDD0-\uDDE6])\uFE0F/g;
 const pairEdgeIndex = (pair, key) => `x${Number(!pair.indexOf(key))}`;
 
@@ -26,10 +28,12 @@ const pairEdgeIndex = (pair, key) => `x${Number(!pair.indexOf(key))}`;
       hops: [{
         channel: <Standard Format Channel Id String>
         channel_capacity: <Channel Capacity Tokens Number>
+        [encrypted_data]: <Blinded Path Encrypted Data Hex String>
         fee: <Fee Number>
         fee_mtokens: <Fee Millitokens String>
         forward: <Forward Tokens Number>
         forward_mtokens: <Forward Millitokens String>
+        [path_key]: <Blinded Path Key Hex String>
         public_key: <Public Key Hex String>
         timeout: <Timeout Block Height Number>
       }]
@@ -109,28 +113,35 @@ module.exports = ({lnd, route, tagged}, cbk) => {
 
         const path = route.hops.map((hop, i, hops) => {
           const {alias} = getAliases.find(n => n.id === hop.public_key);
-          const {channel} = hop;
-          const delta = !i ? null : hops[i - 1].timeout - hops[i].timeout;
+          const isBlinded = isBlindedHop(hop);
           const isFinal = i === hops.length - 1 && hops.length !== 1;
           const pair = [(hops[i - 1] || {}).public_key, hop.public_key].sort();
 
-          const edgeIndex = pairEdgeIndex(pair, hop.public_key);
-          const expiry = delta > 240 ? redBright(` Expiry +${delta}`) : '';
+          // Blinded hops have no channel, timeout or amount of their own
+          const channel = !isBlinded ? hop.channel : blindedChannel;
+          const edge = isBlinded ? '' : pairEdgeIndex(pair, hop.public_key);
           const feeMtokens = isFinal ? hops[i-1].fee_mtokens : hop.fee_mtokens;
           const forwarder = `${aliasColor(alias)} ${hop.public_key}`.trim();
+          const hasForward = !!BigInt(hop.forward_mtokens || Number());
+          const prior = hops[i - 1];
 
-          const feeRate = effectiveFeeRate(feeMtokens, hop.forward_mtokens);
+          const delta = !i || isBlinded ? null : prior.timeout - hop.timeout;
+          const expiry = delta > 240 ? redBright(` Expiry +${delta}`) : '';
 
-          const rate = formatFeeRate({rate: feeRate}).display;
+          // The rate is unknown when the hop forward amount is unknown
+          const rate = !hasForward ? null : formatFeeRate({
+            rate: effectiveFeeRate(feeMtokens, hop.forward_mtokens),
+          }).display;
 
-          const forward = `${forwarder}. Fee rate: ${rate}${expiry}`;
+          const forward = rate === null ? forwarder :
+            `${forwarder}. Fee rate: ${rate}${expiry}`;
 
           if (!i) {
             return [`${gray(channel)} ${description || String()}`, forward];
           } else if (i === hops.length - [i].length) {
-            return [`${gray(channel + edgeIndex)}`];
+            return [`${gray(channel + edge)}`];
           } else {
-            return [`${gray(channel + edgeIndex)}`, forward];
+            return [`${gray(channel + edge)}`, forward];
           }
         });
 

package/network/blinded_path_fee.js

@@ -0,0 +1,61 @@
+const feeRateDenominator = BigInt(1e6);
+const {isArray} = Array;
+const isMtokens = n => typeof n === 'string' && /^\d+$/.test(n);
+const isNumber = n => typeof n === 'number' && !isNaN(n);
+const noFee = '0';
+
+/** Calculate the fee to deliver an amount through a blinded path
+
+  {
+    mtokens: <Millitokens To Deliver To The Destination String>
+    path: {
+      base_fee_mtokens: <Accumulated Base Fee Millitokens String>
+      fee_rate: <Accumulated Fee Rate Millitokens Per Million Number>
+      hops: [{
+        encrypted_data: <Encrypted Recipient Data Hex String>
+        relay_key: <Relaying Node Public Key Hex String>
+      }]
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    fee_mtokens: <Blinded Path Fee Millitokens String>
+  }
+*/
+module.exports = ({mtokens, path}) => {
+  if (!isMtokens(mtokens)) {
+    throw new Error('ExpectedMillitokensToCalculateBlindedPathFee');
+  }
+
+  if (!path) {
+    throw new Error('ExpectedBlindedPathToCalculateBlindedPathFee');
+  }
+
+  if (!isMtokens(path.base_fee_mtokens)) {
+    throw new Error('ExpectedBaseFeeMillitokensToCalculateBlindedPathFee');
+  }
+
+  if (!isNumber(path.fee_rate)) {
+    throw new Error('ExpectedFeeRateToCalculateBlindedPathFee');
+  }
+
+  if (!isArray(path.hops) || !path.hops.length) {
+    throw new Error('ExpectedPathHopsToCalculateBlindedPathFee');
+  }
+
+  // Exit early when the path is just the destination, there is no relaying
+  if (path.hops.length === [path].length) {
+    return {fee_mtokens: noFee};
+  }
+
+  const baseFee = BigInt(path.base_fee_mtokens);
+  const proportional = BigInt(mtokens) * BigInt(path.fee_rate);
+
+  const fee = baseFee + proportional / feeRateDenominator;
+
+  return {fee_mtokens: fee.toString()};
+};

package/network/execute_probe.js

@@ -16,9 +16,11 @@ const tokensAsMillitokens = tok => (BigInt(tok) * BigInt(1e3)).toString();
 
 /** Execute a probe
 
+  `destination` is not required when probing to blinded `paths`
+
   {
     cltv_delta: <Final Cltv Delta Number>
-    destination: <Final Destination Public Key Hex String>
+    [destination]: <Final Destination Public Key Hex String>
     [features]: [{
       bit: <Feature Bit Number>
     }]
@@ -39,6 +41,19 @@ const tokensAsMillitokens = tok => (BigInt(tok) * BigInt(1e3)).toString();
       value: <Message To Final Destination Raw Value Hex Encoded String>
     }]
     [outgoing_channel]: <Outgoing Channel Id 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: <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>
+    }]
     [payment]: <Payment Identifier Hex String>
     [routes]: [[{
       [base_fee_mtokens]: <Base Fee Millitokens String>
@@ -67,10 +82,12 @@ const tokensAsMillitokens = tok => (BigInt(tok) * BigInt(1e3)).toString();
       hops: [{
         channel: <Standard Format Channel Id String>
         channel_capacity: <Channel Capacity Tokens Number>
+        [encrypted_data]: <Blinded Path Encrypted Data Hex String>
         fee: <Fee Number>
         fee_mtokens: <Fee Millitokens String>
         forward: <Forward Tokens Number>
         forward_mtokens: <Forward Millitokens String>
+        [path_key]: <Blinded Path Key Hex String>
         public_key: <Public Key Hex String>
         timeout: <Timeout Block Height Number>
       }]
@@ -89,7 +106,7 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedFinalCltvDeltaToExecuteProbe']);
         }
 
-        if (!args.destination) {
+        if (!args.destination && !args.paths) {
           return cbk([400, 'ExpectedDestinationToExecuteProbe']);
         }
 
@@ -145,25 +162,32 @@ module.exports = (args, cbk) => {
 
         const timeoutMinutes = minutesAsMs((args.timeout_minutes || Number()));
 
-        const sub = subscribeToProbeForRoute({
-          mtokens,
-          cltv_delta: args.cltv_delta,
-          destination: args.destination,
-          features: args.features,
-          ignore: args.ignore,
-          incoming_peer: args.in_through,
-          lnd: args.lnd,
-          max_fee_mtokens: strictMaxFee || undefined,
-          max_timeout_height: args.max_timeout_height,
-          messages: args.messages,
-          outgoing_channel: args.outgoing_channel,
-          path_timeout_ms: pathTimeoutMs,
-          payment: args.payment,
-          probe_timeout_ms: timeoutMinutes || undefined,
-          routes: args.routes,
-          tokens: args.tokens,
-          total_mtokens: !!args.payment ? mtokens : undefined,
-        });
+        let sub;
+
+        try {
+          sub = subscribeToProbeForRoute({
+            mtokens,
+            cltv_delta: args.cltv_delta,
+            destination: args.destination,
+            features: args.features,
+            ignore: args.ignore,
+            incoming_peer: args.in_through,
+            lnd: args.lnd,
+            max_fee_mtokens: strictMaxFee || undefined,
+            max_timeout_height: args.max_timeout_height,
+            messages: args.messages,
+            outgoing_channel: args.outgoing_channel,
+            path_timeout_ms: pathTimeoutMs,
+            paths: args.paths,
+            payment: args.payment,
+            probe_timeout_ms: timeoutMinutes || undefined,
+            routes: args.routes,
+            tokens: args.tokens,
+            total_mtokens: !!args.payment ? mtokens : undefined,
+          });
+        } catch (err) {
+          return cbk([400, 'FailedToStartProbeForRoute', {err}]);
+        }
 
         const finished = (err, res) => {
           sub.removeAllListeners();

package/network/pay.js

@@ -21,6 +21,7 @@ const {isArray} = Array;
 const mtokensAsTokens = mtokens => Number(mtokens / BigInt(1e3));
 const pathTimeoutMs = 1000 * 60 * 5;
 const singlePath = 1;
+const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
 
 /** Make a payment
 
@@ -229,6 +230,11 @@ module.exports = (args, cbk) => {
         const paths = [];
         const request = parsePaymentRequest({request: args.request});
 
+        // Multi-path payments look for paths to a destination, not to paths
+        if (!!request.paths) {
+          return cbk([501, 'MultiPathPayNotSupportedWithBlindedPaths']);
+        }
+
         const sub = subscribeToMultiPathProbe({
           cltv_delta: request.cltv_delta,
           destination: request.destination,
@@ -399,7 +405,15 @@ module.exports = (args, cbk) => {
         'singlePathPay',
         ({multiPathPay, singlePathPay}, cbk) =>
       {
-        return cbk(null, singlePathPay || multiPathPay);
+        const payment = singlePathPay || multiPathPay;
+
+        // Exit early when the payment was not through a blinded path
+        if (!payment || payment.blinded_path_fee === undefined) {
+          return cbk(null, payment);
+        }
+
+        // The fee of a blinded path payment is a total including the path fee
+        return cbk(null, withTotalFee(payment));
       }],
     },
     returnResult({reject, resolve, of: 'payment'}, cbk));

package/network/probe.js

@@ -30,6 +30,7 @@ const pathTimeoutMs = 1000 * 60 * 90;
 const singlePath = 1;
 const uniq = arr => Array.from(new Set(arr));
 const unsupported = 501;
+const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
 
 /** Probe a destination, looking for multiple non-overlapping paths
 
@@ -54,10 +55,12 @@ const unsupported = 501;
 
   @returns via cbk or Promise
   {
+    [blinded_path_fee]: <Blinded Path Fee Tokens Number>
     [fee]: <Total Fee Tokens To Destination Number>
     [latency_ms]: <Latency Milliseconds Number>
     [relays]: [[<Relaying Public Key Hex String>]]
     [routes_maximum]: <Maximum Sendable Tokens on Paths Number>
+    [total_fee]: <Total Fee Tokens Including Blinded Path Fee Number>
   }
 */
 module.exports = (args, cbk) => {
@@ -109,6 +112,7 @@ module.exports = (args, cbk) => {
           cltv_delta: decoded.cltv_delta,
           destination: decoded.destination,
           features: decoded.features,
+          paths: decoded.paths,
           routes: decoded.routes,
         });
       }],
@@ -319,6 +323,11 @@ module.exports = (args, cbk) => {
           return cbk([501, 'StrictMaxFeeNotSupportedWithMultiPathProbes']);
         }
 
+        // Multi-path probing looks for paths to a destination, not to paths
+        if (!!decodeRequest.paths) {
+          return cbk([501, 'MultiPathProbeNotSupportedWithBlindedPaths']);
+        }
+
         // Exit with error when the backing LND is below 0.10.0
         if (!!isLegacy) {
           return cbk([501, 'BackingLndDoesNotSupportMultiPathPayments']);
@@ -433,7 +442,18 @@ module.exports = (args, cbk) => {
 
         return cbk();
       }],
+
+      // Final probe result
+      result: ['checkFee', 'probe', ({probe}, cbk) => {
+        // Exit early when the probe was not through a blinded path
+        if (!probe || probe.blinded_path_fee === undefined) {
+          return cbk(null, probe);
+        }
+
+        // The fee of a blinded path probe is a total that includes the path fee
+        return cbk(null, withTotalFee(probe));
+      }],
     },
-    returnResult({reject, resolve, of: 'probe'}, cbk));
+    returnResult({reject, resolve, of: 'result'}, cbk));
   });
 };

package/network/probe_destination.js

@@ -2,6 +2,7 @@ const {createHash} = require('crypto');
 const {randomBytes} = require('crypto');
 
 const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
 const {decodePaymentRequest} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
@@ -14,10 +15,12 @@ const {returnResult} = require('asyncjs-util');
 const {signBytes} = require('ln-service');
 const {subscribeToFindMaxPayable} = require('probing');
 
+const blindedPathFee = require('./blinded_path_fee');
 const executeProbe = require('./execute_probe');
 const {getIcons} = require('./../display');
 const {sortBy} = require('./../arrays');
 
+const blinded = 'blinded';
 const bufFromHex = hex => Buffer.from(hex, 'hex');
 const channelReserve = n => n.local_reserve || Math.floor(n.capacity * 0.01);
 const cltvBuffer = 3;
@@ -33,14 +36,17 @@ const feeBuffer = fees => fees * 2;
 const {floor} = Math;
 const fromKeyType = '34349339';
 const htlcOutputSize = 43;
+const isBlindedHop = hop => !!hop.encrypted_data && !hop.path_key;
 const keySendPreimageType = '5482373484';
 const makeNonce = () => randomBytes(32).toString('hex');
 const {max} = Math;
 const messageType = '34349334';
 const {min} = Math;
+const mtokensAsTokens = mtokens => Number(BigInt(mtokens) / BigInt(1e3));
 const nodeKeyFamily = 6;
 const preimageByteLength = 32;
 const {now} = Date;
+const pathChannel = hop => isBlindedHop(hop) ? blinded : hop.channel;
 const rate = n => n.commit_transaction_fee / (n.commit_transaction_weight / 4);
 const signatureType = '34349337';
 const tokAsMtok = tokens => (BigInt(tokens || 0) * BigInt(1e3)).toString();
@@ -173,15 +179,17 @@ module.exports = (args, cbk) => {
               features: details.features,
               id: details.id,
               mtokens: tokAsMtok(args.tokens),
+              paths: details.paths,
               payment: details.payment,
               routes: details.routes,
               tokens: args.tokens,
             });
           }
 
+          // The destination of a blinded paths request is not known
           args.logger.info({
             description: details.description || undefined,
-            destination: details.destination,
+            destination: !details.paths ? details.destination : blinded,
             expires: moment(details.expires_at).fromNow(),
             id: details.id,
             tokens: details.tokens,
@@ -193,6 +201,7 @@ module.exports = (args, cbk) => {
             features: details.features,
             id: details.id,
             mtokens: details.mtokens || '0',
+            paths: details.paths,
             payment: details.payment,
             routes: details.routes,
             tokens: details.tokens,
@@ -209,6 +218,11 @@ module.exports = (args, cbk) => {
 
       // Lookup node destination details
       getDestinationNode: ['to', ({to}, cbk) => {
+        // Exit early when the destination is hidden behind blinded paths
+        if (!!to.paths) {
+          return cbk(null, {alias: String()});
+        }
+
         return getNode({
           is_omitting_channels: true,
           lnd: args.lnd,
@@ -224,6 +238,33 @@ module.exports = (args, cbk) => {
         });
       }],
 
+      // Lookup the introduction nodes of blinded paths
+      getIntroductionNodes: ['to', ({to}, cbk) => {
+        // Exit early when there are no blinded paths
+        if (!to.paths) {
+          return cbk();
+        }
+
+        const ids = to.paths.map(n => n.introduction_node);
+
+        return asyncMap(ids, (id, cbk) => {
+          return getNode({
+            is_omitting_channels: true,
+            lnd: args.lnd,
+            public_key: id,
+          },
+          (err, res) => {
+            // Suppress errors when the node is not found
+            if (!!err) {
+              return cbk(null, id);
+            }
+
+            return cbk(null, `${res.alias} ${id}`.trim());
+          });
+        },
+        cbk);
+      }],
+
       // For destinations that are peers, get features directly
       getPeerFeatures: [
         'getDestinationNode',
@@ -243,7 +284,7 @@ module.exports = (args, cbk) => {
           const peer = res.peers.find(n => n.public_key === to.destination);
 
           // Exit early when there are no peer features
-          if (!peer || !peers.features.length) {
+          if (!peer || !peer.features.length) {
             return cbk();
           }
 
@@ -277,8 +318,24 @@ module.exports = (args, cbk) => {
         return cbk(null, {features});
       }],
 
+      // Check that messages can be attached to the payment
+      checkMessages: ['to', ({to}, cbk) => {
+        // Exit early when there are no messages to attach
+        if (!args.message && !args.messages) {
+          return cbk();
+        }
+
+        // Blinded path hops only accept encrypted data in their payloads
+        if (!!to.paths) {
+          return cbk([501, 'MessagesNotSupportedWithBlindedPaths']);
+        }
+
+        return cbk();
+      }],
+
       // Determine messages to attach
       messages: [
+        'checkMessages',
         'getFeatures',
         'getIdentity',
         'to',
@@ -379,9 +436,37 @@ module.exports = (args, cbk) => {
       checkPath: [
         'getDestinationNode',
         'getIdentity',
+        'getIntroductionNodes',
         'to',
-        ({getDestinationNode, getIdentity, to}, cbk) =>
+        ({getDestinationNode, getIdentity, getIntroductionNodes, to}, cbk) =>
       {
+        // Exit early when the path is found to a blinded path introduction node
+        if (!!to.paths) {
+          const [node] = getIntroductionNodes;
+          const isSingle = getIntroductionNodes.length === [node].length;
+
+          // The probe amount is what the paths must deliver to the destination
+          const mtokens = !BigInt(to.mtokens) ? tokAsMtok(defaultTokens) :
+            to.mtokens;
+
+          // The fee of a blinded path is what relaying through it costs
+          const fees = to.paths.map(path => {
+            return mtokensAsTokens(blindedPathFee({mtokens, path}).fee_mtokens);
+          });
+
+          const [fee] = fees;
+
+          const nodes = getIntroductionNodes;
+
+          // A request may have a single path or multiple paths to choose from
+          args.logger.info({
+            blinded_path_fee: isSingle ? fee : fees,
+            checking_for_path_to_introduction: isSingle ? node : nodes,
+          });
+
+          return cbk();
+        }
+
         const sendingTo = `${getDestinationNode.alias} ${to.destination}`;
 
         if (to.destination === getIdentity.public_key) {
@@ -406,7 +491,7 @@ module.exports = (args, cbk) => {
         return executeProbe({
           messages,
           cltv_delta: (to.cltv_delta || defaultCltvDelta) + cltvBuffer,
-          destination: to.destination,
+          destination: !to.paths ? to.destination : undefined,
           features: getFeatures.features,
           ignore: args.ignore,
           in_through: args.in_through,
@@ -418,6 +503,7 @@ module.exports = (args, cbk) => {
           max_fee_mtokens: args.max_fee_mtokens,
           mtokens: !BigInt(to.mtokens) ? tokAsMtok(defaultTokens) : to.mtokens,
           outgoing_channel: !!outId ? outId.id : undefined,
+          paths: to.paths || undefined,
           payment: to.payment,
           routes: to.routes,
           tagged: !!getIcons ? getIcons.nodes : undefined,
@@ -433,6 +519,11 @@ module.exports = (args, cbk) => {
           return cbk(null, {});
         }
 
+        // Finding the maximum needs to probe the hops which are hidden in paths
+        if (!!to.paths) {
+          return cbk([501, 'FindMaxNotSupportedWithBlindedPaths']);
+        }
+
         const sub = subscribeToFindMaxPayable({
           cltv: (to.cltv_delta || defaultCltvDelta) + cltvBuffer,
           hops: probe.route.hops,
@@ -476,9 +567,7 @@ module.exports = (args, cbk) => {
           return cbk([400, 'MaxFeeTooLow', {required_fee: probe.route.fee}]);
         }
 
-        args.logger.info({
-          paying: probe.route.hops.map(({channel}) => channel),
-        });
+        args.logger.info({paying: probe.route.hops.map(pathChannel)});
 
         return payViaRoutes({
           id: to.id,
@@ -499,7 +588,11 @@ module.exports = (args, cbk) => {
 
         const {route} = probe;
 
+        // The introduction node hop of a blinded path takes the path fee
+        const introduction = route.hops.find(hop => !!hop.path_key);
+
         return cbk(null, {
+          blinded_path_fee: !introduction ? undefined : introduction.fee,
           fee: !route ? undefined : route.fee,
           id: !pay ? undefined : pay.id,
           latency_ms: !route ? undefined : probe.latency_ms,
@@ -508,7 +601,7 @@ module.exports = (args, cbk) => {
           preimage: !pay ? undefined : pay.secret,
           probed: !!pay ? undefined : route.tokens - route.fee,
           relays: !route ? undefined : route.hops.map(n => n.public_key),
-          success: !route ? undefined : route.hops.map(({channel}) => channel),
+          success: !route ? undefined : route.hops.map(pathChannel),
         });
       }],
     },