ln-docker-daemons 1.2.0 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Versions
 
+## 2.2.0
+
+- `spawnLightningCluster`, `spawnLightningDocker`: Add `lnd_configuration` to
+    allow specifying additional LND configuration parameters
+
+## 2.1.1
+
+- `DOCKER_LND_VERSION`: add environment variable to control docker lnd image
+
+## 2.0.0
+
+- `spawnLightningCluster`: add `socket` to reveal node LN p2p sockets
+- `spawnLightningDocker`: add `add_chain_peer` method to add a chain peer
+- `spawnLightningDocker`: add `chain_socket` method for the chain p2p socket
+- `spawnLightningDocker`: add `ln_socket` method for the chain p2p socket
+
+### Breaking Changes
+
+- Node 12+ is required
+
 ## 1.2.0
 
 - `spawnLightningCluster` add `generate` to generate coins for a node

package/README.md

@@ -18,6 +18,16 @@ const publicKey = (await getIdentity({lnd})).public_key;
 await kill({});
 ```
 
+## Environment Variables
+
+- `DOCKER_LND_VERSION`: set this to use a custom LND docker image
+
+Example:
+
+```shell
+export DOCKER_LND_VERSION="v0.14.0-beta"
+```
+
 ## spawnBitcoindDocker
 
 Spawn a Bitcoin Core Docker image
@@ -31,6 +41,7 @@ Spawn a Bitcoin Core Docker image
 
     @returns via cbk or Promise
     {
+      host: <Host String>
       kill: ({}, [cbk]) => <Kill Promise>
       rpc_pass: <RPC Password String>
       rpc_user: <RPC Username String>
@@ -58,6 +69,7 @@ await kill({});
 Spawn a cluster of nodes
 
     {
+      [lnd_configuration]: [<LND Configuration Argument String>]
       [size]: <Total Lightning Nodes Number>
     }
 
@@ -68,6 +80,7 @@ Spawn a cluster of nodes
         id: <Node Public Key Hex String>
         kill: <Kill Function> ({}, cbk) => {}
         lnd: <Authenticated LND API Object>
+        socket: <Node Socket String>
       }]
     }
 
@@ -81,11 +94,10 @@ const {spawnLightningCluster} = require('ln-docker-daemons');
 const {nodes} = await spawnLightningCluster({});
 const [{lnd, generate, kill}] = nodes;
 
-const pubilcKey = (await getIdentity({lnd})).public_key;
+const publicKey = (await getIdentity({lnd})).public_key;
 
 // Generate some coins for the wallet
-const {address} = await createChainAddress({lnd, format: 'p2wpkh'});
-await generate({address, count: 500});
+await generate({count: 500});
 
 // Stop the image
 await kill({});
@@ -103,12 +115,16 @@ Spawn an LND Docker
       generate_address: <Generate Blocks to Address String>
       lightning_p2p_port: <Lightning Network P2P Listen Port Number>
       lightning_rpc_port: <Lightning Node RPC Port Number>
+      [lnd_configuration]: [<LND Configuration Argument String>]
     }
 
     @returns via cbk or Promise
     {
+      add_chain_peer: <Add Peer Function> ({socket}) => {}
       cert: <LND Base64 Serialized TLS Cert>
+      chain_socket: <Chain P2P Socket String>
       kill: ({}, [cbk]) => <Kill LND Daemon Promise>
+      ln_socket: <LN P2P Socket String>
       macaroon: <LND Base64 Serialized Macaroon String>
       public_key: <Identity Public Key Hex String>
       socket: <LND RPC Host:Port Network Address String>

package/bitcoind/spawn_bitcoind_docker.js

@@ -30,6 +30,7 @@ const trim = string => string.replace(/=+$/g, '');
 
   @returns via cbk or Promise
   {
+    host: <Host String>
     kill: ({}, [cbk]) => <Kill Promise>
     rpc_pass: <RPC Password String>
     rpc_user: <RPC Username String>
@@ -75,6 +76,7 @@ module.exports = (args, cbk) => {
         return spawnDockerImage({
           arguments: [
             '--disablewallet',
+            '--listen=1',
             '--persistmempool=false',
             '--printtoconsole',
             '--regtest',
@@ -86,12 +88,6 @@ module.exports = (args, cbk) => {
             `--zmqpubrawblock=tcp://*:${args.zmq_block_port}`,
             `--zmqpubrawtx=tcp://*:${args.zmq_tx_port}`,
           ],
-          expose: [
-            '18443/tcp',
-            '18444/tcp',
-            [`${args.zmq_block_port}/tcp`],
-            [`${args.zmq_tx_port}/tcp`],
-          ],
           image: dockerBitcoindImage,
           ports: {
             '18443/tcp': args.rpc_port,

package/bitcoinrpc/add_peer.js

@@ -0,0 +1,54 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const rpc = require('./rpc');
+
+const action = 'add';
+const cmd = 'addnode';
+const host = 'localhost';
+
+/** Add a node as a peer
+
+  {
+    pass: <RPC Password String>
+    port: <RPC Port Number>
+    socket: <Socket to Connect to String>
+    user: <RPC Username String>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({pass, port, socket, user}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!pass) {
+          return cbk([400, 'ExpectedRpcPasswordToAddChainPeer']);
+        }
+
+        if (!port) {
+          return cbk([400, 'ExpectedRpcPortNumberToAddChainPeer']);
+        }
+
+        if (!socket) {
+          return cbk([400, 'ExpectedSocketToAddChainPeer']);
+        }
+
+        if (!user) {
+          return cbk([400, 'ExpectedRpcUsernameToAddChainPeer']);
+        }
+
+        return cbk();
+      },
+
+      // Execute request
+      request: ['validate', ({}, cbk) => {
+        const params = [socket, action];
+
+        return rpc({cmd, host, pass, params, port, user}, cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/bitcoinrpc/get_block_info.js

@@ -0,0 +1,57 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const rpc = require('./rpc');
+
+const cmd = 'getblock';
+const host = 'localhost';
+const infoVerbosityFlag = 1;
+
+/** Get block info from Bitcoin Core daemon
+
+  {
+    id: <Block Hash Hex String>
+    pass: <RPC Password String>
+    port: <RPC Port Number>
+    user: <RPC Username String>
+  }
+
+  @returns via cbk or Promise
+  {
+    tx: [<Transaction Id Hex String>]
+  }
+*/
+module.exports = ({id, pass, port, user}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedBlockIdToGetBlockInfo']);
+        }
+
+        if (!pass) {
+          return cbk([400, 'ExpectedRpcPasswordToGetBlockInfo']);
+        }
+
+        if (!port) {
+          return cbk([400, 'ExpectedRpcPortNumberToGetBlockInfo']);
+        }
+
+        if (!user) {
+          return cbk([400, 'ExpectedRpcUsernameToGetBlockInfo']);
+        }
+
+        return cbk();
+      },
+
+      // Execute request
+      request: ['validate', ({}, cbk) => {
+        const params = [id, infoVerbosityFlag];
+
+        return rpc({cmd, host, pass, params, port, user}, cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'request'}, cbk));
+  });
+};

package/bitcoinrpc/index.js

@@ -1,4 +1,11 @@
+const addPeer = require('./add_peer');
 const generateToAddress = require('./generate_to_address');
+const getBlockInfo = require('./get_block_info');
 const getBlockchainInfo = require('./get_blockchain_info');
 
-module.exports = {generateToAddress, getBlockchainInfo};
+module.exports = {
+  addPeer,
+  generateToAddress,
+  getBlockInfo,
+  getBlockchainInfo,
+};

package/bitcoinrpc/rpc.js

@@ -88,10 +88,6 @@ module.exports = ({cert, cmd, host, params, pass, port, user}, cbk) => {
 
           const {result} = await response.json();
 
-          if (!result) {
-            throw [503, 'ExpectedResultOfRpcRequest'];
-          }
-
           return result;
         } catch (err) {
           if (err.code === 'ECONNRESET') {

package/cluster/spawn_lightning_cluster.js

@@ -1,85 +1,154 @@
 const asyncAuto = require('async/auto');
+const asyncEach = require('async/each');
 const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
 const {authenticatedLndGrpc} = require('lightning');
+const {createChainAddress} = require('lightning');
 const {findFreePorts} = require('find-free-ports');
+const {getUtxos} = require('lightning');
 const {getIdentity} = require('lightning');
 const {returnResult} = require('asyncjs-util');
 
 const {spawnLightningDocker} = require('./../lnd');
 
+const between = (min, max) => Math.floor(Math.random() * (max - min) + min);
 const chunk = (arr, n, size) => [...Array(size)].map(_ => arr.splice(0, n));
 const count = size => size || 1;
+const endPort = 65000;
 const generateAddress = '2N8hwP1WmJrFF5QWABn38y63uYLhnJYJYTF';
+const interval = 10;
+const makeAddress = ({lnd}) => createChainAddress({lnd});
+const maturity = 100;
+const pairs = n => n.map((x, i) => n.slice(i + 1).map(y => [x, y])).flat();
 const portsPerLnd = 6;
+const startPort = 1025;
+const times = 3000;
 
 /** Spawn a cluster of nodes
 
   {
+    [lnd_configuration]: [<LND Configuration Argument String>]
     [size]: <Total Lightning Nodes Number>
   }
 
   @returns via cbk or Promise
   {
     nodes: [{
-      generate: ({address}, [cbk]) => {}
+      generate: ({address, count}, [cbk]) => {}
       id: <Node Public Key Hex String>
       kill: <Kill Function> ({}, cbk) => {}
       lnd: <Authenticated LND API Object>
+      socket: <Node Socket String>
     }]
   }
 */
-module.exports = ({size}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
-      // Find ports for the requested daemons
-      findPorts: async () => {
-        return await findFreePorts(portsPerLnd * count(size));
-      },
-
       // Spawn nodes
-      spawn: ['findPorts', async ({findPorts}) => {
-        const nodes = chunk(findPorts, portsPerLnd, count(size));
-
-        return await asyncMap(nodes, async (ports) => {
-          const [
-            chainP2pPort,
-            chainRpcPort,
-            chainZmqBlockPort,
-            chainZmqTxPort,
-            lightningP2pPort,
-            lightningRpcPort,
-          ] = ports;
-
-          const lightningDocker = await spawnLightningDocker({
-            chain_p2p_port: chainP2pPort,
-            chain_rpc_port: chainRpcPort,
-            chain_zmq_block_port: chainZmqBlockPort,
-            chain_zmq_tx_port: chainZmqTxPort,
-            generate_address: generateAddress,
-            lightning_p2p_port: lightningP2pPort,
-            lightning_rpc_port: lightningRpcPort,
-          });
+      spawn: async () => {
+        return await asyncRetry({interval, times: 25}, async () => {
+          const options = {startPort: between(startPort, endPort)};
+
+          // Find ports for the requested daemons
+          const findPorts = await findFreePorts(
+            portsPerLnd * count(args.size),
+            options
+          );
+
+          const nodes = chunk(findPorts, portsPerLnd, count(args.size));
+
+          return await asyncMap(nodes, async (ports) => {
+            const [
+              chainP2pPort,
+              chainRpcPort,
+              chainZmqBlockPort,
+              chainZmqTxPort,
+              lightningP2pPort,
+              lightningRpcPort,
+            ] = ports;
+
+            const lightningDocker = await spawnLightningDocker({
+              chain_p2p_port: chainP2pPort,
+              chain_rpc_port: chainRpcPort,
+              chain_zmq_block_port: chainZmqBlockPort,
+              chain_zmq_tx_port: chainZmqTxPort,
+              generate_address: generateAddress,
+              lightning_p2p_port: lightningP2pPort,
+              lightning_rpc_port: lightningRpcPort,
+              lnd_configuration: args.lnd_configuration,
+            });
+
+            const {lnd} = authenticatedLndGrpc({
+              cert: lightningDocker.cert,
+              macaroon: lightningDocker.macaroon,
+              socket: lightningDocker.socket,
+            });
 
-          const {lnd} = authenticatedLndGrpc({
-            cert: lightningDocker.cert,
-            macaroon: lightningDocker.macaroon,
-            socket: lightningDocker.socket,
+            const id = (await getIdentity({lnd})).public_key;
+
+            return {
+              id,
+              lnd,
+              chain: {
+                addPeer: lightningDocker.add_chain_peer,
+                generateToAddress: lightningDocker.generate,
+                getBlockInfo: lightningDocker.get_block_info,
+                socket: lightningDocker.chain_socket,
+              },
+              generate: ({address, count}) => {
+                return new Promise(async (resolve, reject) => {
+                  await lightningDocker.generate({
+                    count,
+                    address: address || (await makeAddress({lnd})).address,
+                  });
+
+                  if (!count || count < maturity) {
+                    return resolve();
+                  }
+
+                  await asyncRetry({interval, times}, async () => {
+                    const [utxo] = (await getUtxos({lnd})).utxos;
+
+                    if (!utxo) {
+                      throw new Error('ExpectedUtxoInUtxos');
+                    }
+
+                    return utxo;
+                  });
+
+                  return resolve();
+                });
+              },
+              kill: lightningDocker.kill,
+              public_key: id,
+              socket: lightningDocker.ln_socket,
+            };
           });
+        });
+      },
 
-          const id = (await getIdentity({lnd})).public_key;
+      // Connect nodes in the cluster to each other
+      connect: ['spawn', async ({spawn}) => {
+        return await asyncEach(pairs(spawn), async pair => {
+          const [a, b] = pair.map(({chain}) => chain);
 
-          return {
-            id,
-            lnd,
-            generate: lightningDocker.generate,
-            kill: lightningDocker.kill,
-          };
+          return await a.addPeer({socket: b.socket});
         });
       }],
 
       // Final set of nodes
-      nodes: ['spawn', async ({spawn}) => {
-        return {nodes: spawn};
+      nodes: ['connect', 'spawn', async ({spawn}) => {
+        return {
+          kill: ({}) => asyncEach(spawn, async ({kill}) => await kill({})),
+          nodes: spawn.map(node => ({
+            generate: node.generate,
+            id: node.id,
+            kill: node.kill,
+            lnd: node.lnd,
+            socket: node.socket,
+          })),
+        };
       }],
     },
     returnResult({reject, resolve, of: 'nodes'}, cbk));

package/docker/spawn_docker_image.js

@@ -1,4 +1,5 @@
 const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
 const Dockerode = require('dockerode');
 const {returnResult} = require('asyncjs-util');
 
@@ -66,6 +67,8 @@ module.exports = ({arguments, expose, image, ports}, cbk) => {
             throw [503, 'CannotConnectToDockerDaemon'];
           }
 
+          console.log("ERR", err);
+
           throw [503, 'UnexpectedErrorGettingDockerImage', {err}];
         }
       }],
@@ -125,13 +128,16 @@ module.exports = ({arguments, expose, image, ports}, cbk) => {
 
       // Start the image
       start: ['container', 'docker', ({container, docker}, cbk) => {
-        return container.start(err => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorStartingDockerContainer', {err}]);
-          }
+        return asyncRetry({}, cbk => {
+          return container.start(err => {
+            if (!!err) {
+              return cbk([503, 'UnexpectedErrorStartingContainer', {err}]);
+            }
 
-          return cbk();
-        });
+            return cbk();
+          });
+        },
+        cbk);
       }],
 
       // Get the details about the container

package/lnd/constants.json

@@ -1,3 +1,3 @@
 {
-  "dockerLndImage": "lightninglabs/lnd:v0.13.1-beta"
+  "dockerLndImage": "lightninglabs/lnd:v0.14.0-beta"
 }

package/lnd/spawn_lightning_docker.js

@@ -1,7 +1,9 @@
 const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
 
+const {addPeer} = require('./../bitcoinrpc');
 const {generateToAddress} = require('./../bitcoinrpc');
+const {getBlockInfo} = require('./../bitcoinrpc');
 const {killDockers} = require('./../docker');
 const {spawnBitcoindDocker} = require('./../bitcoind');
 const spawnLndDocker = require('./spawn_lnd_docker');
@@ -16,13 +18,18 @@ const spawnLndDocker = require('./spawn_lnd_docker');
     generate_address: <Generate Blocks to Address String>
     lightning_p2p_port: <Lightning Network P2P Listen Port Number>
     lightning_rpc_port: <Lightning Node RPC Port Number>
+    [lnd_configuration]: [<LND Configuration Argument String>]
   }
 
   @returns via cbk or Promise
   {
+    add_chain_peer: <Add Peer Function> ({socket}) => {}
     cert: <LND Base64 Serialized TLS Cert>
+    chain_socket: <Chain P2P Socket String>
     generate: ({address, count}, cbk) => <Generate to Address Promise>
+    get_block_info: <Get Block Info Function> ({id}) => {}
     kill: ({}, [cbk]) => <Kill LND Daemon Promise>
+    ln_socket: <LN P2P Socket String>
     macaroon: <LND Base64 Serialized Macaroon String>
     public_key: <Identity Public Key Hex String>
     socket: <LND RPC Host:Port Network Address String>
@@ -93,6 +100,7 @@ module.exports = (args, cbk) => {
         ({spawnChainDaemon}, cbk) =>
       {
         return spawnLndDocker({
+          configuration: args.lnd_configuration,
           bitcoind_rpc_host: spawnChainDaemon.host,
           bitcoind_rpc_pass: spawnChainDaemon.rpc_pass,
           bitcoind_rpc_port: args.chain_rpc_port,
@@ -114,7 +122,14 @@ module.exports = (args, cbk) => {
         const dockers = [spawnChainDaemon, spawnLightningDaemon];
 
         return cbk(null, {
+          add_chain_peer: ({socket}) => addPeer({
+            socket,
+            pass: spawnChainDaemon.rpc_pass,
+            port: args.chain_rpc_port,
+            user: spawnChainDaemon.rpc_user,
+          }),
           cert: spawnLightningDaemon.cert,
+          chain_socket: `${spawnChainDaemon.host}`,
           generate: ({address, count}) => generateToAddress({
             address,
             count,
@@ -122,8 +137,15 @@ module.exports = (args, cbk) => {
             port: args.chain_rpc_port,
             user: spawnChainDaemon.rpc_user,
           }),
+          get_block_info: ({id}) => getBlockInfo({
+            id,
+            pass: spawnChainDaemon.rpc_pass,
+            port: args.chain_rpc_port,
+            user: spawnChainDaemon.rpc_user,
+          }),
           kill: ({}, cbk) => killDockers({dockers}, cbk),
           macaroon: spawnLightningDaemon.macaroon,
+          ln_socket: `${spawnLightningDaemon.host}:9735`,
           public_key: spawnLightningDaemon.public_key,
           socket: spawnLightningDaemon.socket,
         });

package/lnd/spawn_lnd_docker.js

@@ -8,7 +8,8 @@ const {unauthenticatedLndGrpc} = require('lightning');
 const {dockerLndImage} = require('./constants');
 const {spawnDockerImage} = require('./../docker');
 
-const interval = 50;
+const imageName = ver => !!ver ? `lightninglabs/lnd:${ver}` : dockerLndImage;
+const interval = 100;
 const macaroonPath = '/root/.lnd/data/chain/bitcoin/regtest/admin.macaroon';
 const times = 500;
 const tlsCertPath = '/root/.lnd/tls.cert';
@@ -22,6 +23,7 @@ const tlsCertPath = '/root/.lnd/tls.cert';
     bitcoind_rpc_user: <Bitcoin Core RPC Username String>
     bitcoind_zmq_block_port: <Bitcoin Core ZMQ Block Port Number>
     bitcoind_zmq_tx_port: <Bitcoin Core ZMQ Transaction Port Number>
+    [configuration]: [<LND Configuration Argument String>]
     p2p_port: <LND Peer to Peer Listen Port Number>
     rpc_port: <LND RPC Port Number>
   }
@@ -77,29 +79,33 @@ module.exports = (args, cbk) => {
         const zmqBlockPort = args.bitcoind_zmq_block_port;
         const zmqTxPort = args.bitcoind_zmq_tx_port;
 
+        const arguments = [
+          '--accept-keysend',
+          '--allow-circular-route',
+          '--autopilot.heuristic=externalscore:0.5',
+          '--autopilot.heuristic=preferential:0.5',
+          '--bitcoin.active',
+          '--bitcoin.minhtlc=1000',
+          '--bitcoin.node=bitcoind',
+          '--bitcoin.regtest',
+          `--bitcoind.rpchost=${chainHost}:18443`,
+          `--bitcoind.rpcpass=${args.bitcoind_rpc_pass}`,
+          `--bitcoind.rpcuser=${args.bitcoind_rpc_user}`,
+          `--bitcoind.zmqpubrawblock=tcp://${chainHost}:${zmqBlockPort}`,
+          `--bitcoind.zmqpubrawtx=tcp://${chainHost}:${zmqTxPort}`,
+          '--debuglevel=trace',
+          `--externalip=127.0.0.1:9735`,
+          '--historicalsyncinterval=1s',
+          `--listen=0.0.0.0:9735`,
+          '--nobootstrap',
+          `--rpclisten=0.0.0.0:10009`,
+          '--trickledelay=1',
+          '--unsafe-disconnect',
+        ];
+
         return spawnDockerImage({
-          arguments: [
-            '--autopilot.heuristic=externalscore:0.5',
-            '--autopilot.heuristic=preferential:0.5',
-            '--bitcoin.active',
-            '--bitcoin.minhtlc=1000',
-            '--bitcoin.node=bitcoind',
-            '--bitcoin.regtest',
-            `--bitcoind.rpchost=${chainHost}:18443`,
-            `--bitcoind.rpcpass=${args.bitcoind_rpc_pass}`,
-            `--bitcoind.rpcuser=${args.bitcoind_rpc_user}`,
-            `--bitcoind.zmqpubrawblock=tcp://${chainHost}:${zmqBlockPort}`,
-            `--bitcoind.zmqpubrawtx=tcp://${chainHost}:${zmqTxPort}`,
-            '--debuglevel=trace',
-            `--externalip=127.0.0.1:9735`,
-            '--historicalsyncinterval=1s',
-            `--listen=0.0.0.0:9735`,
-            '--nobootstrap',
-            `--rpclisten=0.0.0.0:10009`,
-            '--trickledelay=1',
-            '--unsafe-disconnect',
-          ],
-          image: dockerLndImage,
+          arguments: arguments.concat(args.configuration || []),
+          image: imageName(process.env.DOCKER_LND_VERSION),
           ports: {
             '9735/tcp': args.p2p_port,
             '10009/tcp': args.rpc_port,
@@ -123,23 +129,26 @@ module.exports = (args, cbk) => {
 
         const {lnd} = unauthenticatedLndGrpc({cert, socket});
 
-        lnd.unlocker.genSeed({}, (err, res) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorGeneratingSeed', {err}]);
-          }
-
-          lnd.unlocker.initWallet({
-            cipher_seed_mnemonic: res.cipher_seed_mnemonic,
-            wallet_password: Buffer.from('password', 'utf8'),
-          },
-          err => {
+        return asyncRetry({interval, times}, cbk => {
+          return lnd.unlocker.genSeed({}, (err, res) => {
             if (!!err) {
-              return cbk([503, 'UnexpectedErrorInitializingWallet', {err}]);
+              return cbk([503, 'UnexpectedErrorGeneratingSeed', {err}]);
             }
 
-            return cbk();
+            lnd.unlocker.initWallet({
+              cipher_seed_mnemonic: res.cipher_seed_mnemonic,
+              wallet_password: Buffer.from('password', 'utf8'),
+            },
+            err => {
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorInitializingWallet', {err}]);
+              }
+
+              return cbk();
+            });
           });
-        });
+        },
+        cbk);
       }],
 
       // Get the macaroon out of the docker image
@@ -183,6 +192,7 @@ module.exports = (args, cbk) => {
       {
         return cbk(null, {
           cert: getCertificate.file.toString('base64'),
+          host: spawnDocker.host,
           kill: spawnDocker.kill,
           macaroon: getMacaroon.file.toString('base64'),
           public_key: waitForRpc.public_key,

package/package.json

@@ -8,11 +8,11 @@
   },
   "dependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
-    "async": "3.2.1",
-    "asyncjs-util": "1.2.6",
+    "async": "3.2.3",
+    "asyncjs-util": "1.2.8",
     "dockerode": "3.3.1",
     "find-free-ports": "3.0.0",
-    "lightning": "4.10.7",
+    "lightning": "5.3.1",
     "tar-stream": "2.2.0"
   },
   "description": "Spawn and control LN Docker daemons",
@@ -20,7 +20,7 @@
     "@alexbosworth/tap": "15.0.10"
   },
   "engines": {
-    "node": ">=10.12.0"
+    "node": ">=12"
   },
   "keywords": [
     "docker"
@@ -35,5 +35,5 @@
   "scripts": {
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -j 1 test/bitcoind/*.js test/lnd/*.js"
   },
-  "version": "1.2.0"
+  "version": "2.2.0"
 }