ln-service 53.5.0 → 53.7.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## 53.7.0
+
+- `payViaRoutes`, `subscribeToPayViaRoutes`: Add support for relay messages
+
+## 53.6.0
+
+- `partiallySignPsbt`: Add method to add a partial signature to a PSBT
+
+## 53.5.2
+
+- `getPayments`: Correct paging issue that prevented paging through all results
+
 ## 53.5.0
 
 - `createWallet`: Add support for returning the admin `macaroon`

package/README.md

@@ -187,6 +187,7 @@ for `unlocker` methods.
 - [openChannel](#openchannel) - Open a new channel
 - [openChannels](#openchannels) - Open channels with external funding
 - [parsePaymentRequest](#parsepaymentrequest) - Parse a BOLT11 Payment Request
+- [partiallySignPsbt](#partiallysignpsbt) - Sign a PSBT without finalizing it
 - [pay](#pay) - Send a payment
 - [payViaPaymentDetails](#payviapaymentdetails) - Pay using decomposed details
 - [payViaPaymentRequest](#payviapaymentrequest) - Pay using a payment request
@@ -2529,7 +2530,7 @@ LND 0.11.1 and below do not return `last_reconnected` or `reconnection_rate`
         }]
         is_inbound: <Is Inbound Peer Bool>
         [is_sync_peer]: <Is Syncing Graph Data Bool>
-        [last_reconnected]: <Peer Last Reconnected At ISO 8601 Date String>
+        [last_reconnection]: <Peer Last Reconnected At ISO 8601 Date String>
         ping_time: <Ping Latency Milliseconds Number>
         public_key: <Node Identity Public Key String>
         [reconnection_rate]: <Count of Reconnections Over Time Number>
@@ -3392,6 +3393,46 @@ const {parsePaymentRequest} = require('ln-service');
 const requestDetails = parsePaymentRequest({request: 'paymentRequestString'});
 ```
 
+### partiallySignPsbt
+
+Sign a PSBT to produce a partially signed PSBT
+
+Requires `onchain:write` permission
+
+Requires LND built with `walletrpc` tag
+
+This method is not supported in LND 0.14.1 and below
+
+    {
+      lnd: <Authenticated LND API Object>
+      psbt: <Funded PSBT Hex String>
+    }
+
+    @returns via cbk or Promise
+    {
+      psbt: <Partially Signed PSBT Hex String>
+    }
+
+
+Example:
+
+```node
+const {broadcastChainTransaction} = require('ln-service');
+const {fundPsbt, partiallySignPsbt} = require('ln-service');
+const {extractTransaction, finalizePsbt} = require('psbt');
+
+const funding = await fundPsbt({
+  lnd,
+  outputs: [{address: chainAddress, tokens: 100000}]
+})
+
+const finalize = finalizePsbt({psbt: funding.psbt});
+
+const {transaction} = extractTransaction({psbt: finalize.psbt});
+
+await broadcastChainTransaction({lnd, transaction});
+```
+
 ### pay
 
 Make a payment.
@@ -3665,6 +3706,10 @@ Requires `offchain:write` permission
           fee_mtokens: <Fee Millitokens String>
           forward: <Forward Tokens Number>
           forward_mtokens: <Forward Millitokens String>
+          [messages]: [{
+            type: <Message Type Number String>
+            value: <Message Raw Value Hex Encoded String>
+          }]
           [public_key]: <Public Key Hex String>
           timeout: <Timeout Block Height Number>
         }]
@@ -5651,6 +5696,10 @@ Requires `offchain:write` permission
           fee_mtokens: <Fee Millitokens String>
           forward: <Forward Tokens Number>
           forward_mtokens: <Forward Millitokens String>
+          [messages]: [{
+            type: <Message Type Number String>
+            value: <Message Raw Value Hex Encoded String>
+          }]
           public_key: <Public Key Hex String>
           timeout: <Timeout Block Height Number>
         }]

package/index.js

@@ -76,6 +76,7 @@ const {lockUtxo} = require('lightning');
 const {openChannel} = require('lightning');
 const {openChannels} = require('lightning');
 const {parsePaymentRequest} = require('invoices');
+const {partiallySignPsbt} = require('lightning');
 const {pay} = require('lightning');
 const {payViaPaymentDetails} = require('lightning');
 const {payViaPaymentRequest} = require('lightning');
@@ -215,6 +216,7 @@ module.exports = {
   openChannel,
   openChannels,
   parsePaymentRequest,
+  partiallySignPsbt,
   pay,
   payViaPaymentDetails,
   payViaPaymentRequest,

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.17.2",
     "invoices": "2.0.3",
-    "lightning": "5.3.3",
+    "lightning": "5.6.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.4.2"
@@ -26,12 +26,12 @@
     "bitcoinjs-lib": "6.0.1",
     "bn.js": "5.2.0",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.2.0",
+    "ln-docker-daemons": "2.2.3",
     "portfinder": "1.0.28",
-    "psbt": "1.1.10",
+    "psbt": "1.1.11",
     "rimraf": "3.0.2",
     "secp256k1": "4.0.3",
-    "tiny-secp256k1": "2.1.2",
+    "tiny-secp256k1": "2.2.0",
     "uuid": "8.3.2",
     "varuint-bitcoin": "1.1.2"
   },
@@ -53,7 +53,17 @@
     "url": "https://github.com/alexbosworth/ln-service.git"
   },
   "scripts": {
+    "integration-test-daily-lnd-build": "DOCKER_LND_VERSION=daily-testing-only npm run test",
+    "integration-test-0.14.1": "DOCKER_LND_VERSION=v0.14.1-beta npm run test",
+    "integration-test-0.14.0": "DOCKER_LND_VERSION=v0.14.0-beta npm run test",
+    "integration-test-0.13.4": "DOCKER_LND_VERSION=v0.13.4-beta npm run test",
+    "integration-test-0.13.3": "DOCKER_LND_VERSION=v0.13.3-beta npm run test",
+    "integration-test-0.13.2": "DOCKER_LND_VERSION=v0.13.2-beta npm run test",
+    "integration-test-0.13.1": "DOCKER_LND_VERSION=v0.13.1-beta npm run test",
+    "integration-test-0.13.0": "DOCKER_LND_VERSION=v0.13.0-beta npm run test",
+    "integration-test-0.12.1": "DOCKER_LND_VERSION=v0.12.1-beta npm run test",
+    "integration-test-0.12.0": "DOCKER_LND_VERSION=v0.12.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/autopilotrpc-integration/*.js test/chainrpc-integration/*.js test/integration/*.js test/invoicesrpc-integration/*.js test/routerrpc-integration/*.js test/signerrpc-integration/*.js test/tower_clientrpc-integration/*.js test/tower_serverrpc-integration/*.js test/walletrpc-integration/*.js"
   },
-  "version": "53.5.0"
+  "version": "53.7.0"
 }

package/test/integration/test_add_peer.js

@@ -17,30 +17,34 @@ test(`Add a peer`, async ({end, equal}) => {
 
   const [{lnd}, target] = nodes;
 
-  const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
+  try {
+    const connectedKeys = (await getPeers({lnd})).peers.map(n => n.public_key);
 
-  equal(connectedKeys.find(n => n === target.id), undefined, 'No peer');
+    equal(connectedKeys.find(n => n === target.id), undefined, 'No peer');
 
-  await asyncRetry({interval, times}, async () => {
-    await addPeer({
-      lnd,
-      timeout,
-      public_key: target.id,
-      socket: target.socket,
-    });
-
-    const {peers} = await getPeers({lnd});
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd,
+        timeout,
+        public_key: target.id,
+        socket: target.socket,
+      });
 
-    const connected = peers.find(n => n.public_key === target.id);
+      const {peers} = await getPeers({lnd});
 
-    if (!connected) {
-      throw new Error('ExpectedConnectionToTarget');
-    }
+      const connected = peers.find(n => n.public_key === target.id);
 
-    equal(connected.public_key, target.id, 'Connected to remote node');
-  });
+      if (!connected) {
+        throw new Error('ExpectedConnectionToTarget');
+      }
 
-  await kill({});
+      equal(connected.public_key, target.id, 'Connected to remote node');
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });

package/test/integration/test_delete_pending_channel.js

@@ -31,7 +31,7 @@ const timeout = 1000 * 5;
 const times = 200;
 
 // Forfeiting a pending channel should remove the pending channel
-test(`Forfeit pending channel`, async ({end, equal}) => {
+test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target, remote] = nodes;
@@ -136,16 +136,20 @@ test(`Forfeit pending channel`, async ({end, equal}) => {
       equal(code, 503, 'Pending channel cannot be canceled');
     }
 
-    await deletePendingChannel({
-      lnd,
-      confirmed_transaction: transaction,
-      pending_transaction: stuckTx.transaction,
-      pending_transaction_vout: pending.transaction_vout,
-    });
+    try {
+      await deletePendingChannel({
+        lnd,
+        confirmed_transaction: transaction,
+        pending_transaction: stuckTx.transaction,
+        pending_transaction_vout: pending.transaction_vout,
+      });
 
-    const [stillPending] = (await getPendingChannels({lnd})).pending_channels;
+      const [notPending] = (await getPendingChannels({lnd})).pending_channels;
 
-    equal(stillPending, undefined, 'Conflicting pending channel deleted');
+      equal(notPending, undefined, 'Conflicting pending channel deleted');
+    } catch (err) {
+      strictSame(err, [501, 'DeletePendingChannelMethodNotSupported']);
+    }
   } catch (err) {
     equal(err, null, 'No error is expected');
   } finally {

package/test/integration/test_get_failed_payments.js

@@ -28,128 +28,132 @@ test('Get failed payments', async ({end, equal, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const {address} = await createChainAddress({lnd: remote.lnd});
-
-  await generate({count});
-
-  // Send coins to remote so that it can accept the channel
-  await sendToChainAddress({lnd, address, tokens: channelCapacityTokens});
-
-  // Generate to confirm the tx
-  await generate({count: confirmationCount});
-  await remote.generate({count: confirmationCount});
-
-  await setupChannel({
-    generate,
-    lnd,
-    capacity: channelCapacityTokens + channelCapacityTokens,
-    to: target,
-  });
-
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    generator: target,
-    give: Math.round(channelCapacityTokens / 2),
-    to: remote,
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-  const bigInvoice = await createInvoice({
-    tokens: (channelCapacityTokens / 2) + (channelCapacityTokens / 4),
-    lnd: remote.lnd,
-  });
-
   try {
-    await pay({lnd, request: bigInvoice.request});
-  } catch (err) {
-  }
-
-  // Create a new channel to increase total edge liquidity
-  await setupChannel({
-    capacity: channelCapacityTokens,
-    lnd: target.lnd,
-    generate: target.generate,
-    generator: target,
-    to: remote,
-  });
-
-  await deleteForwardingReputations({lnd});
-
-  await asyncRetry({times}, async () => {
-    await pay({lnd, request: invoice.request});
-  });
-
-  {
-    const {payments} = await getFailedPayments({lnd});
-
-    const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
-
-    equal(payment.destination, remote.id, 'Payment to');
-    equal(payment.confirmed_at, undefined, 'No confirmation date');
-    equal(!!payment.created_at, true, 'Got payment created date');
-    equal(payment.fee, undefined, 'No fee when not paid');
-    equal(payment.fee_mtokens, undefined, 'No fee mtokens when not paid');
-    equal(!!payment.id, true, 'Got a payment id');
-    equal(!!payment.index, true, 'Got payment index');
-    equal(payment.is_confirmed, false, 'Failed payment is not confirmed');
-    equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-    equal(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
-    equal(payment.request, bigInvoice.request, 'Probe has a request');
-    equal(payment.secret, undefined, 'Failed has no secret');
-    equal(payment.safe_fee, undefined, 'Failed has no fee');
-    equal(payment.safe_tokens, bigInvoice.tokens, 'Failed has safe tokens');
-    equal(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
-
-    const gotFailed = await getPayment({lnd, id: payment.id});
-
-    strictSame(
-      gotFailed,
-      {
-        failed: {
-          is_insufficient_balance: false,
-          is_invalid_payment: false,
-          is_pathfinding_timeout: false,
-          is_route_not_found: true,
+    const {address} = await createChainAddress({lnd: remote.lnd});
+
+    await generate({count});
+
+    // Send coins to remote so that it can accept the channel
+    await sendToChainAddress({lnd, address, tokens: channelCapacityTokens});
+
+    // Generate to confirm the tx
+    await generate({count: confirmationCount});
+    await remote.generate({count: confirmationCount});
+
+    await setupChannel({
+      generate,
+      lnd,
+      capacity: channelCapacityTokens + channelCapacityTokens,
+      to: target,
+    });
+
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      generator: target,
+      give: Math.round(channelCapacityTokens / 2),
+      to: remote,
+    });
+
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+    const invoice = await createInvoice({tokens, lnd: remote.lnd});
+
+    const bigInvoice = await createInvoice({
+      tokens: (channelCapacityTokens / 2) + (channelCapacityTokens / 4),
+      lnd: remote.lnd,
+    });
+
+    try {
+      await pay({lnd, request: bigInvoice.request});
+    } catch (err) {
+    }
+
+    // Create a new channel to increase total edge liquidity
+    await setupChannel({
+      capacity: channelCapacityTokens,
+      lnd: target.lnd,
+      generate: target.generate,
+      generator: target,
+      to: remote,
+    });
+
+    await deleteForwardingReputations({lnd});
+
+    await asyncRetry({times}, async () => {
+      await pay({lnd, request: invoice.request});
+    });
+
+    {
+      const {payments} = await getFailedPayments({lnd});
+
+      const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
+
+      equal(payment.destination, remote.id, 'Payment to');
+      equal(payment.confirmed_at, undefined, 'No confirmation date');
+      equal(!!payment.created_at, true, 'Got payment created date');
+      equal(payment.fee, undefined, 'No fee when not paid');
+      equal(payment.fee_mtokens, undefined, 'No fee mtokens when not paid');
+      equal(!!payment.id, true, 'Got a payment id');
+      equal(!!payment.index, true, 'Got payment index');
+      equal(payment.is_confirmed, false, 'Failed payment is not confirmed');
+      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
+      equal(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
+      equal(payment.request, bigInvoice.request, 'Probe has a request');
+      equal(payment.secret, undefined, 'Failed has no secret');
+      equal(payment.safe_fee, undefined, 'Failed has no fee');
+      equal(payment.safe_tokens, bigInvoice.tokens, 'Failed has safe tokens');
+      equal(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
+
+      const gotFailed = await getPayment({lnd, id: payment.id});
+
+      strictSame(
+        gotFailed,
+        {
+          failed: {
+            is_insufficient_balance: false,
+            is_invalid_payment: false,
+            is_pathfinding_timeout: false,
+            is_route_not_found: true,
+          },
+          is_confirmed: false,
+          is_failed: true,
+          is_pending: false,
+          payment: undefined,
+          pending: undefined,
         },
-        is_confirmed: false,
-        is_failed: true,
-        is_pending: false,
-        payment: undefined,
-        pending: undefined,
-      },
-      'Got failed state'
-    );
-  }
-
-  {
-    const {payments} = await getPayments({lnd});
-
-    const [payment] = payments;
-
-    equal(payment.destination, remote.id, 'Paid to');
-    equal(!!payment.confirmed_at, true, 'Got confirmation date');
-    equal(!!payment.created_at, true, 'Got payment start date');
-    equal(payment.fee, 1, 'Got fee paid');
-    equal(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
-    strictSame(payment.hops, [target.id], 'Got hops');
-    equal(!!payment.id, true, 'Got a payment id');
-    equal(!!payment.index, true, 'Got payment index');
-    equal(payment.is_confirmed, true, 'Failed payment is not confirmed');
-    equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-    equal(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
-    equal(payment.request, invoice.request, 'Payment has a request');
-    equal(!!payment.secret, true, 'Failed has no secret');
-    equal(payment.safe_fee, 2, 'Failed has no fee');
-    equal(payment.safe_tokens, invoice.tokens, 'Failed has safe tokens');
-    equal(payment.tokens, invoice.tokens, 'Failed has tokens');
+        'Got failed state'
+      );
+    }
+
+    {
+      const {payments} = await getPayments({lnd});
+
+      const [payment] = payments;
+
+      equal(payment.destination, remote.id, 'Paid to');
+      equal(!!payment.confirmed_at, true, 'Got confirmation date');
+      equal(!!payment.created_at, true, 'Got payment start date');
+      equal(payment.fee, 1, 'Got fee paid');
+      equal(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
+      strictSame(payment.hops, [target.id], 'Got hops');
+      equal(!!payment.id, true, 'Got a payment id');
+      equal(!!payment.index, true, 'Got payment index');
+      equal(payment.is_confirmed, true, 'Failed payment is not confirmed');
+      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
+      equal(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
+      equal(payment.request, invoice.request, 'Payment has a request');
+      equal(!!payment.secret, true, 'Failed has no secret');
+      equal(payment.safe_fee, 2, 'Failed has no fee');
+      equal(payment.safe_tokens, invoice.tokens, 'Failed has safe tokens');
+      equal(payment.tokens, invoice.tokens, 'Failed has tokens');
+    }
+  } catch (err) {
+    strictSame(err, null, 'Expected no error');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });

package/test/integration/test_get_network_centrality.js

@@ -9,7 +9,7 @@ const {setupChannel} = require('./../macros');
 
 const interval = 100;
 const size = 3;
-const times = 300;
+const times = 800;
 
 // Getting the network centrality should return the centrality scores
 test(`Get network centrality`, async ({end, equal, strictSame}) => {
@@ -19,42 +19,50 @@ test(`Get network centrality`, async ({end, equal, strictSame}) => {
 
   const {lnd} = control;
 
-  await setupChannel({lnd, generate: control.generate, to: target});
+  try {
+    await control.generate({count: 100});
 
-  await setupChannel({
-    generate: target.generate,
-    lnd: target.lnd,
-    to: remote,
-  });
-
-  await asyncRetry({interval, times}, async () => {
     await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-    const {nodes} = await getNetworkCentrality({lnd});
-
-    const controlScore = nodes.find(n => n.public_key === control.id);
-    const remoteScore = nodes.find(n => n.public_key === remote.id);
-    const targetScore = nodes.find(n => n.public_key === target.id);
-
-    if (!targetScore.betweenness || !targetScore.betweenness_normalized) {
-      throw new Error('UnexpectedValueForTargetScoreBetweenness');
-    }
-
-    if (targetScore.betweenness !== 1e6) {
-      throw new Error('WrongBetweennessScore');
-    }
-
-    equal(controlScore.betweenness, 0, 'No centrality on control');
-    equal(controlScore.betweenness_normalized, 0, 'No centrality on control');
-    equal(remoteScore.betweenness, 0, 'No centrality on remote');
-    equal(remoteScore.betweenness_normalized, 0, 'No centrality on remote');
-    equal(targetScore.betweenness, 1e6, 'Centrality around target');
-    equal(targetScore.betweenness_normalized, 1e6, 'Centrality around target');
-
-    return;
-  });
-
-  await kill({});
+    await setupChannel({lnd, generate: control.generate, to: target});
+
+    await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+      const {nodes} = await getNetworkCentrality({lnd});
+
+      const controlScore = nodes.find(n => n.public_key === control.id);
+      const remoteScore = nodes.find(n => n.public_key === remote.id);
+      const targetScore = nodes.find(n => n.public_key === target.id);
+
+      if (!targetScore.betweenness || !targetScore.betweenness_normalized) {
+        throw new Error('UnexpectedValueForTargetScoreBetweenness');
+      }
+
+      if (targetScore.betweenness !== 1e6) {
+        throw new Error('WrongBetweennessScore');
+      }
+
+      equal(controlScore.betweenness, 0, 'No centrality on control');
+      equal(controlScore.betweenness_normalized, 0, 'No control centrality');
+      equal(remoteScore.betweenness, 0, 'No centrality on remote');
+      equal(remoteScore.betweenness_normalized, 0, 'No centrality on remote');
+      equal(targetScore.betweenness, 1e6, 'Centrality around target');
+      equal(targetScore.betweenness_normalized, 1e6, 'Centrality at target');
+
+      return;
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  } finally {
+    await kill({});
+  }
 
   return end();
 });