balanceofsatoshis 11.40.0 → 11.44.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Versions
 
+## 11.44.0
+
+- `send`: Add support for `--max-fee-rate` to limit fees paid via PPM measure
+
+## 11.43.0
+
+- `limit-forwards`: Add `--min-channel-confirmations` for custom channel ages
+- `limit-forwards`: Add `--only-allow` to restrict forwards to allowed edges
+- `open-balanced-channel`: Disallow fractional fee rate entry
+
+## 11.42.0
+
+- `call`: Add support for `fundPsbt` to create a funded PSBT ready to sign
+- `call`: Add support for `partiallySignPsbt` to add a partial sig to a PSBT
+- `call`: Add support for `signPsbt` to sign and finalize a PSBT for broadcast
+
+## 11.41.0
+
+- `remove-peer`: Add interactive mode to select channels to close
+
 ## 11.40.0
 
 - `peers`: Add `DISK_USAGE_MB` filter to `--filter` formulas for est disk usage

package/bos

@@ -826,10 +826,14 @@ prog
 
   // Intercept forwarding requests, enforce requirements on acceptance
   .command('limit-forwarding', 'Enforce rules for routing payments')
+  .help('Setting --only-allow will disable all forwards except only allowed')
+  .help('--only-allow option can be repeated for multiple forwards')
   .option('--node <node_name>', 'Saved node to enforce rules on')
   .option('--disable-forwards', 'Disable all forwards')
   .option('--max-hours-since-last-block <h>', 'Require fresh blocks', INT, 5)
   .option('--max-new-pending-per-hour <h>', 'Limit held HTLCs', INT)
+  .option('--min-channel-confirmations <confs>', 'Minimum channel confs', INT)
+  .option('--only-allow <pair>', 'only forward fromKey/toKey', REPEATABLE)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -839,6 +843,8 @@ prog
           lnd: (await lndForNode(logger, options.node)).lnd,
           max_hours_since_last_block: options.maxHoursSinceLastBlock,
           max_new_pending_per_hour: options.maxNewPendingPerHour,
+          min_channel_confirmations: options.minChannelConfirmations,
+          only_allow: flatten([options.onlyAllow].filter(n => !!n)),
         });
       } catch (err) {
         return reject(logger.error({err}));
@@ -1396,6 +1402,7 @@ prog
   .option('--outpoint', 'Only remove specific channel with funding txid:vout')
   .option('--private', 'Peer is privately connected')
   .option('--public', 'Peer is publicly connected')
+  .option('--select-channels', 'Select channels to remove interactively')
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1405,6 +1412,7 @@ prog
           lnd,
           logger,
           address: options.address,
+          ask: (n, cbk) => inquirer.prompt([n]).then(n => cbk(n)),
           chain_fee_rate: options.feeRate || undefined,
           fs: {getFile: readFile},
           idle_days: options.idleDays,
@@ -1415,6 +1423,7 @@ prog
           is_offline: !!options.offline,
           is_private: !!options.private,
           is_public: !!options.public,
+          is_selecting_channels: options.selectChannels || undefined,
           omit: flatten([options.omit].filter(n => !!n)),
           outbound_liquidity_below: options.outboundBelow,
           outpoints: flatten([options.outpoint].filter(n => !!n)),
@@ -1455,6 +1464,7 @@ prog
   .option('--dryrun', 'Avoid actually sending funds')
   .option('--in <pubkey_or_alias>', 'Route in through a specific node')
   .option('--max-fee <fee>', 'Maximum fee tokens', INT, 1337)
+  .option('--max-fee-rate <max_fee_rate>', 'Max fee rate in PPM to pay', INT)
   .option('--message <message>', 'Message to include with payment')
   .option('--message-omit-from-key', 'Leave out the from key on messages')
   .option('--no-color', 'Mute all colors')
@@ -1475,6 +1485,7 @@ prog
           is_omitting_message_from: options.messageOmitFromKey,
           lnd: (await lndForNode(logger, options.node)).lnd,
           max_fee: options.maxFee,
+          max_fee_rate: options.maxFeeRate,
           message: options.message,
           quiz_answers: flatten([options.quiz].filter(n => !!n)),
           out_through: options.out,

package/commands/api.json

@@ -242,6 +242,20 @@
       ],
       "method": "enableChannel"
     },
+    {
+      "arguments": [
+        {
+          "description": "Base PSBT to fund",
+          "named": "psbt"
+        },
+        {
+          "description": "Fee rate per vbyte to use for funding",
+          "named": "fee_tokens_per_vbyte",
+          "optional": true
+        }
+      ],
+      "method": "fundPsbt"
+    },
     {
       "method": "getAccessIds"
     },
@@ -582,6 +596,13 @@
       ],
       "method": "openChannel"
     },
+    {
+      "arguments": [{
+        "description": "Funded PSBT Hex String",
+        "named": "psbt"
+      }],
+      "method": "partiallySignPsbt"
+    },
     {
       "arguments": [
         {
@@ -689,6 +710,13 @@
       }],
       "method": "signMessage"
     },
+    {
+      "arguments": [{
+        "description": "Funded PSBT to sign and finalize",
+        "named": "psbt"
+      }],
+      "method": "signPsbt"
+    },
     {
       "method": "stopDaemon"
     },

package/lnd/find_record.js

@@ -236,6 +236,7 @@ module.exports = ({lnd, query}, cbk) => {
                 .map(chan => {
                   const [height] = chan.id.split('x');
                   const local = formatTokens({tokens: chan.local_balance});
+                  const pending = chan.pending_payments;
                   const remote = formatTokens({tokens: chan.remote_balance});
 
                   const inbound = `in: ${balance(remote)}`;
@@ -248,6 +249,7 @@ module.exports = ({lnd, query}, cbk) => {
                     capacity: formatTokens({tokens: chan.capacity}).display,
                     funding: `${chan.transaction_id} ${chan.transaction_vout}`,
                     peer_created: chan.is_partner_initiated || undefined,
+                    pending_payments: !!pending.length ? pending : undefined,
                   };
                 }),
             }

package/network/push_payment.js

@@ -16,6 +16,7 @@ const probeDestination = require('./probe_destination');
 
 const coins = ['BTC', 'LTC'];
 const defaultFiatRateProvider = 'coingecko';
+const feeTokensForFeeRate = (tokens, rate) => Math.floor(rate * tokens / 1e6);
 const fiats = ['EUR', 'USD'];
 const hasFiat = n => /(eur|usd)/gim.test(n);
 const {isArray} = Array;
@@ -23,6 +24,7 @@ const isPublicKey = n => /^[0-9A-F]{66}$/i.test(n);
 const maxQuizLength = 10;
 const rateAsTokens = rate => 1e8 / rate;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
+const {min} = Math;
 const minQuiz = 2;
 const minTokens = 1;
 const networks = {btc: 'BTC', btctestnet: 'BTC', ltc: 'LTC'};
@@ -45,6 +47,7 @@ const utf8AsHex = n => Buffer.from(n, 'utf8').toString('hex');
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     max_fee: <Maximum Fee Tokens Number>
+    [max_fee_rate]: <Max Fee Rate Tokens Per Million Number>
     [message]: <Message to Include With Payment String>
     [out_through]: <Pay Out Through Peer String>
     quiz_answers: [<Quiz Answer String>]
@@ -346,7 +349,18 @@ module.exports = (args, cbk) => {
         };
 
         try {
-          return cbk(null, parseAmount({variables, amount: args.amount}));
+          const {tokens} = parseAmount({variables, amount: args.amount});
+
+          // Exit early when there is no max fee rate to compute max fee for
+          if (!!args.max_fee_rate === undefined) {
+            return cbk(null, {tokens, max_fee: args.mage_fee});
+          }
+
+          // Compute the max potential fee given the max fee rate constraint
+          const maxFeeByRate = feeTokensForFeeRate(tokens, args.max_fee_rate);
+
+          // The maximum fee to pay is the lower of the fee limit, fee by rate
+          return cbk(null, {tokens, max_fee: min(args.max_fee, maxFeeByRate)});
         } catch (err) {
           return cbk([400, 'FailedToParsePushAmount', err]);
         }
@@ -384,7 +398,7 @@ module.exports = (args, cbk) => {
           is_omitting_message_from: args.is_omitting_message_from,
           is_push: payment.is_push,
           is_real_payment: true,
-          max_fee: args.max_fee,
+          max_fee: parseAmount.max_fee,
           message: args.message,
           messages: args.quiz_answers.map((answer, i) => ({
             type: (quizStart + i).toString(),

package/network/remove_peer.js

@@ -1,6 +1,7 @@
 const asyncAuto = require('async/auto');
 const asyncEachSeries = require('async/eachSeries');
 const {closeChannel} = require('ln-service');
+const {decodeChanId} = require('bolt07');
 const {getChainFeeRate} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getNetwork} = require('ln-sync');
@@ -11,20 +12,25 @@ const getPeers = require('./get_peers');
 
 const arrayWithEntries = arr => !!arr.length ? arr : undefined;
 const asOutpoint = n => `${n.transaction_id}:${n.transaction_vout}`;
+const estimateDisk = n => Math.round(n * 500 / 1e6 * 10) / 10;
 const fastConf = 6;
 const {floor} = Math;
 const defaultDays = 365 * 2;
 const getMempoolRetries = 10;
+const iconDisabled = channel => !channel.is_active ? '💀 ' : '';
+const iconPending = channel => channel.pending_payments.length ? '💸 ' : ''
 const {isArray} = Array;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const maxMempoolSize = 2e6;
 const regularConf = 72;
 const slowConf = 144;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Close out channels with a peer and disconnect them
 
   {
     [address]: <Close Out Funds to On-Chain Address String>
+    ask: <Ask Function>
     [chain_fee_rate]: <Chain Fee Per VByte Number>
     fs: {
       getFile: <Read File Contents Function> (path, cbk) => {}
@@ -37,6 +43,7 @@ const slowConf = 144;
     [is_offline]: <Peer Is Disconnected Bool>
     [is_private]: <Peer is Privately Connected Bool>
     [is_public]: <Peer is Publicly Connected Bool>
+    [is_selecting_channels]: <Interactively Select Channels to Remove Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     [omit]: [<Avoid Peer With Public Key String>]
@@ -53,10 +60,18 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToRemovePeer']);
+        }
+
         if (!args.fs) {
           return cbk([400, 'ExpectedFsMethodsToRemovePeer']);
         }
 
+        if (!!args.is_selecting_channels && !args.public_key) {
+          return cbk([400, 'ExpectedPeerToRemoveWhenSelectingChannels']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'LndIsRequiredToRemovePeer']);
         }
@@ -69,6 +84,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedSpecificOutpointsToRemoveFromPeer']);
         }
 
+        if (!!args.outpoints.length && !args.public_key) {
+          return cbk([400, 'ExpectedPeerToRemoteWhenOutpointsSpecified']);
+        }
+
         if (!!args.public_key && !isPublicKey(args.public_key)) {
           return cbk([400, 'ExpectedPublicKeyOfPeerToRemove']);
         }
@@ -137,8 +156,94 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Determine outpoints to use
+      outpoints: ['getChannels', ({getChannels}, cbk) => {
+        // Exit early when a peer is not specified
+        if (!args.public_key) {
+          return cbk(null, []);
+        }
+
+        const channelsWithPeer = getChannels.channels
+          .filter(channel => {
+            // Ignore channels that are not the specified public key
+            if (channel.partner_public_key !== args.public_key) {
+              return false;
+            }
+
+            //Return channels with the peer
+            return true;
+          })
+          .sort((a, b) => {
+            const heightA = decodeChanId({channel: a.id}).block_height;
+            const heightB = decodeChanId({channel: b.id}).block_height;
+
+            // Sort channels by oldest to newest
+            return heightA - heightB;
+          });
+
+        // Exit early when no channels are available
+        if (!channelsWithPeer.length) {
+          return cbk([404, 'NoChannelsToCloseWithSpecifiedPeer']);
+        }
+
+        // Collect any outpoints that are unable to be cooperatively closed
+        const blocked = channelsWithPeer
+          .filter(channel => {
+            // Channels that are inactive or have HTLCs cannot be coop-closed
+            return !channel.is_active || !!channel.pending_payments.length;
+          })
+          .map(channel => asOutpoint(channel));
+
+        // Find a directly referenced outpoint that is in the blocked list
+        const blockedOutpoint = args.outpoints.find(n => blocked.includes(n));
+
+        // Make sure we aren't trying to coop close a channel that can't be
+        if (!args.is_forced && !!blockedOutpoint) {
+          return cbk([400, 'CannotCoopClose', {outpoint: blockedOutpoint}]);
+        }
+
+        // Exit early if not selecting a channel
+        if (!args.is_selecting_channels) {
+          return cbk(null, args.outpoints);
+        }
+
+        // Interactively select outpoints to close
+        return args.ask({
+          choices: channelsWithPeer.map(channel => {
+            // In closing, channels are identified by their funding outpoint
+            const value = asOutpoint(channel);
+
+            // Channels that are inactive or have HTLCs cannot be coop-closed
+            const isBlocked = blocked.includes(value);
+
+            const disk = `Est disk mb: ${estimateDisk(channel.past_states)}`;
+            const icon = iconDisabled(channel) || iconPending(channel);
+            const {id} = channel;
+            const inbound = `in: ${tokensAsBigUnit(channel.remote_balance)}`;
+            const outbound = `out: ${tokensAsBigUnit(channel.local_balance)}`;
+
+            return {
+              value,
+              checked: args.outpoints.includes(value),
+              disabled: !args.is_forced ? isBlocked : false,
+              name: `${icon}${id}: ${inbound} | ${outbound}. ${disk}.`,
+            };
+          }),
+          loop: false,
+          message: `Channels to ${!!args.is_forced ? 'force ' : ''}close?`,
+          name: 'outpoints',
+          type: 'checkbox',
+          validate: input => !!input.length,
+        },
+        ({outpoints}) => cbk(null, outpoints));
+      }],
+
       // Check channels for peer to make sure that they can be cleanly closed
-      checkChannels: ['getChannels', ({getChannels}, cbk) => {
+      checkChannels: [
+        'getChannels',
+        'outpoints',
+        ({getChannels, outpoints}, cbk) =>
+      {
         // Exit early when a peer is not specified or force closing is OK
         if (!args.public_key || !!args.is_forced) {
           return cbk();
@@ -151,12 +256,12 @@ module.exports = (args, cbk) => {
           }
 
           // Exit early when there are no outpoints, consider all peer channels
-          if (!args.outpoints.length) {
+          if (!outpoints.length) {
             return true;
           }
 
           // Only include selected channels
-          return args.outpoints.includes(asOutpoint(channel));
+          return outpoints.includes(asOutpoint(channel));
         });
 
         const costToClose = selectedChannels
@@ -279,8 +384,9 @@ module.exports = (args, cbk) => {
         'checkChannels',
         'getChannels',
         'getNormalFee',
+        'outpoints',
         'selectPeer',
-        ({getChannels, getNormalFee, selectPeer}, cbk) =>
+        ({getChannels, getNormalFee, outpoints, selectPeer}, cbk) =>
       {
         // Exit early when there is no peer to close out with
         if (!selectPeer) {
@@ -292,11 +398,12 @@ module.exports = (args, cbk) => {
         const toClose = getChannels.channels
           .filter(chan => chan.partner_public_key === selectPeer.public_key)
           .filter(chan => {
-            if (!args.outpoints.length)  {
+            // When no outpoints are specified, all channels should be closed
+            if (!outpoints.length) {
               return true;
             }
 
-            return args.outpoints.includes(asOutpoint(chan));
+            return !!outpoints.includes(asOutpoint(chan));
           });
 
         // Exit early when there are no channels to close

package/package.json

@@ -36,7 +36,7 @@
     "invoices": "2.0.3",
     "ln-accounting": "5.0.5",
     "ln-service": "53.6.0",
-    "ln-sync": "3.8.0",
+    "ln-sync": "3.9.0",
     "ln-telegram": "3.12.0",
     "moment": "2.29.1",
     "paid-services": "3.11.0",
@@ -52,7 +52,7 @@
   "description": "Lightning balance CLI",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.10",
-    "ln-docker-daemons": "2.2.1",
+    "ln-docker-daemons": "2.2.2",
     "mock-lnd": "1.4.1",
     "secp256k1": "4.0.3"
   },
@@ -81,5 +81,5 @@
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t alexbosworth/balanceofsatoshis --push .",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 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/peers/*.js test/responses/*.js test/routing/*.js test/services/*.js test/swaps/*.js test/tags/*.js test/wallets/*.js"
   },
-  "version": "11.40.0"
+  "version": "11.44.0"
 }

package/peers/limit_forwarding.js

@@ -4,6 +4,8 @@ const {returnResult} = require('asyncjs-util');
 
 const disableAllForwards = 0;
 const hoursAsSeconds = hours => hours * 60 * 60;
+const {isArray} = Array;
+const isEdge = n => !!n && /^[0-9A-F]{66}\/[0-9A-F]{66}$/i.test(n);
 
 /** Limit forwarding requests
 
@@ -11,8 +13,10 @@ const hoursAsSeconds = hours => hours * 60 * 60;
     lnd: (await lndForNode(logger, options.node)).lnd,
     logger: <Winston Logger Object>
     [is_disabling_all_forwards]: <All Forwards Are Disabled Bool>
-    [max_hours_since_last_block]: options.maxHoursSinceLastBlock,
-    [max_new_pending_per_hour]: options.maxNewPendingPerHour,
+    [max_hours_since_last_block]: <Maximum Hours Since Last Block Number>
+    [max_new_pending_per_hour]: <Maximum Outstanding New HTLCs Per Hour Number>
+    [min_channel_confirmations]: <Minimum Required Channel Confs Number>
+    only_allow: [<In Public Key / Out Public Key String>]
   }
 
   @returns via cbk or Promise
@@ -22,6 +26,14 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!isArray(args.only_allow)) {
+          return cbk([400, 'ExpectedOnlyAllowArrayToLimitForwarding']);
+        }
+
+        if (!!args.only_allow.filter(n => !isEdge(n)).length) {
+          return cbk([400, 'ExpectedOnlyAllowAsPublicKeyPairs']);
+        }
+
         if (!args.logger) {
           return cbk([400, 'ExpectedWinstonLoggerToLimitForwarding']);
         }
@@ -55,11 +67,25 @@ module.exports = (args, cbk) => {
         return cbk(null, hoursAsSeconds(args.max_hours_since_last_block));
       }],
 
+      // Only allow pairs
+      onlyAllow: ['validate', ({}, cbk) => {
+        if (!args.only_allow.length) {
+          return cbk();
+        }
+
+        const allow = args.only_allow.map(([inKey, outKey]) => {
+          return {inbound_peer: inKey, outbound_peer: outKey};
+        });
+
+        return cbk(null, allow);
+      }],
+
       // Limit forward requests
       limit: [
         'maxPendingPerHour',
         'maxSecondsSinceLastBlock',
-        ({maxPendingPerHour, maxSecondsSinceLastBlock}, cbk) =>
+        'onlyAllow',
+        ({maxPendingPerHour, maxSecondsSinceLastBlock, onlyAllow}, cbk) =>
       {
         args.logger.info({limiting_forwards: true});
 
@@ -67,6 +93,8 @@ module.exports = (args, cbk) => {
           lnd: args.lnd,
           max_new_pending_per_hour: maxPendingPerHour,
           max_seconds_since_last_block: maxSecondsSinceLastBlock,
+          min_activation_age: args.min_channel_confirmations || undefined,
+          only_allow: onlyAllow,
         });
 
         sub.on('error', err => {

package/services/initiate_balanced_channel.js

@@ -41,6 +41,7 @@ const giveTokens = capacity => Math.ceil(capacity / 2);
 const hasInbound = channels => !!channels.find(n => !!n.remote_balance);
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const idAsHash = id => Buffer.from(id, 'hex').reverse();
+const {isInteger} = Number;
 const isNumber = n => !isNaN(n);
 const isOdd = n => n % 2;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
@@ -237,11 +238,11 @@ module.exports = (args, cbk) => {
           default: round(getChainFee.tokens_per_vbyte),
           message: 'Fee rate per vbyte for the joint funding transaction?',
           name: 'rate',
-          type: 'number',
+          validate: n => !!isNumber(n) && !!Number(n) && isInteger(Number(n)),
         };
 
         return args.ask(feeRate, ({rate}) => {
-          if (!isNumber(rate)) {
+          if (!isNumber(Number(rate))) {
             return cbk([400, 'ExpectedFeeRatePerVirtualByteToProposeChannel']);
           }
 

package/swaps/rebalance.js

@@ -43,7 +43,6 @@ const isPublicKey = n => /^[0-9A-F]{66}$/i.test(n);
 const legacyMaxRebalanceTokens = 4294967;
 const {max} = Math;
 const maxPaymentSize = 4294967;
-const maxRebalanceTokens = 16777215;
 const {min} = Math;
 const minInboundBalance = 4294967 * 2;
 const minRebalanceAmount = 5e4;
@@ -632,7 +631,7 @@ module.exports = (args, cbk) => {
           lnd,
           cltv_delta: defaultCltvDelta,
           description: 'Rebalance',
-          tokens: min(maxRebalanceTokens, findRoute.route_maximum),
+          tokens: findRoute.route_maximum,
         },
         cbk);
       }],