balanceofsatoshis 11.36.3 → 11.40.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Versions
 
+## 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`
+
 ## 11.36.3
 
 - `telegram`: Add support for `--use-proxy` to specify a SOCKS proxy server

package/bos

@@ -98,19 +98,27 @@ 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) => {
       try {
         return await services.advertise({
           logger,
+          budget: options.budget || undefined,
           filters: flatten([options.filter].filter(n => !!n)),
           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}));
@@ -816,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)
@@ -1138,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)

package/commands/constants.json

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

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/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.36.3"
+  "version": "11.40.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);
 
-            return cbk(null, isRoutingPossible);
+            // 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);
+            }
+
+            // There exists a route to the destination within range constraints
+            return cbk(null, true);
           });
         },
         cbk);
@@ -164,11 +191,22 @@ module.exports = (args, cbk) => {
 
       // Send message to nodes
       send: ['message', 'nodes', ({message, nodes}, cbk) => {
+        const maxSpendPerNode = sendTokens + maxFeeTokens;
         const sent = [];
 
         args.logger.info({routable_nodes: nodes.length});
 
         return asyncMapSeries(nodes, (node, cbk) => {
+          const paidTokens = ceil(Number(sent.reduce((sum, n) => {
+            return sum + BigInt(n.mtokens) + BigInt(n.fee_mtokens);
+          },
+          BigInt(Number()))) / mtokPerToken);
+
+          // Check that the potential next ad would not go over budget
+          if (!!args.budget && paidTokens + maxSpendPerNode > args.budget) {
+            return cbk([400, 'AdvertisingBudgetExhausted']);
+          }
+
           const probe = subscribeToProbeForRoute({
             cltv_delay: cltvDelay,
             destination: node.public_key,

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,