balanceofsatoshis 25.4.0 → 25.6.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 25.6.0
+
+- `stream`: Add command to stream a payment to a lnurl or lightning address
+
+## 25.5.0
+
+- `probe`: Add `--ignore-expiry` to probe expired payment requests
+
 ## 25.4.0
 
 - `accounting`: After 2021-10-19 derive USD prices from chain payments data

package/README.md

@@ -12,7 +12,7 @@ Supported LND versions:
 
 ## Install
 
-- Requires an [installation of Node v20+][nodejs-install-guide]
+- Requires an [installation of Node.js v22+][nodejs-install-guide]
 
 ```shell
 npm install -g balanceofsatoshis
@@ -168,6 +168,9 @@ bos send
 # Run a server of paid services
 bos server
 
+# Stream a payment to a lnurl or lightning address in a series of payments
+bos stream "amount" --lnurl "lnurl/lightning_address"
+
 # Connect up to a Telegram bot
 bos telegram
 

package/bos

@@ -1657,6 +1657,7 @@ prog
   .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')
+  .option('--ignore-expiry', 'Probe even when the request has expired')
   .option('--in <public_key>', 'Route through specific peer of destination')
   .option('--max-fee <max_fee>', 'Max expected fee for route', INT, 1337)
   .option('--max-paths <max>', 'Maximum paths to use for find-max', INT, 1)
@@ -1679,6 +1680,7 @@ prog
           find_max: !!options.findMax ? 16777215 : undefined,
           fs: {getFile: readFile},
           in_through: inThrough.public_key,
+          is_ignoring_expiry: !!options.ignoreExpiry,
           is_strict_max_fee: !!options.avoidHighFeeRoutes,
           max_fee: options.maxFee,
           max_paths: options.maxPaths,
@@ -1952,6 +1954,53 @@ prog
     });
   })
 
+  // Stream a payment in a series of payments
+  .command('stream', 'Stream a payment in a series of payments')
+  .help('Each payment is sized to the most a single route can carry')
+  .help('--lnurl is required, it can stream above the max the service takes')
+  .help('--min-payment defaults to 100*k, a smaller remainder is not sent')
+  .help('--out can take a tag to make the first hop through any tagged peer')
+  .help('--out-filter is checked before every payment, skipping failing peers')
+  .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')
+  .help('Amounts can take m/k variables: 5*m for 5 million, 250*k = 0.0025')
+  .argument('<amount>', 'Total amount to stream')
+  .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
+  .option('--lnurl <url>', 'Lnurl/lightning address', STRING, undefined, true)
+  .option('--max-fee <max_fee>', 'Maximum total fee to pay', STRING, '1337')
+  .option('--max-fee-rate <ppm>', 'Max fee rate for all payments', INT, 1000)
+  .option('--max-payment <amount>', 'Largest single payment to make', STRING)
+  .option('--min-payment <amount>', 'Smallest single payment to make', STRING)
+  .option('--no-color', 'Mute all colors')
+  .option('--node <node_name>', 'Node to stream from')
+  .option('--out <peer_or_tag>', 'Make first hop through peer/tag', REPEATABLE)
+  .option('--out-filter <out_filter>', 'Filter outbound peer/tag', REPEATABLE)
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return network.streamPayment({
+          logger,
+          amount: args.amount,
+          avoid: flatten([options.avoid].filter(n => !!n)),
+          fs: {getFile: readFile},
+          lnd: (await lndForNode(logger, options.node)).lnd,
+          lnurl: options.lnurl,
+          max_fee: options.maxFee,
+          max_fee_rate: options.maxFeeRate,
+          max_payment: options.maxPayment,
+          min_payment: options.minPayment,
+          out: flatten([options.out].filter(n => !!n)),
+          out_filters: flatten([options.outFilter].filter(n => !!n)),
+          request: commands.simpleRequest,
+        },
+        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/chain/fund_transaction.js

@@ -1,5 +1,6 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
+const asyncify = require('async/asyncify');
 const {broadcastTransaction} = require('ln-sync');
 const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {formatTokens} = require('ln-sync');
@@ -112,10 +113,10 @@ module.exports = (args, cbk) => {
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
       // Derive a list of outputs to guide input selection
-      outputs: ['validate', ({}, cbk) => {
+      outputs: ['validate', asyncify(() => {
         // Exit early when the amount is open ended and thus depends on inputs
         if (hasMaxAmount(args.amounts)) {
-          return cbk();
+          return;
         }
 
         try {
@@ -125,11 +126,11 @@ module.exports = (args, cbk) => {
             return {address, tokens};
           });
 
-          return cbk(null, outputs);
+          return outputs;
         } catch (err) {
-          return cbk([400, err.message]);
+          throw [400, err.message];
         }
-      }],
+      })],
 
       // Get UTXOs to use for input selection and final fee rate calculation
       getUtxos: ['validate', ({}, cbk) => getUtxos({lnd: args.lnd}, cbk)],
@@ -238,7 +239,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Parse amounts and put together the final set of outputs
-      finalOutputs: ['getMax', ({getMax}, cbk) => {
+      finalOutputs: ['getMax', asyncify(({getMax}) => {
         try {
           const outputs = args.addresses.map((address, i) => {
             const amount = args.amounts[i];
@@ -252,11 +253,11 @@ module.exports = (args, cbk) => {
             return {address, tokens: parseAmount({amount, variables}).tokens};
           });
 
-          return cbk(null, outputs);
+          return outputs;
         } catch (err) {
-          return cbk([400, err.message]);
+          throw [400, err.message];
         }
-      }],
+      })],
 
       // Create a funded PSBT
       fund: [

package/chain/get_block_transactions.js

@@ -1,4 +1,5 @@
 const asyncAuto = require('async/auto');
+const asyncify = require('async/asyncify');
 const {getBlock} = require('ln-service');
 const {queryTransactions} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
@@ -77,10 +78,10 @@ module.exports = (args, cbk) => {
       }],
 
       // Find the transactions in the block
-      transactions: ['getBlock', ({getBlock}, cbk) => {
+      transactions: ['getBlock', asyncify(({getBlock}) => {
         // Exit early when there is no block to look through
         if (!getBlock.block) {
-          return cbk(null, {transactions: []});
+          return {transactions: []};
         }
 
         try {
@@ -89,11 +90,11 @@ module.exports = (args, cbk) => {
             ids: args.ids,
           });
 
-          return cbk(null, {transactions});
+          return {transactions};
         } catch (err) {
-          return cbk([503, 'UnexpectedErrorParsingBlockTransactions', {err}]);
+          throw [503, 'UnexpectedErrorParsingBlockTransactions', {err}];
         }
-      }],
+      })],
     },
     returnResult({reject, resolve, of: 'transactions'}, cbk));
   });

package/chain/recover_p2pk.js

@@ -1,6 +1,7 @@
 const {createHash} = require('crypto');
 
 const asyncAuto = require('async/auto');
+const asyncify = require('async/asyncify');
 const {broadcastChainTransaction} = require('ln-service');
 const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {createChainAddress} = require('ln-service');
@@ -135,7 +136,7 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
       recoveryScript: [
         'createAddress',
         'getNetwork',
-        ({createAddress, getNetwork}, cbk) =>
+        asyncify(({createAddress, getNetwork}) =>
       {
         try {
           const {script} = outputScriptForAddress({
@@ -143,11 +144,11 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
             network: getNetwork.network,
           });
 
-          return cbk(null, {script});
+          return {script};
         } catch (err) {
-          return cbk([503, 'FailedToParseRecoveryAddress', {err}]);
+          throw [503, 'FailedToParseRecoveryAddress', {err}];
         }
-      }],
+      })],
 
       // Derive the sweep output, less the amount needed to pay for chain fees
       sweep: [

package/chain/split_utxos.js

@@ -1,5 +1,6 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
+const asyncify = require('async/asyncify');
 const asyncMapSeries = require('async/mapSeries');
 const asyncReflect = require('async/reflect');
 const {broadcastChainTransaction} = require('ln-service');
@@ -85,7 +86,7 @@ module.exports = (args, cbk) => {
     getUtxos: ['validate', ({}, cbk) => getUtxos({lnd: args.lnd}, cbk)],
 
     // Select the inputs and the count of outputs that reach the count
-    plan: ['feeRate', 'getUtxos', ({feeRate, getUtxos}, cbk) => {
+    plan: ['feeRate', 'getUtxos', asyncify(({feeRate, getUtxos}) => {
       try {
         const plan = utxoSplitPlan({
           count: args.count,
@@ -95,11 +96,11 @@ module.exports = (args, cbk) => {
           utxos: getUtxos.utxos,
         });
 
-        return cbk(null, plan);
+        return plan;
       } catch (err) {
-        return cbk([400, err.message]);
+        throw [400, err.message];
       }
-    }],
+    })],
 
     // Generate addresses
     getAddresses: ['plan', ({plan}, cbk) => {

package/commands/fetch_request.js

@@ -10,14 +10,12 @@ const timeoutSignals = new WeakMap();
   }
 
   @returns
-  {
-    request: <Request Function>
-  }
+  <Request Function> (args, cbk) => {}
 */
 module.exports = ({fetch}, cbk) => {
   return (options, cbk) => {
     (async () => {
-    	const controller = new AbortController();
+      const controller = new AbortController();
 
       // Setup the timeout controller
       if (!!options.timeout) {
@@ -28,30 +26,40 @@ module.exports = ({fetch}, cbk) => {
 
       const url = options.url + encodeQs(options.qs);
 
-      try {
-        // Make the request
-        const response = await fetch(url, {
-          body: options.body || undefined,
-          method: options.method || undefined,
-          signal: controller.signal,
-        });
+      // Only the request is guarded, so the callback is called once
+      const fetched = await (async () => {
+        try {
+          // Make the request
+          const response = await fetch(url, {
+            body: options.body || undefined,
+            method: options.method || undefined,
+            signal: controller.signal,
+          });
 
-        const res = {statusCode: response.status};
+          const res = {statusCode: response.status};
 
-        if (!!options.json) {
-          return cbk(null, res, await response.json());
-        } else {
-          return cbk(null, res, await response.text());
-        }
-      } catch (err) {
-        // Return request errors back
-        return cbk(err);
-      } finally {
-        // Reset the timeout since the request is over
-        if (!!options.timeout) {
-          clearTimeout(timeoutSignals.get(controller.signal));
+          // Exit early when the response is JSON
+          if (!!options.json) {
+            return {res, body: await response.json()};
+          }
+
+          return {res, body: await response.text()};
+        } catch (err) {
+          return {err};
+        } finally {
+          // Reset the timeout since the request is over
+          if (!!options.timeout) {
+            clearTimeout(timeoutSignals.get(controller.signal));
+          }
         }
+      })();
+
+      // Exit early when the request failed
+      if (!!fetched.err) {
+        return cbk(fetched.err);
       }
+
+      return cbk(null, fetched.res, fetched.body);
     })();
   };
 };

package/display/describe_routing_failure.js

@@ -108,6 +108,7 @@ module.exports = ({index, lnd, reason, route, tagged}, cbk) => {
 
         const {display} = chartAliasForPeer({
           alias: getTo.alias,
+          icons: !!tag ? tag.icons : undefined,
           public_key: getTo.id,
         });
 
@@ -120,11 +121,14 @@ module.exports = ({index, lnd, reason, route, tagged}, cbk) => {
         'toName',
         ({fromName, toName}, cbk) =>
       {
-        const at = `on ${route.hops[index].channel}`;
+        const hop = route.hops[index];
+
+        // A failure at the destination is not on a channel out of it
+        const at = !hop ? '' : ` on ${hop.channel}`;
         const from = !fromName ? '' : `from ${fromName}`;
         const to = !toName ? '' : ` forwarding to ${toName}`;
 
-        return cbk(null, {description: `${reason} ${from} ${at}${to}`});
+        return cbk(null, {description: `${reason} ${from}${at}${to}`});
       }],
     },
     returnResult({reject, resolve, of: 'description'}, cbk));

package/display/get_icons.js

@@ -1,4 +1,5 @@
 const asyncAuto = require('async/auto');
+const asyncify = require('async/asyncify');
 const {returnResult} = require('asyncjs-util');
 
 const {homePath} = require('../storage');
@@ -38,38 +39,48 @@ module.exports = ({fs}, cbk) => {
         return cbk();
       },
 
-      // Get icons from the tags file
-      getIcons: ['validate', ({}, cbk) => {
+      // Get the tags file
+      getFile: ['validate', ({}, cbk) => {
         return fs.getFile(tagFilePath(), (err, res) => {
           // Exit early when there is no tag file
           if (!!err || !res) {
-            return cbk(null, {nodes: []});
+            return cbk();
           }
 
-          try {
-            const file = parse(res.toString());
+          return cbk(null, res.toString());
+        });
+      }],
+
+      // Get icons from the tags file
+      getIcons: ['getFile', asyncify(({getFile}) => {
+        // Exit early when there is no tag file
+        if (!getFile) {
+          return {nodes: []};
+        }
 
-            const keys = uniq(flatten(file.tags.map(n => n.nodes)));
+        try {
+          const file = parse(getFile);
 
-            const nodes = keys.map(key => {
-              // Only tags this node is included in
-              const meta = file.tags.filter(tag => {
-                return isArray(tag.nodes) && tag.nodes.includes(key);
-              });
+          const keys = uniq(flatten(file.tags.map(n => n.nodes)));
 
-              return {
-                aliases: uniq(meta.map(n => n.alias)),
-                icons: uniq(meta.map(n => n.icon)),
-                public_key: key,
-              };
+          const nodes = keys.map(key => {
+            // Only tags this node is included in
+            const meta = file.tags.filter(tag => {
+              return isArray(tag.nodes) && tag.nodes.includes(key);
             });
 
-            return cbk(null, {nodes});
-          } catch (err) {
-            return cbk(null, {nodes: []});
-          }
-        });
-      }],
+            return {
+              aliases: uniq(meta.map(n => n.alias)),
+              icons: uniq(meta.map(n => n.icon)),
+              public_key: key,
+            };
+          });
+
+          return {nodes};
+        } catch (err) {
+          return {nodes: []};
+        }
+      })],
     },
     returnResult({reject, resolve, of: 'getIcons'}, cbk));
   });

package/encryption/cbor_item_head.js

@@ -0,0 +1,45 @@
+const additionalInfo = {1: 24, 2: 25, 4: 26, 8: 27};
+const bitsPerByte = 8;
+const largestSize = 8;
+const majorTypeMultiplier = 32;
+const maxInitialNumber = 23;
+const sizes = [1, 2, 4];
+
+/** Encode the head of a CBOR data item, its major type and its number
+
+  {
+    major: <Major Type Number>
+    number: <Length or Value Number>
+  }
+
+  @returns
+  {
+    head: <Data Item Head Buffer Object>
+  }
+*/
+module.exports = ({major, number}) => {
+  const initial = major * majorTypeMultiplier;
+
+  // Exit early when the number fits into the initial byte
+  if (number <= maxInitialNumber) {
+    return {head: Buffer.from([initial + number])};
+  }
+
+  // The number follows the initial byte, in as few bytes as it fits into
+  const size = sizes.find(n => number < 2 ** (n * bitsPerByte)) || largestSize;
+
+  const head = Buffer.alloc(1 + size);
+
+  head[0] = initial + additionalInfo[size];
+
+  // Exit early when the number needs all eight bytes
+  if (size === largestSize) {
+    head.writeBigUInt64BE(BigInt(number), 1);
+
+    return {head};
+  }
+
+  head.writeUIntBE(number, 1, size);
+
+  return {head};
+};

package/encryption/decode_cbor.js

@@ -0,0 +1,35 @@
+const decodeCborItem = require('./decode_cbor_item');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isString = n => typeof n === 'string';
+
+/** Decode CBOR encoded data
+
+  {
+    cbor: <CBOR Encoded Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    value: <Decoded Value Object>
+  }
+*/
+module.exports = ({cbor}) => {
+  if (!isString(cbor)) {
+    throw new Error('ExpectedHexEncodedCborToDecode');
+  }
+
+  const data = hexAsBuffer(cbor);
+
+  const {end, value} = decodeCborItem({data, start: 0});
+
+  // The data has to be a single item, with nothing left over
+  if (end !== data.length) {
+    throw new Error('UnexpectedDataAfterCborItem');
+  }
+
+  return {value};
+};