balanceofsatoshis 25.4.0 → 25.5.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 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

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,

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/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};
+};

package/encryption/decode_cbor_item.js

@@ -0,0 +1,169 @@
+const additionalInfoMask = 31;
+const argumentSizes = {24: 1, 25: 2, 26: 4, 27: 8};
+const arrayOfLength = length => [...Array(length)];
+const firstSimpleValue = 20;
+const {fromEntries} = Object;
+const {isSafeInteger} = Number;
+const isString = n => typeof n === 'string';
+const majorTypeArray = 4;
+const majorTypeBytes = 2;
+const majorTypeMap = 5;
+const majorTypeNegative = 1;
+const majorTypeShift = 5;
+const majorTypeSimple = 7;
+const majorTypeText = 3;
+const majorTypeUnsigned = 0;
+const maxAdditionalInfo = 27;
+const maxInitialNumber = 23;
+const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+const simpleValues = [false, true, null, undefined];
+const sizeOfLargestNumber = 8;
+
+/** Decode the CBOR data item that starts at an index
+
+  {
+    data: <CBOR Encoded Data Buffer Object>
+    start: <Start Index Number>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    end: <Index After the End of the Data Item Number>
+    value: <Decoded Value Object>
+  }
+*/
+module.exports = ({data, start}) => {
+  if (start >= data.length) {
+    throw new Error('UnexpectedEndOfCborData');
+  }
+
+  const info = data[start] & additionalInfoMask;
+  const major = data[start] >> majorTypeShift;
+
+  // Exit early when the item is false, true, null or undefined
+  if (major === majorTypeSimple) {
+    const index = info - firstSimpleValue;
+
+    if (index < 0 || index >= simpleValues.length) {
+      throw new Error('UnsupportedCborSimpleValue');
+    }
+
+    return {end: start + 1, value: simpleValues[index]};
+  }
+
+  // Indefinite lengths are not supported
+  if (info > maxAdditionalInfo) {
+    throw new Error('UnsupportedCborAdditionalInfo');
+  }
+
+  // A number too large for the initial byte follows after the initial byte
+  const size = info > maxInitialNumber ? argumentSizes[info] : 0;
+
+  const next = start + 1 + size;
+
+  if (next > data.length) {
+    throw new Error('UnexpectedEndOfCborData');
+  }
+
+  const readNumber = () => {
+    // Exit early when the number is in the initial byte
+    if (!size) {
+      return info;
+    }
+
+    // Exit early when the number is in one, two or four bytes
+    if (size !== sizeOfLargestNumber) {
+      return data.readUIntBE(start + 1, size);
+    }
+
+    const number = data.readBigUInt64BE(start + 1);
+
+    if (number > maxSafe) {
+      throw new Error('UnsupportedLargeCborNumber');
+    }
+
+    return Number(number);
+  };
+
+  const number = readNumber();
+
+  // Exit early when the item is an integer at or above zero
+  if (major === majorTypeUnsigned) {
+    return {end: next, value: number};
+  }
+
+  // Exit early when the item is a negative integer
+  if (major === majorTypeNegative) {
+    if (!isSafeInteger(-1 - number)) {
+      throw new Error('UnsupportedLargeCborNumber');
+    }
+
+    return {end: next, value: -1 - number};
+  }
+
+  // Exit early when the item is bytes or text
+  if (major === majorTypeBytes || major === majorTypeText) {
+    const end = next + number;
+
+    if (end > data.length) {
+      throw new Error('UnexpectedEndOfCborData');
+    }
+
+    const bytes = Buffer.from(data.subarray(next, end));
+
+    return {end, value: major === majorTypeText ? bytes.toString() : bytes};
+  }
+
+  // Exit early when the item is an array, decoding each item in order
+  if (major === majorTypeArray) {
+    // Every item takes up at least one byte
+    if (number > data.length - next) {
+      throw new Error('UnexpectedEndOfCborData');
+    }
+
+    const items = [];
+
+    const end = arrayOfLength(number).reduce(at => {
+      const item = module.exports({data, start: at});
+
+      items.push(item.value);
+
+      return item.end;
+    },
+    next);
+
+    return {end, value: items};
+  }
+
+  if (major !== majorTypeMap) {
+    throw new Error('UnsupportedCborTag');
+  }
+
+  // Every map entry takes up at least two bytes, a key and its value
+  if (number * 2 > data.length - next) {
+    throw new Error('UnexpectedEndOfCborData');
+  }
+
+  const entries = [];
+
+  // Decode each key followed by its value
+  const end = arrayOfLength(number).reduce(at => {
+    const key = module.exports({data, start: at});
+
+    if (!isString(key.value)) {
+      throw new Error('ExpectedTextKeysInCborMap');
+    }
+
+    const item = module.exports({data, start: key.end});
+
+    entries.push([key.value, item.value]);
+
+    return item.end;
+  },
+  next);
+
+  return {end, value: fromEntries(entries)};
+};

package/encryption/decrypt_with_node.js

@@ -1,10 +1,11 @@
 const asyncAuto = require('async/auto');
-const {decodeFirst} = require('cbor');
+const asyncify = require('async/asyncify');
 const {diffieHellmanComputeSecret} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNode} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const decodeCbor = require('./decode_cbor');
 const decryptWithSecret = require('./decrypt_with_secret');
 
 const hexAsBuf = hex => Buffer.from(hex, 'hex');
@@ -41,27 +42,29 @@ module.exports = ({encrypted, lnd}, cbk) => {
       },
 
       // Decode encrypted CBOR
-      decode: ['validate', ({}, cbk) => {
-        return decodeFirst(encrypted, (err, details) => {
-          if (!!err) {
-            return cbk([400, 'ExpectedCborEncodedEncryptedData', {err}]);
-          }
+      decode: ['validate', asyncify(() => {
+        let details;
 
-          if (!details) {
-            return cbk([400, 'ExpectedDecodedDetailsToDecryptWithNode']);
-          }
+        try {
+          details = decodeCbor({cbor: encrypted}).value;
+        } catch (err) {
+          throw [400, 'ExpectedCborEncodedEncryptedData', {err}];
+        }
 
-          if (!details.settings) {
-            return cbk([400, 'ExpectedEncryptionSettingsToDecryptWithNode']);
-          }
+        if (!details) {
+          throw [400, 'ExpectedDecodedDetailsToDecryptWithNode'];
+        }
 
-          if (!isArray(details.settings.with)) {
-            return cbk([400, 'ExpectedWithNodesPublicKeyToDecrypt']);
-          }
+        if (!details.settings) {
+          throw [400, 'ExpectedEncryptionSettingsToDecryptWithNode'];
+        }
 
-          return cbk(null, details);
-        });
-      }],
+        if (!isArray(details.settings.with)) {
+          throw [400, 'ExpectedWithNodesPublicKeyToDecrypt'];
+        }
+
+        return details;
+      })],
 
       // Get node public key
       getPublicKey: ['decode', ({decode}, cbk) => getIdentity({lnd}, cbk)],