balanceofsatoshis 22.1.7 → 23.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## 23.1.0
+
+- Add `--avoid-append` to add failing edges to an avoid list based on formula
+- Add support for LND 0.20.2
+
+## 23.0.0
+
+### Breaking Changes
+
+- Remove support for extended range of formulas, supported formulas are here:
+    https://github.com/alexbosworth/formulas#custom-functions
+
 ## 22.1.7
 
 - Add support for LND 0.21.1

package/README.md

@@ -8,7 +8,7 @@ Commands for working with LND balances.
 Supported LND versions:
 
 - v0.21.0-beta to v0.21.1-beta
-- v0.20.0-beta to v0.20.1-beta
+- v0.20.0-beta to v0.20.2-beta
 
 ## Install
 
@@ -564,8 +564,11 @@ alias bosd="docker run -d --rm -v $HOME/.bos:/home/node/.bos alexbosworth/balanc
 Some commands take formula arguments. Formulas are expressions that allow you 
 to perform functions and reference variables.
 
-There is a dynamic playground here where you can play with expressions:
-https://formulajs.info/functions/
+Formulas are modeled after common spreadsheet formulas, but there is not a 1:1
+mapping of supported functions from all spreadsheets.
+
+See supported formula construction here:
+https://github.com/alexbosworth/formulas#custom-functions
 
 ### `--avoid`
 

package/bos

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+const {appendFile} = require('fs');
 const {lstat} = require('fs');
 const {mkdir} = require('fs');
 const {readdir} = require('fs');
@@ -1719,6 +1720,7 @@ prog
   .help('--avoid can take a FORMULA/public_key to avoid inbound peers')
   .help('--avoid can take a public_key/FORMULA to avoid outbound peers')
   .help('--avoid FORMULA variables: FEE_RATE, BASE_FEE, HEIGHT, AGE')
+  .help('--avoid-append vars: FAILURE_REASON, FAILURE_INDEX, ROUTE_HOPS_COUNT')
   .help('--avoid-list allows passing a file of newline separated avoids')
   .help('--avoid-list will delete edges from the file unknown to the node')
   .help('--in decreases the inbound liquidity with a specific peer/tag')
@@ -1728,6 +1730,7 @@ prog
   .help('--out increases the inbound liquidity with a specific peer/tag')
   .option('--amount <amount>', 'Maximum amount to rebalance')
   .option('--avoid <pubkey_or_chanid>', 'Avoid forwarding through', REPEATABLE)
+  .option('--avoid-append', 'Formula for appending failing edges to list')
   .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')
@@ -1747,8 +1750,9 @@ prog
         return swaps.manageRebalance({
           logger,
           avoid: flatten([options.avoid].filter(n => !!n)),
+          avoid_append: options.avoidAppend || undefined,
           avoid_list: options.avoidList || undefined,
-          fs: {writeFile, getFile: readFile},
+          fs: {appendFile, writeFile, getFile: readFile},
           in_filters: flatten([options.inFilter].filter(n => !!n)),
           in_outbound: options.inTargetOutbound || undefined,
           in_through: options.in || undefined,

package/display/index.js

@@ -1,6 +1,5 @@
 const chartAliasForPeer = require('./chart_alias_for_peer');
 const describeConfidence = require('./describe_confidence');
-const describeParseError = require('./describe_parse_error');
 const describeRoute = require('./describe_route');
 const describeRoutingFailure = require('./describe_routing_failure');
 const formatFeeRate = require('./format_fee_rate');
@@ -12,7 +11,6 @@ const sumsForSegment = require('./sums_for_segment');
 module.exports = {
   chartAliasForPeer,
   describeConfidence,
-  describeParseError,
   describeRoute,
   describeRoutingFailure,
   formatFeeRate,

package/display/is_matching_filters.js

@@ -1,10 +1,7 @@
-const {Parser} = require('hot-formula-parser');
-
-const describeParseError = require('./describe_parse_error');
+const {evaluateFormula} = require('@alexbosworth/formulas');
 
 const {assign} = Object;
 const defaultVariables = {btc: 1e8, k: 1e3, m: 1e6, mm: 1e6};
-const {keys} = Object;
 
 /** Determine if variables are consistent with filters
 
@@ -32,25 +29,14 @@ module.exports = ({filters, variables}) => {
 
   const vars = {};
 
-  [defaultVariables, variables].forEach(n => assign(vars, n));
+  [defaultVariables, variables].forEach(variable => assign(vars, variable));
 
   const filtered = filters.map(formula => {
-    const parser = new Parser();
-
-    keys(vars).forEach(key => {
-      parser.setVariable(key.toLowerCase(), vars[key]);
-      parser.setVariable(key.toUpperCase(), vars[key]);
-
-      return;
-    });
-
-    const parsed = parser.parse(formula);
-
-    if (!!parsed.error) {
-      return {formula, error: describeParseError({error: parsed.error})};
+    try {
+      return !evaluateFormula({constants: vars, formula}).result;
+    } catch (err) {
+      return {formula, error: err.message};
     }
-
-    return parsed.result === false;
   });
 
   const [errored] = filtered.filter(n => !!n.error);

package/network/execute_probe.js

@@ -29,6 +29,7 @@ const tokensAsMillitokens = tok => (BigInt(tok) * BigInt(1e3)).toString();
     [in_through]: <In Through Public Key Hex String>
     [is_strict_max_fee]: <Avoid Probing Too-High Fee Routes Bool>
     lnd: <Authenticated LND API Object>
+    [log_failure]: <Failure Details Log Callback Function>
     logger: <Winston Logger Object>
     [max_fee]: <Maximum Fee Tokens Number>
     [max_fee_mtokens]: <Maximum Fee Millitokens Number String>
@@ -180,6 +181,10 @@ module.exports = (args, cbk) => {
 
         // Log failures encountered while trying to find a route
         sub.on('routing_failure', async failure => {
+          if (!!args.log_failure) {
+            args.log_failure(null, failure);
+          }
+
           const {description} = await describeRoutingFailure({
             index: failure.index,
             lnd: args.lnd,

package/network/probe_destination.js

@@ -62,7 +62,8 @@ const tokAsMtok = tokens => (BigInt(tokens || 0) * BigInt(1e3)).toString();
     [is_push]: <Is Push Payment Bool>
     [is_real_payment]: <Pay the Request after Probing Bool> // default: false
     [is_strict_max_fee]: <Avoid Probing Too-High Fee Routes Bool>
-    lnd: <Authenticated LND gRPC API Object>
+    lnd: <Authenticated LND API Object>
+    [log_failure]: <Failure Details Log Callback Function>
     logger: <Winston Logger Object>
     [max_fee]: <Maximum Fee Tokens Number>
     [max_fee_mtokens]: <Maximum Fee Millitokens Number>
@@ -411,6 +412,7 @@ module.exports = (args, cbk) => {
           in_through: args.in_through,
           is_strict_max_fee: args.is_strict_max_fee,
           lnd: args.lnd,
+          log_failure: args.log_failure,
           logger: args.logger,
           max_fee: args.max_fee,
           max_fee_mtokens: args.max_fee_mtokens,

package/package.json

@@ -13,6 +13,7 @@
     "@alexbosworth/blockchain": "3.2.0",
     "@alexbosworth/caporal": "2.0.0",
     "@alexbosworth/fiat": "2.0.0",
+    "@alexbosworth/formulas": "1.4.0",
     "@alexbosworth/html2unicode": "1.1.5",
     "@alexbosworth/node-fetch": "2.6.2",
     "abort-controller": "3.0.0",
@@ -29,19 +30,18 @@
     "colorette": "2.0.20",
     "crypto-js": "4.2.0",
     "csv-parse": "7.0.1",
-    "goldengate": "16.0.3",
-    "grammy": "1.44.0",
-    "hot-formula-parser": "4.0.0",
+    "goldengate": "16.0.4",
+    "grammy": "1.45.1",
     "import-lazy": "4.0.0",
     "ini": "7.0.0",
     "inquirer": "14.0.2",
-    "ln-accounting": "10.0.3",
-    "ln-service": "59.2.0",
+    "ln-accounting": "10.0.4",
+    "ln-service": "59.2.3",
     "ln-sync": "8.0.3",
-    "ln-telegram": "8.0.3",
+    "ln-telegram": "8.0.4",
     "minimist": "1.2.8",
     "moment": "2.30.1",
-    "paid-services": "8.0.3",
+    "paid-services": "8.0.4",
     "probing": "7.0.0",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.4",
@@ -78,7 +78,7 @@
     "integration-tests": "node test/integration",
     "postpack": "PACKAGE_VERSION=$(cat package.json | grep \\\"version\\\" | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g' | tr -d '[[:space:]]') && git tag -s v$PACKAGE_VERSION -m v$PACKAGE_VERSION && git push github --tags",
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
-    "test": "npx nyc@17.1.0 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"
+    "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": "22.1.7"
+  "version": "23.1.0"
 }

package/peers/find_tag_match.js

@@ -12,6 +12,7 @@ const tok = n => Number(BigInt(n) / BigInt(1e3));
 
   {
     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>
@@ -97,20 +98,25 @@ module.exports = ({channels, filters, policies, tags, query}) => {
       const feeRates = peerPolicies.filter(n => n.fee_rate !== undefined);
       const pendingPayments = withPeer.map(n => n.pending_payments.length);
 
-      const matching = isMatchingFilters({
-        filters: filters || [],
-        variables: {
-          capacity: sumOf(withPeer.map(n => n.capacity)),
-          heights: withPeer.map(n => {
-            return decodeChanId({channel: n.id}).block_height;
-          }),
-          inbound_base_fee: max(...feeRates.map(n => tok(n.base_fee_mtokens))),
-          inbound_fee_rate: max(...feeRates.map(n => n.fee_rate)),
-          inbound_liquidity: sumOf(withPeer.map(n => n.remote_balance)),
-          outbound_liquidity: sumOf(withPeer.map(n => n.local_balance)),
-          pending_payments: sumOf(pendingPayments),
-        },
-      });
+      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;

package/peers/open_request_violation.js

@@ -1,4 +1,4 @@
-const {Parser} = require('hot-formula-parser');
+const {evaluateFormula} = require('@alexbosworth/formulas');
 
 const {isArray} = Array;
 const {keys} = Object;
@@ -72,7 +72,7 @@ module.exports = args => {
     throw new Error('ExpectedTorStatusToCheckOpenRequestRules');
   }
 
-  const variables = {
+  const constants = {
     btc: 1e8,
     capacities: args.capacities,
     capacity: args.capacity,
@@ -84,46 +84,14 @@ module.exports = args => {
     local_balance: args.local_balance,
     m: 1e6,
     mm: 1e6,
-    obsolete: args.is_obsolete,
+    obsolete: !!args.is_obsolete,
     private: args.is_private,
     public_key: args.public_key,
     tor: args.is_tor,
   };
 
-  const parser = new Parser();
-
-  // Add the variables to the parser
-  keys(variables).forEach(key => {
-    parser.setVariable(key.toLowerCase(), variables[key]);
-    parser.setVariable(key.toUpperCase(), variables[key]);
-
-    return;
-  });
-
   const violation = args.rules.find(rule => {
-    const parsed = parser.parse(rule);
-
-    switch (parsed.error) {
-    case '#DIV/0!':
-      throw new Error('CannotDivideByZeroInOpenRequestRule');
-
-    case '#ERROR!':
-      throw new Error('FailedToParseSpecifiedOpenRequestRule');
-
-    case '#N/A':
-    case '#NAME?':
-      throw new Error('UnrecognizedVariableOrFunctionInRequestRule');
-
-    case '#NUM':
-      throw new Error('InvalidNumberFoundInRequestRule');
-
-    case '#VALUE!':
-      throw new Error('UnexpectedValueTypeInRequestRule');
-
-    default:
-      // Rules must evaluate as truthy
-      return !parsed.result;
-    }
+    return !evaluateFormula({constants, formula: rule}).result;
   });
 
   return {rule: violation};

package/routing/get_ignores.js

@@ -1,18 +1,15 @@
 const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
+const {evaluateFormula} = require('@alexbosworth/formulas');
 const {findKey} = require('ln-sync');
 const {getChannel} = require('ln-service');
 const {getHeight} = require('ln-service');
 const {getNode} = require('ln-service');
-const {Parser} = require('hot-formula-parser');
 const {returnResult} = require('asyncjs-util');
 
-const {describeParseError} = require('./../display');
-
 const amountVariables = {btc: 1e8, k: 1e3, m: 1e6, mm: 1e6};
 const asFormula = n => ({formula: n.slice(0, n.length-67), key: n.slice(-66)});
 const asOutFilter = n => ({out_filter: n.slice(67), key: n.slice(0, 66)});
-const {assign} = Object;
 const channelFromEdge = edge => edge.slice(0, -2);
 const decodePair = n => n.split('/');
 const flatten = arr => [].concat(...arr);
@@ -25,7 +22,6 @@ const isFormula = n => /(.*)\/0[2-3][0-9A-F]{64}$/gim.test(n);
 const isOutFilter = n => /^0[2-3][0-9A-F]{64}\/(.*)/gim.test(n);
 const isPair = n => !!n && /^0[2-3][0-9A-F]{64}\/0[2-3][0-9A-F]{64}$/i.test(n);
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/gim.test(n);
-const {keys} = Object;
 const pairAsIgnore = (a, b) => ({from_public_key: a, to_public_key: b});
 const uniq = arr => Array.from(new Set(arr));
 
@@ -255,35 +251,25 @@ module.exports = (args, cbk) => {
                   return;
                 }
 
-                const parser = new Parser();
-                const variables = {};
-
-                assign(variables, amountVariables);
-
-                assign(variables, {
-                  capacity,
-                  height,
-                  age: getHeight.current_block_height - height,
-                  base_fee: Number(outPolicy.base_fee_mtokens) || Number(),
-                  fee_rate: outPolicy.fee_rate || Number(),
-                  opposite_fee_rate: peerPolicy.fee_rate || Number(),
-                });
-
-                keys(variables).forEach(key => {
-                  parser.setVariable(key.toLowerCase(), variables[key]);
-                  parser.setVariable(key.toUpperCase(), variables[key]);
-
-                  return;
-                });
-
-                const parsed = parser.parse(formula);
-
-                if (!!parsed.error) {
-                  return {error: describeParseError({error: parsed.error})};
-                }
-
-                if (parsed.result === false) {
-                  return;
+                try {
+                  const parsed = evaluateFormula({
+                    formula,
+                    constants: {
+                      ...amountVariables,
+                      capacity,
+                      height,
+                      age: getHeight.current_block_height - height,
+                      base_fee: Number(outPolicy.base_fee_mtokens) || Number(),
+                      fee_rate: outPolicy.fee_rate || Number(),
+                      opposite_fee_rate: peerPolicy.fee_rate || Number(),
+                    },
+                  });
+
+                  if (!parsed.result) {
+                    return;
+                  }
+                } catch (err) {
+                  return {error: err.message};
                 }
 
                 return {
@@ -333,35 +319,25 @@ module.exports = (args, cbk) => {
                   return;
                 }
 
-                const parser = new Parser();
-                const variables = {};
-
-                assign(variables, amountVariables);
-
-                assign(variables, {
-                  capacity,
-                  height,
-                  age: getHeight.current_block_height - height,
-                  base_fee: Number(inPolicy.base_fee_mtokens) || Number(),
-                  fee_rate: inPolicy.fee_rate || Number(),
-                  opposite_fee_rate: outPolicy.fee_rate || Number(),
-                });
-
-                keys(variables).forEach(key => {
-                  parser.setVariable(key.toLowerCase(), variables[key]);
-                  parser.setVariable(key.toUpperCase(), variables[key]);
-
-                  return;
-                });
-
-                const parsed = parser.parse(formula);
-
-                if (!!parsed.error) {
-                  return {error: describeParseError({error: parsed.error})};
-                }
-
-                if (parsed.result === false) {
-                  return;
+                try {
+                  const parsed = evaluateFormula({
+                    formula,
+                    constants: {
+                      ...amountVariables,
+                      capacity,
+                      height,
+                      age: getHeight.current_block_height - height,
+                      base_fee: Number(inPolicy.base_fee_mtokens) || Number(),
+                      fee_rate: inPolicy.fee_rate || Number(),
+                      opposite_fee_rate: outPolicy.fee_rate || Number(),
+                    },
+                  });
+
+                  if (!parsed.result) {
+                    return;
+                  }
+                } catch (err) {
+                  return {error: err.message};
                 }
 
                 return {

package/routing/parse_fee_rate_formula.js

@@ -1,4 +1,4 @@
-const {Parser} = require('hot-formula-parser');
+const {evaluateFormula} = require('@alexbosworth/formulas');
 
 const bipsAsPpm = bips => bips * 1e2;
 const {ceil} = Math;
@@ -12,7 +12,7 @@ const percentAsPpm = percent => percent * 1e4;
     inbound_liquidity: <Inbound Tokens Number>
     outbound_liquidity: <Outbound Tokens Number>
     node_rates: [{
-      key: <Node Key String>
+      key: <Label Prefixed Node Key String>
       rate: <Node PPM Rate Number>
     }]
   }
@@ -28,31 +28,30 @@ module.exports = args => {
     return {};
   }
 
-  const parser = new Parser();
-
-  parser.setFunction('BIPS', params => bipsAsPpm(params.slice().pop()));
-  parser.setFunction('PERCENT', params => percentAsPpm(params.slice().pop()));
-  parser.setVariable('INBOUND', args.inbound_liquidity);
-  parser.setVariable('INBOUND_FEE_RATE', args.inbound_fee_rate);
-  parser.setVariable('OUTBOUND', args.outbound_liquidity);
-
-  args.node_rates.forEach(({key, rate}) => parser.setVariable(key, rate));
-
-  const parsedRate = parser.parse(args.fee_rate.toUpperCase());
-
-  switch (parsedRate.error) {
-  case null:
-    break;
-
-  case '#DIV/0!':
-    return {failure: 'FeeRateCalculationCannotDivideByZeroFormula'};
-
-  case '#ERROR!':
-    return {failure: 'FailedToParseFeeRateFormula'};
-
-  default:
-    return {failure: 'UnrecognizedVariableOrFunctionInFeeRateFormula'};
+  const rates = args.node_rates.reduce((sum, n) => {
+    sum[n.key] = n.rate;
+
+    return sum;
+  },
+  {});
+
+  try {
+    const {result} = evaluateFormula({
+      constants: {
+        ...rates,
+        inbound: args.inbound_liquidity,
+        inbound_fee_rate: args.inbound_fee_rate,
+        outbound: args.outbound_liquidity,
+      },
+      formula: args.fee_rate,
+      functions: {
+        bips: bipsAsPpm,
+        percent: percentAsPpm,
+      },
+    });
+
+    return {rate: ceil(result)};
+  } catch (err) {
+    return {failure: err.message};
   }
-
-  return {rate: ceil(parsedRate.result)};
 };

package/swaps/append_failing_edge.js

@@ -0,0 +1,108 @@
+const asyncAuto = require('async/auto');
+const {evaluateFormula} = require('@alexbosworth/formulas');
+const {returnResult} = require('asyncjs-util');
+
+const pairEdgeIndex = (pair, key) => `x${Number(!pair.indexOf(key))}`;
+
+/** Append failing edge based on formula match
+
+  {
+    avoid: <Formula For Edge To Avoid String>
+    failure: {
+      index: <Failure Hop Index Number>
+      reason: <Failure Reason String>
+      route: [{
+        hops: [{
+          channel: <Standard Format Channel Id String>
+          public_key: <Node Public Key Hex String>
+        }]
+      }]
+    }
+    fs: {
+      appendFile: <Append to File Function> (path, content, cbk) => {}
+    }
+    list: <File Path To Avoid List String>
+  }
+
+  @returns via cbk
+  {
+    edge: <Appended Failing Edge Id String>
+  }
+*/
+module.exports = ({avoid, failure, fs, list}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!avoid) {
+          return cbk([400, 'ExpectedAvoidanceFormulaToAppendFailingEdge']);
+        }
+
+        if (!failure) {
+          return cbk([400, 'ExpectedFailureDetailsToAppendFailingEdge']);
+        }
+
+        if (!fs) {
+          return cbk([400, 'ExpectedFilesystemMethodsToAppendFailingEdge']);
+        }
+
+        if (!list) {
+          return cbk([400, 'ExpectedPathToAvoidListToAppendFailingEdge']);
+        }
+
+        return cbk();
+      },
+
+      // Derive the set of edges
+      edges: ['validate', ({}, cbk) => {
+        return cbk(null, failure.route.hops.map((hop, i, hops) => {
+          const pair = [(hops[i - 1] || {}).public_key, hop.public_key].sort();
+
+          return `${hop.channel}${pairEdgeIndex(pair, hop.public_key)}`;
+        }));
+      }],
+
+      // Determine if there is a formula matching edge
+      failing: ['edges', ({edges}, cbk) => {
+        const edge = edges[failure.index];
+
+        try {
+          const {result} = evaluateFormula({
+            constants: {
+              FAILURE_INDEX: failure.index,
+              FAILURE_REASON: failure.reason,
+              ROUTE_HOPS_COUNT: failure.route.hops.length,
+            },
+            formula: avoid,
+          });
+
+          // Exit early when there is no append edge formula match
+          if (!result) {
+            return cbk(null, {});
+          }
+
+          return cbk(null, {edge});
+        } catch (err) {
+          return cbk([400, 'ExpectedValidAppendEdgeFormula', err.message]);
+        }
+      }],
+
+      // Append the failing edge to the avoid list
+      append: ['failing', ({failing}, cbk) => {
+        // Exit early when there is no relevant failing edge to append
+        if (!failing.edge) {
+          return cbk();
+        }
+
+        return fs.appendFile(list, `\n${failing.edge}`, err => {
+          if (!!err) {
+            return cbk([500, 'UnexpectedErrorAppendingFailEdge', err.message]);
+          }
+
+          return cbk()
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'failing'}, cbk));
+  });
+};

package/swaps/manage_rebalance.js

@@ -4,6 +4,7 @@ const asyncRetry = require('async/retry');
 const {getChannel} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const appendFailingEdge = require('./append_failing_edge');
 const rebalance = require('./rebalance');
 
 const channelFromEdge = edge => edge.slice(0, -2);
@@ -18,7 +19,10 @@ const uniq = arr => Array.from(new Set(arr));
 
   {
     [avoid]: [<Avoid Forwarding Through Node With Public Key Hex String>]
+    [avoid_append]: <Append Avoid Edges To Avoid List Matching Formula String>
+    [avoid_list]: <Use Avoid Directives From File At Path String>
     fs: {
+      appendFile: <Append to File Function> (path, content, cbk) => {}
       getFile: <Read File Contents Function> (path, cbk) => {}
       writeFile: <Write File Contents Function> (path, contents, cbk) => {}
     }
@@ -45,6 +49,10 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!!args.avoid_append && !args.avoid_list) {
+          return cbk([400, 'ExpectedAvoidListToAppendAvoidsTo']);
+        }
+
         if (!args.fs) {
           return cbk([400, 'ExpectedFsToManageRebalance']);
         }
@@ -95,6 +103,35 @@ module.exports = (args, cbk) => {
         });
       }],
 
+      // Create failing edge logger for avoid appending
+      logFail: ['validate', ({}, cbk) => {
+        // Exit early when there is no avoid appending
+        if (!args.avoid_append) {
+          return cbk();
+        }
+
+        return cbk(null, (err, failure) => {
+          return appendFailingEdge({
+            failure,
+            avoid: args.avoid_append,
+            fs: args.fs,
+            list: args.avoid_list
+          },
+          (err, res) => {
+            if (!!err) {
+              return args.logger.error({append_failure_error: err});
+            }
+
+            // Exit early when there was no append
+            if (!res.edge) {
+              return;
+            }
+
+            return args.logger.info({appended_failing_edge: res.edge});
+          });
+        });
+      }],
+
       // Look at all of the lines in the file and clean them up
       getCleanAvoids: ['getAvoids', ({getAvoids}, cbk) => {
         return asyncFilter(getAvoids.file, (line, cbk) => {
@@ -119,7 +156,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Run the rebalance
-      rebalance: ['getAvoids', ({getAvoids}, cbk) => {
+      rebalance: ['getAvoids', 'logFail', ({getAvoids, logFail}, cbk) => {
         const start = new Date().toISOString();
 
         return asyncRetry({
@@ -156,6 +193,7 @@ module.exports = (args, cbk) => {
             in_through: args.in_through,
             is_strict_max_fee_rate: args.is_strict_max_fee_rate,
             lnd: args.lnd,
+            log_failure: logFail || undefined,
             logger: args.logger,
             max_fee: Number(args.max_fee) || undefined,
             max_fee_rate: Number(args.max_fee_rate) || undefined,

package/swaps/rebalance.js

@@ -77,6 +77,7 @@ const uniq = arr => Array.from(new Set(arr));
     [in_through]: <Pay In Through Peer String>
     [is_strict_max_fee_rate]: <Avoid Probing Too-High Fee Rate Routes Bool>
     lnd: <Authenticated LND API Object>
+    [log_failure]: <Failure Details Log Callback Function>
     logger: <Winston Logger Object>
     [max_fee]: <Maximum Fee Tokens Number>
     [max_fee_rate]: <Max Fee Rate Tokens Per Million Number>
@@ -643,6 +644,7 @@ module.exports = (args, cbk) => {
           is_strict_max_fee: args.is_strict_max_fee_rate || undefined,
           logger: args.logger,
           lnd: args.lnd,
+          log_failure: args.log_failure,
           max_fee_mtokens: maxFeeMtokens,
           out_through: getOutbound.public_key,
           timeout_minutes: args.timeout_minutes,

package/test/balances/test_is_matching_filters.js

@@ -15,7 +15,7 @@ const tests = [
     description: 'An invalid filter returns a failure',
     expected: {
       failure: {
-        error: 'UnrecognizedVariableOrFunctionInFormula',
+        error: 'ExpectedAllKnownConstantsInFormulaToEvaluate',
         formula: 'foo',
       },
     },

package/test/peers/test_find_tag_match.js

@@ -7,6 +7,7 @@ const {findTagMatch} = require('./../../peers');
 const makeArgs = overrides => {
   const args = {
     channels: [{
+      capacity: 3,
       id: '1x1x1',
       local_balance: 1,
       partner_public_key: Buffer.alloc(33, 3).toString('hex'),
@@ -36,13 +37,17 @@ const tests = [
     args: makeArgs({filters: ['invalid formula']}),
     description: 'A failed formula is provided',
     expected: {
-      failure: {error: 'FailedToParseFormula', formula: 'invalid formula'},
+      failure: {
+        error: 'UnexpectedTrailingTokenForFormulaParsing',
+        formula: 'invalid formula',
+      },
     },
   },
   {
     args: makeArgs({
       channels: [
         {
+          capacity: 2e8,
           id: '1x1x1',
           local_balance: 1e3,
           partner_public_key: Buffer.alloc(33, 3).toString('hex'),
@@ -50,6 +55,7 @@ const tests = [
           remote_balance: 1,
         },
         {
+          capacity: 2e8,
           id: '2x2x2',
           local_balance: 1e8,
           partner_public_key: Buffer.alloc(33, 2).toString('hex'),

package/test/routing/test_parse_fee_rate_formula.js

@@ -42,17 +42,17 @@ const tests = [
   {
     args: makeArgs({fee_rate: '1/0'}),
     description: 'Cannot divide by zero',
-    expected: {failure: 'FeeRateCalculationCannotDivideByZeroFormula'},
+    expected: {failure: 'ExpectedNonZeroDivisorForFormulaEvaluation'},
   },
   {
     args: makeArgs({fee_rate: '/'}),
     description: 'Formula must be valid',
-    expected: {failure: 'FailedToParseFeeRateFormula'},
+    expected: {failure: 'UnexpectedPrimaryTokenForFormulaParsing'},
   },
   {
     args: makeArgs({fee_rate: 'fee_rate'}),
     description: 'Formula must be valid',
-    expected: {failure: 'UnrecognizedVariableOrFunctionInFeeRateFormula'},
+    expected: {failure: 'ExpectedAllKnownConstantsInFormulaToEvaluate'},
   },
 ];
 

package/test/swaps/test_append_failing_edge.js

@@ -0,0 +1,127 @@
+const {deepEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const appendFailingEdge = require('./../../swaps/append_failing_edge.js');
+
+const makeFailure = override => {
+  const failure = {
+    index: 1,
+    reason: 'TemporaryChannelFailure',
+    route: {
+      hops: [
+        {
+          channel: '1x1x1',
+          public_key: '02',
+        },
+        {
+          channel: '2x2x2',
+          public_key: '03',
+        },
+      ],
+    },
+  };
+
+  Object.keys(override).forEach(key => failure[key] = override[key]);
+
+  return failure;
+};
+
+const makeFs = ({err} = {}) => {
+  const fs = {
+    calls: [],
+    appendFile: (path, content, cbk) => {
+      fs.calls.push({content, path});
+
+      return cbk(err);
+    },
+  };
+
+  return fs;
+};
+
+const makeArgs = override => {
+  const args = {
+    avoid: [
+      'AND(',
+      'FAILURE_INDEX = 1,',
+      'FAILURE_REASON = "TemporaryChannelFailure",',
+      'ROUTE_HOPS_COUNT = 2',
+      ')',
+    ].join(''),
+    failure: makeFailure({}),
+    fs: makeFs({}),
+    list: '/tmp/avoid',
+  };
+
+  Object.keys(override).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({avoid: undefined}),
+    description: 'An avoidance formula is required',
+    error: [400, 'ExpectedAvoidanceFormulaToAppendFailingEdge'],
+  },
+  {
+    args: makeArgs({failure: undefined}),
+    description: 'Failure details are required',
+    error: [400, 'ExpectedFailureDetailsToAppendFailingEdge'],
+  },
+  {
+    args: makeArgs({fs: undefined}),
+    description: 'Filesystem methods are required',
+    error: [400, 'ExpectedFilesystemMethodsToAppendFailingEdge'],
+  },
+  {
+    args: makeArgs({list: undefined}),
+    description: 'An avoid list path is required',
+    error: [400, 'ExpectedPathToAvoidListToAppendFailingEdge'],
+  },
+  {
+    args: makeArgs({avoid: '('}),
+    description: 'A valid avoidance formula is required',
+    error: [400, 'ExpectedValidAppendEdgeFormula'],
+  },
+  {
+    appended: [],
+    args: makeArgs({avoid: 'FALSE'}),
+    description: 'An edge is not appended when the formula does not match',
+    expected: {},
+  },
+  {
+    appended: [
+      {
+        content: '\n2x2x2x0',
+        path: '/tmp/avoid',
+      },
+    ],
+    args: makeArgs({}),
+    description: 'A failing edge is appended',
+    expected: {edge: '2x2x2x0'},
+  },
+  {
+    args: makeArgs({
+      fs: makeFs({err: new Error('Failed to append')}),
+    }),
+    description: 'An append error is returned',
+    error: [500, 'UnexpectedErrorAppendingFailEdge'],
+  },
+];
+
+tests.forEach(({appended, args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(appendFailingEdge(args), error, 'Got expected error');
+    } else {
+      const result = await appendFailingEdge(args);
+
+      deepEqual(result, expected, 'Got expected result');
+      deepEqual(args.fs.calls, appended, 'Got expected appended data');
+    }
+
+    return;
+  });
+});

package/display/describe_parse_error.js

@@ -1,16 +0,0 @@
-const {parseErrors} = require('./constants');
-
-const defaultError = '#ERROR!';
-
-/** Describe a hot formula parser error
-
-  {
-    error: <Error Type String>
-  }
-
-  @returns
-  <Display String>
-*/
-module.exports = ({error}) => {
-  return parseErrors[error] || parseErrors[defaultError];
-};