ln-service 57.23.0 → 57.24.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 57.24.0
+
+- `closeChannel`: Add `is_graceful_close` option to wait for pending resolution
+
+## 57.23.1
+
+- Add support for LND 0.18.5
+
 ## 57.23.0
 
 - `getRoutingFeeEstimate`: Add method to estimate an offchain payment fee

package/README.md

@@ -9,7 +9,7 @@ through npm.
 
 Supported LND versions:
 
-- v0.18.0-beta to v0.18.4-beta
+- v0.18.0-beta to v0.18.5-beta
 - v0.17.0-beta to v0.17.5-beta
 - v0.16.0-beta to v0.16.4-beta
 - v0.15.2-beta to v0.15.5-beta
@@ -613,10 +613,13 @@ permissions
 
 `max_tokens_per_vbyte` is not supported in LND 0.15.0 and below
 
+`is_graceful_close` is not supported in LND 0.17.5 and below
+
     {
       [address]: <Request Sending Local Channel Funds To Address String>
       [id]: <Standard Format Channel Id String>
       [is_force_close]: <Is Force Close Bool>
+      [is_graceful_close]: <Is Waiting For Pending Payments to Coop Close Bool>
       lnd: <Authenticated LND API Object>
       [max_tokens_per_vbyte]: <Fail Cooperative Close Above Fee Rate Number>
       [public_key]: <Peer Public Key String>

package/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "bolt07": "1.9.4",
     "invoices": "3.0.0",
-    "lightning": "10.23.0",
+    "lightning": "10.24.0",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -24,13 +24,13 @@
     "bn.js": "5.2.1",
     "bs58check": "4.0.0",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.23",
+    "ln-docker-daemons": "6.0.24",
     "p2tr": "2.0.0",
-    "portfinder": "1.0.32",
+    "portfinder": "1.0.34",
     "psbt": "3.0.0",
     "rimraf": "6.0.1",
     "tiny-secp256k1": "2.2.3",
-    "uuid": "11.0.3",
+    "uuid": "11.1.0",
     "varuint-bitcoin": "2.0.0"
   },
   "engines": {
@@ -51,6 +51,9 @@
     "url": "https://github.com/alexbosworth/ln-service.git"
   },
   "scripts": {
+    "integration-test-0.18.5": "DOCKER_LND_VERSION=v0.18.5-beta npm run test",
+    "integration-test-0.18.4": "DOCKER_LND_VERSION=v0.18.4-beta npm run test",
+    "integration-test-0.18.3": "DOCKER_LND_VERSION=v0.18.3-beta npm run test",
     "integration-test-0.18.2": "DOCKER_LND_VERSION=v0.18.2-beta npm run test",
     "integration-test-0.18.1": "DOCKER_LND_VERSION=v0.18.1-beta npm run test",
     "integration-test-0.18.0": "DOCKER_LND_VERSION=v0.18.0-beta npm run test",
@@ -73,5 +76,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": "57.23.0"
+  "version": "57.24.0"
 }

package/test/integration/test_close_wait_pending.js

@@ -0,0 +1,121 @@
+const {equal} = require('node:assert').strict;
+const test = require('node:test');
+
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {cancelHodlInvoice} = require('./../../');
+const {createHodlInvoice} = require('./../../');
+const {getInvoice} = require('./../../');
+const {getChannels} = require('./../../');
+const {getClosedChannels} = require('./../../');
+const {pay} = require('./../../');
+const {setupChannel} = require('ln-docker-daemons');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+
+const {closeChannel} = require('./../../');
+
+const interval = 100;
+const size = 2;
+const times = 1000;
+const tokens = 10;
+
+// Closing a pending payments channel should close the channel after a wait
+test(`Close channel with wait for pending`, async () => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
+
+  try {
+    // Open a channel from control to target
+    const channelOpen = await setupChannel({
+      generate: control.generate,
+      lnd: control.lnd,
+      to: target,
+    });
+
+    // Create a hold invoice to create the pending state
+    const invoice = await createHodlInvoice({tokens, lnd: target.lnd});
+
+    await asyncAuto({
+      makePayment: async () => {
+        // Pay to the hold invoice
+        try {
+          await pay({lnd: control.lnd, request: invoice.request});
+        } catch (err) {
+          const [, type] = err;
+
+          // We expect that it would be canceled back
+          equal(type, 'PaymentRejectedByDestination');
+        }
+      },
+
+      // Wait for the payment to be held
+      lookForPayment: async () => {
+        await asyncRetry({interval, times}, async () => {
+          const received = await getInvoice({id: invoice.id, lnd: target.lnd});
+
+          if (!received.is_held) {
+            throw new Error('ExpectedPaymentHeld');
+          }
+        });
+      },
+
+      // Start the closing process
+      closeChannel: ['lookForPayment', async () => {
+        try {
+          await closeChannel({
+            id: channelOpen.id,
+            is_graceful_close: true,
+            lnd: control.lnd,
+          });
+        } catch (err) {
+          const [,, error] = err;
+
+          const {details} = error.err;
+
+          // LND 0.17.5 and below do not support graceful closes
+          if (details === 'cannot co-op close channel with active htlcs') {
+            throw new Error('FeatureUnsupported');
+          }
+
+          throw err;
+        }
+      }],
+
+      // Wait for channel to be in closing mode
+      confirmClosing: ['lookForPayment', async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {channels} = await getChannels({lnd: control.lnd});
+
+          if (!channels.filter(n => !n.is_active).length) {
+            throw new Error('ExpectedInactiveChannels');
+          }
+        });
+      }],
+
+      // Stop the payment to void the pending state
+      cancelPayment: ['confirmClosing', async () => {
+        await cancelHodlInvoice({id: invoice.id, lnd: target.lnd});
+      }],
+
+      // Confirm that the channel closed cleanly
+      confirmClosed: ['cancelPayment', async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {channels} = await getClosedChannels({lnd: control.lnd});
+
+          await control.generate({});
+
+          if (!channels.filter(n => !!n.is_cooperative_close).length) {
+            throw new Error('ExpectedCooperativelyClosedChannels');
+          }
+        });
+      }],
+    });
+  } catch (err) {
+    equal(err.message, 'FeatureUnsupported', 'Expected no error');
+  } finally {
+    await kill({});
+  }
+
+  return;
+});