balanceofsatoshis 25.6.2 → 25.7.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Versions
 
+## 25.7.0
+
+- `accounting`: Add `lightning-fees` category to report the routing fees paid
+    on payments
+- `accounting`: Keep the payments of recent blocks in `chain_blocks.json`, so
+    that later runs only fetch the blocks that are new
+- `accounting`: Pass `--node` more than once to get one report of several
+    nodes, with their records together in order of date
+- `fund`: Add `--fee-rate-precise` to set a fee rate per 1000 vbytes
+- `fund`: `MAX` amounts send as much as possible without overpaying the fee
+
 ## 25.6.2
 
 - `telegram`: Fix invoices settled before the bot started being reported as new

package/README.md

@@ -305,6 +305,9 @@ You can also add a JSON file to your .bos directory: config.json, add
 
 `bos` keeps its files in `~/.bos`, or in `BOS_DATA_PATH` when that is set:
 
+- `chain_blocks.json`: the payments in the last few days of blocks that
+    `bos accounting` derives prices from, kept so that later runs only fetch
+    the blocks that are new. The file can be deleted
 - `chain_prices.json`: USD prices of BTC that `bos accounting` derived from
     chain data, kept so that a day is only derived once. Prices are derived
     this way when no `--rate-provider` is given, and the prices of the days

package/balances/accounting_categories.json

@@ -4,5 +4,6 @@
   "chain-sends": "chain_sends",
   "forwards": "forwards",
   "invoices": "invoices",
+  "lightning-fees": "lightning_fees",
   "payments": "payments"
 }

package/balances/chain_price_range.js

@@ -0,0 +1,30 @@
+const {isFinite} = Number;
+const {round} = Math;
+const {sqrt} = Math;
+
+/** Get the range of prices that the round dollar payments of a day point to
+
+  {
+    [dispersion]: <Peak Width Beyond Smoothing As Price Fraction Number>
+    price: <Price String>
+  }
+
+  @returns
+  {
+    [range]: <Low Price to High Price String>
+  }
+*/
+module.exports = ({dispersion, price}) => {
+  // Exit early when there is no width to describe
+  if (!isFinite(dispersion)) {
+    return {};
+  }
+
+  // The peak reaches the square root of the dispersion factor either side
+  const reach = sqrt(1 + dispersion);
+
+  const high = round(Number(price) * reach);
+  const low = round(Number(price) / reach);
+
+  return {range: `${low} to ${high}`};
+};

package/balances/chain_prices_logger.js

@@ -0,0 +1,78 @@
+const chainPriceRange = require('./chain_price_range');
+const {chainPriceFlagNotes} = require('./constants');
+
+const {floor} = Math;
+const {keys} = Object;
+const msPerDay = 1000 * 60 * 60 * 24;
+
+/** Make a logger that describes deriving prices from chain data
+
+  {
+    [logger]: <Winston Logger Object>
+  }
+
+  @returns
+  {
+    [logger]: {
+      error: <Error Function>
+      info: <Info Function>
+    }
+  }
+*/
+module.exports = ({logger}) => {
+  // Exit early when there is no logger to describe progress with
+  if (!logger) {
+    return {};
+  }
+
+  return {
+    logger: {
+      error: err => logger.error(err),
+      info: line => {
+        // Exit early describing fetching blocks as calculating prices
+        if (!!line && !!line.fetching_blocks) {
+          const {blocks, date} = line.fetching_blocks;
+
+          const days = floor((Date.now() - Date.parse(date)) / msPerDay);
+
+          const isToday = days === 0;
+
+          return logger.info({
+            calculating_prices_from_blocks: {
+              blocks,
+              day: date,
+              days_out_of_date: !isNaN(days) && !isToday ? days : undefined,
+            },
+          });
+        }
+
+        // Exit early when the line is not a price derived from chain data
+        if (!line || !line.chain_price || !line.chain_price.price) {
+          return logger.info(line);
+        }
+
+        const price = line.chain_price;
+
+        const flags = keys(chainPriceFlagNotes).filter(flag => !!price[flag]);
+
+        const note = flags.map(flag => chainPriceFlagNotes[flag]).join(', ');
+
+        // Only a price from a full day of blocks has the measures behind it
+        const isFullDay = price.outputs !== undefined;
+
+        // Keys are in reading order, the price first and then its evidence
+        return logger.info({
+          chain_price: {
+            date: price.date,
+            price: price.price,
+            price_range: isFullDay ? chainPriceRange(price).range : undefined,
+            blocks: isFullDay ? price.blocks : undefined,
+            payment_outputs: isFullDay ? price.outputs : undefined,
+            round_dollar_payments: isFullDay ? price.payments : undefined,
+            note: note || undefined,
+          },
+        });
+      },
+    },
+  };
+};

package/balances/constants.json

@@ -1,4 +1,11 @@
 {
+  "chainBlocksFile": "chain_blocks.json",
+  "chainPriceFlagNotes": {
+    "is_provisional": "provisional, the day is not over yet",
+    "is_sample": "rough estimate from a sample of the blocks",
+    "is_unsettled": "the estimate was still shifting when refining stopped",
+    "is_widened": "found outside the expected price range"
+  },
   "chainPricesFile": "chain_prices.json",
   "coinbaseProvider": "coinbase",
   "defaultCurrency": "BTC",

package/balances/get_accounting_report.js

@@ -1,11 +1,17 @@
 const asyncAuto = require('async/auto');
+const asyncify = require('async/asyncify');
+const asyncMap = require('async/map');
+const asyncMapSeries = require('async/mapSeries');
 const {chainRates} = require('@alexbosworth/fiat');
 const {getAccountingReport} = require('ln-accounting');
 const {getNetwork} = require('ln-sync');
+const {harmonize} = require('ln-accounting');
 const {returnResult} = require('asyncjs-util');
 
 const categories = require('./accounting_categories');
+const {chainBlocksFile} = require('./constants');
 const {chainPricesFile} = require('./constants');
+const chainPricesLogger = require('./chain_prices_logger');
 const {coinbaseProvider} = require('./constants');
 const {defaultCurrency} = require('./constants');
 const {defaultFiat} = require('./constants');
@@ -18,11 +24,14 @@ const {monthNumbers} = require('./constants');
 const {monthOffset} = require('./constants');
 const {notFoundIndex} = require('./constants');
 const rangeForDate = require('./range_for_date');
+const {sortBy} = require('./../arrays');
 const tableRowsFromCsv = require('./table_rows_from_csv');
 
 const assetType = 'BTC';
-const currentDate = new Date().toISOString();
 const empty = '';
+const flatten = arr => [].concat(...arr);
+const {isArray} = Array;
+const {keys} = Object;
 const round = n => parseFloat(n).toFixed(2);
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const summaryHeadings = ['Total', 'Asset', 'Report Date', 'Total Fiat'];
@@ -42,10 +51,9 @@ const summaryHeadings = ['Total', 'Asset', 'Report Date', 'Total Fiat'];
     }
     [is_csv]: <Return CSV Output Bool>
     [is_fiat_disabled]: <Omit Fiat Conversion Bool>
-    lnd: <Authenticated LND API Object>
+    lnds: [<Authenticated LND API Object>]
     [logger]: <Winston Logger Object>
     [month]: <Month for Report String>
-    [node]: <Node Name String>
     [rate_provider]: <Rate Provider String>
     request: <Request Function>
     [year]: <Year for Report String>
@@ -65,7 +73,9 @@ module.exports = (args, cbk) => {
         const {fs} = args;
 
         if (!args.category || !categories[args.category]) {
-          return cbk([400, 'ExpectedKnownAccountingRecordsCategory']);
+          return cbk([400, 'ExpectedKnownAccountingRecordsCategory', {
+            categories: keys(categories),
+          }]);
         }
 
         if (!!args.date && !args.month) {
@@ -76,8 +86,8 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedFileSystemMethodsToGetAccountingReport']);
         }
 
-        if (!args.lnd) {
-          return cbk([400, 'ExpectedAuthenticatedLndToGetAccountingReport']);
+        if (!isArray(args.lnds) || !args.lnds.length) {
+          return cbk([400, 'ExpectedAuthenticatedLndsToGetAccountingReport']);
         }
 
         if (!args.request) {
@@ -88,34 +98,37 @@ module.exports = (args, cbk) => {
       },
 
       // Get date range
-      dateRange: ['validate', ({}, cbk) => {
-        const range = (() => {
-          try {
-            return {
-              value: rangeForDate({
-                date: args.date,
-                month: args.month,
-                year: args.year,
-              }),
-            };
-          } catch (err) {
-            return {err};
-          }
-        })();
-
-        // Exit early when the date range cannot be determined
-        if (!!range.err) {
-          return cbk([400, range.err.message]);
+      dateRange: ['validate', asyncify(() => {
+        try {
+          return rangeForDate({
+            date: args.date,
+            month: args.month,
+            year: args.year,
+          });
+        } catch (err) {
+          throw [400, err.message];
         }
+      })],
 
-        return cbk(null, range.value);
+      // Get the network names of the nodes
+      getNetworks: ['validate', ({}, cbk) => {
+        return asyncMap(args.lnds, (lnd, cbk) => getNetwork({lnd}, cbk), cbk);
       }],
 
-      // Get the network name
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
+      // The network that the nodes are on
+      network: ['getNetworks', ({getNetworks}, cbk) => {
+        const [{network}] = getNetworks;
+
+        // Exit early when the nodes are not all on the same network
+        if (getNetworks.some(n => n.network !== network)) {
+          return cbk([400, 'ExpectedSameNetworkNodesForAccountingReport']);
+        }
+
+        return cbk(null, network);
+      }],
 
       // Make the method that gets chain prices, used without a rate provider
-      chain: ['getNetwork', ({getNetwork}, cbk) => {
+      chain: ['network', ({network}, cbk) => {
         // Exit early when fiat is disabled or a rate provider is specified
         if (!!args.is_fiat_disabled || !!args.rate_provider) {
           return cbk();
@@ -123,17 +136,23 @@ module.exports = (args, cbk) => {
 
         // Exit early when there are no chain prices for the network or no
         // file system to keep them in
-        if (!args.fs || getNetwork.network !== mainnet) {
+        if (!args.fs || network !== mainnet) {
           return cbk();
         }
 
         // Progress is only logged when it cannot end up in CSV output
-        const logger = !args.is_csv ? args.logger : undefined;
+        const {logger} = chainPricesLogger({
+          logger: !args.is_csv ? args.logger : undefined,
+        });
+
+        // Chain prices are derived through the first node
+        const [lnd] = args.lnds;
 
         const {getChainRate} = chainRates({
+          lnd,
           logger,
+          blocks_path: homePath({file: chainBlocksFile}).path,
           fs: args.fs,
-          lnd: args.lnd,
           path: homePath({file: chainPricesFile}).path,
         });
 
@@ -165,51 +184,63 @@ module.exports = (args, cbk) => {
         });
       }],
 
-      // Get accounting info
+      // Get the accounting records of each node, one node after another
       getAccounting: [
         'dateRange',
-        'getNetwork',
+        'network',
         'rate',
-        ({dateRange, getNetwork, rate}, cbk) =>
+        ({dateRange, network, rate}, cbk) =>
       {
-        return getAccountingReport({
-          after: dateRange.after,
-          before: dateRange.before,
-          category: categories[args.category],
-          currency: args.currency || defaultCurrency,
-          fiat: !args.is_fiat_disabled ? (args.fiat || defaultFiat) : null,
-          lnd: args.lnd,
-          network: getNetwork.network,
-          rate: !!rate ? rate.rate : undefined,
-          rate_provider: !rate ? args.rate_provider : undefined,
-          request: args.request,
+        return asyncMapSeries(args.lnds, (lnd, cbk) => {
+          return getAccountingReport({
+            lnd,
+            network,
+            after: dateRange.after,
+            before: dateRange.before,
+            category: categories[args.category],
+            currency: args.currency || defaultCurrency,
+            fiat: !args.is_fiat_disabled ? (args.fiat || defaultFiat) : null,
+            rate: !!rate ? rate.rate : undefined,
+            rate_provider: !rate ? args.rate_provider : undefined,
+            request: args.request,
+          },
+          cbk);
         },
         cbk);
       }],
 
-      // Convert the accounting CSV into rows for table display output
-      accounting: ['getAccounting', ({getAccounting}, cbk) => {
-        const csvType = `${categories[args.category]}_csv`;
+      // The records of all of the nodes in the category, in order of date
+      records: ['getAccounting', ({getAccounting}, cbk) => {
+        const category = categories[args.category];
+
+        const records = flatten(getAccounting.map(report => report[category]));
+
+        const {sorted} = sortBy({array: records, attribute: 'created_at'});
+
+        return cbk(null, sorted);
+      }],
+
+      // Convert the records into a CSV, or into rows for table display output
+      accounting: ['records', ({records}, cbk) => {
+        const {csv} = harmonize({records});
 
         // Exit early when a CSV dump is requested
         if (!!args.is_csv) {
-          return cbk(null, getAccounting[csvType]);
+          return cbk(null, csv);
         }
 
-        return tableRowsFromCsv({csv: getAccounting[csvType]}, cbk);
+        return tableRowsFromCsv({csv}, cbk);
       }],
 
       // Calculate total amounts
-      total: ['getAccounting', ({getAccounting}, cbk) => {
+      total: ['records', ({records}, cbk) => {
         // Exit early when a CSV dump is requested
         if (!!args.is_csv) {
           return cbk();
         }
 
-        const rows = getAccounting[categories[args.category]];
-
         // Token values are represented as amounts
-        const tokens = sumOf(rows.map(n => n.amount));
+        const tokens = sumOf(records.map(n => n.amount));
 
         // Exit early when there is no fiat data
         if (!!args.is_fiat_disabled) {
@@ -217,13 +248,13 @@ module.exports = (args, cbk) => {
         }
 
         // Fiat values are represented as fiat amounts
-        const fiat = round(sumOf(rows.map(n => n.fiat_amount)));
+        const fiat = round(sumOf(records.map(n => n.fiat_amount)));
 
         return cbk(null, {fiat, tokens});
       }],
 
       // Clean rows for display if necessary
-      report: ['accounting', 'total',({accounting, total}, cbk) => {
+      report: ['accounting', 'total', ({accounting, total}, cbk) => {
         // Exit early when there is no cleaning necessary
         if (!!args.is_csv) {
           return cbk(null, accounting);
@@ -249,7 +280,7 @@ module.exports = (args, cbk) => {
 
         const summary = [
           summaryHeadings,
-          [total.tokens, assetType, currentDate, total.fiat],
+          [total.tokens, assetType, new Date().toISOString(), total.fiat],
         ];
 
         return cbk(null, {rows, rows_summary: summary});

package/balances/range_for_date.js

@@ -4,7 +4,9 @@ const {monthNumbers} = require('./constants');
 const {monthOffset} = require('./constants');
 const {notFoundIndex} = require('./constants');
 
-/** Get a before and after range 
+const isDay = n => /^\d+$/.test(n) && Number(n) > 0;
+
+/** Get a before and after range
 
   {
     [date]: <Day of Month String>
@@ -17,8 +19,8 @@ const {notFoundIndex} = require('./constants');
 
   @returns
   {
-    [after]: <After ISO 8601 Date String>
-    [before]: <Before ISO 8601 Date String>
+    [after]: <Records Created On or After ISO 8601 Date String>
+    [before]: <Records Created Before ISO 8601 Date String>
   }
 */
 module.exports = ({date, month, year}) => {
@@ -32,12 +34,6 @@ module.exports = ({date, month, year}) => {
     after.year(year);
   }
 
-  try {
-    after.toISOString();
-  } catch (err) {
-    throw new Error('UnrecognizedFormatForAccountingYear');
-  }
-
   const end = after.clone();
 
   if (!!month && monthNumbers.indexOf(month) !== notFoundIndex) {
@@ -46,8 +42,12 @@ module.exports = ({date, month, year}) => {
     [after, end].forEach(n => n.month(month));
   }
 
+  if (!!date && (!isDay(date) || Number(date) > after.daysInMonth())) {
+    throw new Error('ExpectedDayInMonthForAccountingDate');
+  }
+
   if (!!date) {
-    [after, end].forEach(n => n.date(date));
+    [after, end].forEach(n => n.date(Number(date)));
   }
 
   if (!!date) {
@@ -58,13 +58,5 @@ module.exports = ({date, month, year}) => {
     end.add([after].length, 'years');
   }
 
-  try {
-    after.toISOString();
-  } catch (err) {
-    throw new Error('UnrecognizedFormatForAccountingMonth');
-  }
-
-  after.subtract([after].length, 'millisecond');
-
   return {after: after.toISOString(), before: end.toISOString()};
 };

package/bos

@@ -67,16 +67,17 @@ prog
 
   // Get accounting information
   .command('accounting', 'Get an accounting rundown')
-  .argument('<category>', 'Report category', keys(accountingCategories))
+  .argument('<category>', 'Report category')
   .help(`Categories: ${keys(accountingCategories).join(', ')}`)
   .help(`Rate providers: ${rateProviders.join(', ')}`)
   .help('By default fiat rates after 2021-10-19 use chain data derived rates')
+  .help('Multiple --node arguments are supported to report on nodes together')
   .help('Privacy note: this requests tx related data from third parties')
   .option('--csv', 'Output a CSV')
   .option('--date <day>', 'Show only records for specific date')
   .option('--disable-fiat', 'Avoid looking up fiat conversions for records')
   .option('--month <month>', 'Show only records for specific month', months)
-  .option('--node <node_name>', 'Get details from named node')
+  .option('--node <node_name>', 'Get details from saved node(s)', REPEATABLE)
   .option('--rate-provider <rate_provider>', 'Rate provider', rateProviders)
   .option('--year <year>', 'Show only records for specified year', yearMatch)
   .action((args, options, logger) => {
@@ -96,9 +97,8 @@ prog
           },
           is_csv: !!options.csv,
           is_fiat_disabled: options.disableFiat,
-          lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
+          lnds: (await lnd.getLnds({logger, nodes: options.node})).lnds,
           month: options.month,
-          node: options.node,
           rate_provider: options.rateProvider,
           request: commands.simpleRequest,
           year: options.year,
@@ -824,10 +824,12 @@ prog
   .help('Specify <address> <amount> <address> <amount> for addresses, amounts')
   .help('Amounts support formulas, use MAX to reference selected UTXOs total')
   .help('--utxo can be specified multiple times to spend multiple UTXOs')
+  .help('--fee-rate-precise is per 1000 vbytes, so 1500 is 1.5 per vbyte')
   .argument('<address_amount...>', 'Address and amount to send')
   .option('--broadcast', 'Broadcast the signed transaction')
   .option('--dryrun', 'Avoid locking up UTXOs')
   .option('--fee-rate <fee>', 'Per vbyte fee rate for on-chain tx fee')
+  .option('--fee-rate-precise <per_kvbyte>', 'Fee rate per 1000 vbytes', INT)
   .option('--node <node_name>', 'Node to spend coins')
   .option('--select-utxos', 'Specify UTXOs to spend interactively from a list')
   .option('--utxo <outpoint>', 'Spend a specific tx_id:vout', REPEATABLE)
@@ -839,6 +841,7 @@ prog
           addresses: args.addressAmount.filter((n, i) => !(i % 2)),
           amounts: args.addressAmount.filter((n, i) => i % 2),
           ask: await commands.interrogate({}),
+          fee_mtokens_per_vbyte: options.feeRatePrecise,
           fee_tokens_per_vbyte: options.feeRate,
           is_broadcast: options.broadcast,
           is_dry_run: !!options.dryrun,

package/chain/fund_transaction.js

@@ -1,32 +1,40 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
 const asyncify = require('async/asyncify');
+const asyncMap = require('async/map');
+const asyncReflect = require('async/reflect');
 const {broadcastTransaction} = require('ln-sync');
 const {componentsOfTransaction} = require('@alexbosworth/blockchain');
+const {createFundedPsbt} = require('ln-service');
 const {formatTokens} = require('ln-sync');
-const {fundPsbt} = require('ln-service');
 const {getChainFeeRate} = require('ln-service');
-const {getMaxFundAmount} = require('ln-sync');
+const {getMaxFundingValue} = require('ln-sync');
 const {getNetwork} = require('ln-sync');
 const {getUtxos} = require('ln-service');
+const {lockUtxo} = require('ln-service');
+const {outputScriptForAddress} = require('@alexbosworth/blockchain');
 const {parseAmount} = require('ln-accounting');
 const {returnResult} = require('asyncjs-util');
 const {signPsbt} = require('ln-service');
 const {sizeOfTransaction} = require('@alexbosworth/blockchain');
 const {unlockUtxo} = require('ln-service');
 
-const allowUnconfirmed = 0;
 const asBigUnit = n => (n / 1e8).toFixed(8);
 const asOutpoint = utxo => `${utxo.transaction_id}:${utxo.transaction_vout}`;
 const asInput = n => ({transaction_id: n.id, transaction_vout: n.vout});
+const asMtokens = tokens => Math.round(Number(tokens) * 1e3);
 const asUtxo = n => ({id: n.slice(0, 64), vout: Number(n.slice(65))});
 const dustValue = 293;
 const formattedFeeRate = n => n.toFixed(2);
 const hasMaxAmount = amounts => !!amounts.find(n => !!n && !!/max/gim.test(n));
 const {isArray} = Array;
 const isOutpoint = n => !!n && /^[0-9A-F]{64}:[0-9]{1,6}$/i.test(n);
+const isPreciseFeeRate = n => !n || (Number.isSafeInteger(n) && n > 0);
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const isValidFeeRate = n => !n || Number.isInteger(Number(n));
+const mtokensPerToken = 1e3;
+const noCoinSelectionMinConfs = 2147483647;
+const placeholderTokens = 546;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
 
 /** Fund and sign a transaction
@@ -35,7 +43,7 @@ const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
     addresses: [<Address String>]
     amounts: [<Amount String>]
     ask: <Ask Function>
-    spend: [<Coin Outpoint String>]
+    [fee_mtokens_per_vbyte]: <Fee Millitokens Per Virtual Byte Number>
     [fee_tokens_per_vbyte]: <Fee Tokens Per Virtual Byte Number>
     [is_broadcast]: <Broadcast Signed Transaction Bool>
     is_dry_run: <Release Locks on Transaction Bool>
@@ -87,6 +95,14 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedIntegerFeeRateForFundingTransaction']);
         }
 
+        if (!isPreciseFeeRate(args.fee_mtokens_per_vbyte)) {
+          return cbk([400, 'ExpectedIntegerPreciseFeeRateToFundTransaction']);
+        }
+
+        if (!!args.fee_mtokens_per_vbyte && !!args.fee_tokens_per_vbyte) {
+          return cbk([400, 'ExpectedEitherFeeRateOrPreciseFeeRateNotBoth']);
+        }
+
         if (!!args.is_broadcast && !!args.is_dry_run) {
           return cbk([400, 'BroadcastingSignedTxUnsupportedInDryRun']);
         }
@@ -193,13 +209,38 @@ module.exports = (args, cbk) => {
         ({inputs}) => cbk(null, inputs));
       }],
 
+      // Get the fee rate to fund at in mtokens per vbyte
+      feeRate: ['getFee', ({getFee}, cbk) => {
+        // Exit early when the fee rate is already in mtokens
+        if (!!args.fee_mtokens_per_vbyte) {
+          return cbk(null, args.fee_mtokens_per_vbyte);
+        }
+
+        const rate = args.fee_tokens_per_vbyte || getFee.tokens_per_vbyte;
+
+        return cbk(null, asMtokens(rate));
+      }],
+
+      // Get the output scripts of the addresses to send to
+      scripts: ['getNetwork', asyncify(({getNetwork}) => {
+        const {network} = getNetwork;
+
+        try {
+          return args.addresses.map(address => {
+            return outputScriptForAddress({address, network}).script;
+          });
+        } catch (err) {
+          throw [400, err.message];
+        }
+      })],
+
       // Calculate the maximum possible amount to fund for selected inputs
       getMax: [
-        'getFee',
+        'feeRate',
         'getUtxos',
-        'outputs',
+        'scripts',
         'utxos',
-        ({getFee, getUtxos, outputs, utxos}, cbk) =>
+        ({feeRate, getUtxos, scripts, utxos}, cbk) =>
       {
         // Exit early when the amount is not open ended
         if (!hasMaxAmount(args.amounts)) {
@@ -211,8 +252,6 @@ module.exports = (args, cbk) => {
           return cbk([400, 'MaxAmountOnlySupportedWhenUtxosSpecified']);
         }
 
-        const feeRate = args.fee_tokens_per_vbyte || getFee.tokens_per_vbyte;
-
         // Find the local UTXOs in order to get the input values
         const spend = utxos.map(outpoint => {
           return getUtxos.utxos.find(n => asOutpoint(n) === outpoint);
@@ -225,32 +264,54 @@ module.exports = (args, cbk) => {
           return cbk([400, 'UnknownInputSelected', {known: knownUtxos}]);
         }
 
-        return getMaxFundAmount({
-          addresses: args.addresses,
-          fee_tokens_per_vbyte: feeRate,
+        const [script, ...others] = scripts;
+
+        // Size the max as the first output, with placeholders for the others
+        return getMaxFundingValue({
+          fee_mtokens_per_vbyte: feeRate,
           inputs: spend.map(utxo => ({
-            tokens: utxo.tokens,
             transaction_id: utxo.transaction_id,
             transaction_vout: utxo.transaction_vout,
           })),
           lnd: args.lnd,
+          output_script: script,
+          outputs: others.map(n => ({script: n, tokens: placeholderTokens})),
         },
         cbk);
       }],
 
+      // The value that the outputs can add up to when spending the max
+      maxTokens: ['getMax', 'scripts', ({getMax, scripts}, cbk) => {
+        // Exit early when there is no max amount
+        if (getMax.max_tokens === undefined) {
+          return cbk();
+        }
+
+        // Outputs after the first were sized with placeholder values
+        const placeholders = scripts.slice(1).map(() => placeholderTokens);
+
+        return cbk(null, getMax.max_tokens + sumOf(placeholders));
+      }],
+
       // Parse amounts and put together the final set of outputs
-      finalOutputs: ['getMax', asyncify(({getMax}) => {
+      finalOutputs: [
+        'maxTokens',
+        'scripts',
+        asyncify(({maxTokens, scripts}) =>
+      {
         try {
           const outputs = args.addresses.map((address, i) => {
             const amount = args.amounts[i];
             const variables = {};
 
             // The max variable is only defined when a maximum is calculated
-            if (getMax.max_tokens !== undefined) {
-              variables.max = getMax.max_tokens;
+            if (maxTokens !== undefined) {
+              variables.max = maxTokens;
             }
 
-            return {address, tokens: parseAmount({amount, variables}).tokens};
+            const {tokens} = parseAmount({amount, variables});
+
+            return {address, tokens, script: scripts[i]};
           });
 
           return outputs;
@@ -259,64 +320,135 @@ module.exports = (args, cbk) => {
         }
       })],
 
-      // Create a funded PSBT
+      // Make sure that the outputs are not dust
+      checkDust: ['finalOutputs', ({finalOutputs}, cbk) => {
+        if (!!finalOutputs.filter(n => n.tokens < dustValue).length) {
+          return cbk([400, 'ExpectedNonDustAmountValueForFundingAmount']);
+        }
+
+        return cbk();
+      }],
+
+      // Lock the inputs to spend, LND needs them locked before funding
+      lock: ['checkDust', 'utxos', ({utxos}, cbk) => {
+        return asyncMap(utxos.map(asUtxo), asyncReflect((utxo, cbk) => {
+          return lockUtxo({
+            lnd: args.lnd,
+            transaction_id: utxo.id,
+            transaction_vout: utxo.vout,
+          },
+          cbk);
+        }),
+        cbk);
+      }],
+
+      // The inputs that were locked, with the ids of their locks
+      locked: ['lock', 'utxos', ({lock, utxos}, cbk) => {
+        const inputs = utxos.map(asUtxo).map((utxo, i) => ({
+          id: !lock[i].error ? lock[i].value.id : undefined,
+          transaction_id: utxo.id,
+          transaction_vout: utxo.vout,
+        }));
+
+        return cbk(null, inputs.filter(n => !!n.id));
+      }],
+
+      // Create a funded PSBT, holding on to a failure to unlock inputs first
       fund: [
+        'feeRate',
         'finalOutputs',
-        'getFee',
-        'getNetwork',
-        'utxos',
-        ({finalOutputs, getFee, getNetwork, utxos}, cbk) =>
+        'lock',
+        'locked',
+        asyncReflect(({feeRate, finalOutputs, lock, locked}, cbk) =>
       {
-        const inputs = utxos.map(asUtxo).map(asInput);
-        const feeRate = args.fee_tokens_per_vbyte || getFee.tokens_per_vbyte;
+        const [failed] = lock.filter(n => !!n.error);
 
-        if (!!finalOutputs.filter(n => n.tokens < dustValue).length) {
-          return cbk([400, 'ExpectedNonDustAmountValueForFundingAmount']);
+        // Exit early when an input could not be locked
+        if (!!failed) {
+          return cbk(failed.error);
         }
 
+        const minConfs = !!locked.length ? noCoinSelectionMinConfs : undefined;
+
         args.logger.info({
           send_to: finalOutputs.map(({address, tokens}) => ({
             [address]: formatTokens({tokens}).display,
           })),
-          requested_fee_rate: feeRate,
+          requested_fee_rate: feeRate / mtokensPerToken,
         });
 
-        return fundPsbt({
-          fee_tokens_per_vbyte: feeRate,
-          inputs: !!inputs.length ? inputs : undefined,
+        return createFundedPsbt({
+          fee_mtokens_per_vbyte: feeRate,
+          inputs: locked.map(input => ({
+            transaction_id: input.transaction_id,
+            transaction_vout: input.transaction_vout,
+          })),
           lnd: args.lnd,
-          min_confirmations: !!inputs.length ? allowUnconfirmed : undefined,
-          outputs: finalOutputs,
+          // No coins are added to inputs that are specified to be spent
+          min_confirmations: minConfs,
+          outputs: finalOutputs.map(({script, tokens}) => ({script, tokens})),
         },
         cbk);
+      })],
+
+      // The funded PSBT, the inputs are unlocked when it could not be funded
+      funding: ['fund', 'locked', ({fund, locked}, cbk) => {
+        // Exit early when the PSBT was funded
+        if (!fund.error) {
+          return cbk(null, fund.value);
+        }
+
+        return asyncEach(locked, (input, cbk) => {
+          return unlockUtxo({
+            id: input.id,
+            lnd: args.lnd,
+            transaction_id: input.transaction_id,
+            transaction_vout: input.transaction_vout,
+          },
+          () => {
+            // Ignore errors unlocking a UTXO, the lock will expire on its own
+            return cbk();
+          });
+        },
+        () => {
+          // Return the original error that stopped funding
+          return cbk(fund.error);
+        });
       }],
 
       // Sign the funded PSBT
-      sign: ['fund', ({fund}, cbk) => {
-        const [change] = fund.outputs.filter(n => !!n.is_change);
-        const total = sumOf(fund.outputs.map(n => n.tokens));
+      sign: ['funding', ({funding}, cbk) => {
+        const [change] = funding.outputs.filter(n => !!n.is_change);
+        const total = sumOf(funding.outputs.map(n => n.tokens));
 
         const tokens = !!change ? change.tokens : undefined;
 
         args.logger.info({
           change: !!tokens ? formatTokens({tokens}).display : undefined,
           sum_of_outputs: formatTokens({tokens: total}).display,
-          spending_utxos: fund.inputs.map(asOutpoint),
+          spending_utxos: funding.inputs.map(asOutpoint),
         });
 
-        return signPsbt({lnd: args.lnd, psbt: fund.psbt}, cbk);
+        return signPsbt({lnd: args.lnd, psbt: funding.psbt}, cbk);
       }],
 
       // Unlock the locked UTXOs in a dry run scenario
-      unlock: ['fund', 'sign', ({fund}, cbk) => {
+      unlock: ['funding', 'locked', 'sign', ({funding, locked}, cbk) => {
         // Exit early and keep UTXOs locked when not a dry run
         if (!args.is_dry_run) {
           return cbk();
         }
 
-        return asyncEach(fund.inputs, (input, cbk) => {
+        // LND locks the inputs that it adds to fund the PSBT
+        const added = funding.inputs.filter(n => !!n.lock_id).map(input => ({
+          id: input.lock_id,
+          transaction_id: input.transaction_id,
+          transaction_vout: input.transaction_vout,
+        }));
+
+        return asyncEach(locked.concat(added), (input, cbk) => {
           return unlockUtxo({
-            id: input.lock_id,
+            id: input.id,
             lnd: args.lnd,
             transaction_id: input.transaction_id,
             transaction_vout: input.transaction_vout,
@@ -380,7 +512,7 @@ module.exports = (args, cbk) => {
           transaction: funded.signed_transaction,
         },
         cbk);
-      }]
+      }],
     },
     returnResult({reject, resolve, of: 'broadcast'}, cbk));
   });

package/commands/constants.json

@@ -5,6 +5,7 @@
     "chain-sends": "chain_sends",
     "forwards": "forwards",
     "invoices": "invoices",
+    "lightning-fees": "lightning_fees",
     "payments": "payments"
   },
   "lnurlFunctions": {

package/package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "@alexbosworth/blockchain": "4.12.0",
     "@alexbosworth/caporal": "2.0.0",
-    "@alexbosworth/fiat": "3.0.0",
+    "@alexbosworth/fiat": "3.1.0",
     "@alexbosworth/formulas": "1.5.0",
     "@alexbosworth/html2unicode": "1.1.5",
     "asciichart": "1.5.25",
@@ -29,14 +29,14 @@
     "bolt07": "2.0.0",
     "colorette": "2.0.20",
     "csv-parse": "7.0.3",
-    "goldengate": "16.0.9",
+    "goldengate": "16.0.10",
     "grammy": "1.46.0",
     "import-lazy": "4.0.0",
     "ini": "7.0.0",
     "inquirer": "14.2.5",
-    "ln-accounting": "10.0.9",
-    "ln-service": "60.2.0",
-    "ln-sync": "8.0.9",
+    "ln-accounting": "11.0.0",
+    "ln-service": "60.3.0",
+    "ln-sync": "8.1.0",
     "ln-telegram": "8.2.0",
     "moment": "2.31.0",
     "paid-services": "10.3.3",
@@ -99,9 +99,9 @@
     "build-docker": "docker build -t alexbosworth/balanceofsatoshis . && docker save alexbosworth/balanceofsatoshis > balanceofsatoshis.tar && gzip balanceofsatoshis.tar",
     "integration-tests": "node test/integration",
     "postpack": "PACKAGE_VERSION=$(cat package.json | grep \\\"version\\\" | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g' | tr -d '[[:space:]]') && git tag -s v$PACKAGE_VERSION -m v$PACKAGE_VERSION && git push github --tags",
-    "postpublish": "docker buildx build --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
+    "postpublish": "docker buildx build --pull --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
     "reinstall-dependencies": "rm -rf node_modules package-lock.json && npm i",
     "test": "node --experimental-test-coverage --test test/arrays/*.js test/balances/*.js test/chain/*.js test/commands/*.js test/display/*.js test/encryption/*.js test/lnd/*.js test/lnurl/*.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.6.2"
+  "version": "25.7.0"
 }