ln-service 56.11.1 → 56.13.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 56.13.0
+
+- `openChannels`: Add `is_simplified_taproot` to make a simplified taproot chan
+
+## 56.12.0
+
+- `openChannel`: Add `is_simplified_taproot` to make a simplified taproot chan
+
 ## 56.11.1
 
 - `openChannel`: Add `inputs` to select inputs for channel open funding

package/README.md

@@ -99,6 +99,39 @@ const nodePublicKey = (await lnService.getWalletInfo({lnd})).public_key;
 An [unauthenticatedLndGrpc](#unauthenticatedLndGrpc) function is also available
 for `unlocker` methods.
 
+## Subscriptions
+
+- Besides the events listed in this documentation, all `EventEmitter` objects
+  returned by any of the `subscribeTo...` methods also offer an `error`
+  event. This event is triggered e.g. when LND is shut down. So, in order to
+  detect and correctly handle such a situation, robust client code should
+  generally also add a listener for the `error` event. For example, a
+  function that will wait for and return the next forward but throw an
+  exception when LND is either not reachable or shuts down while waiting for
+  the forward would look something like this:
+
+  ``` node
+  const getNextForward = async (lnd) => {
+      const emitter = subscribeToForwards({ lnd });
+
+      try {
+          return await new Promise((resolve, reject) => {
+              emitter.on("forward", resolve);
+              // Without the following line, the function will never throw
+              // when the connection is lost after calling subscribeToForwards
+              emitter.on("error", reject);
+          });
+      } finally {
+          emitter.removeAllListeners();
+      }
+  };
+  ```
+
+- After the last listener has been removed from an `EventEmitter` object, the
+  subscription is released and subsequent attempts to add a listener will
+  result in an error. Call `subscribeTo...` again and add new listeners to the
+  new `EventEmitter` object.
+
 ## All Methods
 
 - [addExternalSocket](#addexternalsocket) - Advertise a new p2p host:ip address
@@ -3731,6 +3764,9 @@ Requires `offchain:write`, `onchain:write`, `peers:write` permissions
 
 `inputs` is not supported on LND 0.16.4 and below
 
+`is_simplified_taproot` is not supported on LND 0.16.4 and below and requires
+`--protocol.simple-taproot-chans` set on both sides.
+
     {
       [base_fee_mtokens]: <Routing Base Fee Millitokens Charged String>
       [chain_fee_tokens_per_vbyte]: <Chain Fee Tokens Per VByte Number>
@@ -3744,6 +3780,7 @@ Requires `offchain:write`, `onchain:write`, `peers:write` permissions
       }]
       [is_max_funding]: <Use Maximal Chain Funds For Local Funding Bool>
       [is_private]: <Channel is Private Bool> // Defaults to false
+      [is_simplified_taproot]: <Channel is Simplified Taproot Type Bool>
       [is_trusted_funding]: <Accept Funding as Trusted Bool>
       lnd: <Authenticated LND API Object>
       local_tokens: <Total Channel Capacity Tokens Number>
@@ -3793,6 +3830,9 @@ as well as a channel open request listener to accept the trusted funding.
 
 `description` is not supported on LND 0.16.4 and below
 
+`is_simplified_taproot` is not supported on LND 0.16.4 and below and requires
+`--protocol.simple-taproot-chans` set on both sides.
+
     {
       channels: [{
         [base_fee_mtokens]: <Routing Base Fee Millitokens Charged String>
@@ -3802,6 +3842,7 @@ as well as a channel open request listener to accept the trusted funding.
         [fee_rate]: <Routing Fee Rate In Millitokens Per Million Number>
         [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
         [is_private]: <Channel is Private Bool> // Defaults to false
+        [is_simplified_taproot]: <Channel is Simplified Taproot Type Bool>
         [is_trusted_funding]: <Peer Should Avoid Waiting For Confirmation Bool>
         [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
         [partner_csv_delay]: <Peer Output CSV Delay Number>

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.18.2",
     "invoices": "3.0.0",
-    "lightning": "9.11.2",
+    "lightning": "9.13.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.13.0"
@@ -28,7 +28,7 @@
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "5.1.2",
+    "ln-docker-daemons": "5.1.3",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
@@ -69,5 +69,5 @@
     "integration-test-0.14.4": "DOCKER_LND_VERSION=v0.14.4-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && node test/runner"
   },
-  "version": "56.11.1"
+  "version": "56.13.0"
 }

package/test/integration/test_open_simplified_taproot.js

@@ -0,0 +1,174 @@
+const {equal} = require('node:assert').strict;
+const test = require('node:test');
+
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+
+const {addPeer} = require('./../../');
+const {broadcastChainTransaction} = require('./../../');
+const {fundPendingChannels} = require('./../../');
+const {fundPsbt} = require('./../../');
+const {getChannels} = require('./../../');
+const {openChannel} = require('./../../');
+const {openChannels} = require('./../../');
+const {signPsbt} = require('./../../');
+
+const channelCapacityTokens = 1e6;
+const count = 100;
+const defaultFee = 1e3;
+const description = 'description';
+const interval = 250;
+const size = 2;
+const times = 1000;
+
+// Opening a simplified taproot channel should open a simple taproot channel
+test(`Open simplified taproot channel`, async () => {
+  // Test for LND 0.16.4 or below to exit early and avoid test
+  {
+    const {kill, nodes} = await spawnLightningCluster({size});
+
+    const [{generate, id, lnd}, target] = nodes;
+
+    await generate({count});
+
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+      return await openChannel({
+        description,
+        lnd,
+        chain_fee_tokens_per_vbyte: defaultFee,
+        local_tokens: channelCapacityTokens,
+        partner_public_key: target.id,
+        socket: target.socket,
+      });
+    });
+
+    const channel = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {channels} = await getChannels({lnd});
+
+      const [channel] = channels;
+
+      if (!channel) {
+        throw new Error('ExpectedChannelOpened');
+      }
+
+      return channel;
+    });
+
+    await kill({});
+
+    // Exit early when on LND 0.16.4 that do not support simplified taproot
+    if (channel.description !== description) {
+      return;
+    }
+  }
+
+  // Try opening a simplified taproot channel
+  {
+    const {kill, nodes} = await spawnLightningCluster({
+      size,
+      lnd_configuration: ['--protocol.simple-taproot-chans'],
+    });
+
+    const [{generate, id, lnd}, target] = nodes;
+
+    await generate({count});
+
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+      return await openChannel({
+        lnd,
+        chain_fee_tokens_per_vbyte: defaultFee,
+        is_private: true,
+        is_simplified_taproot: true,
+        local_tokens: channelCapacityTokens,
+        partner_public_key: target.id,
+        socket: target.socket,
+      });
+    });
+
+    const channel = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {channels} = await getChannels({lnd});
+
+      const [channel] = channels;
+
+      if (!channel) {
+        throw new Error('ExpectedChannelOpened');
+      }
+
+      return channel;
+    });
+
+    equal(channel.type, 'simplified_taproot', 'Opened simplified taproot');
+
+    await kill({});
+  }
+
+  // Try opening a simplified taproot channel via PSBT funding
+  {
+    const {kill, nodes} = await spawnLightningCluster({
+      size,
+      lnd_configuration: ['--protocol.simple-taproot-chans'],
+    });
+
+    const [{generate, id, lnd}, target] = nodes;
+
+    await generate({count});
+
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+      return await openChannels({
+        lnd,
+        channels: [{
+          capacity: channelCapacityTokens,
+          is_private: true,
+          is_simplified_taproot: true,
+          partner_public_key: target.id,
+        }],
+      });
+    });
+
+    const funded = await fundPsbt({lnd, outputs: channelOpen.pending});
+
+    const signed = await signPsbt({lnd, psbt: funded.psbt});
+
+    await fundPendingChannels({
+      lnd,
+      channels: channelOpen.pending.map(n => n.id),
+      funding: signed.psbt,
+    });
+
+    await broadcastChainTransaction({lnd, transaction: signed.transaction});
+
+    const channel = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {channels} = await getChannels({lnd});
+
+      const [channel] = channels;
+
+      if (!channel) {
+        throw new Error('ExpectedChannelOpened');
+      }
+
+      return channel;
+    });
+
+    equal(channel.type, 'simplified_taproot', 'Opened simplified taproot');
+
+    await kill({});
+  }
+
+  return;
+});