ln-service 57.23.1 → 57.25.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 57.25.0
+
+- Add support for Testnet4
+
+## 57.24.0
+
+- `closeChannel`: Add `is_graceful_close` option to wait for pending resolution
+
 ## 57.23.1
 
 - Add support for LND 0.18.5

package/README.md

@@ -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

@@ -8,8 +8,8 @@
   },
   "dependencies": {
     "bolt07": "1.9.4",
-    "invoices": "3.0.0",
-    "lightning": "10.23.1",
+    "invoices": "4.0.0",
+    "lightning": "10.25.0",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -21,16 +21,16 @@
     "bip32": "4.0.0",
     "bip66": "2.0.0",
     "bitcoinjs-lib": "6.1.7",
-    "bn.js": "5.2.1",
+    "bn.js": "5.2.2",
     "bs58check": "4.0.0",
-    "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.23",
+    "ecpair": "3.0.0",
+    "ln-docker-daemons": "6.0.25",
     "p2tr": "2.0.0",
-    "portfinder": "1.0.32",
-    "psbt": "3.0.0",
+    "portfinder": "1.0.37",
+    "psbt": "4.0.0",
     "rimraf": "6.0.1",
     "tiny-secp256k1": "2.2.3",
-    "uuid": "11.0.5",
+    "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.1"
+  "version": "57.25.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;
+});

package/test/signerrpc-integration/test_sign_taproot.js

@@ -194,7 +194,10 @@ test(`Sign a taproot transaction`, async () => {
 
     const unusedKey = ecp.makeRandom({network: networks.regtest});
 
-    const witnessScript = compile([unusedKey.publicKey.slice(1), OP_CHECKSIG]);
+    const witnessScript = compile([
+      Buffer.from(unusedKey.publicKey).slice(1),
+      OP_CHECKSIG,
+    ]);
 
     const branches = [{script: witnessScript}];
 
@@ -273,6 +276,9 @@ test(`Sign a taproot transaction`, async () => {
       }
     });
   } catch (err) {
+    console.log("ERR", err);
+    await kill({});
+
     equal(err, null, 'Expected no error');
   }
 

package/test/walletrpc-integration/test_fund_psbt.js

@@ -128,14 +128,20 @@ test(`Fund PSBT`, async () => {
     const keyPair2 = ecp.makeRandom({network: networks.regtest});
     const unusedKey = ecp.makeRandom({network: networks.regtest});
 
-    const witnessScript = compile([unusedKey.publicKey.slice(1), OP_CHECKSIG]);
+    const witnessScript = compile([
+      from(unusedKey.publicKey).slice(1),
+      OP_CHECKSIG,
+    ]);
 
     const branches = [{script: witnessScript}];
 
     const {hash} = hashForTree({branches});
 
     // Create a combined key using public key material
-    const combinedPoint = pointAdd(keyPair1.publicKey, keyPair2.publicKey);
+    const combinedPoint = pointAdd(
+      from(keyPair1.publicKey),
+      from(keyPair2.publicKey)
+    );
 
     const output = v1OutputScript({
       hash,
@@ -187,7 +193,10 @@ test(`Fund PSBT`, async () => {
     });
 
     // Ready for private key combining
-    const combinedKey = privateAdd(keyPair1.privateKey, keyPair2.privateKey);
+    const combinedKey = privateAdd(
+      from(keyPair1.privateKey),
+      from(keyPair2.privateKey)
+    );
 
     const signedInput = signHash({
       hash,
@@ -224,7 +233,10 @@ test(`Fund PSBT`, async () => {
 
     const keyPair = ecp.makeRandom({network: networks.regtest});
 
-    const witnessScript = compile([keyPair.publicKey.slice(1), OP_CHECKSIG]);
+    const witnessScript = compile([
+      from(keyPair.publicKey.slice(1)),
+      OP_CHECKSIG,
+    ]);
 
     const branches = [{script: witnessScript}];
 
@@ -277,7 +289,7 @@ test(`Fund PSBT`, async () => {
       );
     });
 
-    const signature = from(signSchnorr(hashToSign, keyPair.privateKey));
+    const signature = from(signSchnorr(hashToSign, from(keyPair.privateKey)));
 
     const {block} = controlBlock({
       external_key: output.external_key,
@@ -308,7 +320,11 @@ test(`Fund PSBT`, async () => {
       }
     });
   } catch (err) {
+    await kill({});
+
     equal(err, null, 'Expected no error');
+
+    return;
   }
 
   // A Taproot output should be funded for a regular key spend
@@ -318,7 +334,7 @@ test(`Fund PSBT`, async () => {
     const keyPair = ecp.makeRandom({network: networks.regtest});
 
     const output = v1OutputScript({
-      internal_key: keyPair.publicKey.toString('hex'),
+      internal_key: from(keyPair.publicKey).toString('hex'),
     });
 
     const outputScript = hexAsBuffer(output.script);
@@ -368,8 +384,8 @@ test(`Fund PSBT`, async () => {
     });
 
     const signedInput = signHash({
-      private_key: keyPair.privateKey.toString('hex'),
-      public_key: keyPair.publicKey.toString('hex'),
+      private_key: from(keyPair.privateKey).toString('hex'),
+      public_key: from(keyPair.publicKey).toString('hex'),
       sign_hash: hashToSign.toString('hex'),
     });