balanceofsatoshis 24.1.0 → 24.2.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## 24.2.1
+
+- `open`: Adhere to BIP 69 when ordering funding outputs with equal amounts
+
+## 24.2.0
+
+- Add support for LND 0.21.4 and LND 0.20.5
+- `pay`, `probe`: Add support for tags in `--out`, `--out-filter`
+
 ## 24.1.0
 
 - `fees`: Add `--repeat-interval-ms` to show or set the fees again each time an

package/README.md

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

package/bos

@@ -14,7 +14,6 @@ const {writeFile} = require('fs');
 const importLazy = require('import-lazy')(require);
 
 const accounting = importLazy('ln-accounting');
-const fetch = importLazy('@alexbosworth/node-fetch');
 const fiat = importLazy('@alexbosworth/fiat');
 const lnService = importLazy('ln-service');
 const lnSync = importLazy('ln-sync');
@@ -1517,6 +1516,10 @@ prog
   // Pay a payment request, probing first
   .command('pay', 'Pay a payment request, probing first')
   .help('Blinded path requests are probed to the introduction node, 1 path')
+  .help('--out can take a tag to make the first hop through any tagged peer')
+  .help('--out-filter vars: CAPACITY/HEIGHTS/INBOUND_LIQUIDITY')
+  .help('--out-filter vars: OUTBOUND_LIQUIDITY/PENDING_PAYMENTS')
+  .help('--out-filter vars: INBOUND_BASE_FEE/INBOUND_FEE_RATE')
   .argument('<request>', 'Payment Request')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
   .option('--avoid-high-fee-routes', 'Avoid evaluating too-high fee routes')
@@ -1526,7 +1529,8 @@ prog
   .option('--message <message>', 'Attach text message to payment')
   .option('--no-color', 'Mute all colors')
   .option('--node <node_name>', 'Node to use to pay payment request')
-  .option('--out <public_key>', 'Make first hop through peer', REPEATABLE)
+  .option('--out <peer_or_tag>', 'Make first hop through peer/tag', REPEATABLE)
+  .option('--out-filter <out_filter>', 'Filter outbound peer/tag', REPEATABLE)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1545,6 +1549,7 @@ prog
           max_paths: options.maxPaths,
           message: options.message,
           out: flatten([options.out].filter(n => !!n)),
+          out_filters: flatten([options.outFilter].filter(n => !!n)),
           request: args.request,
         },
         responses.returnObject({logger, reject, resolve}));
@@ -1637,6 +1642,10 @@ prog
   .command('probe', 'Check if a payment request is sendable')
   .help('Simulate paying a payment request without actually paying it')
   .help('Blinded path requests are probed to the introduction node, 1 path')
+  .help('--out can take a tag to make the first hop through any tagged peer')
+  .help('--out-filter vars: CAPACITY/HEIGHTS/INBOUND_LIQUIDITY')
+  .help('--out-filter vars: OUTBOUND_LIQUIDITY/PENDING_PAYMENTS')
+  .help('--out-filter vars: INBOUND_BASE_FEE/INBOUND_FEE_RATE')
   .argument('<to>', 'Payment request or node public key')
   .argument('[amount]', 'Amount to probe, default: request amount')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
@@ -1647,7 +1656,8 @@ prog
   .option('--max-paths <max>', 'Maximum paths to use for find-max', INT, 1)
   .option('--no-color', 'Mute all colors')
   .option('--node <node_name>', 'Node to use for payment request check')
-  .option('--out <public_key>', 'Make first hop through peer', REPEATABLE)
+  .option('--out <peer_or_tag>', 'Make first hop through peer/tag', REPEATABLE)
+  .option('--out-filter <out_filter>', 'Filter outbound peer/tag', REPEATABLE)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1667,6 +1677,7 @@ prog
           max_fee: options.maxFee,
           max_paths: options.maxPaths,
           out: flatten([options.out].filter(n => !!n)),
+          out_filters: flatten([options.outFilter].filter(n => !!n)),
           request: args.to.length !== 66 ? args.to : undefined,
           tokens: args.amount || undefined,
         },

package/commands/fetch_request.js

@@ -1,14 +1,12 @@
 const {stringify} = require('querystring');
 
-const {AbortController} = require('abort-controller');
-
 const encodeQs = qs => !qs ? '' : '?' + stringify(qs);
 const timeoutSignals = new WeakMap();
 
 /** Derive a request function that uses fetch to simulate request behavior
 
   {
-    fetch: <Node Fetch Function>
+    fetch: <Fetch Function>
   }
 
   @returns

package/network/execute_probe.js

@@ -40,7 +40,7 @@ const tokensAsMillitokens = tok => (BigInt(tok) * BigInt(1e3)).toString();
       type: <Message To Final Destination Type Number String>
       value: <Message To Final Destination Raw Value Hex Encoded String>
     }]
-    [outgoing_channel]: <Outgoing Channel Id String>
+    [outgoing_channels]: [<Outgoing Channel Id String>]
     [paths]: [{
       base_fee_mtokens: <Accumulated Base Fee Millitokens String>
       cltv_delta: <Accumulated CLTV Expiry Delta Number>
@@ -176,7 +176,7 @@ module.exports = (args, cbk) => {
             max_fee_mtokens: strictMaxFee || undefined,
             max_timeout_height: args.max_timeout_height,
             messages: args.messages,
-            outgoing_channel: args.outgoing_channel,
+            outgoing_channels: args.outgoing_channels,
             path_timeout_ms: pathTimeoutMs,
             paths: args.paths,
             payment: args.payment,

package/network/get_out_peers.js

@@ -0,0 +1,235 @@
+const asyncAuto = require('async/auto');
+const asyncMapSeries = require('async/mapSeries');
+const {findKey} = require('ln-sync');
+const {getChannels} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {getNode} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const findPeerMatch = require('./../peers/find_peer_match');
+const {getTags} = require('./../tags');
+
+const flatten = arr => [].concat(...arr);
+const {isArray} = Array;
+const isFeeFilter = n => /\binbound_(base_fee|fee_rate)\b/i.test(n);
+const uniq = arr => Array.from(new Set(arr));
+
+/** Get the peers to route out through, expanding tags and applying filters
+
+  A tag query expands to all of the tagged peers that satisfy the filters
+
+  {
+    [filters]: [<Outbound Peer Filter Formula String>]
+    [fs]: {
+      getFile: <Read File Contents Function> (path, cbk) => {}
+    }
+    lnd: <Authenticated LND API Object>
+    out: [<Out Through Peer Public Key, Alias, or Tag String>]
+  }
+
+  @returns via cbk or Promise
+  {
+    public_keys: [<Out Through Peer Public Key Hex String>]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!!args.filters && !isArray(args.filters)) {
+          return cbk([400, 'ExpectedArrayOfOutFiltersToGetOutPeers']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetOutPeers']);
+        }
+
+        if (!isArray(args.out)) {
+          return cbk([400, 'ExpectedArrayOfOutQueriesToGetOutPeers']);
+        }
+
+        if (!!args.out.filter(n => !n).length) {
+          return cbk([400, 'ExpectedNonEmptyOutQueriesToGetOutPeers']);
+        }
+
+        // Filters narrow down out peers so there must be out peers to filter
+        if (!args.out.length && !!args.filters && !!args.filters.length) {
+          return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+        }
+
+        return cbk();
+      },
+
+      // Get channels to find peers
+      getChannels: ['validate', ({}, cbk) => {
+        // Exit early when there are no out peers
+        if (!args.out.length) {
+          return cbk();
+        }
+
+        return getChannels({lnd: args.lnd}, cbk);
+      }],
+
+      // Get the identity key to find the remote policies of channels
+      getIdentity: ['validate', ({}, cbk) => {
+        // Exit early when there are no filters that use fee variables
+        if (!(args.filters || []).some(isFeeFilter)) {
+          return cbk();
+        }
+
+        return getIdentity({lnd: args.lnd}, cbk);
+      }],
+
+      // Get the set of tags
+      getTags: ['validate', ({}, cbk) => {
+        // Exit early when there are no out peers or no way to read tags
+        if (!args.fs || !args.out.length) {
+          return cbk(null, {tags: []});
+        }
+
+        return getTags({fs: args.fs}, cbk);
+      }],
+
+      // Get the remote policies of channels for fee filter variables
+      getPolicies: ['getIdentity', ({getIdentity}, cbk) => {
+        // Exit early when there are no filters that use fee variables
+        if (!getIdentity) {
+          return cbk(null, []);
+        }
+
+        const id = getIdentity.public_key;
+
+        return getNode({lnd: args.lnd, public_key: id}, (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          const policies = res.channels
+            .map(channel => channel.policies.find(n => n.public_key !== id))
+            .filter(n => !!n)
+            .map(policy => ({
+              base_fee_mtokens: policy.base_fee_mtokens,
+              fee_rate: policy.fee_rate,
+              public_key: policy.public_key,
+            }));
+
+          return cbk(null, policies);
+        });
+      }],
+
+      // Find the peers for each out query
+      getPeers: [
+        'getChannels',
+        'getPolicies',
+        'getTags',
+        ({getChannels, getPolicies, getTags}, cbk) =>
+      {
+        // Exit early when there are no out peers
+        if (!args.out.length) {
+          return cbk(null, []);
+        }
+
+        const active = getChannels.channels.filter(n => !!n.is_active);
+        const filters = args.filters || [];
+
+        const peerKeys = uniq(active.map(n => n.partner_public_key));
+
+        // Check if a peer satisfies the filters
+        const isMatch = key => findPeerMatch({
+          filters,
+          channels: active,
+          nodes: [key],
+          policies: getPolicies,
+        });
+
+        return asyncMapSeries(args.out.map(n => String(n)), (query, cbk) => {
+          // Find tags that match on id or on alias
+          const tagMatches = getTags.tags.filter(tag => {
+            const alias = tag.alias || String();
+
+            const isAliasMatch = alias.toLowerCase() === query.toLowerCase();
+            const isIdMatch = tag.id.startsWith(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 [tag, ...otherTags] = matches;
+
+          if (!!otherTags.length) {
+            return cbk([400, 'MultipleTagMatchesFoundForOutPeer', {matches}]);
+          }
+
+          // A recognized tag must not fall through to an alias search
+          if (!tag && !!tagMatches.length) {
+            return cbk([400, 'NoActivePeersFoundForOutTag', {query}]);
+          }
+
+          // Exit early when the query is a tag, expanding to its peers
+          if (!!tag) {
+            const results = uniq(tag.nodes)
+              .filter(n => peerKeys.includes(n))
+              .map(key => isMatch(key));
+
+            const {failure} = results.find(n => !!n.failure) || {};
+
+            if (!!failure) {
+              return cbk([400, 'FailedToParseFilter', failure]);
+            }
+
+            const keys = results.map(n => n.match).filter(n => !!n);
+
+            if (!keys.length) {
+              return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+            }
+
+            return cbk(null, keys);
+          }
+
+          // The query is not a tag so look for a public key or alias match
+          return findKey({
+            query,
+            channels: getChannels.channels,
+            lnd: args.lnd,
+          },
+          (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            const key = res.public_key.toLowerCase();
+
+            // Exit early when there are no filters to apply
+            if (!filters.length) {
+              return cbk(null, [key]);
+            }
+
+            const {failure, match} = isMatch(key);
+
+            if (!!failure) {
+              return cbk([400, 'FailedToParseFilter', failure]);
+            }
+
+            if (!match) {
+              return cbk([400, 'NoPeerMatchesFoundToSatisfyOutboundFilter']);
+            }
+
+            return cbk(null, [match]);
+          });
+        },
+        cbk);
+      }],
+
+      // Final set of out peers
+      peers: ['getPeers', ({getPeers}, cbk) => {
+        return cbk(null, {public_keys: uniq(flatten(getPeers))});
+      }],
+    },
+    returnResult({reject, resolve, of: 'peers'}, cbk));
+  });
+};

package/network/multi_path_probe.js

@@ -121,7 +121,7 @@ module.exports = (args, cbk) => {
           in_through: args.in_through,
           lnd: args.lnd,
           logger: args.logger,
-          out_through: args.out_through,
+          out_through: [args.out_through].filter(n => !!n),
           request: args.request,
           timeout_minutes: args.timeout_minutes,
           tokens: args.tokens,

package/network/pay.js

@@ -1,6 +1,5 @@
 const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
-const {findKey} = require('ln-sync');
 const {formatTokens} = require('ln-sync');
 const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
@@ -14,6 +13,7 @@ const {describeRoute} = require('./../display');
 const {describeRoutingFailure} = require('./../display');
 const {getIgnores} = require('./../routing');
 const {getTags} = require('./../tags');
+const getOutPeers = require('./get_out_peers');
 const probeDestination = require('./probe_destination');
 
 const cltvDeltaBuffer = 3;
@@ -37,7 +37,8 @@ const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
     max_fee: <Max Fee Tokens Number>
     max_paths: <Maximum Paths Number>
     [message]: <Message String>
-    out: [<Out Through Peer With Public Key Hex String>]
+    out: [<Out Through Peer With Public Key, Alias, or Tag String>]
+    [out_filters]: [<Out Through Peer Filter Formula String>]
     request: <BOLT 11 Payment Request String>
   }
 */
@@ -113,8 +114,11 @@ module.exports = (args, cbk) => {
 
       // Find public keys to pay out through
       getOuts: ['validate', ({}, cbk) => {
-        return asyncMap(args.out, (query, cbk) => {
-          return findKey({query, lnd: args.lnd}, cbk);
+        return getOutPeers({
+          filters: args.out_filters,
+          fs: args.fs,
+          lnd: args.lnd,
+          out: args.out,
         },
         cbk);
       }],
@@ -133,15 +137,16 @@ module.exports = (args, cbk) => {
       getBaseIgnores: [
         'getChannels',
         'getIdentity',
+        'getOuts',
         'getTags',
-        ({getChannels, getIdentity, getTags}, cbk) =>
+        ({getChannels, getIdentity, getOuts, getTags}, cbk) =>
       {
         // Exit early when there are no avoids
         if (!args.avoid.length) {
           return cbk(null, {ignore: []});
         }
 
-        const [out] = args.out || [];
+        const [out, ...otherOuts] = getOuts.public_keys;
 
         return getIgnores({
           avoid: args.avoid,
@@ -149,7 +154,7 @@ module.exports = (args, cbk) => {
           in_through: args.in_through,
           lnd: args.lnd,
           logger: args.logger,
-          out_through: out,
+          out_through: !otherOuts.length ? out : undefined,
           public_key: getIdentity.public_key,
           tags: getTags.tags,
         },
@@ -168,14 +173,14 @@ module.exports = (args, cbk) => {
         }
 
         // Exit early when there is no outbound restriction
-        if (!getOuts.length) {
+        if (!getOuts.public_keys.length) {
           return cbk(null, {ignore: getBaseIgnores.ignore});
         }
 
         return getSyntheticOutIgnores({
           ignore: getBaseIgnores.ignore,
           lnd: args.lnd,
-          out: getOuts.map(n => n.public_key),
+          out: getOuts.public_keys,
         },
         cbk);
       }],
@@ -183,19 +188,14 @@ module.exports = (args, cbk) => {
       // Make single-path payment
       singlePathPay: [
         'getBaseIgnores',
-        'getOuts', ({getBaseIgnores, getOuts}, cbk) =>
+        'getOuts',
+        ({getBaseIgnores, getOuts}, cbk) =>
       {
         // Exit early when doing a multi-path
         if (args.max_paths !== singlePath) {
           return cbk();
         }
 
-        const [outThrough, otherKey] = getOuts.map(n => n.public_key);
-
-        if (!!otherKey) {
-          return cbk([501, 'CannotPayThroughMultipleOutPeersOnSinglePath']);
-        }
-
         return probeDestination({
           fs: args.fs,
           ignore: getBaseIgnores.ignore,
@@ -206,7 +206,7 @@ module.exports = (args, cbk) => {
           lnd: args.lnd,
           max_fee: args.max_fee,
           message: args.message,
-          out_through: outThrough,
+          out_through: getOuts.public_keys,
           request: args.request,
         },
         cbk);

package/network/probe.js

@@ -1,7 +1,5 @@
 const asyncAuto = require('async/auto');
-const asyncMap = require('async/map');
 const asyncWhilst = require('async/whilst');
-const {findKey} = require('ln-sync');
 const {formatTokens} = require('ln-sync');
 const {getChannel} = require('ln-service');
 const {getChannels} = require('ln-service');
@@ -19,6 +17,7 @@ const {describeRoutingFailure} = require('./../display');
 const {getIcons} = require('./../display');
 const {getIgnores} = require('./../routing');
 const {getTags} = require('./../tags');
+const getOutPeers = require('./get_out_peers');
 const probeDestination = require('./probe_destination');
 
 const defaultFinalCltvDelta = 144;
@@ -47,7 +46,8 @@ const withTotalFee = ({fee, ...res}) => ({total_fee: fee, ...res});
     logger: <Winston Logger Object>
     max_fee: <Max Fee Tokens Number>
     [max_paths]: <Maximum Probe Paths Number>
-    out: [<Out Through Peer With Public Key Hex String>]
+    out: [<Out Through Peer With Public Key, Alias, or Tag String>]
+    [out_filters]: [<Out Through Peer Filter Formula String>]
     [request]: <BOLT 11 Encoded Payment Request String>
     [timeout_minutes]: <Stop Searching For Routes After N Minutes Number>
     [tokens]: <Tokens Amount String>
@@ -148,8 +148,11 @@ module.exports = (args, cbk) => {
 
       // Find public keys to pay out through
       getOuts: ['validate', ({}, cbk) => {
-        return asyncMap(args.out, (query, cbk) => {
-          return findKey({query, lnd: args.lnd}, cbk);
+        return getOutPeers({
+          filters: args.out_filters,
+          fs: args.fs,
+          lnd: args.lnd,
+          out: args.out,
         },
         cbk);
       }],
@@ -197,15 +200,16 @@ module.exports = (args, cbk) => {
       getBaseIgnores: [
         'getChannels',
         'getIdentity',
+        'getOuts',
         'getTags',
-        ({getChannels, getIdentity, getTags}, cbk) =>
+        ({getChannels, getIdentity, getOuts, getTags}, cbk) =>
       {
         // Exit early when there are no avoids
         if (!args.avoid.length) {
           return cbk(null, {ignore: []});
         }
 
-        const [out] = args.out || [];
+        const [out, ...otherOuts] = getOuts.public_keys;
 
         return getIgnores({
           avoid: args.avoid,
@@ -213,7 +217,7 @@ module.exports = (args, cbk) => {
           in_through: args.in_through,
           lnd: args.lnd,
           logger: args.logger,
-          out_through: out,
+          out_through: !otherOuts.length ? out : undefined,
           public_key: getIdentity.public_key,
           tags: getTags.tags,
         },
@@ -232,14 +236,14 @@ module.exports = (args, cbk) => {
         }
 
         // Exit early when there is no outbound restriction
-        if (!getOuts.length) {
+        if (!getOuts.public_keys.length) {
           return cbk(null, {ignore: getBaseIgnores.ignore});
         }
 
         return getSyntheticOutIgnores({
           ignore: getBaseIgnores.ignore,
           lnd: args.lnd,
-          out: getOuts.map(n => n.public_key),
+          out: getOuts.public_keys,
         },
         cbk);
       }],
@@ -256,13 +260,6 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
-        // Exit early when probing on a single path
-        if (getOuts.length > singlePath) {
-          return cbk([501, 'MultipleOutPeersNotSupportedWithSinglePath']);
-        }
-
-        const [outThrough] = getOuts.map(n => n.public_key);
-
         return probeDestination({
           tokens,
           destination: args.destination,
@@ -273,7 +270,7 @@ module.exports = (args, cbk) => {
           lnd: args.lnd,
           logger: args.logger,
           max_fee: args.max_fee,
-          out_through: outThrough,
+          out_through: getOuts.public_keys,
           request: args.request,
         },
         cbk);

package/network/probe_destination.js

@@ -36,6 +36,7 @@ const feeBuffer = fees => fees * 2;
 const {floor} = Math;
 const fromKeyType = '34349339';
 const htlcOutputSize = 43;
+const {isArray} = Array;
 const isBlindedHop = hop => !!hop.encrypted_data && !hop.path_key;
 const keySendPreimageType = '5482373484';
 const makeNonce = () => randomBytes(32).toString('hex');
@@ -49,6 +50,7 @@ const {now} = Date;
 const pathChannel = hop => isBlindedHop(hop) ? blinded : hop.channel;
 const rate = n => n.commit_transaction_fee / (n.commit_transaction_weight / 4);
 const signatureType = '34349337';
+const singlePeer = 1;
 const tokAsMtok = tokens => (BigInt(tokens || 0) * BigInt(1e3)).toString();
 
 /** Determine if a destination can be paid by probing it
@@ -78,7 +80,7 @@ const tokAsMtok = tokens => (BigInt(tokens || 0) * BigInt(1e3)).toString();
       type: <Additional Message To Final Destination Type Number String>
       value: <Message To Final Destination Raw Value Hex Encoded String>
     }]
-    [out_through]: <Out Through Peer With Public Key Hex String>
+    [out_through]: [<Out Through Any Peer With Public Key Hex String>]
     [request]: <Payment Request String>
     [timeout_minutes]: <Stop Searching For Route After N Minutes Number>
     [tokens]: <Tokens Number>
@@ -109,13 +111,24 @@ module.exports = (args, cbk) => {
           return cbk([400, "ExpectedLoggerToProbeDestination"]);
         }
 
+        if (!!args.out_through && !isArray(args.out_through)) {
+          return cbk([400, 'ExpectedArrayOfOutThroughPeersToProbe']);
+        }
+
+        const outPeers = args.out_through || [];
+
+        // Finding the maximum is limited by a single outgoing channel
+        if (!!args.find_max && outPeers.length > singlePeer) {
+          return cbk([501, 'FindMaxNotSupportedWithMultipleOutThroughPeers']);
+        }
+
         return cbk();
       },
 
       // Get channels to determine an outgoing channel id restriction
       getChannels: ['validate', ({}, cbk) => {
         // Exit early when there is no need to add an outgoing channel id
-        if (!args.out_through) {
+        if (!args.out_through || !args.out_through.length) {
           return cbk();
         }
 
@@ -395,12 +408,12 @@ module.exports = (args, cbk) => {
         }
 
         const {channels} = getChannels;
-        const outPeer = args.out_through;
+        const outPeers = args.out_through;
         const tokens = args.tokens || to.tokens || defaultTokens;
 
         const withPeer = channels
           .filter(n => !!n.is_active)
-          .filter(n => n.partner_public_key === outPeer);
+          .filter(n => outPeers.includes(n.partner_public_key));
 
         if (!withPeer.length) {
           return cbk([404, 'NoActiveChannelWithOutgoingPeer']);
@@ -417,6 +430,12 @@ module.exports = (args, cbk) => {
           return cbk([404, 'NoOutboundPeerWithSufficientBalance']);
         }
 
+        // Exit early when going out through any channel of multiple peers
+        if (outPeers.length > singlePeer) {
+          return cbk(null, {ids: withBalance.map(n => n.id)});
+        }
+
+        // A single peer goes out through one channel with enough balance
         const attribute = 'local_balance';
 
         const [channel] = sortBy({attribute, array: withBalance}).sorted;
@@ -427,9 +446,9 @@ module.exports = (args, cbk) => {
         const fees = channel.commit_transaction_fee + bufferFees;
         const spendable = channel.local_balance - reserve;
 
-        const maxPayable = floor(spendable - feeBuffer(fees));
+        const maxPayable = floor(spendable - feeBuffer(fees)) || args.find_max;
 
-        return cbk(null, {id: channel.id, max: maxPayable || args.find_max});
+        return cbk(null, {ids: [channel.id], max: maxPayable});
       }],
 
       // Log sending towards destination
@@ -502,7 +521,7 @@ module.exports = (args, cbk) => {
           max_fee: args.max_fee,
           max_fee_mtokens: args.max_fee_mtokens,
           mtokens: !BigInt(to.mtokens) ? tokAsMtok(defaultTokens) : to.mtokens,
-          outgoing_channel: !!outId ? outId.id : undefined,
+          outgoing_channels: !!outId ? outId.ids : undefined,
           paths: to.paths || undefined,
           payment: to.payment,
           routes: to.routes,