balanceofsatoshis 23.1.7 → 23.1.9

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## 23.1.7
+## 23.1.9
+
+- `rebalance`: Apply `--in-filter` and `--out-filter` to key and alias peers
+
+## 23.1.8
 
 - Add support for LND 0.21.2
 - Add support for LND 0.20.3

package/bos

@@ -4,6 +4,7 @@ const {lstat} = require('fs');
 const {mkdir} = require('fs');
 const {readdir} = require('fs');
 const {readFile} = require('fs');
+const {rename} = require('fs');
 const {rmdir} = require('fs');
 const {spawn} = require('child_process');
 const {statSync} = require('fs');
@@ -1734,7 +1735,7 @@ prog
   .option('--avoid-high-fee-routes', 'Avoid trying routes above max-fee-rate')
   .option('--avoid-list', 'Path to file with newline separated list of avoids')
   .option('--in <pubkey_or_alias>', 'Route in through a specific peer')
-  .option('--in-filter <in_filter>', 'Filter inbound tag nodes', REPEATABLE)
+  .option('--in-filter <in_filter>', 'Filter inbound peer/tag', REPEATABLE)
   .option('--in-target-outbound <amt>', 'Balance up to outbound amount')
   .option('--max-fee <max_fee>', 'Maximum fee to pay')
   .option('--max-fee-rate <max_fee_rate>', 'Max fee rate to pay')
@@ -1742,7 +1743,7 @@ prog
   .option('--no-color', 'Mute all colors')
   .option('--node <node_name>', 'Saved node to use for rebalance')
   .option('--out <pubkey_or_alias>', 'Route out through a specific peer')
-  .option('--out-filter <out_filter>', 'Filter outbound tag nodes', REPEATABLE)
+  .option('--out-filter <out_filter>', 'Filter outbound peer/tag', REPEATABLE)
   .option('--out-target-inbound <amount>', 'Balance up to inbound amount')
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
@@ -1752,7 +1753,7 @@ prog
           avoid: flatten([options.avoid].filter(n => !!n)),
           avoid_append: options.avoidAppend || undefined,
           avoid_list: options.avoidList || undefined,
-          fs: {appendFile, writeFile, getFile: readFile},
+          fs: {appendFile, writeFile, getFile: readFile, renameFile: rename},
           in_filters: flatten([options.inFilter].filter(n => !!n)),
           in_outbound: options.inTargetOutbound || undefined,
           in_through: options.in || undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "allowScripts": {
-    "protobufjs@7.6.5": true,
+    "protobufjs@7.6.6": true,
     "ssh2@1.17.0": true,
     "cpu-features@0.0.10": true
   },
@@ -15,7 +15,7 @@
     "url": "https://github.com/alexbosworth/balanceofsatoshis/issues"
   },
   "dependencies": {
-    "@alexbosworth/blockchain": "4.5.1",
+    "@alexbosworth/blockchain": "4.5.3",
     "@alexbosworth/caporal": "2.0.0",
     "@alexbosworth/fiat": "2.0.0",
     "@alexbosworth/formulas": "1.4.0",
@@ -35,13 +35,13 @@
     "colorette": "2.0.20",
     "csv-parse": "7.0.2",
     "goldengate": "16.0.6",
-    "grammy": "1.45.1",
+    "grammy": "1.46.0",
     "import-lazy": "4.0.0",
     "ini": "7.0.0",
-    "inquirer": "14.1.0",
+    "inquirer": "14.2.0",
     "ln-accounting": "10.0.5",
-    "ln-service": "59.3.4",
-    "ln-sync": "8.0.5",
+    "ln-service": "59.3.5",
+    "ln-sync": "8.0.6",
     "ln-telegram": "8.0.5",
     "moment": "2.30.1",
     "paid-services": "8.0.6",
@@ -55,7 +55,7 @@
   },
   "description": "Lightning balance CLI",
   "devDependencies": {
-    "invoices": "6.1.3",
+    "invoices": "6.1.4",
     "ln-docker-daemons": "8.0.4"
   },
   "engines": {
@@ -83,5 +83,5 @@
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
     "test": "node --experimental-test-coverage --test 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/telegram/*.js test/wallets/*.js"
   },
-  "version": "23.1.7"
+  "version": "23.1.9"
 }

package/peers/find_peer_match.js

@@ -0,0 +1,109 @@
+const {decodeChanId} = require('bolt07');
+
+const {shuffle} = require('./../arrays');
+const {isMatchingFilters} = require('./../display');
+
+const channelHeight = channel => decodeChanId({channel}).block_height;
+const {max} = Math;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
+const tok = n => Number(BigInt(n) / BigInt(1e3));
+const uniq = arr => Array.from(new Set(arr));
+
+/** Find a peer that matches filters
+
+  {
+    channels: [{
+      capacity: <Channel Token Capacity Number>
+      id: <Standard Format Channel Id String>
+      local_balance: <Channel Local Balance Tokens Number>
+      partner_public_key: <Peer Public Key Hex String>
+      pending_payments: [<Pending Payment Object>]
+      remote_balance: <Channel Remote Balance Tokens Number>
+    }]
+    [filters]: [<Filter Expression String>]
+    policies: [{
+      [base_fee_mtokens]: <Remote Base Fee Charged In Millitokens Number>
+      [fee_rate]: <Remote Fees Charged in Millitokens Per Million Number>
+      [is_disabled]: <Remote Channel Forwarding Is Disabled Bool>
+      public_key: <Remote Public Key Hex String>
+    }]
+    nodes: [<Candidate Peer Public Key Hex String>]
+  }
+
+  @returns
+  {
+    [failure]: {
+      error: <Error String>
+      formula: <Errored Formula String>
+    }
+    [match]: <Matching Peer Public Key Hex String>
+  }
+*/
+module.exports = ({channels, filters, nodes, policies}) => {
+  const disabled = policies.filter(n => n.is_disabled).map(n => n.public_key);
+
+  const peers = channels.map(n => n.partner_public_key)
+    .filter(n => !disabled.includes(n));
+
+  const candidates = uniq((nodes || [])
+    .filter(n => peers.includes(n)));
+
+  // Filter out peers that do not fulfill the supplied criteria
+  const candidateResults = candidates
+    .map(key => {
+      if (!filters || !filters.length) {
+        return {match: key};
+      }
+
+      const peerPolicies = policies.filter(n => n.public_key === key);
+      const withPeer = channels.filter(n => n.partner_public_key === key);
+
+      const feeRates = peerPolicies.filter(n => n.fee_rate !== undefined);
+      const pendingPayments = withPeer.map(n => n.pending_payments.length);
+
+      const maxBaseFee = max(...feeRates.map(n => tok(n.base_fee_mtokens)));
+      const maxFeeRate = max(...feeRates.map(n => n.fee_rate));
+
+      const variables = {
+        capacity: sumOf(withPeer.map(n => n.capacity)),
+        heights: withPeer.map(n => channelHeight(n.id)),
+        inbound_liquidity: sumOf(withPeer.map(n => n.remote_balance)),
+        outbound_liquidity: sumOf(withPeer.map(n => n.local_balance)),
+        pending_payments: sumOf(pendingPayments),
+      };
+
+      if (!!feeRates.length) {
+        variables.inbound_base_fee = maxBaseFee;
+        variables.inbound_fee_rate = maxFeeRate;
+      }
+
+      const matching = isMatchingFilters({variables, filters: filters || []});
+
+      if (!!matching.failure) {
+        return matching;
+      }
+
+      if (!matching.is_matching) {
+        return;
+      }
+
+      return {match: key};
+    })
+    .filter(n => !!n);
+
+  // Exit early when there is no match
+  if (!candidateResults.length) {
+    return {};
+  }
+
+  // Exit early when there is a failure in a candidate
+  if (!!candidateResults.find(n => !!n.failure)) {
+    return candidateResults.find(n => !!n.failure);
+  }
+
+  const {shuffled} = shuffle({array: candidateResults});
+
+  const [{match}] = shuffled;
+
+  return {match};
+};

package/peers/find_tag_match.js

@@ -1,12 +1,4 @@
-const {decodeChanId} = require('bolt07');
-
-const flatten = arr => [].concat(...arr);
-const {shuffle} = require('./../arrays');
-const {isMatchingFilters} = require('./../display');
-
-const {max} = Math;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
-const tok = n => Number(BigInt(n) / BigInt(1e3));
+const findPeerMatch = require('./find_peer_match');
 
 /** Find a node for a tag query
 
@@ -40,6 +32,7 @@ const tok = n => Number(BigInt(n) / BigInt(1e3));
       formula: <Errored Formula String>
     }
     [match]: <Matching Node Public Key Hex String>
+    [is_tag_filtered]: <Tag Matched But All Nodes Failed Filters Bool>
     [matches]: [{
       [alias]: <Tag Alias String>
       id: <Tag Id Hex String>
@@ -54,14 +47,8 @@ module.exports = ({channels, filters, policies, tags, query}) => {
     .map(n => n.partner_public_key)
     .filter(n => !disabled.includes(n));
 
-  // Find tags that match on id or on alias, and also have relevant nodes
-  const matches = tags.filter(tag => {
-    const nodes = (tag.nodes || []).filter(n => peerKeys.includes(n));
-
-    if (!nodes.length) {
-      return false;
-    }
-
+  // Find tags that match on id or on alias
+  const tagMatches = tags.filter(tag => {
     const alias = tag.alias || String();
 
     const isAliasMatch = alias.toLowerCase() === (query || '').toLowerCase();
@@ -70,9 +57,18 @@ module.exports = ({channels, filters, policies, tags, query}) => {
     return isAliasMatch || isIdMatch;
   });
 
+  // Limit tag matches to tags with relevant peers
+  const matches = tagMatches.filter(tag => {
+    return (tag.nodes || []).some(n => peerKeys.includes(n));
+  });
+
   const [tagMatch, ...otherTagMatches] = matches;
 
   // Exit early when there are no matches at all
+  if (!tagMatch && !!tagMatches.length && !!filters && !!filters.length) {
+    return {is_tag_filtered: true};
+  }
+
   if (!tagMatch) {
     return {};
   }
@@ -82,68 +78,16 @@ module.exports = ({channels, filters, policies, tags, query}) => {
     return {matches};
   }
 
-  // Get the array of nodes in the tag match
-  const tagMatches = tagMatch.nodes.filter(n => peerKeys.includes(n));
-
-  // Filter out matches in the array of peers that do not fulfill criteria
-  const array = tagMatches
-    .map(key => {
-      if (!filters || !filters.length) {
-        return {match: key};
-      }
-
-      const peerPolicies = policies.filter(n => n.public_key === key);
-      const withPeer = channels.filter(n => n.partner_public_key === key);
-
-      const feeRates = peerPolicies.filter(n => n.fee_rate !== undefined);
-      const pendingPayments = withPeer.map(n => n.pending_payments.length);
-
-      const maxBaseFee = max(...feeRates.map(n => tok(n.base_fee_mtokens)));
-      const maxFeeRate = max(...feeRates.map(n => n.fee_rate));
-
-      const variables = {
-        capacity: sumOf(withPeer.map(n => n.capacity)),
-        heights: withPeer.map(n => {
-          return decodeChanId({channel: n.id}).block_height;
-        }),
-        inbound_liquidity: sumOf(withPeer.map(n => n.remote_balance)),
-        outbound_liquidity: sumOf(withPeer.map(n => n.local_balance)),
-        pending_payments: sumOf(pendingPayments),
-      };
-
-      if (!!feeRates.length) {
-        variables.inbound_base_fee = maxBaseFee;
-        variables.inbound_fee_rate = maxFeeRate;
-      }
-
-      const matching = isMatchingFilters({variables, filters: filters || []});
-
-      if (!!matching.failure) {
-        return matching;
-      }
-
-      if (!matching.is_matching) {
-        return;
-      }
-
-      return {match: key};
-    })
-    .filter(n => !!n);
-
-  // Exit early when there is no match
-  if (!array.length) {
-    return {};
-  }
+  const {failure, match} = findPeerMatch({
+    channels,
+    filters,
+    policies,
+    nodes: tagMatch.nodes.filter(n => peerKeys.includes(n)),
+  });
 
-  // Exit early when there is a failure in the tag
-  if (!!array.find(n => !!n.failure)) {
-    return array.find(n => !!n.failure);
+  if (!failure && !match && !!filters && !!filters.length) {
+    return {is_tag_filtered: true};
   }
 
-  // Shuffle the results
-  const {shuffled} = shuffle({array});
-
-  const [{match}] = shuffled;
-
-  return {match};
+  return {failure, match};
 };

package/swaps/find_rebalance_peer.js

@@ -0,0 +1,149 @@
+const asyncAuto = require('async/auto');
+const {findKey} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const findPeerMatch = require('./../peers/find_peer_match');
+const findTagMatch = require('./../peers/find_tag_match');
+
+/** Find a peer for a rebalance
+
+  {
+    active_channels: [{
+      capacity: <Channel Token Capacity Number>
+      id: <Standard Format Channel Id String>
+      local_balance: <Channel Local Balance Tokens Number>
+      partner_public_key: <Peer Public Key Hex String>
+      pending_payments: [<Pending Payment Object>]
+      remote_balance: <Channel Remote Balance Tokens Number>
+    }]
+    channels: [{
+      partner_public_key: <Peer Public Key Hex String>
+    }]
+    direction: <In or Out Direction String>
+    [filters]: [<Peer Filter Formula String>]
+    lnd: <Authenticated LND API Object>
+    policies: [{
+      [base_fee_mtokens]: <Remote Base Fee Charged In Millitokens Number>
+      [fee_rate]: <Remote Fees Charged in Millitokens Per Million Number>
+      [is_disabled]: <Remote Channel Forwarding Is Disabled Bool>
+      public_key: <Remote Public Key Hex String>
+    }]
+    [query]: <Tag, Public Key, or Alias String>
+    tags: [{
+      [alias]: <Tag Alias String>
+      id: <Tag Id Hex String>
+      [nodes]: [<Public Key Hex String>]
+    }]
+  }
+
+  @returns via cbk or Promise
+  {
+    [public_key]: <Peer Public Key Hex String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (args.direction !== 'in' && args.direction !== 'out') {
+          return cbk([400, 'ExpectedInOrOutDirectionToFindRebalancePeer']);
+        }
+
+        return cbk();
+      },
+
+      // Find a tag, preserving tag precedence over peer aliases
+      tag: ['validate', ({}, cbk) => {
+        const filters = args.filters || [];
+
+        if (!args.query && !!filters.length) {
+          if (args.direction === 'in') {
+            return cbk([400, 'NoPeerMatchesFoundToSatisfyInboundFilter']);
+          }
+
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+        }
+
+        const {failure, is_tag_filtered, match, matches} = findTagMatch({
+          filters,
+          channels: args.active_channels,
+          policies: args.policies,
+          query: args.query,
+          tags: args.tags,
+        });
+
+        if (!!failure) {
+          return cbk([400, 'FailedToParseFilter', failure]);
+        }
+
+        if (!!matches) {
+          if (args.direction === 'in') {
+            return cbk([400, 'MultipleTagMatchesFoundForInPeer', {matches}]);
+          }
+
+          return cbk([400, 'MultipleTagMatchesFoundForOutPeer', {matches}]);
+        }
+
+        if (!!is_tag_filtered && args.direction === 'in') {
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyInboundFilter']);
+        }
+
+        if (!!is_tag_filtered) {
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+        }
+
+        if (!!match) {
+          return cbk(null, {public_key: match});
+        }
+
+        return cbk();
+      }],
+
+      // Resolve a public key or node alias when the query was not a tag
+      key: ['tag', ({tag}, cbk) => {
+        if (!!tag) {
+          return cbk(null, tag);
+        }
+
+        return findKey({
+          lnd: args.lnd,
+          channels: args.channels,
+          query: args.query,
+        },
+        cbk);
+      }],
+
+      // Apply filters to the single explicitly resolved peer
+      peer: ['key', 'tag', ({key, tag}, cbk) => {
+        const filters = args.filters || [];
+
+        if (!!tag || !filters.length) {
+          return cbk(null, key);
+        }
+
+        const {failure, match} = findPeerMatch({
+          filters,
+          channels: args.active_channels,
+          nodes: [key.public_key.toLowerCase()],
+          policies: args.policies,
+        });
+
+        if (!!failure) {
+          return cbk([400, 'FailedToParseFilter', failure]);
+        }
+
+        if (!match && args.direction === 'in') {
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyInboundFilter']);
+        }
+
+        if (!match) {
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+        }
+
+        return cbk(null, {public_key: match});
+      }],
+    },
+    returnResult({reject, resolve, of: 'peer'}, cbk));
+  });
+};

package/swaps/get_avoid_list.js

@@ -0,0 +1,53 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const matchNewLines = /\r?\n/;
+const trim = n => n.trim();
+const uniq = arr => Array.from(new Set(arr));
+
+/** Get the list of avoid directives from an avoid list file
+
+  {
+    fs: {
+      getFile: <Read File Contents Function> (path, cbk) => {}
+    }
+    path: <Path To Avoid List File String>
+  }
+
+  @returns via cbk or Promise
+  {
+    lines: [<Avoid Directive Line String>]
+  }
+*/
+module.exports = ({fs, path}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!fs) {
+          return cbk([400, 'ExpectedFilesystemMethodsToGetAvoidList']);
+        }
+
+        if (!path) {
+          return cbk([400, 'ExpectedPathToAvoidListFileToGetAvoidList']);
+        }
+
+        return cbk();
+      },
+
+      // Get the lines of the avoid list file
+      getList: ['validate', ({}, cbk) => {
+        return fs.getFile(path, (err, res) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingAvoidListFile', {err}]);
+          }
+
+          const lines = res.toString().split(matchNewLines).map(trim);
+
+          return cbk(null, {lines: uniq(lines.filter(n => !!n))});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getList'}, cbk));
+  });
+};