ln-service 59.4.0 → 59.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## 59.5.0
+
+- `createSignedRequest`: Add support for signing BLIP39 path payment requests
+- `createUnsignedRequest`: Add support for specifying BLIP39 payment req paths
+- `parsePaymentRequest`: Add support for parsing BLIP39 payment request paths
+
+## 59.4.1
+
+- `subscribeToForwardRequests`: Invalid requests to forward more than the
+    inbound HTLC amount or with an outbound CLTV past the inbound CLTV are no
+    longer emitted and are released for LND to fail
+
 ## 59.4.0
 
 - `sendMessage`: Add method to send a network onion message

package/README.md

@@ -5882,6 +5882,9 @@ Subscribe to requests to forward payments
 Note that the outbound channel is only the requested channel, another may be
 selected internally to complete the forward.
 
+Invalid requests that have invalid fees or CLTVs cannot be forwarded and are
+not emitted, they are released for LND to fail
+
 Requires `offchain:read`, `offchain:write` permission
 
 `onion` is not supported in LND 0.11.1 and below

package/package.json

@@ -13,8 +13,8 @@
   },
   "dependencies": {
     "bolt07": "2.0.0",
-    "invoices": "6.1.4",
-    "lightning": "12.3.0",
+    "invoices": "6.2.0",
+    "lightning": "12.3.1",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -24,12 +24,12 @@
     "asyncjs-util": "1.2.12",
     "bip32": "5.0.1",
     "bip66": "2.0.0",
-    "bolt04": "1.0.0",
+    "bolt04": "1.2.0",
     "ecpair": "3.0.2",
     "ln-docker-daemons": "8.0.5",
     "p2tr": "3.0.0",
     "portfinder": "1.0.38",
-    "psbt": "6.0.3",
+    "psbt": "6.0.4",
     "tiny-secp256k1": "2.2.4"
   },
   "engines": {
@@ -61,5 +61,5 @@
     "integration-test-0.20.0": "DOCKER_LND_VERSION=v0.20.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && node test/runner"
   },
-  "version": "59.4.0"
+  "version": "59.5.0"
 }

package/test/integration/test_encrypted_routes.js

@@ -1,13 +1,20 @@
 const asyncRetry = require('async/retry');
+const {equal} = require('node:assert').strict;
 const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 
+const {paymentPathFromChannels} = require('bolt04');
 const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 
 const {addPeer} = require('./../../');
 const {createInvoice} = require('./../../');
+const {createSignedRequest} = require('./../../');
+const {createUnsignedRequest} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
+const {getChannel} = require('./../../');
+const {getHeight} = require('./../../');
+const {getInvoice} = require('./../../');
 const {getWalletInfo} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
 const {pay} = require('./../../');
@@ -15,13 +22,14 @@ const {pay} = require('./../../');
 const count = 100;
 const expiry = () => new Date(Date.now() + (4 * 60 * 60 * 1000)).toISOString();
 const give = 500000;
+const hopCount = 5;
 const interval = 100;
 const size = 3;
 const times = 10000;
 const tokens = 100;
 
 // Paying to an encrypted routes invoice should result in a payment
-test(`Create an invoice`, async () => {
+test(`Create an encrypted routes invoice`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;
@@ -29,11 +37,16 @@ test(`Create an invoice`, async () => {
   await generate({count});
 
   try {
-    await setupChannel({generate, lnd, give_tokens: give, to: target});
+    const channel1 = await setupChannel({
+      generate,
+      lnd,
+      give_tokens: give,
+      to: target,
+    });
 
     await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-    await setupChannel({
+    const channel2 = await setupChannel({
       generate: target.generate,
       give_tokens: give,
       lnd: target.lnd,
@@ -55,6 +68,89 @@ test(`Create an invoice`, async () => {
       await pay({lnd: remote.lnd, request: invoice.request});
     });
 
+    // Try padded variations on encrypted routes
+    const remoteInvoice = await createInvoice({tokens, lnd: remote.lnd});
+    const targetInvoice = await createInvoice({tokens, lnd: target.lnd});
+
+    const remotePaymentDetails = parsePaymentRequest({
+      request: remoteInvoice.request,
+    });
+
+    const targetPaymentDetails = parsePaymentRequest({
+      request: targetInvoice.request,
+    });
+
+    const remoteHeight = await getHeight({lnd: remote.lnd});
+    const targetHeight = await getHeight({lnd: target.lnd});
+
+    // Paying to a direct peer but with dummy hops to hide that
+    const targetPath = paymentPathFromChannels({
+      channels: [],
+      cltv_delta: targetPaymentDetails.cltv_delta + 3,
+      destination: targetPaymentDetails.destination,
+      current_block_height: targetHeight.current_block_height,
+      hop_count: hopCount,
+      id: targetPaymentDetails.payment,
+      max_mtokens: targetPaymentDetails.mtokens,
+    });
+
+    // Paying to an indirect peer with a receiver fee added
+    const remotePath = paymentPathFromChannels({
+      channels: [await getChannel({lnd: remote.lnd, id: channel2.id})],
+      cltv_delta: remotePaymentDetails.cltv_delta + 3,
+      destination: remotePaymentDetails.destination,
+      current_block_height: remoteHeight.current_block_height,
+      hop_count: hopCount,
+      id: remotePaymentDetails.payment,
+      max_mtokens: remotePaymentDetails.mtokens,
+      receiver_base_fee_mtokens: '1000',
+      receiver_fee_rate: 10000,
+    });
+
+    equal(remotePath.hops.length, hopCount, 'Got expected hops for target');
+    equal(targetPath.hops.length, hopCount, 'Got expected hops for remote');
+
+    // Try paying a remote path
+    {
+      // Make a blinded version of the invoice
+      const {hrp, tags} = createUnsignedRequest({
+        description: remotePaymentDetails.description,
+        expires_at: remotePaymentDetails.expires_at,
+        features: [{bit: 8}, {bit: 15}, {bit: 24}, {bit: 262}],
+        id: remotePaymentDetails.id,
+        mtokens: remotePaymentDetails.mtokens,
+        network: 'regtest',
+        paths: [remotePath],
+      });
+
+      const request = createSignedRequest({hrp, tags}).request;
+
+      await pay({lnd, request});
+
+      const received = await getInvoice({
+        id: remotePaymentDetails.id,
+        lnd: remote.lnd,
+      });
+
+      equal(received.received_mtokens, '102001', 'Got receiver fee');
+    }
+
+    // Try paying a peer path to target
+    {
+      // Make a blinded version of the invoice
+      const {hrp, tags} = createUnsignedRequest({
+        description: targetPaymentDetails.description,
+        expires_at: targetPaymentDetails.expires_at,
+        features: [{bit: 8}, {bit: 15}, {bit: 24}, {bit: 262}],
+        id: targetPaymentDetails.id,
+        mtokens: targetPaymentDetails.mtokens,
+        network: 'regtest',
+        paths: [targetPath],
+      });
+
+      await pay({lnd, request: createSignedRequest({hrp, tags}).request});
+    }
+
     await kill({});
   } catch (err) {
     await kill({});

package/test/integration/test_trusted_funding.js

@@ -235,18 +235,22 @@ test(`Open unconfirmed channels`, async () => {
 
     // Confirm the private channel
     const privateConfirmed = await asyncRetry({interval, times}, async () => {
-      // Generate the channel into a block
-      await broadcastChainTransaction({
-        lnd,
-        transaction: signedPrivate.transaction,
-      });
-
       await generate({});
 
       const [confirmed] = (await getChannels({lnd})).channels;
 
       const shut = await getClosedChannels({lnd});
 
+      if (!!shut.channels.length) {
+        return confirmed;
+      }
+
+      // Generate the channel into a block
+      await broadcastChainTransaction({
+        lnd,
+        transaction: signedPrivate.transaction,
+      });
+
       if (!shut.channels.length) {
         throw new Error('ExpectedClosedChannel');
       }

package/test/routerrpc-integration/test_probe_for_route.js

@@ -54,6 +54,8 @@ test('Probe for route', async () => {
       await addPeer({lnd, public_key: remote.id, socket: remote.socket});
     });
 
+    await generate({});
+
     await setupChannel({
       generate,
       lnd,
@@ -61,6 +63,8 @@ test('Probe for route', async () => {
       to: target,
     });
 
+    await target.generate({});
+
     await setupChannel({
       capacity: channelCapacityTokens,
       lnd: target.lnd,
@@ -68,7 +72,6 @@ test('Probe for route', async () => {
       give_tokens: Math.round(channelCapacityTokens / 2),
       to: remote,
     });
-
     const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
     await delay(1000);