balanceofsatoshis 11.37.0 → 11.41.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Versions
 
+## 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
+- `peers`: Add `est_disk_usage_mb` to allowed `--sort` fields
+
+## 11.39.0
+
+- `limit-forwarding`: Add new command to limit allowed routing
+
+## 11.38.0
+
+- `advertise`: Add support for `--max-hops` to specify a maximum graph distance
+- `advertise`: Add support for `--min-hops` to specify a minimum graph distance
+
 ## 11.37.0
 
 - `advertise`: Add support for specifying a maximum ad spend with `--budget`

package/bos

@@ -98,10 +98,14 @@ prog
   .help('use --filter conditions to limit broadcast scope: capacity > 1*m')
   .help('--filter variables: CAPACITY/CHANNELS_COUNT/K/M')
   .help('Default filter scope: channels_count > 9')
+  .help('To only advertise to direct peers use --max-hops 0')
+  .help('To avoid advertising to direct peers use --min-hops 1')
   .option('--budget <budget>', 'Spending amount to allow for advertising', INT)
   .option('--dryrun', 'Avoid actually sending advertisements')
   .option('--filter <expression>', 'Require node match condition', REPEATABLE)
+  .option('--max-hops <max_hops>', 'Maximum number of relaying nodes', INT)
   .option('--message <message>', 'Custom advertisement message')
+  .option('--min-hops <min_hops>', 'Minimum number of relaying nodes', INT)
   .option('--node <node_name>', 'Advertise via saved node')
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
@@ -113,6 +117,8 @@ prog
           is_dry_run: !!options.dryrun,
           lnd: (await lndForNode(logger, options.node)).lnd,
           message: options.message,
+          max_hops: options.maxHops,
+          min_hops: options.minHops,
         });
       } catch (err) {
         return reject(logger.error({err}));
@@ -818,6 +824,28 @@ prog
     });
   })
 
+  // Intercept forwarding requests, enforce requirements on acceptance
+  .command('limit-forwarding', 'Enforce rules for routing payments')
+  .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)
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return await peers.limitForwarding({
+          logger,
+          is_disabling_all_forwards: options.disableForwards || undefined,
+          lnd: (await lndForNode(logger, options.node)).lnd,
+          max_hours_since_last_block: options.maxHoursSinceLastBlock,
+          max_new_pending_per_hour: options.maxNewPendingPerHour,
+        });
+      } catch (err) {
+        return reject(logger.error({err}));
+      }
+    });
+  })
+
   // Get inbound liquidity information: available inbound off-chain tokens
   .command('inbound-liquidity', 'Get inbound liquidity size')
   .option('--above <tokens>', 'Return amount above watermark', INT)
@@ -1140,8 +1168,11 @@ prog
   .help('Icons: 🤢 often d/c, 💸 active HTLC, 💀 d/c, 🌚 private')
   .help('Icons: 🧊 delayed coop close, ⏳ pending channel, 🚫 in disabled')
   .help('Icons: 🦐 limited max htlc')
-  .help('Filters can take formula expressions like inbound_liquidity > 1*m')
-  .help('Filter formula variables: AGE|INBOUND_LIQUIDITY|OUTBOUND_LIQUIDITY')
+  .help('Filters can take formula expressions to limit results')
+  .help('Filter variable AGE: "age > 144 * 7" for peers older than a week')
+  .help('Filter variable DISK_USAGE_MB: "disk_usage_mb > 9" for disk estimate')
+  .help('Filter variable INBOUND_LIQUIDITY: "inbound_liquidity > 1*m"')
+  .help('Filter variable OUTBOUND_LIQUIDITY: "outbound_liquidity > 1*m"')
   .option('--active', 'Only active peer channels')
   .option('--complete', 'Show complete set of records in non table view')
   .option('--fee-days <past_days>', 'Include fees earned over n days', INT)
@@ -1365,6 +1396,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 {
@@ -1374,6 +1406,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,
@@ -1384,6 +1417,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)),

package/commands/constants.json

@@ -9,6 +9,7 @@
   },
   "peerSortOptions": [
     "alias",
+    "est_disk_usage_mb",
     "fee_earnings",
     "first_connected",
     "inbound_fee_rate",

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/get_peers.js

@@ -30,7 +30,9 @@ const {sortBy} = require('./../arrays');
 const closedSorts = ['fee_earnings', 'first_connected'];
 const defaultInvoicesLimit = 200;
 const defaultSort = 'first_connected';
+const estimateDiskFootprint = n => Math.round(n * 500 / 1e6 * 10) / 10;
 const fromNow = epoch => !epoch ? undefined : moment(epoch * 1e3).fromNow();
+const hasDiskFilter = filter => /disk_usage_mb/gim.test(filter);
 const {isArray} = Array;
 const {max} = Math;
 const minutesPerBlock = network => network === 'ltcmainnet' ? 10 / 4 : 10;
@@ -488,6 +490,8 @@ module.exports = (args, cbk) => {
           const disabled = policies.map(n => !!n.is_disabled).filter(n => !!n);
           const feeRate = !feeRates.length ? undefined : max(...feeRates);
           const maxHtlcSizes = policies.map(n => n.max_htlc_mtokens);
+          const pastStates = sumOf(active.map(n => n.past_states));
+
           const totalCapacity = sumOf(active.map(n => n.capacity));
 
           const totalMaxHtlc = mtokensAsTokens(sumOfBig(maxHtlcSizes));
@@ -503,6 +507,7 @@ module.exports = (args, cbk) => {
             filters: args.filters || [],
             variables: {
               age: blocks,
+              disk_usage_mb: estimateDiskFootprint(pastStates),
               fee_earnings: mtokensAsTokens(feeMtokens),
               inbound_fee_rate: feeRate,
               inbound_liquidity: sumOf(channels.map(n => n.remote_balance)),
@@ -539,6 +544,7 @@ module.exports = (args, cbk) => {
           return {
             alias: node.alias,
             downtime_percentage: round(100 * (downtime / (downtime + uptime))),
+            est_disk_usage_mb: estimateDiskFootprint(pastStates),
             fee_earnings: mtokensAsTokens(feeMtokens),
             first_connected: moment().subtract(blocks * mpb, 'minutes').unix(),
             inbound_fee_rate: feeRate,
@@ -590,6 +596,7 @@ module.exports = (args, cbk) => {
               return {
                 alias: peer.alias,
                 downtime_percentage: peer.downtime_percentage,
+                est_disk_usage_mb: peer.est_disk_usage_mb,
                 fee_earnings: peer.fee_earnings,
                 first_connected: fromNow(peer.first_connected),
                 last_activity: fromNow(peer.last_activity),
@@ -615,6 +622,7 @@ module.exports = (args, cbk) => {
           return cbk(null, {
             peers: peers.peers.map(n => ({
               alias: n.alias,
+              est_disk_usage_mb: n.est_disk_usage_mb || undefined,
               fee_earnings: n.fee_earnings || undefined,
               downtime_percentage: n.downtime_percentage || undefined,
               first_connected: n.first_connected || undefined,
@@ -634,13 +642,18 @@ module.exports = (args, cbk) => {
           });
         }
 
+        const isDiskFilter = (args.filters || []).find(n => hasDiskFilter(n));
+        const isDiskSort = args.sort_by === 'est_disk_usage_mb';
         const isWideSize = !size || size.get().width > wideSizeCols;
 
+        const isShowingDisk = isDiskFilter || isDiskSort;
+
         return cbk(null, {
           peers: peers.peers,
           rows: []
             .concat([notNull([
               'Alias',
+              !!isShowingDisk ? 'Disk Mb' : null,
               'Inbound',
               'In Fee',
               'Outbound',
@@ -682,6 +695,7 @@ module.exports = (args, cbk) => {
 
               return notNull([
                 alias.display,
+                !!isShowingDisk ? peer.est_disk_usage_mb || ' ' : null,
                 inbound.display || ' ',
                 peer.inbound_fee_rate || ' ',
                 outbound.display || ' ',

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.7.1",
+    "ln-sync": "3.8.0",
     "ln-telegram": "3.12.0",
     "moment": "2.29.1",
     "paid-services": "3.11.0",
@@ -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.37.0"
+  "version": "11.41.0"
 }

package/peers/index.js

@@ -1,5 +1,11 @@
 const findTagMatch = require('./find_tag_match');
 const interceptInboundChannels = require('./intercept_inbound_channels');
+const limitForwarding = require('./limit_forwarding');
 const openChannels = require('./open_channels');
 
-module.exports = {findTagMatch, interceptInboundChannels, openChannels};
+module.exports = {
+  findTagMatch,
+  interceptInboundChannels,
+  limitForwarding,
+  openChannels,
+};

package/peers/limit_forwarding.js

@@ -0,0 +1,87 @@
+const asyncAuto = require('async/auto');
+const {enforceForwardRequestRules} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const disableAllForwards = 0;
+const hoursAsSeconds = hours => hours * 60 * 60;
+
+/** Limit forwarding requests
+
+  {
+    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,
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToLimitForwarding']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToLimitForwarding']);
+        }
+
+        return cbk();
+      },
+
+      // Max pending per hour
+      maxPendingPerHour: ['validate', ({}, cbk) => {
+        if (!!args.is_disabling_all_forwards) {
+          return cbk(null, disableAllForwards);
+        }
+
+        if (!!args.max_new_pending_per_hour) {
+          return cbk(null, args.max_new_pending_per_hour);
+        }
+
+        return cbk();
+      }],
+
+      // Max seconds allowed since the last block
+      maxSecondsSinceLastBlock: ['validate', ({}, cbk) => {
+        if (!args.max_hours_since_last_block) {
+          return cbk();
+        }
+
+        return cbk(null, hoursAsSeconds(args.max_hours_since_last_block));
+      }],
+
+      // Limit forward requests
+      limit: [
+        'maxPendingPerHour',
+        'maxSecondsSinceLastBlock',
+        ({maxPendingPerHour, maxSecondsSinceLastBlock}, cbk) =>
+      {
+        args.logger.info({limiting_forwards: true});
+
+        const sub = enforceForwardRequestRules({
+          lnd: args.lnd,
+          max_new_pending_per_hour: maxPendingPerHour,
+          max_seconds_since_last_block: maxSecondsSinceLastBlock,
+        });
+
+        sub.on('error', err => {
+          return cbk([503, 'UnexpectedErrorLimitingForwarding', {err}]);
+        });
+
+        sub.on('rejected', async rejected => {
+          const forward = `${rejected.in_channel} → ${rejected.out_channel}`;
+
+          const rejection = `${rejected.reject_reason} ${forward}`;
+
+          return args.logger.info({rejection});
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/services/advertise.js

@@ -36,6 +36,7 @@ const mtokPerToken = 1e3;
 const pathTimeoutMs = 1000 * 45;
 const payTimeoutMs = 1000 * 60;
 const probeTimeoutMs = 1000 * 60 * 2;
+const routeDistance = route => route.hops.length - 1;
 const sendTokens = 10;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
 const textMessageType = '34349334';
@@ -49,6 +50,8 @@ const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     [message]: <Message To Send String>
+    [max_hops]: <Maxmimum Relaying Nodes Number>
+    [min_hops]: <Minimum Relaying Nodes Number>
   }
 */
 module.exports = (args, cbk) => {
@@ -75,6 +78,14 @@ module.exports = (args, cbk) => {
       getGraph: ['validate', ({}, cbk) => {
         args.logger.info({sending_to_all_graph_nodes: true});
 
+        if (args.max_hops !== undefined) {
+          args.logger.info({maximum_relay_distance_allowed: args.max_hops});
+        }
+
+        if (args.min_hops !== undefined) {
+          args.logger.info({minimum_relay_distance_required: args.min_hops});
+        }
+
         return getNetworkGraph({lnd: args.lnd}, cbk);
       }],
 
@@ -154,9 +165,25 @@ module.exports = (args, cbk) => {
             tokens: sendTokens,
           },
           (err, res) => {
-            const isRoutingPossible = !!res && !!res.route;
+            // Exit early when there is a problem getting a route
+            if (!!err || !res.route) {
+              return cbk(null, false);
+            }
+
+            const relaysCount = routeDistance(res.route);
+
+            // Exit early when there are too many relaying nodes
+            if (args.max_hops !== undefined && relaysCount > args.max_hops) {
+              return cbk(null, false);
+            }
+
+            // Exit early when there are too few relaying nodes
+            if (args.min_hops !== undefined && relaysCount < args.min_hops) {
+              return cbk(null, false);
+            }
 
-            return cbk(null, isRoutingPossible);
+            // There exists a route to the destination within range constraints
+            return cbk(null, true);
           });
         },
         cbk);

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);
       }],

package/test/network/test_get_peers.js

@@ -170,6 +170,7 @@ const tests = [
     expected: {
       peers: [{
         alias: 'alias',
+        est_disk_usage_mb: undefined,
         fee_earnings: undefined,
         downtime_percentage: undefined,
         last_activity: undefined,
@@ -270,8 +271,9 @@ const tests = [
     expected: {
       peers: [{
         alias: 'alias',
-        fee_earnings: undefined,
+        est_disk_usage_mb: undefined,
         downtime_percentage: undefined,
+        fee_earnings: undefined,
         last_activity: undefined,
         inbound_fee_rate: undefined,
         inbound_liquidity: 1,