balanceofsatoshis 25.0.0 → 25.1.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## 25.1.0
+
+- `pay`, `probe`: Add support for sending to BOLT 12 offers
+- `server`: Add new command to run a BOLT 12 service to receive funds
+
 ## 25.0.0
 
 - `pending`: Add command to show pending channels and in-flight HTLCs

package/README.md

@@ -141,8 +141,8 @@ bos open-balanced-channel
 # Outputs the sum total of local channel liquidity
 bos outbound-liquidity
 
-# Pay a payment request (invoice), probing first
-bos pay "payment_request"
+# Pay a payment request (invoice) or offer, probing first
+bos pay "payment_request/offer"
 
 # Show channel-connected peers
 bos peers
@@ -151,7 +151,7 @@ bos peers
 bos pending
 
 # Test if funds can be sent to a destination
-bos probe "payment_request/public_key"
+bos probe "payment_request/offer/public_key"
 
 # Rebalance funds between peers
 bos rebalance
@@ -165,6 +165,9 @@ bos report
 # Send funds using keysend and an optional message to a node
 bos send
 
+# Run a server of paid services
+bos server
+
 # Connect up to a Telegram bot
 bos telegram
 

package/bos

@@ -1513,13 +1513,14 @@ prog
   })
 
   // Pay a payment request, probing first
-  .command('pay', 'Pay a payment request, probing first')
+  .command('pay', 'Pay a payment request or offer, probing first')
   .help('Blinded path requests are probed to the introduction node, 1 path')
   .help('--out can take a tag to make the first hop through any tagged peer')
   .help('--out-filter vars: CAPACITY/HEIGHTS/INBOUND_LIQUIDITY')
   .help('--out-filter vars: OUTBOUND_LIQUIDITY/PENDING_PAYMENTS')
   .help('--out-filter vars: INBOUND_BASE_FEE/INBOUND_FEE_RATE')
-  .argument('<request>', 'Payment Request')
+  .argument('<request>', 'Payment request or offer')
+  .argument('[amount]', 'Amount to pay an offer, default: offer amount')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
   .option('--avoid-high-fee-routes', 'Avoid evaluating too-high fee routes')
   .option('--in <public_key>', 'Route through specific peer of destination')
@@ -1550,6 +1551,7 @@ prog
           out: flatten([options.out].filter(n => !!n)),
           out_filters: flatten([options.outFilter].filter(n => !!n)),
           request: args.request,
+          tokens: args.amount || undefined,
         },
         responses.returnObject({logger, reject, resolve}));
       } catch (err) {
@@ -1638,15 +1640,15 @@ prog
   })
 
   // Determine if a payment request is sendable
-  .command('probe', 'Check if a payment request is sendable')
+  .command('probe', 'Check if a payment request or offer is sendable')
   .help('Simulate paying a payment request without actually paying it')
   .help('Blinded path requests are probed to the introduction node, 1 path')
   .help('--out can take a tag to make the first hop through any tagged peer')
   .help('--out-filter vars: CAPACITY/HEIGHTS/INBOUND_LIQUIDITY')
   .help('--out-filter vars: OUTBOUND_LIQUIDITY/PENDING_PAYMENTS')
   .help('--out-filter vars: INBOUND_BASE_FEE/INBOUND_FEE_RATE')
-  .argument('<to>', 'Payment request or node public key')
-  .argument('[amount]', 'Amount to probe, default: request amount')
+  .argument('<to>', 'Payment request, offer, or node public key')
+  .argument('[amount]', 'Amount to probe, default: request or offer amount')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
   .option('--avoid-high-fee-routes', 'Avoid evaluating too-high fee routes')
   .option('--find-max', 'Find the maximum routeable amount on success route')
@@ -1922,6 +1924,29 @@ prog
     });
   })
 
+  // Run a server of paid services
+  .command('server', 'Run a server of paid services')
+  .help('Makes a new service, or resumes one from its service record')
+  .help('Requires LND with support for onion messages')
+  .argument('[service_record]', 'Service record to resume a service', hexMatch)
+  .option('--node <node_name>', 'Saved node to run the server on')
+  .option('--qr', 'Encode the offer into a terminal output QR code')
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return services.runServer({
+          logger,
+          is_including_qr: !!options.qr || undefined,
+          lnd: (await lndForNode(logger, options.node)).lnd,
+          record: args.serviceRecord,
+        },
+        responses.returnObject({logger, reject, resolve}));
+      } catch (err) {
+        return logger.error({err}) && reject();
+      }
+    });
+  })
+
   // Get a swap API key or inspect an existing one
   .command('swap-api-key', 'Purchase a swap API key or inspect a swap API key')
   .visible(false)

package/network/get_pending_paths.js

@@ -29,20 +29,20 @@ const notFound = 404;
     }]
   }
 */
-module.exports = ({id, lnd, timeout_ms}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!isHash(id)) {
+        if (!isHash(args.id)) {
           return cbk([400, 'ExpectedPaymentHashToGetPendingPaths']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToGetPendingPaths']);
         }
 
-        if (!timeout_ms) {
+        if (!args.timeout_ms) {
           return cbk([400, 'ExpectedTimeoutMillisecondsToGetPendingPaths']);
         }
 
@@ -51,7 +51,7 @@ module.exports = ({id, lnd, timeout_ms}, cbk) => {
 
       // Subscribe to the payment to get its current state
       getPaths: ['validate', ({}, cbk) => {
-        const sub = subscribeToPastPayment({id, lnd});
+        const sub = subscribeToPastPayment({id: args.id, lnd: args.lnd});
 
         // Removing the listeners cancels the subscription to the payment
         const finished = (err, res) => {
@@ -63,9 +63,9 @@ module.exports = ({id, lnd, timeout_ms}, cbk) => {
         };
 
         // Payments that are not in flight have no pending paths
-        const noPaths = () => finished(null, {id, paths: []});
+        const noPaths = () => finished(null, {id: args.id, paths: []});
 
-        const timeout = setTimeout(noPaths, timeout_ms);
+        const timeout = setTimeout(noPaths, args.timeout_ms);
 
         sub.once('confirmed', noPaths);
         sub.once('end', noPaths);
@@ -82,8 +82,8 @@ module.exports = ({id, lnd, timeout_ms}, cbk) => {
 
         sub.once('paying', pending => {
           return finished(null, {
-            id,
             created_at: pending.created_at,
+            id: args.id,
             paths: pending.paths,
           });
         });

package/network/pay.js

@@ -3,7 +3,9 @@ const asyncMap = require('async/map');
 const {formatTokens} = require('ln-sync');
 const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
+const {getOfferInvoice} = require('paid-services');
 const {getSyntheticOutIgnores} = require('probing');
+const {parseAmount} = require('ln-accounting');
 const {parsePaymentRequest} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {subscribeToMultiPathPay} = require('probing');
@@ -18,13 +20,20 @@ const probeDestination = require('./probe_destination');
 
 const cltvDeltaBuffer = 3;
 const {isArray} = Array;
+const isOffer = n => !!n && /^lno1/i.test(n);
+const isPositive = n => isSafeInteger(n) && n > 0;
+const {isSafeInteger} = Number;
 const mtokensAsTokens = mtokens => Number(mtokens / BigInt(1e3));
 const pathTimeoutMs = 1000 * 60 * 5;
 const singlePath = 1;
+const tokensAsMtokens = tokens => (BigInt(tokens) * BigInt(1e3)).toString();
 const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
 
 /** Make a payment
 
+  An offer is paid with an invoice that is requested from the offer, and a
+  message is sent as the payer note of the invoice request
+
   {
     avoid: [<Avoid Forwarding Through String>]
     [fs]: {
@@ -36,10 +45,11 @@ const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
     logger: <Winston Logger Object>
     max_fee: <Max Fee Tokens Number>
     max_paths: <Maximum Paths Number>
-    [message]: <Message String>
+    [message]: <Message or Offer Payer Note String>
     out: [<Out Through Peer With Public Key, Alias, or Tag String>]
     [out_filters]: [<Out Through Peer Filter Formula String>]
-    request: <BOLT 11 Payment Request String>
+    request: <BOLT 11 Payment Request or BOLT 12 Offer String>
+    [tokens]: <Amount To Pay An Offer String>
   }
 */
 module.exports = (args, cbk) => {
@@ -75,6 +85,21 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedBolt11PaymentRequestToPayPaymentRequest']);
         }
 
+        // Exit early when paying an offer, which is checked getting an invoice
+        if (isOffer(args.request)) {
+          // An offer is paid over blinded paths, so a single path is used
+          if (args.max_paths !== singlePath) {
+            return cbk([501, 'MultiPathPayNotSupportedWithBlindedPaths']);
+          }
+
+          return cbk();
+        }
+
+        // A payment request has its amount, an amount is only for an offer
+        if (!!args.tokens) {
+          return cbk([400, 'UnexpectedAmountToPayPaymentRequest']);
+        }
+
         try {
           parsePaymentRequest({request: args.request});
         } catch (err) {
@@ -133,6 +158,28 @@ module.exports = (args, cbk) => {
         return getTags({fs: args.fs}, cbk);
       }],
 
+      // Parse the amount to pay an offer
+      tokens: ['validate', ({}, cbk) => {
+        // Exit early when there is no amount to pay
+        if (!args.tokens) {
+          return cbk();
+        }
+
+        try {
+          parseAmount({amount: args.tokens});
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+
+        const {tokens} = parseAmount({amount: args.tokens});
+
+        if (!isPositive(tokens)) {
+          return cbk([400, 'ExpectedPositiveAmountToPayOffer']);
+        }
+
+        return cbk(null, tokens);
+      }],
+
       // Get base ignores
       getBaseIgnores: [
         'getChannels',
@@ -185,29 +232,57 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Get an invoice to pay for an offer
+      getOfferInvoice: [
+        'getBaseIgnores',
+        'getOuts',
+        'tokens',
+        ({tokens}, cbk) =>
+      {
+        // Exit early when paying a payment request
+        if (!isOffer(args.request)) {
+          return cbk();
+        }
+
+        args.logger.info({requesting_invoice_for_offer: true});
+
+        return getOfferInvoice({
+          lnd: args.lnd,
+          mtokens: !tokens ? undefined : tokensAsMtokens(tokens),
+          offer: args.request,
+          payer_note: args.message,
+        },
+        cbk);
+      }],
+
       // Make single-path payment
       singlePathPay: [
         'getBaseIgnores',
+        'getOfferInvoice',
         'getOuts',
-        ({getBaseIgnores, getOuts}, cbk) =>
+        ({getBaseIgnores, getOfferInvoice, getOuts}, cbk) =>
       {
         // Exit early when doing a multi-path
         if (args.max_paths !== singlePath) {
           return cbk();
         }
 
+        // An offer is paid with its invoice, which has the message as a note
+        const isInvoice = !!getOfferInvoice;
+
         return probeDestination({
           fs: args.fs,
           ignore: getBaseIgnores.ignore,
           in_through: args.in_through,
+          invoice: getOfferInvoice,
           is_real_payment: true,
           is_strict_max_fee: args.is_strict_max_fee,
           logger: args.logger,
           lnd: args.lnd,
           max_fee: args.max_fee,
-          message: args.message,
+          message: isInvoice ? undefined : args.message,
           out_through: getOuts.public_keys,
-          request: args.request,
+          request: isInvoice ? undefined : args.request,
         },
         cbk);
       }],
@@ -401,9 +476,10 @@ module.exports = (args, cbk) => {
 
       // Final payment details
       payment: [
+        'getOfferInvoice',
         'multiPathPay',
         'singlePathPay',
-        ({multiPathPay, singlePathPay}, cbk) =>
+        ({getOfferInvoice, multiPathPay, singlePathPay}, cbk) =>
       {
         const payment = singlePathPay || multiPathPay;
 
@@ -413,7 +489,19 @@ module.exports = (args, cbk) => {
         }
 
         // The fee of a blinded path payment is a total including the path fee
-        return cbk(null, withTotalFee(payment));
+        const paid = withTotalFee(payment);
+
+        // Exit early when the payment was not for an offer
+        if (!getOfferInvoice) {
+          return cbk(null, paid);
+        }
+
+        // The invoice and payer key of a paid offer are kept to prove payment
+        return cbk(null, {
+          ...paid,
+          invoice: getOfferInvoice.invoice,
+          payer_key_index: getOfferInvoice.payer_key_index,
+        });
       }],
     },
     returnResult({reject, resolve, of: 'payment'}, cbk));

package/network/pending_summary.js

@@ -64,10 +64,15 @@ const shortKey = key => key.substring(0, 8);
     summary: <Pending Items Summary String>
   }
 */
-module.exports = ({is_monochrome, max_relays, nodes, tagged}) => {
+module.exports = args => {
   // Zero or absent tokens have no amount to display
   const amount = tokens => {
-    return formatTokens({is_monochrome, tokens}).display.trim();
+    const {display} = formatTokens({
+      tokens,
+      is_monochrome: args.is_monochrome,
+    });
+
+    return display.trim();
   };
 
   // Paths may collapse their relaying peers to keep the path short
@@ -79,15 +84,15 @@ module.exports = ({is_monochrome, max_relays, nodes, tagged}) => {
     const relays = reversedRelays.reverse();
 
     // Exit early when there is no limit or the relays are within the limit
-    if (max_relays === undefined || !others.length) {
+    if (args.max_relays === undefined || !others.length) {
       return joinPath(hops);
     }
 
-    if (relays.length <= max_relays) {
+    if (relays.length <= args.max_relays) {
       return joinPath(hops);
     }
 
-    const shown = relays.slice(Number(), max_relays);
+    const shown = relays.slice(Number(), args.max_relays);
 
     const hidden = [moreHops(relays.length - shown.length)];
 
@@ -102,14 +107,14 @@ module.exports = ({is_monochrome, max_relays, nodes, tagged}) => {
   // Other nodes are named with their tag icons and no emojis of their own
   const peer = (alias, key) => {
     const regularAlias = (alias || String()).replace(isEmoji, String()).trim();
-    const tags = (tagged || []).find(n => n.public_key === key);
+    const tags = (args.tagged || []).find(n => n.public_key === key);
 
     const icons = !tags ? [] : tags.icons;
 
     return [].concat(icons).concat(named(regularAlias, key)).join(' ');
   };
 
-  const sections = nodes.map(node => {
+  const sections = args.nodes.map(node => {
     // Channels that are waiting for their funding transaction to confirm
     const opening = node.opening.map(channel => {
       const direction = !channel.is_partner_initiated ? 'outbound' : 'inbound';
@@ -188,14 +193,14 @@ module.exports = ({is_monochrome, max_relays, nodes, tagged}) => {
   }
 
   // Exit early when there is a single node, there is no need for a title
-  if (nodes.length === [nodes].length) {
+  if (args.nodes.length === [args.nodes].length) {
     const [node] = pending;
 
     return {summary: joinLines(node.lines)};
   }
 
   const titled = pending.map(node => {
-    const title = !!is_monochrome ? node.title : bold(node.title);
+    const title = !!args.is_monochrome ? node.title : bold(node.title);
 
     return joinLines([title].concat(node.lines));
   });

package/network/probe.js

@@ -5,6 +5,7 @@ const {getChannel} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNode} = require('ln-service');
+const {getOfferInvoice} = require('paid-services');
 const {getSyntheticOutIgnores} = require('probing');
 const {getWalletVersion} = require('ln-service');
 const {parseAmount} = require('ln-accounting');
@@ -25,14 +26,20 @@ const defaultMaxPaths = 5;
 const effectiveFeeRate = (n, m) => Number(BigInt(1e6) * BigInt(n) / BigInt(m));
 const flatten = arr => [].concat(...arr);
 const {isArray} = Array;
+const isOffer = n => !!n && /^lno1/i.test(n);
+const isPositive = n => isSafeInteger(n) && n > 0;
+const {isSafeInteger} = Number;
 const pathTimeoutMs = 1000 * 60 * 90;
 const singlePath = 1;
+const tokensAsMtokens = tokens => (BigInt(tokens) * BigInt(1e3)).toString();
 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
 
+  An offer is probed with an invoice that is requested from the offer
+
   {
     avoid: [<Avoid Forwarding Through String>]
     [destination]: <Destination Public Key Hex String>
@@ -48,7 +55,7 @@ const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
     [max_paths]: <Maximum Probe Paths Number>
     out: [<Out Through Peer With Public Key, Alias, or Tag String>]
     [out_filters]: [<Out Through Peer Filter Formula String>]
-    [request]: <BOLT 11 Encoded Payment Request String>
+    [request]: <BOLT 11 Encoded Payment Request or BOLT 12 Offer String>
     [timeout_minutes]: <Stop Searching For Routes After N Minutes Number>
     [tokens]: <Tokens Amount String>
   }
@@ -88,7 +95,14 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedArrayOfOutPeersToStartProbe']);
         }
 
-        if (!!args.request) {
+        const isMultiPath = !!args.find_max || args.max_paths !== singlePath;
+
+        // An offer is paid over blinded paths, which are probed on one path
+        if (isOffer(args.request) && isMultiPath) {
+          return cbk([501, 'MultiPathProbeNotSupportedWithBlindedPaths']);
+        }
+
+        if (!!args.request && !isOffer(args.request)) {
           try {
             parsePaymentRequest({request: args.request});
           } catch (err) {
@@ -101,8 +115,8 @@ module.exports = (args, cbk) => {
 
       // Decode payment request
       decodeRequest: ['validate', ({}, cbk) => {
-        // Exit early when there is no request to decode
-        if (!args.request) {
+        // Exit early when there is no payment request to decode
+        if (!args.request || isOffer(args.request)) {
           return cbk(null, {});
         }
 
@@ -190,10 +204,19 @@ module.exports = (args, cbk) => {
         }
 
         try {
-          return cbk(null, parseAmount({amount: args.tokens}).tokens);
+          parseAmount({amount: args.tokens});
         } catch (err) {
           return cbk([400, err.message]);
         }
+
+        const {tokens} = parseAmount({amount: args.tokens});
+
+        // The amount for an offer is in its invoice, so it is a whole amount
+        if (isOffer(args.request) && !isPositive(tokens)) {
+          return cbk([400, 'ExpectedPositiveAmountToProbeOffer']);
+        }
+
+        return cbk(null, tokens);
       }],
 
       // Get base ignores
@@ -248,30 +271,57 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Get an invoice to probe for an offer
+      getOfferInvoice: [
+        'getBaseIgnores',
+        'getOuts',
+        'tokens',
+        ({tokens}, cbk) =>
+      {
+        // Exit early when not probing an offer
+        if (!isOffer(args.request)) {
+          return cbk();
+        }
+
+        args.logger.info({requesting_invoice_for_offer: true});
+
+        return getOfferInvoice({
+          lnd: args.lnd,
+          mtokens: !tokens ? undefined : tokensAsMtokens(tokens),
+          offer: args.request,
+        },
+        cbk);
+      }],
+
       // Probe just through a single path
       singleProbe: [
         'getBaseIgnores',
+        'getOfferInvoice',
         'getOuts',
         'tokens',
-        ({getBaseIgnores, getOuts, tokens}, cbk) =>
+        ({getBaseIgnores, getOfferInvoice, getOuts, tokens}, cbk) =>
       {
         // Exit early when not finding max
         if (!!args.find_max || args.max_paths !== singlePath) {
           return cbk();
         }
 
+        // An offer is probed with its invoice, which is for the amount
+        const isInvoice = !!getOfferInvoice;
+
         return probeDestination({
-          tokens,
           destination: args.destination,
           fs: args.fs,
           ignore: getBaseIgnores.ignore,
           in_through: args.in_through,
+          invoice: getOfferInvoice,
           is_strict_max_fee: args.is_strict_max_fee,
           lnd: args.lnd,
           logger: args.logger,
           max_fee: args.max_fee,
           out_through: getOuts.public_keys,
-          request: args.request,
+          request: isInvoice ? undefined : args.request,
+          tokens: isInvoice ? undefined : tokens,
         },
         cbk);
       }],
@@ -280,6 +330,11 @@ module.exports = (args, cbk) => {
       getDestination: ['decodeRequest', ({decodeRequest}, cbk) => {
         const publicKey = decodeRequest.destination || args.destination;
 
+        // Exit early when there is no destination, like for an offer
+        if (!publicKey) {
+          return cbk();
+        }
+
         return getNode({
           is_omitting_channels: true,
           lnd: args.lnd,

package/network/probe_destination.js

@@ -38,11 +38,14 @@ const fromKeyType = '34349339';
 const htlcOutputSize = 43;
 const {isArray} = Array;
 const isBlindedHop = hop => !!hop.encrypted_data && !hop.path_key;
+const isMppRequired = features => features.some(n => n.bit === mppRequiredBit);
+const isPast = date => new Date(date).getTime() <= now();
 const keySendPreimageType = '5482373484';
 const makeNonce = () => randomBytes(32).toString('hex');
 const {max} = Math;
 const messageType = '34349334';
 const {min} = Math;
+const mppRequiredBit = 16;
 const mtokensAsTokens = mtokens => Number(BigInt(mtokens) / BigInt(1e3));
 const nodeKeyFamily = 6;
 const preimageByteLength = 32;
@@ -66,6 +69,28 @@ const tokAsMtok = tokens => (BigInt(tokens || 0) * BigInt(1e3)).toString();
       [to_public_key]: <Avoid Routing To Node With Public Key Hex String>
     }]
     [in_through]: <Pay In Through Public Key Hex String>
+    [invoice]: {
+      [description]: <Invoice Description String>
+      expires_at: <Invoice Expires At ISO 8601 Date String>
+      [features]: [{
+        bit: <BOLT 09 Feature Bit Number>
+      }]
+      id: <Payment Hash Hex String>
+      mtokens: <Invoice Amount Millitokens String>
+      paths: [{
+        base_fee_mtokens: <Accumulated Base Fee Millitokens String>
+        cltv_delta: <Accumulated CLTV Expiry Delta Number>
+        fee_rate: <Accumulated Fee Rate Millitokens Per Million Number>
+        hops: [{
+          encrypted_data: <Encrypted Recipient Data Hex String>
+          relay_key: <Blinded Relaying Node Public Key Hex String>
+        }]
+        introduction_node: <Introduction Node Public Key Hex String>
+        key: <First Hop Path Key Public Key Hex String>
+        max_htlc_mtokens: <Maximum HTLC Millitokens String>
+        min_htlc_mtokens: <Minimum HTLC Millitokens String>
+      }]
+    }
     [is_omitting_message_from]: <Omit Message From Fields Bool>
     [is_push]: <Is Push Payment Bool>
     [is_real_payment]: <Pay the Request after Probing Bool> // default: false
@@ -122,6 +147,25 @@ module.exports = (args, cbk) => {
           return cbk([501, 'FindMaxNotSupportedWithMultipleOutThroughPeers']);
         }
 
+        if (!!args.invoice && !isArray(args.invoice.paths)) {
+          return cbk([400, 'ExpectedArrayOfPaymentPathsToPayInvoice']);
+        }
+
+        // An invoice is paid over its blinded payment paths
+        if (!!args.invoice && !args.invoice.paths.length) {
+          return cbk([400, 'ExpectedPaymentPathsToPayInvoice']);
+        }
+
+        // An invoice is paid the amount that it is for
+        if (!!args.invoice && !!args.tokens) {
+          return cbk([400, 'UnexpectedTokensToPayInvoice']);
+        }
+
+        // An invoice that requires multiple parts can't be paid over one path
+        if (!!args.invoice && isMppRequired(args.invoice.features || [])) {
+          return cbk([501, 'RequiredMultiPathNotSupportedWithBlindedPaths']);
+        }
+
         return cbk();
       },
 
@@ -163,6 +207,31 @@ module.exports = (args, cbk) => {
           });
         }
 
+        // Exit early when paying an invoice over its payment paths
+        if (!!args.invoice) {
+          const {invoice} = args;
+
+          if (isPast(invoice.expires_at)) {
+            return cbk([400, 'InvoiceIsExpired']);
+          }
+
+          // The destination of an invoice is hidden behind its payment paths
+          args.logger.info({
+            description: invoice.description || undefined,
+            destination: blinded,
+            expires: moment(invoice.expires_at).fromNow(),
+            id: invoice.id,
+            tokens: mtokensAsTokens(invoice.mtokens),
+          });
+
+          return cbk(null, {
+            id: invoice.id,
+            mtokens: invoice.mtokens,
+            paths: invoice.paths,
+            tokens: mtokensAsTokens(invoice.mtokens),
+          });
+        }
+
         // Exit early when probing a destination
         if (!args.request && !!args.destination) {
           return cbk(null, {
@@ -289,6 +358,11 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
+        // Exit early when the destination is hidden behind blinded paths
+        if (!!to.paths) {
+          return cbk();
+        }
+
         return getPeers({lnd: args.lnd}, (err, res) => {
           if (!!err) {
             return cbk(err);
@@ -466,22 +540,42 @@ module.exports = (args, 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;
+          const ownKey = getIdentity.public_key;
+
+          const isOwn = path => path.introduction_node === ownKey;
+
+          // A path that starts at this node is entered from this node, and the
+          // fee of its own hop is not paid, so no path fee is shown for it
+          if (to.paths.some(isOwn)) {
+            args.logger.info({blinded_path_starts_at_this_node: true});
+          }
+
+          // Other paths are probed through a route to their introduction node
+          const others = to.paths
+            .map((path, i) => ({path, node: getIntroductionNodes[i]}))
+            .filter(n => !isOwn(n.path));
+
+          // Exit early when every path starts at this node
+          if (!others.length) {
+            return cbk();
+          }
+
+          const nodes = others.map(n => n.node);
+
+          const [node] = nodes;
+          const isSingle = nodes.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 => {
+          const fees = others.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,

package/package.json

@@ -15,7 +15,7 @@
     "url": "https://github.com/alexbosworth/balanceofsatoshis/issues"
   },
   "dependencies": {
-    "@alexbosworth/blockchain": "4.10.0",
+    "@alexbosworth/blockchain": "4.11.0",
     "@alexbosworth/caporal": "2.0.0",
     "@alexbosworth/fiat": "2.0.0",
     "@alexbosworth/formulas": "1.5.0",
@@ -37,11 +37,11 @@
     "ini": "7.0.0",
     "inquirer": "14.2.3",
     "ln-accounting": "10.0.8",
-    "ln-service": "60.1.3",
+    "ln-service": "60.1.5",
     "ln-sync": "8.0.7",
     "ln-telegram": "8.0.7",
     "moment": "2.31.0",
-    "paid-services": "9.0.1",
+    "paid-services": "10.3.0",
     "probing": "7.0.1",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.4",
@@ -53,7 +53,7 @@
   "description": "Lightning balance CLI",
   "devDependencies": {
     "invoices": "6.3.0",
-    "ln-docker-daemons": "8.1.0"
+    "ln-docker-daemons": "8.1.2"
   },
   "engines": {
     "node": ">=22"
@@ -104,5 +104,5 @@
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
     "test": "node --experimental-test-coverage --test test/arrays/*.js test/balances/*.js test/chain/*.js test/display/*.js test/encryption/*.js test/lnd/*.js test/network/*.js test/nodes/*.js test/offchain/*.js test/peers/*.js test/responses/*.js test/routing/*.js test/services/*.js test/swaps/*.js test/tags/*.js test/telegram/*.js test/wallets/*.js"
   },
-  "version": "25.0.0"
+  "version": "25.1.0"
 }

package/services/get_offer_introduction.js

@@ -0,0 +1,107 @@
+const asyncAuto = require('async/auto');
+const {getChannels} = require('ln-service');
+const {getPeers} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const getPublicPeer = require('./get_public_peer');
+const {sortBy} = require('./../arrays');
+
+const isMessagesBit = n => onionMessagesBits.includes(n.bit);
+const isRelay = peer => peer.features.some(isMessagesBit);
+const onionMessagesBits = [38, 39];
+const uniq = arr => Array.from(new Set(arr));
+
+/** Get the peer to start the path of a new support offer at
+
+  A node with a public channel starts the offer path at itself. A node that is
+  connected only by private channels starts it at a publicly reachable peer,
+  as BOLT 12 requires, so that payers can reach the offer.
+
+  That peer has an active channel with the node, relays onion messages, and
+  has public channels. The peer with the largest channel is picked.
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    [introduction]: <Introduction Peer Public Key Hex String>
+  }
+*/
+module.exports = ({lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetOfferIntroduction']);
+        }
+
+        return cbk();
+      },
+
+      // Get the channels of the node to see if it has a public channel
+      getChannels: ['validate', ({}, cbk) => getChannels({lnd}, cbk)],
+
+      // Get the connected peers to see which of them relay onion messages
+      getPeers: ['getChannels', ({getChannels}, cbk) => {
+        // Exit early when the node has a public channel
+        if (getChannels.channels.some(n => !n.is_private)) {
+          return cbk();
+        }
+
+        return getPeers({lnd}, cbk);
+      }],
+
+      // Peers that relay onion messages over active channels, largest first
+      candidates: [
+        'getChannels',
+        'getPeers',
+        ({getChannels, getPeers}, cbk) =>
+      {
+        // Exit early when the node has a public channel
+        if (!getPeers) {
+          return cbk(null, []);
+        }
+
+        const relays = getPeers.peers.filter(isRelay).map(n => n.public_key);
+
+        const channels = getChannels.channels
+          .filter(n => n.is_active)
+          .filter(n => relays.includes(n.partner_public_key));
+
+        const {sorted} = sortBy({array: channels, attribute: 'capacity'});
+
+        const largestFirst = sorted.slice().reverse();
+
+        return cbk(null, uniq(largestFirst.map(n => n.partner_public_key)));
+      }],
+
+      // Find the first candidate that is publicly reachable
+      getPublicPeer: ['candidates', ({candidates}, cbk) => {
+        return getPublicPeer({lnd, peers: candidates}, cbk);
+      }],
+
+      // The peer to start the offer path at, when the node is private
+      introduction: [
+        'getPeers',
+        'getPublicPeer',
+        ({getPeers, getPublicPeer}, cbk) =>
+      {
+        // Exit early when the node has a public channel to start the path at
+        if (!getPeers) {
+          return cbk(null, {});
+        }
+
+        // Exit early when no peer can start the offer path of a private node
+        if (!getPublicPeer.public_key) {
+          return cbk([503, 'ExpectedPublicPeerToStartPrivateNodeOfferPath']);
+        }
+
+        return cbk(null, {introduction: getPublicPeer.public_key});
+      }],
+    },
+    returnResult({reject, resolve, of: 'introduction'}, cbk));
+  });
+};

package/services/get_public_peer.js

@@ -0,0 +1,67 @@
+const asyncAuto = require('async/auto');
+const asyncDetectSeries = require('async/detectSeries');
+const {getNode} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {isArray} = Array;
+
+/** Get the first of a list of peers that has public channels in the graph
+
+  A peer that is not in the graph, or that has no public channels, is not
+  publicly reachable
+
+  {
+    lnd: <Authenticated LND API Object>
+    peers: [<Peer Public Key Hex String>]
+  }
+
+  @returns via cbk or Promise
+  {
+    [public_key]: <Publicly Reachable Peer Public Key Hex String>
+  }
+*/
+module.exports = ({lnd, peers}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetPublicPeer']);
+        }
+
+        if (!isArray(peers)) {
+          return cbk([400, 'ExpectedArrayOfPeersToGetPublicPeer']);
+        }
+
+        return cbk();
+      },
+
+      // Look up each peer in the graph in turn until one has public channels
+      getPeer: ['validate', ({}, cbk) => {
+        return asyncDetectSeries(peers, (key, cbk) => {
+          return getNode({
+            lnd,
+            is_omitting_channels: true,
+            public_key: key,
+          },
+          (err, res) => {
+            // A peer that is not in the graph is not publicly reachable
+            if (!!err) {
+              return cbk(null, false);
+            }
+
+            return cbk(null, !!res.channel_count);
+          });
+        },
+        (err, key) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          return cbk(null, {public_key: key});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getPeer'}, cbk));
+  });
+};

package/services/index.js

@@ -1,4 +1,5 @@
 const advertise = require('./advertise');
 const openBalancedChannel = require('./open_balanced_channel');
+const runServer = require('./run_server');
 
-module.exports = {advertise, openBalancedChannel};
+module.exports = {advertise, openBalancedChannel, runServer};

package/services/run_server.js

@@ -0,0 +1,121 @@
+const asyncAuto = require('async/auto');
+const {createSupportOffer} = require('paid-services');
+const qrcode = require('qrcode-terminal');
+const {returnResult} = require('asyncjs-util');
+const {serviceSupportOffer} = require('paid-services');
+
+const getOfferIntroduction = require('./get_offer_introduction');
+const supporterDetails = require('./supporter_details');
+
+const isHex = n => typeof n === 'string' && /^([0-9a-f]{2})+$/i.test(n);
+const urlForOffer = offer => `lightning:${offer}`;
+
+/** Run a server of paid services: a support offer that supporters can pay
+
+  A new support offer service is made, unless the service record of a service
+  that was made before is given to resume running it. The offer is shown once
+  the service has checked its record, with the record of a new service, and
+  with a QR code of the offer when asked for. The offer can only be paid while
+  the server is running.
+
+  The offer path of a node that only has private channels starts at a public
+  peer, so that payers can reach it.
+
+  The server runs until the service ends, and then returns an error.
+
+  {
+    [is_including_qr]: <Show QR Code of Offer Bool>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+    [record]: <Resume Service With Service Record Hex String>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToRunServer']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToRunServer']);
+        }
+
+        if (!!args.record && !isHex(args.record)) {
+          return cbk([400, 'ExpectedHexServiceRecordToResumeService']);
+        }
+
+        return cbk();
+      },
+
+      // Find the peer to start a new offer path at, for a private node
+      getIntroduction: ['validate', ({}, cbk) => {
+        // Exit early when resuming a service, its offer already has a path
+        if (!!args.record) {
+          return cbk(null, {});
+        }
+
+        return getOfferIntroduction({lnd: args.lnd}, cbk);
+      }],
+
+      // Make a new support offer when not resuming a service
+      createOffer: ['getIntroduction', ({getIntroduction}, cbk) => {
+        // Exit early when resuming a service from its service record
+        if (!!args.record) {
+          return cbk();
+        }
+
+        return createSupportOffer({
+          introduction: getIntroduction.introduction,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Run the support offer service until it ends
+      run: ['createOffer', ({createOffer}, cbk) => {
+        const record = !createOffer ? args.record : createOffer.record;
+
+        let service;
+
+        try {
+          service = serviceSupportOffer({record, lnd: args.lnd});
+        } catch (err) {
+          return cbk([400, 'FailedToRunSupportOfferService', {err}]);
+        }
+
+        service.error(err => args.logger.error({err}));
+
+        // Show the offer once the service has checked its record, with the
+        // record of a new service, which is used to resume the service later
+        service.start(({offer}) => {
+          const show = code => args.logger.info({
+            public_offer: offer,
+            qr: code,
+            service_record: !!createOffer ? createOffer.record : undefined,
+          });
+
+          // Exit early when not showing a QR code of the offer
+          if (!args.is_including_qr) {
+            return show();
+          }
+
+          return qrcode.generate(urlForOffer(offer), {small: true}, show);
+        });
+
+        // Show the payments of supporters as they are received
+        service.supporter(supporter => {
+          return args.logger.info(supporterDetails(supporter));
+        });
+
+        // The server stops running when the service ends
+        return service.end(() => cbk([503, 'SupportOfferServiceEnded']));
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/services/supporter_details.js

@@ -0,0 +1,30 @@
+const controlCharacters = /[\u0000-\u001f\u007f-\u009f]/g;
+const mtokAsBig = n => (Number(BigInt(n) / BigInt(1e3)) / 1e8).toFixed(8);
+const printable = n => !n ? undefined : n.replace(controlCharacters, space);
+const space = ' ';
+
+/** Get the details to show for a payment received from a supporter
+
+  The note of a supporter is shown with its control characters as spaces, so
+  that it cannot change how the terminal shows other lines
+
+  {
+    mtokens: <Received Millitokens String>
+    [payer_note]: <Supporter Note String>
+    [payer_offer]: <Supporter Signed BOLT 12 Offer String>
+  }
+
+  @returns
+  {
+    received: <Received Amount Big Unit Tokens String>
+    [supporter_note]: <Supporter Note String>
+    [supporter_offer]: <Supporter Signed BOLT 12 Offer String>
+  }
+*/
+module.exports = args => {
+  return {
+    received: mtokAsBig(args.mtokens),
+    supporter_note: printable(args.payer_note),
+    supporter_offer: args.payer_offer,
+  };
+};