ln-docker-daemons 2.2.11 → 2.3.1

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## 2.2.11
+## 2.3.1
+
+- `setupChannel`: Add method to setup a channel between LND nodes
+
+## 2.2.12
 
 - Change default LND version to v0.14.3-beta
 

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Alex Bosworth
+Copyright (c) 2020-2022 Alex Bosworth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -18,6 +18,19 @@ const publicKey = (await getIdentity({lnd})).public_key;
 await kill({});
 ```
 
+Supported methods:
+
+- setupChannel: Create a channel between lnds
+- spawnBitcoindDocker: Run a Bitcoin Core container
+- spawnLightningCluster: Spin up a group of nodes
+- spawnLightningDocker: Run lnd + bitcoind
+
+One liner for killing all running Docker containers:
+
+```
+docker container kill $(docker ps -q)
+```
+
 ## Environment Variables
 
 - `DOCKER_LND_VERSION`: set this to use a custom LND docker image
@@ -31,7 +44,48 @@ export DOCKER_LND_VERSION="v0.14.0-beta"
 A list of available tags can be found here:
 https://hub.docker.com/r/lightninglabs/lnd/tags
 
-## spawnBitcoindDocker
+## `setupChannel`
+
+Setup channel
+
+    {
+      [capacity]: <Channel Capacity Tokens Number>
+      generate: <Generate Blocks Promise>
+      [give_tokens]: <Gift Tokens Number>
+      lnd: <Authenticated LND API Object>
+      [partner_csv_delay]: <Partner CSV Delay Number>
+      to: {
+        id: <Partner Public Key Hex String>
+        socket: <Network Address String>
+      }
+    }
+
+    @returns via cbk or Promise
+    {
+      id: <Standard Format Channel Id String>
+      transaction_id: <Funding Transaction Id Hex String>
+      transaction_vout: <Funding Transaction Output Index Number>
+    }
+
+Example:
+
+```node
+const {getNetworkInfo} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+
+const {kill, nodes} = await spawnLightningCluster({size: 2});
+
+const [alice, bob] = nodes;
+
+await setupChannel({generate: alice.generate, lnd: alice.lnd, to: bob});
+
+const networkInfo = await getNetworkInfo({lnd: alice.lnd});
+// networkInfo.channel_count now equals 1
+
+await kill({});
+```
+
+## `spawnBitcoindDocker`
 
 Spawn a Bitcoin Core Docker image
 
@@ -106,7 +160,7 @@ await generate({count: 500});
 await kill({});
 ```
 
-## spawnLightningDocker
+## `spawnLightningDocker`
 
 Spawn an LND Docker
 

package/index.js

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

package/package.json

@@ -8,11 +8,11 @@
   },
   "dependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
-    "async": "3.2.3",
-    "asyncjs-util": "1.2.9",
-    "dockerode": "3.3.1",
+    "async": "3.2.4",
+    "asyncjs-util": "1.2.10",
+    "dockerode": "3.3.2",
     "find-free-ports": "3.0.0",
-    "lightning": "5.16.0",
+    "lightning": "5.16.3",
     "tar-stream": "2.2.0"
   },
   "description": "Spawn and control LN Docker daemons",
@@ -35,5 +35,5 @@
   "scripts": {
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -j 1 test/bitcoind/*.js test/lnd/*.js"
   },
-  "version": "2.2.11"
+  "version": "2.3.1"
 }

package/setup/index.js

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

package/setup/setup_channel.js

@@ -0,0 +1,98 @@
+const {addPeer} = require('lightning');
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {getChainBalance} = require('lightning');
+const {openChannel} = require('lightning');
+const {returnResult} = require('asyncjs-util');
+
+const waitForChannel = require('./wait_for_channel');
+const waitForPendingChannel = require('./wait_for_pending_channel');
+
+const channelCapacityTokens = 1e6;
+const confCount = 6;
+const count = 100;
+const defaultFee = 1e3;
+const interval = 100;
+const times = 1500;
+
+/** Setup channel
+
+  {
+    [capacity]: <Channel Capacity Tokens Number>
+    generate: <Generate Blocks Promise>
+    [give_tokens]: <Gift Tokens Number>
+    lnd: <Authenticated LND API Object>
+    [partner_csv_delay]: <Partner CSV Delay Number>
+    to: {
+      id: <Partner Public Key Hex String>
+      socket: <Network Address String>
+    }
+  }
+
+  @returns via cbk or Promise
+  {
+    id: <Standard Format Channel Id String>
+    transaction_id: <Funding Transaction Id Hex String>
+    transaction_vout: <Funding Transaction Output Index Number>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Make sure the node is connected
+      addPeer: cbk => {
+        return addPeer({
+          lnd: args.lnd,
+          public_key: args.to.id || args.to.public_key,
+          socket: args.to.socket,
+        },
+        cbk);
+      },
+
+      // Make sure the node has funds
+      generateFunds: async () => await args.generate({count}),
+
+      // Open channel
+      chanOpen: cbk => {
+        return asyncRetry({interval, times}, cbk => {
+          return openChannel({
+            chain_fee_tokens_per_vbyte: defaultFee,
+            give_tokens: args.give_tokens,
+            lnd: args.lnd,
+            local_tokens: args.capacity || channelCapacityTokens,
+            partner_csv_delay: args.partner_csv_delay,
+            partner_public_key: args.to.public_key || args.to.id,
+            socket: args.to.socket,
+          },
+          cbk);
+        },
+        cbk);
+      },
+
+      // Wait for pending
+      waitPending: ['chanOpen', ({chanOpen}, cbk) => {
+        return waitForPendingChannel({
+          id: chanOpen.transaction_id,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Generate blocks to confirm the pending channel
+      generate: ['waitPending', async ({}) => {
+        return await args.generate({count: confCount});
+      }],
+
+      // Wait for open
+      channel: ['chanOpen', ({chanOpen}, cbk) => {
+        return waitForChannel({
+          id: chanOpen.transaction_id,
+          lnd: args.lnd,
+          vout: chanOpen.transaction_vout,
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'channel'}, cbk));
+  });
+};

package/setup/wait_for_channel.js

@@ -0,0 +1,96 @@
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {returnResult} = require('asyncjs-util');
+
+const {getChannel} = require('lightning');
+const {getChannels} = require('lightning');
+
+const interval = 20;
+const times = 10000;
+
+/** Wait for channel to be open
+
+  {
+    id: <Channel Transaction Id Hex String>
+    lnd: <Authenticated LND API Object>
+    vout: <Channel Output Index Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    capacity: <Channel Token Capacity Number>
+    commit_transaction_fee: <Commit Transaction Fee Number>
+    commit_transaction_weight: <Commit Transaction Weight Number>
+    id: <Standard Format Channel Id String>
+    is_active: <Channel Active Bool>
+    is_closing: <Channel Is Closing Bool>
+    is_opening: <Channel Is Opening Bool>
+    is_partner_initiated: <Channel Partner Opened Channel>
+    is_private: <Channel Is Private Bool>
+    local_balance: <Local Balance Tokens Number>
+    partner_public_key: <Channel Partner Public Key String>
+    pending_payments: [{
+      id: <Payment Preimage Hash Hex String>
+      is_outgoing: <Payment Is Outgoing Bool>
+      timeout: <Chain Height Expiration Number>
+      tokens: <Payment Tokens Number>
+    }]
+    received: <Received Tokens Number>
+    remote_balance: <Remote Balance Tokens Number>
+    sent: <Sent Tokens Number>
+    transaction_id: <Blockchain Transaction Id String>
+    transaction_vout: <Blockchain Transaction Vout Number>
+    unsettled_balance: <Unsettled Balance Tokens Number>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.id) {
+          return cbk([400, 'ExpectedTransactionIdToWaitForChannelOpen']);
+        }
+
+        if (!args.lnd || !args.lnd.default) {
+          return cbk([400, 'ExpectedAuthenticatedLndToWaitForChannelOpen']);
+        }
+
+        return cbk();
+      },
+
+      // Find channel in channels list
+      channel: ['validate', async () => {
+        return await asyncRetry({interval, times}, async () => {
+          const {channels} = await getChannels({lnd: args.lnd});
+
+          const chan = channels.find(channel => {
+            const txVout = channel.transaction_vout;
+
+            return channel.transaction_id === args.id && txVout === args.vout;
+          });
+
+          if (!chan) {
+            throw new Error('FailedToFindChannelWithTransactionId');
+          }
+
+          return chan;
+        });
+      }],
+
+      // Check channel fully created
+      gotChannel: ['channel', async ({channel}) => {
+        return await asyncRetry({interval, times}, async () => {
+          const {policies} = await getChannel({id: channel.id, lnd: args.lnd});
+
+          if (!!policies.find(n => !n.cltv_delta)) {
+            throw new Error('FailedToFindChannelWithFullPolicyDetails');
+          }
+
+          return;
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'channel'}, cbk));
+  });
+};

package/setup/wait_for_pending_channel.js

@@ -0,0 +1,43 @@
+const asyncRetry = require('async/retry');
+const {getPendingChannels} = require('lightning');
+
+const interval = 10;
+const times = 20000;
+
+/** Wait for a pending channel to appear
+
+  {
+    id: <Channel Transaction Id Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk
+*/
+module.exports = (args, cbk) => {
+  if (!args.id) {
+    return cbk([400, 'ExpectedTransactionIdToWaitForChannelPending']);
+  }
+
+  if (!args.lnd || !args.lnd.default) {
+    return cbk([400, 'ExpectedAuthenticatedLndToWaitForChannelPending']);
+  }
+
+  const {id} = args;
+
+  return asyncRetry({interval, times}, cbk => {
+    return getPendingChannels({lnd: args.lnd}, (err, res) => {
+      if (!!err) {
+        return cbk(err);
+      }
+
+      const channel = res.pending_channels.find(n => n.transaction_id === id);
+
+      if (!channel) {
+        return cbk([503, 'FailedToFindPendingChannelWithTransactionId']);
+      }
+
+      return cbk(null, {channel});
+    });
+  },
+  cbk);
+};