balanceofsatoshis 11.49.2 → 11.52.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Versions
 
+## 11.52.0
+
+- `call`: Add command `getMasterPublicKeys` to list extended public keys
+
+## 11.51.0
+
+- `telegram`: Support notifications when a channel is pending closing
+
+## 11.50.1
+
+- `telegram`: Support forwards and payments with `--use-proxy`
+
+## 11.50.0
+
+- `open`: Add `--opening-node` to batch open channels with multiple saved nodes
+
 ## 11.49.2
 
 - `open`: Fix crash when using `--set-fee-rate` but policy details are missing

package/bos

@@ -44,6 +44,7 @@ const wallets = importLazy('./wallets');
 const {version} = importLazy('./package');
 
 const {BOOL} = prog;
+const collect = arr => [].concat(...[arr]).filter(n => !!n);
 const {exit} = process;
 const flatten = arr => [].concat(...arr);
 const {FLOAT} = prog;
@@ -1050,27 +1051,27 @@ prog
   .option('--coop-close-address <addr>', 'Coop-close address', REPEATABLE)
   .option('--external-funding', 'Use external funds for the channel open')
   .option('--give <give_amount>', 'Amount to gift to peer', REPEATABLE)
-  .option('--node <node_name>', 'Node to open channels')
+  .option('--node <node_name>', 'Saved node to open channels')
+  .option('--opening-node <node_name>', 'Open with saved node', REPEATABLE)
   .option('--set-fee-rate <ppm>', 'Set forward fee rate to peer', REPEATABLE)
   .option('--type <type>', 'Type of channel (private/public)', REPEATABLE)
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
-      const collect = n => flatten([n]).filter(n => !!n);
-
       try {
         return peers.openChannels({
           logger,
           ask: (n, cbk) => inquirer.prompt([n]).then(res => cbk(res)),
-          capacities: flatten([options.amount].filter(n => !!n)),
+          capacities: collect(options.amount),
           cooperative_close_addresses: collect(options.coopCloseAddress),
           fs: {getFile: readFile},
-          gives: flatten([options.give].filter(n => !!n)),
+          gives: collect(options.give),
           is_external: options.externalFunding,
           lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
+          opening_nodes: collect(options.openingNode),
           public_keys: args.peerPublicKeys,
           request: commands.simpleRequest,
-          set_fee_rates: flatten([options.setFeeRate]).filter(n => !!n),
-          types: flatten([options.type].filter(n => !!n)),
+          set_fee_rates: collect(options.setFeeRate),
+          types: collect(options.type),
         },
         responses.returnObject({logger, reject, resolve}));
       } catch (err) {

package/commands/api.json

@@ -427,6 +427,9 @@
     {
       "method": "getLockedUtxos"
     },
+    {
+      "method": "getMasterPublicKeys"
+    },
     {
       "method": "getMethods"
     },

package/package.json

@@ -37,7 +37,7 @@
     "ln-accounting": "5.0.5",
     "ln-service": "53.8.0",
     "ln-sync": "3.10.0",
-    "ln-telegram": "3.15.1",
+    "ln-telegram": "3.16.0",
     "moment": "2.29.1",
     "paid-services": "3.11.0",
     "probing": "2.0.3",
@@ -81,5 +81,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/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.49.2"
+  "version": "11.52.0"
 }

package/peers/channels_from_arguments.js

@@ -1,4 +1,5 @@
 const defaultChannelCapacity = 5e6;
+const uniq = arr => Array.from(new Set(arr));
 
 /** Derive channel to open details from channel argument list
 
@@ -6,32 +7,48 @@ const defaultChannelCapacity = 5e6;
     addresses: [<Address String>]
     capacities: [<Channel Capacity Tokens Number>]
     gives: [<Give Tokens String>]
-    nodes: [<Node Identity Public Key Hex String>]
+    nodes: [<Channel Partner Node Identity Public Key Hex String>]
+    rates: [<Set Fee Rate String>]
+    saved: [<Open on Saved Node Name String>]
     types: [<Channel Type String>]
   }
 
   @returns
   {
-    channels: [{
-      capacity: <Channel Capacity Tokens Number>
-      [give_tokens]: <Give Tokens Number>
-      is_private: <Channel Is Private Bool>
-      partner_public_key: <Channel Partner Identity Public Key Hex String>
+    opens: [{
+      channels: [{
+        capacity: <Channel Capacity Tokens Number>
+        [cooperative_close_address]: <Restrict Coop Close to Address String>
+        [give_tokens]: <Give Tokens Number>
+        is_private: <Channel Is Private Bool>
+        partner_public_key: <Channel Partner Identity Public Key Hex String>
+        [rate]: <Set Fee Rate String>
+      }]
+      [node]: <Saved Node Name String>
     }]
   }
 */
-module.exports = ({addresses, capacities, gives, nodes, types}) => {
-  const channels = nodes.map((key, i) => {
-    const type = types[i] || undefined;
-
+module.exports = args => {
+  const channels = args.nodes.map((key, i) => {
     return {
-      capacity: capacities[i] || defaultChannelCapacity,
-      cooperative_close_address: !!addresses[i] ? addresses[i] : undefined,
-      give_tokens: !!gives[i] ? Number(gives[i]) : undefined,
-      is_private: !!type && type === 'private',
+      capacity: args.capacities[i] || defaultChannelCapacity,
+      cooperative_close_address: args.addresses[i] || undefined,
+      give_tokens: !!args.gives[i] ? Number(args.gives[i]) : undefined,
+      is_private: !!args.types[i] && args.types[i] === 'private',
+      node: args.saved[i] || undefined,
       partner_public_key: key,
+      rate: args.rates[i] || undefined,
     };
   });
 
-  return {channels};
+  // Exit early when there are no saved nodes to use
+  if (!args.saved.length) {
+    return {opens: [{channels}]};
+  }
+
+  const opens = uniq(args.saved).map(node => {
+    return {node, channels: channels.filter(n => n.node === node)};
+  });
+
+  return {opens};
 };

package/peers/open_channels.js

@@ -1,5 +1,6 @@
 const {randomBytes} = require('crypto');
 
+const {acceptsChannelOpen} = require('ln-sync');
 const {addPeer} = require('ln-service');
 const {address} = require('bitcoinjs-lib');
 const {askForFeeRate} = require('ln-sync');
@@ -8,8 +9,10 @@ const asyncEach = require('async/each');
 const asyncEachSeries = require('async/eachSeries');
 const asyncDetectSeries = require('async/detectSeries');
 const asyncMap = require('async/map');
+const asyncMapSeries = require('async/mapSeries');
 const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
 const {cancelPendingChannel} = require('ln-service');
 const {fundPendingChannels} = require('ln-service');
 const {getFundedTransaction} = require('ln-sync');
@@ -26,16 +29,19 @@ const {Transaction} = require('bitcoinjs-lib');
 const {unlockUtxo} = require('ln-service');
 
 const adjustFees = require('./../routing/adjust_fees');
+const {authenticatedLnd} = require('./../lnd');
 const channelsFromArguments = require('./channels_from_arguments');
 const {getAddressUtxo} = require('./../chain');
 const {parseAmount} = require('./../display');
 
 const bech32AsData = bech32 => address.fromBech32(bech32).data;
+const detectNetworks = ['btc', 'btctestnet'];
+const flatten = arr => [].concat(...arr);
 const format = 'p2wpkh';
 const {isArray} = Array;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
-const lineBreak = '\n';
 const knownTypes = ['private', 'public'];
+const lineBreak = '\n';
 const noInternalFundingVersions = ['0.11.0-beta', '0.11.1-beta'];
 const notFound = -1;
 const peerAddedDelayMs = 1000 * 5;
@@ -60,6 +66,7 @@ const utxoPollingTimes = 20;
     [is_external]: <Use External Funds to Open Channels Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    opening_nodes: [<Open New Channel With Saved Node Name String>]
     public_keys: [<Public Key Hex String>]
     request: <Request Function>
     set_fee_rates: [<Fee Rate Number>]
@@ -100,6 +107,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedLoggerToInitiateOpenChannelRequests']);
         }
 
+        if (!isArray(args.opening_nodes)) {
+          return cbk([400, 'ExpectedOpeningNodesArrayToInitiateOpenChannels']);
+        }
+
         if (!isArray(args.public_keys)) {
           return cbk([400, 'ExpectedPublicKeysToOpenChannels']);
         }
@@ -112,6 +123,7 @@ module.exports = (args, cbk) => {
         const hasCapacities = !!args.capacities.length;
         const hasGives = !!args.gives.length;
         const hasFeeRates = !!args.set_fee_rates.length;
+        const hasNodes = !!args.opening_nodes.length;
         const publicKeysLength = args.public_keys.length;
 
         if (!!hasCapacities && publicKeysLength !== args.capacities.length) {
@@ -130,6 +142,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'MustSetFeeRateForEveryPublicKey']);
         }
 
+        if (!!hasNodes && publicKeysLength !== args.opening_nodes.length) {
+          return cbk([400, 'MustSetOpeningNodeForEveryPublicKey']);
+        }
+
         if (!args.request) {
           return cbk([400, 'ExpectedRequestFunctionToOpenChannels']);
         }
@@ -162,13 +178,33 @@ module.exports = (args, cbk) => {
         return cbk(null, capacities);
       }],
 
-      // Get network name
+      // Get LNDs associated with nodes specified for opening
+      getLnds: ['validate', ({}, cbk) => {
+        // Exit early when there are no opening nodes specified
+        if (!args.opening_nodes.length) {
+          return cbk(null, [{lnd: args.lnd}]);
+        }
+
+        return asyncMapSeries(uniq(args.opening_nodes), (node, cbk) => {
+          return authenticatedLnd({node, logger: args.logger}, (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, {node, lnd: res.lnd});
+          });
+        },
+        cbk);
+      }],
+
+      // Get the default network name
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
       // Get sockets in case we need to connect
       getNodes: ['validate', ({}, cbk) => {
         return asyncMap(uniq(args.public_keys), (key, cbk) => {
           return getNode({lnd: args.lnd, public_key: key}, (err, res) => {
+            // Ignore errors when a node is unknown in the graph
             if (!!err) {
               return cbk(null, {public_key: key, sockets: []});
             }
@@ -192,35 +228,89 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
-      // Get connected peers to see if we are already connected
-      getPeers: ['validate', ({}, cbk) => getPeers({lnd: args.lnd}, cbk)],
-
-      // Get the wallet version and check if it is compatible
+      // Get the wallet version to make sure the node supports internal funding
       getWalletVersion: ['validate', ({}, cbk) => {
-        return getWalletVersion({lnd: args.lnd}, (err, res) => {
-          if (!!err) {
-            return cbk([400, 'BackingLndCannotBeUsedToOpenChannels', {err}]);
-          }
+        return getWalletVersion({lnd: args.lnd}, cbk);
+      }],
 
-          return cbk(null, {version: res.version});
-        });
+      // Get the networks of the opening nodes
+      getOpeningNetworks: ['getLnds', ({getLnds}, cbk) => {
+        if (!getLnds) {
+          return cbk();
+        }
+
+        return asyncMap(getLnds, ({lnd}, cbk) => getNetwork({lnd}, cbk), cbk);
       }],
 
-      // Connect up to the peers
-      connect: [
-        'capacities',
-        'getNodes',
-        'getPeers',
-        ({capacities, getNodes, getPeers}, cbk) =>
-      {
-        const {channels} = channelsFromArguments({
+      // Get the opening parameters to use to open the new channels
+      opens: ['capacities', ({capacities}, cbk) => {
+        const {opens} = channelsFromArguments({
           capacities,
           addresses: args.cooperative_close_addresses,
           gives: args.gives,
           nodes: args.public_keys,
+          rates: args.set_fee_rates,
+          saved: args.opening_nodes,
           types: args.types,
         });
 
+        return cbk(null, opens);
+      }],
+
+      // Check if all networks are the same
+      checkNetworks: [
+        'getNetwork',
+        'getOpeningNetworks',
+        ({getNetwork, getOpeningNetworks}, cbk) =>
+      {
+        // Exit early when there are no networks to check
+        if (!getOpeningNetworks) {
+          return cbk();
+        }
+
+        if (!!getOpeningNetworks.find(n => n.network !== getNetwork.network)) {
+          return cbk([400, 'AllOpeningNodesMustBeOnSameChain']);
+        }
+
+        return cbk();
+      }],
+
+      // Get connected peers to see if we are already connected
+      getPeers: ['getLnds', ({getLnds}, cbk) => {
+        // Exit early when there are no opening nodes
+        if (!args.opening_nodes.length) {
+          return getPeers({lnd: args.lnd}, (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, [{peers: res.peers}]);
+          });
+        }
+
+        return asyncMap(args.opening_nodes, (node, cbk) => {
+          const {lnd} = getLnds.find(n => n.node === node);
+
+          return getPeers({lnd}, (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, {node, peers: res.peers});
+          });
+        },
+        cbk);
+      }],
+
+      // Connect up to the peers
+      connect: [
+        'getLnds',
+        'getNodes',
+        'getPeers',
+        'opens',
+        ({getLnds, getNodes, getPeers, opens}, cbk) =>
+      {
+        // Collect some details about nodes being connected to
         const nodes = getNodes.filter(n => !!n.channels_count).map(node => {
           return {
             node: `${node.alias || node.public_key}`,
@@ -231,49 +321,67 @@ module.exports = (args, cbk) => {
 
         args.logger.info(nodes);
 
-        const openingTo = getNodes.map(node => {
-          const {capacity} = channels.find(channel => {
-            return channel.partner_public_key === node.public_key;
-          });
+        // Connect up as peers
+        return asyncEach(opens, ({node, channels}, cbk) => {
+          // Summarize who is being opened to
+          const openingTo = getNodes
+            .filter(remote => {
+              return !!channels.find(channel => {
+                return channel.partner_public_key === remote.public_key;
+              });
+            })
+            .map(remote => {
+              const {capacity} = channels.find(channel => {
+                return channel.partner_public_key === remote.public_key;
+              });
 
-          return `${node.alias || node.public_key}: ${tokAsBigUnit(capacity)}`;
-        });
+              const remoteNamed = remote.alias || remote.public_key;
 
-        args.logger.info({opening_to: openingTo});
+              return `${remoteNamed}: ${tokAsBigUnit(capacity)}`;
+            });
 
-        return asyncEach(args.public_keys, (key, cbk) => {
-          // Exit early when the peer is already connected
-          if (getPeers.peers.map(n => n.public_key).includes(key)) {
-            return cbk();
-          }
+          args.logger.info({node, opening_to: openingTo});
 
-          const node = getNodes.find(n => n.public_key === key);
+          const connectToKeys = channels.map(n => n.partner_public_key);
+          const {lnd} = getLnds.find(n => n.node === node);
+          const {peers} = getPeers.find(n => n.node === node);
 
-          if (!node.sockets.length) {
-            return cbk([503, 'NoAddressFoundToConnectToNode', {node}]);
-          }
-
-          args.logger.info({
-            connecting_to: {alias: node.alias, public_key: node.public_key},
-          });
+          return asyncEach(connectToKeys, (key, cbk) => {
+            // Exit early when the peer is already connected
+            if (peers.map(n => n.public_key).includes(key)) {
+              return cbk();
+            }
 
-          return asyncRetry({times}, cbk => {
-            return asyncDetectSeries(node.sockets, ({socket}, cbk) => {
-              return addPeer({socket, lnd: args.lnd, public_key: key}, err => {
-                return cbk(null, !err);
-              });
-            },
-            (err, res) => {
-              if (!!err) {
-                return cbk(err);
-              }
+            const to = getNodes.find(n => n.public_key === key);
 
-              if (!res) {
-                return cbk([503, 'FailedToConnectToPeer', ({peer: key})]);
-              }
+            if (!to.sockets.length) {
+              return cbk([503, 'NoAddressFoundToConnectToNode', {to}]);
+            }
 
-              return setTimeout(() => cbk(null, true), peerAddedDelayMs);
+            args.logger.info({
+              connecting_to: {alias: to.alias, public_key: to.public_key},
+              from: node,
             });
+
+            return asyncRetry({times}, cbk => {
+              return asyncDetectSeries(to.sockets, ({socket}, cbk) => {
+                return addPeer({lnd, socket, public_key: key}, err => {
+                  return cbk(null, !err);
+                });
+              },
+              (err, res) => {
+                if (!!err) {
+                  return cbk(err);
+                }
+
+                if (!res) {
+                  return cbk([503, 'FailedToConnectToPeer', ({peer: key})]);
+                }
+
+                return setTimeout(() => cbk(null, true), peerAddedDelayMs);
+              });
+            },
+            cbk);
           },
           cbk);
         },
@@ -282,40 +390,33 @@ module.exports = (args, cbk) => {
 
       // Check all nodes that they will allow an inbound channel
       checkAcceptance: [
-        'capacities',
         'connect',
-        ({capacities, connect}, cbk) => 
+        'getLnds',
+        'opens',
+        ({connect, getLnds, opens}, cbk) =>
       {
-        const {channels} = channelsFromArguments({
-          capacities,
-          addresses: args.cooperative_close_addresses,
-          gives: args.gives,
-          nodes: args.public_keys,
-          types: args.types,
+        // Flatten out the opens so that they can be tried serially
+        const tests = opens.map(({channels, node}) => {
+          return channels.map(channel => ({
+            capacity: channel.capacity,
+            cooperative_close_address: channel.cooperative_close_address,
+            give_tokens: channel.give_tokens,
+            is_private: channel.is_private,
+            lnd: getLnds.find(n => n.node === node).lnd,
+            partner_public_key: channel.partner_public_key,
+          }));
         });
 
-        return asyncEachSeries(channels, (channel, cbk) => {
-          const to = channel.partner_public_key;
-
-          return openChannels({
-            channels: [channel],
-            lnd: args.lnd,
+        return asyncEachSeries(flatten(tests), (test, cbk) => {
+          return acceptsChannelOpen({
+            capacity: test.capacity,
+            cooperative_close_address: test.cooperative_close_address,
+            give_tokens: test.give_tokens,
+            is_private: test.is_private,
+            lnd: test.lnd,
+            partner_public_key: test.partner_public_key,
           },
-          (err, res) => {
-            if (!!err) {
-              return cbk([503, 'UnexpectedErrorProposingChannel', {to, err}]);
-            }
-
-            const [{id}] = res.pending;
-
-            return cancelPendingChannel({id, lnd: args.lnd}, (err, res) => {
-              if (!!err) {
-                return cbk([503, 'UnexpectedErrorCancelingChannel', {err}]);
-              }
-
-              return cbk(null, false);
-            });
-          });
+          cbk);
         },
         cbk);
       }],
@@ -341,7 +442,7 @@ module.exports = (args, cbk) => {
         // Peers are connected - what type of funding will be used?
         args.logger.info(lineBreak);
 
-        // Prompt to make sure that internal funding should really be used
+        // Prompt to make sure that internal funding should be used
         return args.ask({
           default: true,
           message: 'Use internal wallet funds?',
@@ -366,39 +467,77 @@ module.exports = (args, cbk) => {
         'askForFeeRate',
         'capacities',
         'connect',
-        'getWalletVersion',
+        'getLnds',
+        'getNodes',
         'isExternal',
-        ({capacities}, cbk) =>
+        'opens',
+        ({getLnds, getNodes, opens}, cbk) =>
       {
-        const {channels} = channelsFromArguments({
-          capacities,
-          addresses: args.cooperative_close_addresses,
-          gives: args.gives,
-          nodes: args.public_keys,
-          types: args.types,
-        });
+        // When there are multiple batches, broadcasting must be stopped
+        const [, hasMultipleBatches] = opens;
 
-        return openChannels({channels, lnd: args.lnd}, (err, res) => {
-          if (!!err) {
-            return cbk(err);
+        // Go through each batch and open channels
+        return asyncMapSeries(opens, asyncReflect(({channels, node}, cbk) => {
+          const {lnd} = getLnds.find(n => n.node === node);
+
+          return openChannels({
+            channels,
+            lnd,
+            is_avoiding_broadcast: !!hasMultipleBatches,
+          },
+          (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, {lnd, node, pending: res.pending});
+          });
+        }),
+        (err, res) => {
+          const openError = res.find(n => !!n.error);
+          const opening = res.map(n => n.value).filter(n => !!n);
+
+          if (!!openError) {
+            // Cancel past successful batch channel open proposals
+            return asyncEach(opening, ({lnd, pending}, cbk) => {
+              return asyncEach(pending, ({id}, cbk) => {
+                return cancelPendingChannel({id, lnd}, err => {
+                  // Suppress errors
+                  return cbk();
+                });
+              },
+              cbk);
+            },
+            () => {
+              // Return the original error
+              return cbk(openError.error);
+            });
           }
 
-          const pending = res.pending.slice();
+          return cbk(null, res.map(n => n.value));
+        });
+      }],
+
+      // Pending channel outputs
+      outputs: ['openChannels', ({openChannels}, cbk) => {
+        // All batches will be paid out together in a single tx
+        const pending = flatten(openChannels.map(({pending}) => {
+          return pending.map(n => ({address: n.address, tokens: n.tokens}));
+        }));
 
-          // Sort outputs using BIP 69
-          try {
+        // Sort all the outputs using BIP 69
+        try {
             pending.sort((a, b) => {
-              // Sort by tokens ascending when no tie breaker needed
-              if (a.tokens !== b.tokens) {
-                return a.tokens - b.tokens;
-              }
+            // Sort by tokens ascending when no tie breaker needed
+            if (a.tokens !== b.tokens) {
+              return a.tokens - b.tokens;
+            }
 
-              return bech32AsData(a.address).compare(bech32AsData(b.address));
-            });
-          } catch (err) {}
+            return bech32AsData(a.address).compare(bech32AsData(b.address));
+          });
+        } catch (err) {}
 
-          return cbk(null, {pending});
-        });
+        return cbk(null, pending);
       }],
 
       // Detect funding transaction
@@ -407,13 +546,19 @@ module.exports = (args, cbk) => {
         'openChannels',
         ({getNetwork, openChannels}, cbk) =>
       {
+        if (!detectNetworks.includes(getNetwork.network)) {
+          return cbk();
+        }
+
+        const [{pending}] = openChannels;
+
+        const [{address, tokens}] = pending;
+
         return asyncRetry({
           interval: utxoPollingIntervalMs,
           times: utxoPollingTimes,
         },
         cbk => {
-          const [{address, tokens}] = openChannels.pending;
-
           return getAddressUtxo({
             address,
             tokens,
@@ -445,12 +590,15 @@ module.exports = (args, cbk) => {
                 funding_detected: Transaction.fromHex(foundTx).getId(),
               });
 
-              return fundPendingChannels({
-                channels: openChannels.pending.map(n => n.id),
-                funding: res.psbt,
-                lnd: args.lnd,
+              return asyncEach(openChannels, ({lnd, node, pending}, cbk) => {
+                return fundPendingChannels({
+                  lnd,
+                  channels: pending.map(n => n.id),
+                  funding: res.psbt,
+                },
+                () => cbk());
               },
-              () => cbk());
+              cbk);
             });
           });
         },
@@ -464,8 +612,8 @@ module.exports = (args, cbk) => {
       getFunding: [
         'askForFeeRate',
         'isExternal',
-        'openChannels',
-        asyncReflect(({askForFeeRate, isExternal, openChannels}, cbk) =>
+        'outputs',
+        asyncReflect(({askForFeeRate, isExternal, outputs}, cbk) =>
       {
         // Warn external funding that funds are expected within 10 minutes
         if (!!isExternal) {
@@ -475,15 +623,12 @@ module.exports = (args, cbk) => {
         }
 
         return getFundedTransaction({
+          outputs,
           ask: args.ask,
           chain_fee_tokens_per_vbyte: askForFeeRate.tokens_per_vbyte,
           is_external: isExternal,
           lnd: args.lnd,
           logger: args.logger,
-          outputs: openChannels.pending.map(({address, tokens}) => ({
-            address,
-            tokens,
-          })),
         },
         cbk);
       })],
@@ -528,25 +673,65 @@ module.exports = (args, cbk) => {
       fundChannels: [
         'fundingPsbt',
         'openChannels',
-        asyncReflect(({fundingPsbt, openChannels}, cbk) =>
+        'outputs',
+        asyncReflect(({fundingPsbt, openChannels, outputs}, cbk) =>
       {
         // Exit early when there is no funding PSBT
         if (!fundingPsbt.value || !fundingPsbt.value.psbt) {
           return cbk(null, {});
         }
 
-        args.logger.info({
-          funding: openChannels.pending.map(n => tokAsBigUnit(n.tokens)),
-        });
+        args.logger.info({funding: outputs.map(n => tokAsBigUnit(n.tokens))});
 
-        return fundPendingChannels({
-          channels: openChannels.pending.map(n => n.id),
-          funding: fundingPsbt.value.psbt,
-          lnd: args.lnd,
+        return asyncMap(openChannels, ({lnd, node, pending}, cbk) => {
+          return fundPendingChannels({
+            lnd,
+            channels: pending.map(n => n.id),
+            funding: fundingPsbt.value.psbt,
+          },
+          cbk);
         },
         cbk);
       })],
 
+      // Broadcast the funding transaction when opening on multiple nodes
+      broadcastChainTransaction: [
+        'fundChannels',
+        'fundingPsbt',
+        'getFunding',
+        'openChannels',
+        ({fundChannels, fundingPsbt, getFunding, openChannels}, cbk) =>
+      {
+        const fundingError = getFunding.error || fundingPsbt.error;
+        const error = fundChannels.error || fundingError;
+
+        // Exit early when the opening had an error and broadcasting isn't safe
+        if (!!error || !!fundingError) {
+          return cbk();
+        }
+
+        const [, multiNodeOpening] = openChannels;
+
+        // Exit early when not opening in multi-node mode
+        if (!multiNodeOpening) {
+          return cbk();
+        }
+
+        return broadcastChainTransaction({
+          lnd: args.lnd,
+          transaction: getFunding.value.transaction,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          args.logger.info({transaction: getFunding.value.transaction});
+
+          return cbk();
+        });
+      }],
+
       // Cancel pending if there is an error
       cancelPending: [
         'fundChannels',
@@ -565,15 +750,20 @@ module.exports = (args, cbk) => {
         }
 
         args.logger.info({
-          canceling_pending_channels: openChannels.pending.map(n => n.id),
+          canceling_pending_channels: openChannels.map(({node, pending}) => ({
+            node,
+            ids: pending.map(n => n.id),
+          })),
         });
 
-        // Cancel outstanding pending channels when there is an error
-        return asyncEach(openChannels.pending, (channel, cbk) => {
-          return cancelPendingChannel({id: channel.id, lnd: args.lnd}, () => {
-            // Ignore errors when trying to cancel a pending channel
-            return cbk();
-          });
+        return asyncEach(openChannels, ({lnd, pending}, cbk) => {
+          return asyncEach(pending => ({id}, cbk) => {
+            return cancelPendingChannel({id, lnd}, err => {
+              // Ignore errors when trying to cancel a pending channel
+              return cbk();
+            });
+          },
+          cbk);
         },
         () => {
           // Return the original error that canceled the finalization
@@ -592,7 +782,7 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
-        // Exit early when there is no UTXOs to unlock
+        // Exit early when there are no UTXOs to unlock, like external funding
         if (!isArray(getFunding.inputs)) {
           return cbk(cancelPending);
         }
@@ -619,28 +809,31 @@ module.exports = (args, cbk) => {
 
       // Set fee rates
       setFeeRates: [
-        'cancelPending',
+        'broadcastChainTransaction',
+        'cancelLocks',
         'detectFunding',
         'fundChannels',
-        ({}, cbk) =>
+        'getLnds',
+        'opens',
+        ({getLnds, opens}, cbk) =>
       {
         // Exit early when not specifying fee rates
         if (args.set_fee_rates.length !== args.public_keys.length) {
           return cbk();
         }
 
-        const feesToSet = args.set_fee_rates.map((rate, i) => ({
-          rate,
-          public_key: args.public_keys[i],
-        }));
+        return asyncEachSeries(opens, ({channels, node}, cbk) => {
+          const {lnd} = getLnds.find(n => n.node === node);
 
-        return asyncEachSeries(feesToSet, (toSet, cbk) => {
-          return adjustFees({
-            fee_rate: toSet.rate,
-            fs: args.fs,
-            lnd: args.lnd,
-            logger: args.logger,
-            to: [toSet.public_key],
+          return asyncEachSeries(channels, (channel, cbk) => {
+            return adjustFees({
+              lnd,
+              fee_rate: channel.rate,
+              fs: args.fs,
+              logger: args.logger,
+              to: [channel.partner_public_key],
+            },
+            cbk);
           },
           cbk);
         },
@@ -649,6 +842,7 @@ module.exports = (args, cbk) => {
 
       // Transaction complete
       completed: [
+        'broadcastChainTransaction',
         'cancelPending',
         'fundingPsbt',
         'getFunding',

package/telegram/start_telegram_bot.js

@@ -34,6 +34,7 @@ const {isMessageReplyAction} = require('ln-telegram');
 const {notifyOfForwards} = require('ln-telegram');
 const {postChainTransaction} = require('ln-telegram');
 const {postClosedMessage} = require('ln-telegram');
+const {postClosingMessage} = require('ln-telegram');
 const {postCreatedTrade} = require('ln-telegram');
 const {postOpenMessage} = require('ln-telegram');
 const {postOpeningMessage} = require('ln-telegram');
@@ -684,6 +685,20 @@ module.exports = (args, cbk) => {
 
           subscriptions.push(sub);
 
+          // Listen for pending closing channel events
+          sub.on('closing', update => {
+            return postClosingMessage({
+              from,
+              lnd,
+              closing: update.channels,
+              id: connectedId,
+              nodes: getNodes,
+              send: (id, msg, opt) => bot.api.sendMessage(id, msg, opt),
+            },
+            err => !!err ? logger.error({from, closing_err: err}) : null);
+          });
+
+          // Listen for pending opening events
           sub.on('opening', update => {
             return postOpeningMessage({
               from,
@@ -752,7 +767,6 @@ module.exports = (args, cbk) => {
               return notifyOfForwards({
                 from,
                 lnd,
-                request,
                 forwards: res.forwards.filter(forward => {
                   if (!limits || !limits.min_forward_tokens) {
                     return true;
@@ -761,8 +775,9 @@ module.exports = (args, cbk) => {
                   return forward.tokens >= limits.min_forward_tokens;
                 }),
                 id: connectedId,
-                key: apiKey.key,
                 node: node.public_key,
+                nodes: getNodes,
+                send: (id, msg, opt) => bot.api.sendMessage(id, msg, opt),
               },
               err => {
                 if (!!err) {
@@ -845,10 +860,8 @@ module.exports = (args, cbk) => {
             }
 
             return postSettledPayment({
-              request,
               from: node.from,
               id: connectedId,
-              key: apiKey.key,
               lnd: node.lnd,
               nodes: getNodes.map(n => n.public_key),
               payment: {
@@ -857,10 +870,9 @@ module.exports = (args, cbk) => {
                 safe_fee: payment.safe_fee,
                 safe_tokens: payment.safe_tokens,
               },
+              send: (id, msg, opts) => bot.api.sendMessage(id, msg, opts),
             },
             err => !!err ? logger.error({post_payment_error: err}) : null);
-
-            return;
           });
 
           sub.on('error', err => {

package/test/integration/test_open_channels.js

@@ -0,0 +1,113 @@
+const {addPeer} = require('ln-service');
+const asyncAuto = require('async/auto');
+const asyncEach = require('async/each');
+const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {fundPsbt} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getPendingChannels} = require('ln-service');
+const {getWalletInfo} = require('ln-service');
+const {openChannel} = require('ln-service');
+const {signPsbt} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {openChannels} = require('./../../peers');
+
+const count = 100;
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+const interval = 200;
+const log = () => {};
+const size = 2;
+const times = 1000;
+
+// Opening channels should open channels with specified nodes
+test(`Open channels`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, lnd}, target] = nodes;
+
+  try {
+    await generate({count});
+
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+      await asyncEach(nodes, async ({lnd}) => {
+        const chain = await getWalletInfo({lnd});
+
+        if (!chain.is_synced_to_chain || !chain.is_synced_to_graph) {
+          throw new Error('WaitingForSync');
+        }
+      });
+    });
+
+    const {address} = await createChainAddress({lnd});
+
+    await delay(4000);
+
+    // Open a single channel from a single node
+    await asyncAuto({
+      // Open channel
+      propose: async () => {
+        await openChannels({
+          lnd,
+          ask: async (args, cbk) => {
+            if (args.name === 'internal') {
+              return cbk({internal: false});
+            }
+
+            if (args.name === 'fund') {
+              const address = args.message.split(' ')[9];
+
+              const {psbt} = await fundPsbt({
+                lnd,
+                outputs: [{address, tokens: 6e6}],
+              });
+
+              const signed = await signPsbt({lnd, psbt});
+
+              return cbk({fund: signed.psbt});
+            }
+
+            throw new Error('UnrecognizedParameter');
+          },
+          capacities: ['6*m'],
+          cooperative_close_addresses: [address],
+          fs: {getFile: () => {}},
+          gives: [1e5],
+          logger: {info: log, error: log},
+          opening_nodes: [],
+          public_keys: [target.id],
+          request: () => {},
+          set_fee_rates: [],
+          types: [],
+        });
+      },
+
+      // Generate blocks until the channel confirms
+      generate: async () => {
+        return await asyncRetry({interval, times}, async () => {
+          await generate({});
+
+          const {channels} = await getChannels({lnd});
+
+          if (!channels.length) {
+            throw new Error('Expected Channels');
+          }
+
+          const [channel] = channels;
+
+          equal(channel.remote_balance, 1e5, 'Gift balance is reflected');
+          equal(channel.capacity, 6e6, 'Channel capacity is set');
+          equal(channel.cooperative_close_address, address, 'Coop address');
+        });
+      },
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
+
+  await kill({});
+});

package/test/peers/test_channels_from_arguments.js

@@ -8,6 +8,8 @@ const makeArgs = overrides => {
     capacities: [2],
     gives: ['1'],
     nodes: [Buffer.alloc(33, 3).toString('hex')],
+    rates: [],
+    saved: [],
     types: ['private'],
   };
 
@@ -21,12 +23,16 @@ const tests = [
     args: makeArgs({}),
     description: 'Arguments are mapped to channel details',
     expected: {
-      channels: [{
-        capacity: 2,
-        cooperative_close_address: 'address',
-        give_tokens: 1,
-        is_private: true,
-        partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+      opens: [{
+        channels: [{
+          capacity: 2,
+          cooperative_close_address: 'address',
+          give_tokens: 1,
+          is_private: true,
+          node: undefined,
+          partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+          rate: undefined,
+        }],
       }],
     },
   },
@@ -39,15 +45,59 @@ const tests = [
     }),
     description: 'Remove optional arguments',
     expected: {
-      channels: [{
-        capacity: 5000000,
-        cooperative_close_address: undefined,
-        give_tokens: undefined,
-        is_private: false,
-        partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+      opens: [{
+        channels: [{
+          capacity: 5000000,
+          cooperative_close_address: undefined,
+          give_tokens: undefined,
+          is_private: false,
+          node: undefined,
+          partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+          rate: undefined,
+        }],
       }],
     },
   },
+  {
+    args: makeArgs({
+      addresses: ['coopCloseAddressNodeA', 'coopCloseAddressNodeB'],
+      capacities: [1, 2],
+      gives: [3, 4],
+      nodes: ['remoteNodeA', 'remoteNodeB'],
+      rates: ['1', '2'],
+      saved: ['savedA', 'savedB'],
+      types: ['private', 'public'],
+    }),
+    description: 'Two nodes are batch opening',
+    expected: {
+      opens: [
+        {
+          channels: [{
+            capacity: 1,
+            cooperative_close_address: 'coopCloseAddressNodeA',
+            give_tokens: 3,
+            is_private: true,
+            node: 'savedA',
+            partner_public_key: 'remoteNodeA',
+            rate: '1',
+          }],
+          node: 'savedA',
+        },
+        {
+          channels: [{
+            capacity: 2,
+            cooperative_close_address: 'coopCloseAddressNodeB',
+            give_tokens: 4,
+            is_private: false,
+            node: 'savedB',
+            partner_public_key: 'remoteNodeB',
+            rate: '2',
+          }],
+          node: 'savedB',
+        },
+      ],
+    },
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {