balanceofsatoshis 11.0.0 → 11.3.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Versions
 
+## Version 11.3.0
+
+- `credentials`: Allow specifying specific methods to allow in a credential
+
+## Version 11.2.1
+
+- Improve support for LND v0.13.3
+
+## Version 11.2.0
+
+- `rebalance`: Add support for `key/formula` expressions in `--avoid`
+
+## Version 11.1.0
+
+- `avoid`: Add `capacity` to reference channel capacity amount
+- `call`: Add support for force closing a channel
+- `find`: Improve lookup speed when querying a tx id or peer
+- `open-balanced-channel`: Avoid showing incoming requests that were accepted
+- `rebalance`: Add `capacity` variable to `--in-filter` and `--out-filter`
+- `transfer`: Add `in_inbound` and `in_outbound` variables to amount formulas
+
 ## Version 11.0.0
 
 - `rebalance`: Add `--in-filter` to filter inbound tagged nodes

package/README.md

@@ -524,3 +524,134 @@ You can also create an alias to run a command in the background
 ```shell
 alias bosd="docker run -d --rm -v $HOME/.bos:/home/node/.bos alexbosworth/balanceofsatoshis"
 ```
+
+## Formulas
+
+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/
+
+### `amount`
+
+Formula amounts are supported in the following commands:
+
+- `fund`
+- `inbound-channel-rules`
+- `open`
+- `probe`
+- `rebalance`
+- `send`
+
+When passing an amount you can pass a formula expression, and the following variables are
+defined:
+
+- `k`: 1,000
+- `m`: 1,000,000
+
+Examples:
+
+```
+bos fund <address> 7*m
+// Fund address with value 7,000,000
+
+bos probe <key> 100*k
+// Probe to key amount 100,000
+
+bos send <key> m/2
+// Push 500,000 to key
+```
+
+#### `rebalance`
+
+Rebalance defines additional variables for `--amount`:
+
+-  `capacity`: The total of inbound and outbound
+
+And for `--in-filter` and `--out-filter`:
+
+- `capacity`: The total capacity with the peer
+- `heights`: The set of heights of the channels with the peer
+- `inbound_liquidity`: The inbound liquidity with the peer
+- `outbound_liquidity`: The outbound liquidity with the peer
+
+Example:
+
+```
+// Rebalance with a target of 1,000,000
+bos rebalance --amount 1*m
+```
+
+#### `send`
+
+Send defines additional variables:
+
+- `eur`: The value of 1 Euro as defined by rate provider
+- `inbound`: The inbound liquidity with the destination
+- `liquidity`: The total capacity with the destination
+- `outbound`: The inbound liquidity with the destination
+- `usd`: The value of 1 US Dollar as defined by rate provider
+
+Example:
+
+```
+// Send node $1
+bos send <key> --amount 1*usd
+```
+
+#### `transfer`
+
+Transfer variables:
+
+- `out_inbound`: The outbound liquidity with the outbound peer
+- `out_liquidity`: The total inbound+outbound with the outbound peer
+- `out_outbound`: The total outbound liquidity with the outbound peer
+
+Example:
+
+```
+// Equalize inbound with a mutual peer
+bos transfer node "in_inbound - (in_inbound + out_inbound)/2" --through peer
+```
+
+### `fees`
+
+Variables can be referenced for `--set-fee-rate`
+
+- `fee_rate_of_<pubkey>`: Reference other node's fee rate
+- `inbound`: Remote balance with peer
+- `inbound_fee_rate`: Incoming fee rate
+- `outbound`: Local balance with peer
+
+You can also use functions:
+
+- `bips(n)`: Set fee as parts per thousand
+- `percent(0.00)`: Set fee as fractional percentage
+
+Example:
+
+```
+// Set the fee rate to a tag to 1% of the value forwarded
+bos fees --to tag --set-fee-rate "percent(1)"
+```
+
+### `inbound-channel-rules`
+
+Pass formulas for rules with `--rule`.
+
+Formula variables:
+
+- `capacities`: sizes of the peer's public channels
+- `capacity`: size of the inbound channel
+- `channel_ages`: block ages of the peer's public channels
+- `fee_rates`: outbound fee rates for the peer
+- `local_balance`: gifted amount on the incoming channel
+- `public_key`: key of the incoming peer
+
+Example:
+
+```
+// Reject channels that are smaller than 2,000,000 capacity
+bos inbound-channel-rules "capacity < 2*m"
+```

package/bos

@@ -420,6 +420,7 @@ prog
   .help('Output encrypted remote access credentials. Use with "nodes --add"')
   .option('--cleartext', 'Output remote access credentials without encryption')
   .option('--days <days>', 'Expiration days for credentials', INT, 365)
+  .option('--method <method_name>', 'White-list specific method', REPEATABLE)
   .option('--node <node_name>', 'Get credentials for a saved node')
   .option('--nospend', 'Credentials do not include spending privileges')
   .option('--readonly', 'Credentials only include read permissions')
@@ -432,6 +433,7 @@ prog
         is_cleartext: options.cleartext,
         is_nospend: options.nospend,
         is_readonly: options.readonly,
+        methods: flatten([options.method].filter(n => !!n)),
         node: options.node,
       },
       responses.returnObject({logger, reject, resolve}));
@@ -1174,18 +1176,19 @@ prog
   .help('--avoid can take a channel id or a public key to avoid')
   .help('--avoid can take a public_key/public_key to avoid a directed pair')
   .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('--in decreases the inbound liquidity with a specific peer/tag')
-  .help('--in-filter vars: HEIGHTS, INBOUND_LIQUIDITY/OUTBOUND_LIQUIDITY')
+  .help('--in-filter vars: CAPACITY/HEIGHTS/(INBOUND|OUTBOUND)_LIQUIDITY')
   .help('--out increases the inbound liquidity with a specific peer/tag')
-  .help('--out-filter vars: HEIGHTS, INBOUND_LIQUIDITY/OUTBOUND_LIQUIDITY')
+  .help('--out-filter vars: CAPACITY/HEIGHTS(INBOUND|OUTBOUND)_LIQUIDITY')
   .option('--amount <amount>', 'Maximum amount to rebalance')
   .option('--avoid <pubkey_or_chanid>', 'Avoid forwarding through', REPEATABLE)
   .option('--in <pubkey_or_alias>', 'Route in through a specific peer')
   .option('--in-filter <in_filter>', 'Filter inbound tag nodes', REPEATABLE)
   .option('--in-target-outbound <amt>', 'Balance up to outbound amount')
-  .option('--max-fee <max_fee>', 'Maximum fee to pay', INT)
-  .option('--max-fee-rate <max_fee_rate>', 'Max fee rate to pay', INT)
+  .option('--max-fee <max_fee>', 'Maximum fee to pay')
+  .option('--max-fee-rate <max_fee_rate>', 'Max fee rate to pay')
   .option('--minutes <minutes>', 'Time-out route search after N minutes', INT)
   .option('--no-color', 'Mute all colors')
   .option('--node <node_name>', 'Node to use for rebalance')
@@ -1560,6 +1563,7 @@ prog
   .help('Formulas are supported in amount')
   .help('Also supported in formulas: OUT_LIQUIDITY (with outbound peer)')
   .help('OUT_INBOUND, OUT_OUTBOUND (when specifying outbound peer)')
+  .help('IN_INBOUND, IN_OUTBOUND (when specifying inbound peer)')
   .option('--description', 'Label describing transfer')
   .option('--dryrun', 'Avoid actually sending funds')
   .option('--in <pubkey_or_alias>', 'Route in through a specific peer')

package/commands/api.json

@@ -50,11 +50,22 @@
     },
     {
       "arguments": [
+        {
+          "description": "Request close out to address for cooperative close",
+          "named": "address",
+          "optional": true
+        },
         {
           "description": "Requested chain fee tokens per vbyte",
           "named": "tokens_per_vbyte",
+          "optional": true,
           "type": "number"
         },
+        {
+          "description": "Force close the channel",
+          "named": "is_force_close",
+          "type": "boolean"
+        },
         {
           "description": "Hex encoded funding transaction id",
           "named": "transaction_id",

package/commands/call_raw_api.js

@@ -77,6 +77,16 @@ module.exports = ({ask, lnd, logger, method}, cbk) => {
         }
 
         return asyncMapSeries(arguments, (argument, cbk) => {
+          if (argument.type === 'boolean') {
+            return ask({
+              default: false,
+              name: argument.named,
+              message: argument.description,
+              type: 'confirm',
+            },
+            cbk);
+          }
+
           return ask({
             default: () => !!argument.optional ? String() : undefined,
             message: argument.description,

package/fiat/index.js

@@ -3,7 +3,6 @@ const getCoindeskCurrentPrice = require('./get_coindesk_current_price');
 const getCoindeskRates = require('./get_coindesk_rates');
 const getCoingeckoRates = require('./get_coingecko_rates');
 const getExchangeRates = require('./get_exchange_rates');
-const getPriceChart = require('./get_price_chart');
 const getPrices = require('./get_prices');
 const marketPairs = require('./market').pairs;
 const priceProviders = require('./market').price_providers;
@@ -22,7 +21,6 @@ module.exports = {
   getCoindeskRates,
   getCoingeckoRates,
   getExchangeRates,
-  getPriceChart,
   getPrices,
   pairs,
   priceProviders,

package/lnd/credential_restrictions.js

@@ -0,0 +1,41 @@
+const {noSpendPerms} = require('./constants');
+const {permissionEntities} = require('./constants');
+
+const readPerms = permissionEntities.map(entity => `${entity}:read`);
+
+/** Derive restrictions for macaroon
+
+  {
+    [is_nospend]: <Restrict Credentials To Non-Spending Permissions Bool>
+    [is_readonly]: <Restrict Credentials To Read-Only Permissions Bool>
+    [methods]: [<Allow Specific Method String>]
+  }
+
+  @returns
+  {
+    [allow]: {
+      methods: [<Allow Specific Method String>]
+      permissions: [<Entity:Action String>]
+    }
+  }
+*/
+module.exports = args => {
+  const methods = args.methods || [];
+
+  // Exit early when specific credentials are not requested
+  if (!args.is_readonly && !args.is_nospend && !methods.length) {
+    return {};
+  }
+
+  const permissions = [];
+
+  if (!!args.is_readonly) {
+    readPerms.forEach(n => permissions.push(n));
+  }
+
+  if (!!args.is_nospend) {
+    noSpendPerms.forEach(n => permissions.push(n));
+  }
+
+  return {allow: {methods, permissions}};
+};

package/lnd/find_record.js

@@ -1,4 +1,5 @@
 const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
 const {chanFormat} = require('bolt07');
 const {formatTokens} = require('ln-sync');
 const {getChannel} = require('ln-service');
@@ -6,17 +7,21 @@ const {getChannels} = require('ln-service');
 const {getClosedChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
 const {getNetworkGraph} = require('ln-service');
+const {getNode} = require('ln-service');
 const {getPayment} = require('ln-service');
 const {getTransactionRecord} = require('ln-sync');
 const {gray} = require('colorette');
 const moment = require('moment');
 const {returnResult} = require('asyncjs-util');
 
+const {findKey} = require('ln-sync');
+
 const asBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const balance = ({display}) => display.trim() || gray('0.00000000');
 const blocksTime = (n, p) => moment.duration(n * 10, 'minutes').humanize(p);
 const {isArray} = Array;
 const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const notFound = 404;
 const standardIdHexLength = Buffer.alloc(32).toString('hex').length;
 
@@ -77,8 +82,47 @@ module.exports = ({lnd, query}, cbk) => {
       // Get closed
       getClosed: ['validate', ({}, cbk) => getClosedChannels({lnd}, cbk)],
 
+      // Determine the public key to use
+      getKey: ['validate', asyncReflect(({}, cbk) => {
+        if (query.length === standardIdHexLength) {
+          return cbk();
+        }
+
+        return findKey({lnd, query}, cbk);
+      })],
+
       // Get graph
-      getGraph: ['validate', ({}, cbk) => getNetworkGraph({lnd}, cbk)],
+      getGraph: ['getKey', ({getKey}, cbk) => {
+        if (query.length === standardIdHexLength) {
+          return cbk(null, {channels: [], nodes: []});
+        }
+
+        if (!!getKey.value) {
+          return getNode({
+            lnd,
+            public_key: getKey.value.public_key,
+          },
+          (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, {
+              channels: res.channels,
+              nodes: [{
+                alias: res.alias,
+                color: res.color,
+                features: res.features,
+                public_key: getKey.value.public_key,
+                sockets: res.sockets,
+                updated_at: res.last_updated,
+              }],
+            });
+          });
+        }
+
+        return getNetworkGraph({lnd}, cbk);
+      }],
 
       // Get blockchain height
       getHeight: ['validate', ({}, cbk) => getHeight({lnd}, cbk)],

package/lnd/get_credentials.js

@@ -16,6 +16,7 @@ const {pemAsDer} = require('./../encryption');
     is_nospend: <Restrict Credentials To Non-Spending Permissions Bool>
     is_readonly: <Restrict Credentials To Read-Only Permissions Bool>
     logger: <Winston Logger Object> ({info}) => ()
+    [methods]: [<Allow Specific Method String>]
     [node]: <Node Name String>
   }
 
@@ -81,6 +82,7 @@ module.exports = (args, cbk) => {
           is_nospend: args.is_nospend,
           is_readonly: args.is_readonly,
           logger: args.logger,
+          methods: args.methods,
           node: args.node,
         },
         cbk);

package/lnd/lnd_credentials.js

@@ -12,6 +12,7 @@ const {grantAccess} = require('ln-service');
 const {restrictMacaroon} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const credentialRestrictions = require('./credential_restrictions');
 const {decryptCiphertext} = require('./../encryption');
 const {derAsPem} = require('./../encryption');
 const getCert = require('./get_cert');
@@ -38,6 +39,7 @@ const socket = 'localhost:10009';
     [is_readonly]: <Restrict Credentials To Read-Only Permissions Bool>
     [key]: <Encrypt to Public Key DER Hex String>
     [logger]: <Winston Logger Object>
+    [methods]: [<Allow Specific Method String>]
     [node]: <Node Name String> // Defaults to default local mainnet node creds
   }
 
@@ -199,8 +201,14 @@ module.exports = (args, cbk) => {
         'macaroon',
         ({credentials, macaroon}, cbk) =>
       {
+        const {allow} = credentialRestrictions({
+          is_nospend: args.is_nospend,
+          is_readonly: args.is_readonly,
+          methods: args.methods,
+        });
+
         // Exit early when readonly credentials are not requested
-        if (!args.is_readonly && !args.is_nospend) {
+        if (!allow) {
           return cbk(null, {macaroon});
         }
 
@@ -210,9 +218,12 @@ module.exports = (args, cbk) => {
           socket: credentials.socket,
         });
 
-        const permissions = !!args.is_readonly ? readPerms : noSpendPerms;
-
-        return grantAccess({lnd, permissions}, cbk);
+        return grantAccess({
+          lnd,
+          methods: allow.methods,
+          permissions: allow.permissions,
+        },
+        cbk);
       }],
 
       // Final credentials with encryption applied

package/network/transfer_funds.js

@@ -160,11 +160,48 @@ module.exports = (args, cbk) => {
       // Parse the amount specified
       parseAmount: [
         'getChannels',
+        'getInKey',
         'getOutKey',
+        'getRemoteChannels',
         'getToKey',
         'outPeer',
-        ({getChannels, getOutKey, getToKey, outPeer}, cbk) =>
+        ({
+          getChannels,
+          getInKey,
+          getOutKey,
+          getRemoteChannels,
+          getToKey,
+          outPeer,
+        },
+        cbk) =>
       {
+        // Calculate the inbound peer inbound liquidity
+        const inInbound = getRemoteChannels.channels
+          .filter(n => n.partner_public_key === getInKey.public_key)
+          .reduce((sum, chan) => {
+            // Treat incoming payment as if they were still remote balance
+            const inbound = chan.pending_payments.filter(n => !n.is_outgoing);
+
+            const pending = sumOf(inbound.map(({tokens}) => tokens));
+
+            return sum + chan.remote_balance + pending;
+          },
+          Number());
+
+        // Calculate the inbound peer outbound liquidity
+        const inOutbound = getRemoteChannels.channels
+          .filter(n => n.partner_public_key === getInKey.public_key)
+          .reduce((sum, chan) => {
+            // Treat outgoing payment as if they were still local balance
+            const outbound = chan.pending_payments
+              .filter(n => !!n.is_outgoing);
+
+            const pending = sumOf(outbound.map(({tokens}) => tokens));
+
+            return sum + chan.local_balance + pending;
+          },
+          Number());
+
         // Calculate the outbound peer inbound liquidity
         const outInbound = getChannels.channels
           .filter(n => n.partner_public_key === getOutKey.public_key)
@@ -194,6 +231,8 @@ module.exports = (args, cbk) => {
 
         // Variables to use in amount
         const variables = {
+          in_inbound: inInbound,
+          in_outbound: inOutbound,
           out_inbound: outInbound,
           out_liquidity: sumOf(
             getChannels.channels

package/package.json

@@ -23,9 +23,9 @@
     "bolt03": "1.2.10",
     "bolt07": "1.7.3",
     "caporal": "1.4.0",
-    "cbor": "8.0.0",
+    "cbor": "8.0.2",
     "cert-info": "1.5.1",
-    "colorette": "2.0.12",
+    "colorette": "2.0.14",
     "crypto-js": "4.1.1",
     "csv-parse": "4.16.3",
     "goldengate": "10.4.0",
@@ -35,7 +35,7 @@
     "inquirer": "8.1.5",
     "invoices": "2.0.0",
     "ln-accounting": "5.0.3",
-    "ln-service": "52.8.0",
+    "ln-service": "52.10.2",
     "ln-sync": "2.0.2",
     "ln-telegram": "3.3.0",
     "moment": "2.29.1",
@@ -45,7 +45,7 @@
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.3",
     "stats-lite": "2.2.0",
-    "table": "6.7.1",
+    "table": "6.7.2",
     "telegraf": "4.4.2",
     "update-notifier": "5.1.0",
     "window-size": "1.1.1"
@@ -80,5 +80,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/fiat/*.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.0.0"
+  "version": "11.3.0"
 }

package/peers/find_tag_match.js

@@ -83,7 +83,10 @@ module.exports = ({channels, filters, tags, query}) => {
       const matching = isMatchingFilters({
         filters: filters || [],
         variables: {
-          heights: withPeer.map(n => decodeChanId({channel: n.id}).block_height),
+          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)),
         },

package/routing/get_ignores.js

@@ -9,13 +9,17 @@ 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 decodePair = n => n.split('/');
 const flatten = arr => [].concat(...arr);
 const heightFromId = id => Number(id.split('x').shift());
 const {isArray} = Array;
 const isChannel = n => /^\d*x\d*x\d*$/.test(n);
 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;
@@ -108,6 +112,11 @@ module.exports = (args, cbk) => {
             return asFormula(id);
           }
 
+          // Exit early when the id is an out filter
+          if (isOutFilter(id)) {
+            return asOutFilter(id);
+          }
+
           // Exit early when the id is a public key
           if (isPublicKey(id)) {
             return {node: {from_public_key: id}};
@@ -161,16 +170,96 @@ module.exports = (args, cbk) => {
 
       // Get the block height for use in formulas
       getHeight: ['sortedAvoids', ({sortedAvoids}, cbk) => {
-        const formulas = sortedAvoids.filter(n => n.formula);
+        const hasFormula = !!sortedAvoids.find(n => !!n.formula);
+        const hasOutFilter = !!sortedAvoids.find(n => !!n.out_filter);
 
         // Exit early when there are no formulas
-        if (!formulas.length) {
+        if (!hasFormula &&  !hasOutFilter) {
           return cbk();
         }
 
         return getHeight({lnd: args.lnd}, cbk);
       }],
 
+      // Get out filter avoids
+      getOutFilterIgnores: [
+        'getHeight',
+        'sortedAvoids',
+        ({getHeight, sortedAvoids}, cbk) =>
+      {
+        const filters = sortedAvoids
+          .filter(n => !!n.out_filter)
+          .map(n => ({formula: n.out_filter, key: n.key}));
+
+        return asyncMap(filters, ({formula, key}, cbk) => {
+          return getNode({lnd: args.lnd, public_key: key}, (err, res) => {
+            // Exit early when the node in question is unknown
+            if (isArray(err) && err.slice().shift() === 404) {
+              return cbk(null, []);
+            }
+
+            if (!!err) {
+              return cbk(err);
+            }
+
+            const outboundAvoids = res.channels
+              .map(({capacity, id, policies}) => {
+                const height = heightFromId(id);
+                const outPolicy = policies.find(n => n.public_key === key);
+                const peerPolicy = policies.find(n => n.public_key !== key);
+
+                if (!outPolicy || !peerPolicy) {
+                  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(),
+                });
+
+                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;
+                }
+
+                return {
+                  from_public_key: key,
+                  to_public_key: peerPolicy.public_key,
+                };
+              });
+
+            const {error} = outboundAvoids.find(n => !!n && !!n.error) || {};
+
+            if (!!error) {
+              return cbk([400, 'InvalidAvoidDirective', {error, formula}]);
+            }
+
+            return cbk(null, outboundAvoids.filter(n => !!n));
+          });
+        },
+        cbk);
+      }],
+
       // Get formula avoids
       getFormulaIgnores: [
         'getHeight',
@@ -181,12 +270,17 @@ module.exports = (args, cbk) => {
 
         return asyncMap(formulas, ({formula, key}, cbk) => {
           return getNode({lnd: args.lnd, public_key: key}, (err, res) => {
+            // Exit early when the node in question is unknown
+            if (isArray(err) && err.slice().shift() === 404) {
+              return cbk(null, []);
+            }
+
             if (!!err) {
               return cbk(err);
             }
 
             const inboundAvoids = res.channels
-              .map(({id, policies}) => {
+              .map(({capacity, id, policies}) => {
                 const height = heightFromId(id);
                 const inPolicy = policies.find(n => n.public_key !== key);
 
@@ -195,13 +289,17 @@ module.exports = (args, cbk) => {
                 }
 
                 const parser = new Parser();
+                const variables = {};
 
-                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(),
-                };
+                });
 
                 keys(variables).forEach(key => {
                   parser.setVariable(key.toLowerCase(), variables[key]);
@@ -263,11 +361,13 @@ module.exports = (args, cbk) => {
       combinedIgnores: [
         'getChannelIgnores',
         'getFormulaIgnores',
+        'getOutFilterIgnores',
         'getQueryIgnores',
         'sortedAvoids',
         ({
           getChannelIgnores,
           getFormulaIgnores,
+          getOutFilterIgnores,
           getQueryIgnores,
           sortedAvoids,
         },
@@ -276,6 +376,7 @@ module.exports = (args, cbk) => {
         const ignore = [
           flatten(getChannelIgnores),
           flatten(getFormulaIgnores),
+          flatten(getOutFilterIgnores),
           getQueryIgnores,
           sortedAvoids.map(n => n.node).filter(n => !!n),
         ];

package/services/get_balanced_opens.js

@@ -163,9 +163,33 @@ module.exports = ({lnd}, cbk) => {
         return cbk(null, balancedChannelRequests.filter(n => !!n));
       }],
 
+      // Filter out incoming opens that were already accepted
+      unacceptedOpens: ['incomingOpens', ({incomingOpens}, cbk) => {
+        const asyncFilter = require('async/filter');
+        const {getPayment} = require('ln-service');
+        return asyncFilter(incomingOpens, (incoming, cbk) => {
+          const {id} = parsePaymentRequest({request: incoming.accept_request});
+
+          return getPayment({id, lnd}, (err, res) => {
+            // An unknown payment means the open was not ack'ed
+            if (!!err && err.slice().shift() === 404) {
+              return cbk(null, true);
+            }
+
+            if (!!err) {
+              return cbk(err);
+            }
+
+            // If an accept request was not paid nothing happened yet
+            return cbk(null, !!res.is_failed);
+          });
+        },
+        cbk);
+      }],
+
       // Final set of active balanced open requests
-      opens: ['incomingOpens', ({incomingOpens}, cbk) => {
-        return cbk(null, {incoming: incomingOpens});
+      opens: ['unacceptedOpens', ({unacceptedOpens}, cbk) => {
+        return cbk(null, {incoming: unacceptedOpens});
       }],
     },
     returnResult({reject, resolve, of: 'opens'}, cbk));

package/swaps/manage_rebalance.js

@@ -43,6 +43,14 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedLoggerToManageRebalance'])
         }
 
+        if (isArray(args.max_fee)) {
+          return cbk([400, 'ExpectedSingleMaxFeeValue']);
+        }
+
+        if (isArray(args.max_fee_rate)) {
+          return cbk([400, 'ExpectedSingleMaxFeeValue']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'ExpectedLndToManageRebalance']);
         }
@@ -85,8 +93,8 @@ module.exports = (args, cbk) => {
             in_through: args.in_through,
             lnd: args.lnd,
             logger: args.logger,
-            max_fee: args.max_fee,
-            max_fee_rate: args.max_fee_rate,
+            max_fee: Number(args.max_fee) || undefined,
+            max_fee_rate: Number(args.max_fee_rate) || undefined,
             max_rebalance: args.max_rebalance,
             out_filters: args.out_filters,
             out_inbound: args.out_inbound,

package/test/lnd/test_credential_restrictions.js

@@ -0,0 +1,74 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../lnd/credential_restrictions');
+
+const tests = [
+  {
+    args: {},
+    description: 'No restrictions results in no allow elements',
+    expected: {},
+  },
+  {
+    args: {is_nospend: true},
+    description: 'No spend results in nospend permissions',
+    expected: {
+      allow: {
+        methods: [],
+        permissions: [
+          'address:read',
+          'address:write',
+          'info:read',
+          'info:write',
+          'invoices:read',
+          'invoices:write',
+          'macaroon:read',
+          'message:read',
+          'offchain:read',
+          'onchain:read',
+          'peers:read',
+          'peers:write',
+          'signer:read',
+        ],
+      },
+    },
+  },
+  {
+    args: {is_readonly: true},
+    description: 'Readonly results in read permissions',
+    expected: {
+      allow: {
+        methods: [],
+        permissions: [
+          'address:read',
+          'info:read',
+          'invoices:read',
+          'macaroon:read',
+          'message:read',
+          'offchain:read',
+          'onchain:read',
+          'peers:read',
+          'signer:read',
+        ],
+      },
+    },
+  },
+  {
+    args: {methods: ['getWalletInfo']},
+    description: 'Readonly results in read permissions',
+    expected: {allow: {methods: ['getWalletInfo'], permissions: []}},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => method(args), new Error(error), 'Got expected error');
+    } else {
+      const res = method(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/services/test_get_balanced_opens.js

@@ -1,3 +1,5 @@
+const EventEmitter = require('events');
+
 const {createSignedRequest} = require('invoices');
 const {createUnsignedRequest} = require('invoices');
 const sign = require('secp256k1').ecdsaSign;
@@ -107,6 +109,15 @@ const makeArgs = overrides => {
           });
         },
       },
+      router: {
+        trackPaymentV2: ({}) => {
+          const emitter = new EventEmitter();
+
+          process.nextTick(() => emitter.emit('data', {status: 'FAILED'}));
+
+          return emitter;
+        },
+      },
     },
   };
 

package/fiat/get_price_chart.js

@@ -1,194 +0,0 @@
-const asyncAuto = require('async/auto');
-const {decodePaymentRequest} = require('ln-service');
-const {getHeight} = require('ln-service');
-const moment = require('moment');
-const {payViaPaymentRequest} = require('ln-service');
-const {returnResult} = require('asyncjs-util');
-
-const {authenticatedLnd} = require('./../lnd');
-const {decryptPayload} = require('./../encryption');
-const {exchanges} = require('./market');
-const {pairs} = require('./market');
-
-const api = 'https://api.suredbits.com/historical/v0/';
-const base64ToHex = base64 => Buffer.from(base64, 'base64').toString('hex');
-const daysCount = 80;
-const defaultMaxFee = 5;
-const {isArray} = Array;
-const maxCltvDelta = 144 * 30;
-const {parse} = JSON;
-const pathfindingTimeoutMs = 1000 * 60 * 5;
-const titleCase = str => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
-
-/** Get historic exchange rates
-
-  {
-    exchange: <Exchange String>
-    [fee]: <Desired Maximum Fee Tokens Number>
-    [node]: <Saved Node Name String>
-    pair: <Pair String>
-    request: <Request Function>
-  }
-
-  @returns via cbk or Promise
-  {
-    description: <Price Range Description String>
-    prices: [<Price on Day String>]
-  }
-*/
-module.exports = ({exchange, fee, node, pair, request}, cbk) => {
-  return new Promise((resolve, reject) => {
-    return asyncAuto({
-      // Get lnd
-      getLnd: cbk => authenticatedLnd({node}, cbk),
-
-      // Check arguments
-      validate: cbk => {
-        if (!exchanges.find(n => n === exchange)) {
-          return cbk([400, 'ExpectedKnownExchangeToGetPriceData']);
-        }
-
-        if (fee !== undefined && !fee) {
-          return cbk([400, 'ExpectedNonZeroMaxFeeToGetPriceData']);
-        }
-
-        if (!pairs[pair]) {
-          return cbk([400, 'ExpectedKnownPairToGetPriceData']);
-        }
-
-        if (!pairs[pair].find(n => n === exchange)) {
-          return cbk([400, 'UnsupportedExchange', {supported: pairs[pair]}]);
-        }
-
-        return cbk();
-      },
-
-      // Get price data
-      getPrices: ['validate', ({}, cbk) => {
-        const year = moment().format('Y');
-
-        return request({
-          json: true,
-          url: `${api}${exchange}/${pair.toUpperCase()}/${year}/daily`,
-        },
-        (err, r, json) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorGettingHistoricalPrices', {err}]);
-          }
-
-          if (!r) {
-            return cbk([503, 'ExpectedResponseWhenGettingHistoricalPrices']);
-          }
-
-          if (r.statusCode !== 200) {
-            return cbk([503, 'UnexpectedStatusCodeGettingHistoricalPrices'])
-          }
-
-          if (!json) {
-            return cbk([503, 'ExpectedResponseDataFromHistoricalPriceApi']);
-          }
-
-          if (!json.encryptedData) {
-            return cbk([503, 'ExpectedEncryptedHistoricalPriceData']);
-          }
-
-          if (!json.invoice) {
-            return cbk([503, 'ExpectedPaymentRequestForHistoricalPriceData']);
-          }
-
-          try {
-            return cbk(null, {
-              encrypted: base64ToHex(json.encryptedData),
-              request: json.invoice,
-            });
-          } catch (err) {
-            return cbk([503, 'UnexpectedDataFromHistoricalPriceApi', {err}]);
-          }
-        });
-      }],
-
-      // Decode request
-      decodedRequest: ['getLnd', 'getPrices', ({getLnd, getPrices}, cbk) => {
-        return decodePaymentRequest({
-          lnd: getLnd.lnd,
-          request: getPrices.request,
-        },
-        cbk);
-      }],
-
-      // Get height
-      getHeight: ['decodedRequest', 'getLnd', ({getLnd}, cbk) => {
-        return getHeight({lnd: getLnd.lnd}, cbk);
-      }],
-
-      // Purchase preimage needed to decrypt price data
-      payInvoice: [
-        'decodedRequest',
-        'getHeight',
-        'getLnd',
-        'getPrices',
-        ({decodedRequest, getHeight, getLnd, getPrices}, cbk) =>
-      {
-        const {tokens} = decodedRequest;
-
-        // Check that the payment request doesn't require too many tokens
-        if (tokens > (fee || defaultMaxFee)) {
-          return cbk([400, 'MaxFeePriceFetchFeeTooLow', {needed_fee: tokens}]);
-        }
-
-        return payViaPaymentRequest({
-          lnd: getLnd.lnd,
-          max_fee: (fee || defaultMaxFee) - tokens,
-          max_timeout_height: getHeight.current_block_height + maxCltvDelta,
-          pathfinding_timeout: pathfindingTimeoutMs,
-          request: getPrices.request,
-        },
-        cbk);
-      }],
-
-      // Decrypt price data
-      prices: ['getPrices', 'payInvoice', ({getPrices, payInvoice}, cbk) => {
-        const {encrypted} = getPrices;
-        const {secret} = payInvoice;
-
-        try {
-          const {payload} = decryptPayload({encrypted, secret});
-
-          if (!isArray(parse(payload)) || !parse(payload).length) {
-            return cbk([503, 'ExpectedArrayOfPricesInPayload']);
-          }
-
-          const prices = parse(payload).slice(-daysCount);
-
-          if (!!prices.find(n => n.pair !== pair.toUpperCase())) {
-            return cbk([503, 'ExpectedPriceForSpecifiedHistoricPair']);
-          }
-
-          if (!!prices.find(n => !n.price)) {
-            return cbk([503, 'ExpectedPriceForHistoricPriceQuote']);
-          }
-
-          if (!!prices.find(n => !n.timestamp)) {
-            return cbk([503, 'ExpectedTimestampForHistoricPriceQuote']);
-          }
-
-          const [end] = prices.slice().reverse();
-          const [start] = prices;
-
-          const day0 = `${moment(start.timestamp).format('L')}`;
-          const fin = `${moment(end.timestamp).format('L')}`;
-          const last = `Last Price: ${end.price}`
-          const market = `${titleCase(exchange)} ${start.pair}`;
-
-          return cbk(null, {
-            description: `${market} from ${day0} to ${fin}. ${last}.`,
-            prices: prices.map(({price}) => price),
-          });
-        } catch (err) {
-          return cbk([503, 'FailedToDecryptHistoricPricesData', {err}]);
-        }
-      }],
-    },
-    returnResult({reject, resolve, of: 'prices'}, cbk));
-  });
-};