ln-docker-daemons 1.0.2 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Versions
 
+## 2.1.0
+
+- `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
+
+## 1.1.0
+
+- Add `spawnLightningCluster` to spawn multiple lightning dockers
+
 ## 1.0.2
 
 - Update lnd to 0.13.1 and Bitcoin Core to 0.21.1

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>
@@ -53,6 +64,44 @@ const {kill} = spawnBitcoindDocker({
 await kill({});
 ```
 
+## `spawnLightningCluster`
+
+Spawn a cluster of nodes
+
+    {
+      [size]: <Total Lightning Nodes Number>
+    }
+
+    @returns via cbk or Promise
+    {
+      nodes: [{
+        generate: ({address, [count]}) => {}
+        id: <Node Public Key Hex String>
+        kill: <Kill Function> ({}, cbk) => {}
+        lnd: <Authenticated LND API Object>
+        socket: <Node Socket String>
+      }]
+    }
+
+Example:
+
+```node
+const {createChainAddress, getIdentity} = require('lightning');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+
+// Launch a lightning node
+const {nodes} = await spawnLightningCluster({});
+const [{lnd, generate, kill}] = nodes;
+
+const publicKey = (await getIdentity({lnd})).public_key;
+
+// Generate some coins for the wallet
+await generate({count: 500});
+
+// Stop the image
+await kill({});
+```
+
 ## spawnLightningDocker
 
 Spawn an LND Docker
@@ -69,8 +118,11 @@ Spawn an LND Docker
 
     @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/generate_to_address.js

@@ -10,6 +10,7 @@ const host = 'localhost';
 
   {
     address: <Address to Mine Outputs Towards String>
+    [count]: <Generate Count Number>
     pass: <RPC Password String>
     port: <RPC Port Number>
     user: <RPC Username String>
@@ -20,7 +21,7 @@ const host = 'localhost';
     blocks: <Best Chain Block Height Number>
   }
 */
-module.exports = ({address, pass, port, user}, cbk) => {
+module.exports = ({address, count, pass, port, user}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -46,7 +47,7 @@ module.exports = ({address, pass, port, user}, cbk) => {
 
       // Execute request
       request: ['validate', ({}, cbk) => {
-        const params = [[address].length, address];
+        const params = [count || [address].length, address];
 
         return rpc({cmd, host, pass, params, port, user}, 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/index.js

@@ -0,0 +1,3 @@
+const spawnLightningCluster = require('./spawn_lightning_cluster');
+
+module.exports = {spawnLightningCluster};

package/cluster/spawn_lightning_cluster.js

@@ -0,0 +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
+
+  {
+    [size]: <Total Lightning Nodes Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    nodes: [{
+      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 = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Spawn nodes
+      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,
+            });
+
+            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,
+            };
+          });
+        });
+      },
+
+      // 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 await a.addPeer({socket: b.socket});
+        });
+      }],
+
+      // Final set of nodes
+      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');
 
@@ -62,6 +63,12 @@ module.exports = ({arguments, expose, image, ports}, cbk) => {
             return;
           }
 
+          if (err.code === 'ECONNREFUSED') {
+            throw [503, 'CannotConnectToDockerDaemon'];
+          }
+
+          console.log("ERR", err);
+
           throw [503, 'UnexpectedErrorGettingDockerImage', {err}];
         }
       }],
@@ -121,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/index.js

@@ -1,4 +1,9 @@
 const {spawnBitcoindDocker} = require('./bitcoind');
+const {spawnLightningCluster} = require('./cluster');
 const {spawnLightningDocker} =  require('./lnd');
 
-module.exports = {spawnBitcoindDocker, spawnLightningDocker};
+module.exports = {
+  spawnBitcoindDocker,
+  spawnLightningCluster,
+  spawnLightningDocker,
+};

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');
@@ -20,8 +22,13 @@ const spawnLndDocker = require('./spawn_lnd_docker');
 
   @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>
@@ -113,9 +120,30 @@ 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,
+            pass: spawnChainDaemon.rpc_pass,
+            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';
@@ -79,6 +80,8 @@ module.exports = (args, cbk) => {
 
         return spawnDockerImage({
           arguments: [
+            '--accept-keysend',
+            '--allow-circular-route',
             '--autopilot.heuristic=externalscore:0.5',
             '--autopilot.heuristic=preferential:0.5',
             '--bitcoin.active',
@@ -99,7 +102,7 @@ module.exports = (args, cbk) => {
             '--trickledelay=1',
             '--unsafe-disconnect',
           ],
-          image: dockerLndImage,
+          image: imageName(process.env.DOCKER_LND_VERSION),
           ports: {
             '9735/tcp': args.p2p_port,
             '10009/tcp': args.rpc_port,
@@ -123,23 +126,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 +189,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,10 +8,11 @@
   },
   "dependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
-    "async": "3.2.1",
-    "asyncjs-util": "1.2.6",
+    "async": "3.2.2",
+    "asyncjs-util": "1.2.7",
     "dockerode": "3.3.1",
-    "lightning": "4.7.0",
+    "find-free-ports": "3.0.0",
+    "lightning": "5.0.0",
     "tar-stream": "2.2.0"
   },
   "description": "Spawn and control LN Docker daemons",
@@ -19,7 +20,7 @@
     "@alexbosworth/tap": "15.0.10"
   },
   "engines": {
-    "node": ">=10.12.0"
+    "node": ">=12"
   },
   "keywords": [
     "docker"
@@ -34,5 +35,5 @@
   "scripts": {
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -j 1 test/bitcoind/*.js test/lnd/*.js"
   },
-  "version": "1.0.2"
+  "version": "2.1.0"
 }