balanceofsatoshis 23.1.8 → 23.1.10

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## 23.1.10
+
+- Add support for LND 0.21.3
+- Add support for LND 0.20.4
+
+## 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

package/README.md

@@ -7,8 +7,8 @@ Commands for working with LND balances.
 
 Supported LND versions:
 
-- v0.21.0-beta to v0.21.2-beta
-- v0.20.0-beta to v0.20.3-beta
+- v0.21.0-beta to v0.21.3-beta
+- v0.20.0-beta to v0.20.4-beta
 
 ## Install
 

package/bos

@@ -1735,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')
@@ -1743,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) => {

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.7.2",
     "@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.7",
+    "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.8"
+  "version": "23.1.10"
 }

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

@@ -3,7 +3,6 @@ const asyncMap = require('async/map');
 const asyncMapSeries = require('async/mapSeries');
 const asyncRetry = require('async/retry');
 const {createInvoice} = require('ln-service');
-const {findKey} = require('ln-sync');
 const {getChannel} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
@@ -17,13 +16,14 @@ const {payViaRoutes} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {routeFromChannels} = require('ln-service');
 
-const {findTagMatch} = require('./../peers');
+const findRebalancePeer = require('./find_rebalance_peer');
 const {formatFeeRate} = require('./../display');
 const {getIgnores} = require('./../routing');
 const {homePath} = require('../storage');
 const {probeDestination} = require('./../network');
 const {sortBy} = require('./../arrays');
 
+const activeFilter = channels => channels.filter(n => !!n.is_active);
 const asRate = (fee, tokens) => ({rate: Math.ceil(fee / tokens * 1e6)});
 const {ceil} = Math;
 const channelMatch = /^\d*x\d*x\d*$/;
@@ -216,18 +216,22 @@ module.exports = (args, cbk) => {
         return getNode({lnd, public_key: getPublicKey.public_key}, cbk);
       }],
 
-      // Find inbound tag public key
-      findInTag: [
+      // Find inbound peer key
+      findInKey: [
         'getFees',
         'getInitialLiquidity',
         'getPublicKey',
         'getTags',
-        ({getFees, getInitialLiquidity, getPublicKey, getTags}, cbk) =>
+        'lnd',
+        ({getFees, getInitialLiquidity, getPublicKey, getTags, lnd}, cbk) =>
       {
         const id = getPublicKey.public_key;
 
-        const {failure, match, matches} = findTagMatch({
-          channels: getInitialLiquidity.channels.filter(n => n.is_active),
+        return findRebalancePeer({
+          lnd,
+          active_channels: activeFilter(getInitialLiquidity.channels),
+          channels: getInitialLiquidity.channels,
+          direction: 'in',
           filters: args.in_filters,
           policies: getFees.channels.map(channel => {
             const policy = channel.policies.find(n => n.public_key !== id);
@@ -239,41 +243,8 @@ module.exports = (args, cbk) => {
               public_key: policy.public_key,
             };
           }),
-          tags: getTags.tags,
-          query: args.in_through,
-        });
-
-        // Exit early when there is a filter error
-        if (!!failure) {
-          return cbk([400, 'FailedToParseFilter', failure]);
-        }
-
-        if (!!matches) {
-          return cbk([400, 'MultipleTagMatchesFoundForInPeer', {matches}]);
-        }
-
-        if (!match && !!args.in_filters && !!args.in_filters.length) {
-          return cbk([400, 'NoPeerMatchesFoundToSatisfyInboundFilter']);
-        }
-
-        return cbk(null, match);
-      }],
-
-      // Find inbound peer key if a name is specified
-      findInKey: [
-        'findInTag',
-        'getInitialLiquidity',
-        'lnd',
-        ({findInTag, getInitialLiquidity, lnd}, cbk) =>
-      {
-        if (!!findInTag) {
-          return cbk(null, findInTag);
-        }
-
-        return findKey({
-          lnd,
-          channels: getInitialLiquidity.channels,
           query: args.in_through,
+          tags: getTags.tags,
         },
         (err, res) => {
           if (!!err) {
@@ -286,14 +257,12 @@ module.exports = (args, cbk) => {
 
       // Find outbound peer key if a name is specified
       findOutKey: [
-        'findInTag',
         'getFees',
         'getInitialLiquidity',
         'getPublicKey',
         'getTags',
         'lnd',
         ({
-          findInTag,
           getFees,
           getInitialLiquidity,
           getPublicKey,
@@ -304,8 +273,11 @@ module.exports = (args, cbk) => {
       {
         const id = getPublicKey.public_key;
 
-        const {failure, match, matches} = findTagMatch({
-          channels: getInitialLiquidity.channels.filter(n => n.is_active),
+        return findRebalancePeer({
+          lnd,
+          active_channels: activeFilter(getInitialLiquidity.channels),
+          channels: getInitialLiquidity.channels,
+          direction: 'out',
           filters: args.out_filters,
           policies: getFees.channels.map(channel => {
             const policy = channel.policies.find(n => n.public_key !== id);
@@ -316,31 +288,8 @@ module.exports = (args, cbk) => {
               public_key: policy.public_key,
             };
           }),
-          tags: getTags.tags,
-          query: args.out_through,
-        });
-
-        // Exit early when there is a filter error
-        if (!!failure) {
-          return cbk([400, 'FailedToParseFilter', failure]);
-        }
-
-        if (!!matches) {
-          return cbk([400, 'MultipleTagMatchesFoundForOutPeer', {matches}]);
-        }
-
-        if (match) {
-          return cbk(null, match);
-        }
-
-        if (!match && !!args.out_filters && !!args.out_filters.length) {
-          return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
-        }
-
-        return findKey({
-          lnd,
-          channels: getInitialLiquidity.channels,
           query: args.out_through,
+          tags: getTags.tags,
         },
         (err, res) => {
           if (!!err) {
@@ -371,8 +320,7 @@ module.exports = (args, cbk) => {
       {
         const ban = ignore.filter(n => !n.channel).map(n => n.from_public_key);
 
-        const active = getInitialLiquidity.channels
-          .filter(n => !!n.is_active)
+        const active = activeFilter(getInitialLiquidity.channels)
           .filter(n => !ban.includes(n.partner_public_key));
 
         const channels = active
@@ -435,8 +383,7 @@ module.exports = (args, cbk) => {
         const ban = ignore.filter(n => !n.channel).map(n => n.from_public_key);
         const hasInThrough = !!args.in_through;
 
-        const activeChannels = getInitialLiquidity.channels
-          .filter(n => !!n.is_active)
+        const activeChannels = activeFilter(getInitialLiquidity.channels)
           .filter(n => n.partner_public_key !== getOutbound.public_key)
           .filter(n => !ban.includes(n.partner_public_key));
 

package/test/peers/test_find_tag_match.js

@@ -31,7 +31,7 @@ const tests = [
   {
     args: makeArgs({}),
     description: 'A tagged node is found',
-    expected: {match: Buffer.alloc(33, 3).toString('hex')},
+    expected: {failure: undefined, match: Buffer.alloc(33, 3).toString('hex')},
   },
   {
     args: makeArgs({filters: ['invalid formula']}),
@@ -41,8 +41,14 @@ const tests = [
         error: 'UnexpectedTrailingTokenForFormulaParsing',
         formula: 'invalid formula',
       },
+      match: undefined,
     },
   },
+  {
+    args: makeArgs({filters: ['outbound_liquidity > 1']}),
+    description: 'A tag with no peers satisfying a filter is identified',
+    expected: {is_tag_filtered: true},
+  },
   {
     args: makeArgs({
       channels: [
@@ -74,6 +80,7 @@ const tests = [
     }),
     description: 'A tagged node is found which complies with a filter',
     expected: {
+      failure: undefined,
       match: Buffer.alloc(33, 2).toString('hex'),
     },
   },

package/test/swaps/test_find_rebalance_peer.js

@@ -0,0 +1,329 @@
+const {deepEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const findRebalancePeer = require('./../../swaps/find_rebalance_peer');
+
+const highKey = Buffer.alloc(33, 2).toString('hex');
+const lowKey = Buffer.alloc(33, 3).toString('hex');
+const inactiveKey = Buffer.alloc(33, 4).toString('hex');
+const unknownKey = Buffer.alloc(33, 5).toString('hex');
+const inboundFilters = ['inbound_liquidity > 10'];
+
+const channels = [
+  {
+    capacity: 10,
+    id: '1x1x1',
+    local_balance: 4,
+    partner_public_key: highKey,
+    pending_payments: [],
+    remote_balance: 6,
+  },
+  {
+    capacity: 10,
+    id: '2x2x2',
+    local_balance: 4,
+    partner_public_key: highKey,
+    pending_payments: [],
+    remote_balance: 6,
+  },
+  {
+    capacity: 10,
+    id: '3x3x3',
+    local_balance: 2,
+    partner_public_key: lowKey,
+    pending_payments: [],
+    remote_balance: 8,
+  },
+];
+
+const makeLnd = aliases => ({
+  default: {
+    getNodeInfo: (args, cbk) => cbk(null, {
+      channels: [],
+      node: {
+        addresses: [],
+        alias: aliases[args.pub_key] || String(),
+        color: '#000000',
+        features: {},
+        last_update: 0,
+        pub_key: args.pub_key,
+      },
+      num_channels: 0,
+      total_capacity: '1',
+    }),
+  },
+});
+
+const makeArgs = overrides => {
+  const args = {
+    channels,
+    active_channels: channels,
+    direction: 'out',
+    filters: ['outbound_liquidity > 5'],
+    lnd: makeLnd({[highKey]: 'alpha', [lowKey]: 'beta'}),
+    policies: [],
+    query: highKey,
+    tags: [],
+  };
+
+  Object.keys(overrides).forEach(key => args[key] = overrides[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({direction: undefined}),
+    description: 'A known rebalance direction is required',
+    error: [400, 'ExpectedInOrOutDirectionToFindRebalancePeer'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'An explicit public key satisfying the filter is selected',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({query: highKey.toUpperCase()}),
+    description: 'An uppercase public key is matched to the active peer',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({query: lowKey}),
+    description: 'An explicit public key failing the filter is rejected',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({query: 'alpha'}),
+    description: 'An explicit peer alias satisfying the filter is selected',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({query: 'beta'}),
+    description: 'Only the explicitly aliased peer is tested by the filter',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({
+      query: 'group',
+      tags: [{alias: 'group', id: '00', nodes: [highKey, lowKey]}],
+    }),
+    description: 'An outbound tag continues to select a filtered peer',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({[highKey]: 'group'}),
+      query: 'group',
+      tags: [{alias: 'group', id: '00', nodes: [lowKey]}],
+    }),
+    description: 'A filtered-out tag does not fall through to a peer alias',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({
+      channels: channels.concat({partner_public_key: inactiveKey}),
+      lnd: makeLnd({[highKey]: 'inactive-tag'}),
+      query: 'inactive-tag',
+      tags: [{alias: 'inactive-tag', id: '00', nodes: [inactiveKey]}],
+    }),
+    description: 'A tag with no active peers does not fall through to an alias',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({
+      query: 'group',
+      tags: [
+        {alias: 'group', id: '00', nodes: [highKey]},
+        {alias: 'group', id: '11', nodes: [lowKey]},
+      ],
+    }),
+    description: 'Ambiguous outbound tags remain rejected',
+    error: [
+      400,
+      'MultipleTagMatchesFoundForOutPeer',
+      {
+        matches: [
+          {alias: 'group', id: '00', nodes: [highKey]},
+          {alias: 'group', id: '11', nodes: [lowKey]},
+        ],
+      },
+    ],
+  },
+  {
+    args: makeArgs({query: unknownKey}),
+    description: 'An unknown explicit public key does not satisfy a filter',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({
+      channels: channels.concat({partner_public_key: inactiveKey}),
+      lnd: makeLnd({[inactiveKey]: 'inactive'}),
+      query: 'inactive',
+    }),
+    description: 'An inactive aliased peer does not satisfy a filter',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({
+      filters: ['invalid formula'],
+      query: 'alpha',
+    }),
+    description: 'An invalid filter on an explicit alias is rejected',
+    error: [
+      400,
+      'FailedToParseFilter',
+      {
+        error: 'UnexpectedTrailingTokenForFormulaParsing',
+        formula: 'invalid formula',
+      },
+    ],
+  },
+  {
+    args: makeArgs({filters: [], query: 'beta'}),
+    description: 'An explicit alias is preserved when there are no filters',
+    expected: {public_key: lowKey},
+  },
+  {
+    args: makeArgs({
+      channels: channels.concat({partner_public_key: inactiveKey}),
+      filters: [],
+      lnd: makeLnd({[inactiveKey]: 'inactive'}),
+      query: 'inactive',
+    }),
+    description: 'An inactive alias still resolves when there are no filters',
+    expected: {public_key: inactiveKey},
+  },
+  {
+    args: makeArgs({query: undefined}),
+    description: 'An outbound filter still requires an outbound selector',
+    error: [400, 'NoPeerMatchesFoundToSatisfyOutboundFilter'],
+  },
+  {
+    args: makeArgs({filters: [], query: undefined}),
+    description: 'No selector and no filter preserves automatic selection',
+    expected: {public_key: undefined},
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: highKey,
+    }),
+    description: 'An inbound public key satisfying the filter is selected',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: lowKey,
+    }),
+    description: 'An inbound public key failing the filter is rejected',
+    error: [400, 'NoPeerMatchesFoundToSatisfyInboundFilter'],
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: 'alpha',
+    }),
+    description: 'An inbound alias satisfying the filter is selected',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: 'beta',
+    }),
+    description: 'Only the explicitly aliased inbound peer is filtered',
+    error: [400, 'NoPeerMatchesFoundToSatisfyInboundFilter'],
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: 'group',
+      tags: [{alias: 'group', id: '00', nodes: [highKey, lowKey]}],
+    }),
+    description: 'An inbound tag continues to select a filtered peer',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      lnd: makeLnd({[highKey]: 'group'}),
+      query: 'group',
+      tags: [{alias: 'group', id: '00', nodes: [lowKey]}],
+    }),
+    description: 'A filtered inbound tag does not fall through to an alias',
+    error: [400, 'NoPeerMatchesFoundToSatisfyInboundFilter'],
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      policies: [{is_disabled: true, public_key: highKey}],
+      query: highKey,
+    }),
+    description: 'An inbound-disabled explicit peer fails the filter',
+    error: [400, 'NoPeerMatchesFoundToSatisfyInboundFilter'],
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: [],
+      policies: [{is_disabled: true, public_key: highKey}],
+      query: highKey,
+    }),
+    description: 'An inbound-disabled explicit peer resolves without filters',
+    expected: {public_key: highKey},
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: 'group',
+      tags: [
+        {alias: 'group', id: '00', nodes: [highKey]},
+        {alias: 'group', id: '11', nodes: [lowKey]},
+      ],
+    }),
+    description: 'Ambiguous inbound tags remain rejected',
+    error: [
+      400,
+      'MultipleTagMatchesFoundForInPeer',
+      {
+        matches: [
+          {alias: 'group', id: '00', nodes: [highKey]},
+          {alias: 'group', id: '11', nodes: [lowKey]},
+        ],
+      },
+    ],
+  },
+  {
+    args: makeArgs({
+      direction: 'in',
+      filters: inboundFilters,
+      query: undefined,
+    }),
+    description: 'An inbound filter still requires an inbound selector',
+    error: [400, 'NoPeerMatchesFoundToSatisfyInboundFilter'],
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(findRebalancePeer(args), error, 'Got expected error');
+    } else {
+      const res = await findRebalancePeer(args);
+
+      deepEqual(res, expected, 'Got expected rebalance peer');
+    }
+
+    return;
+  });
+});