ln-service 53.4.2 → 53.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## 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`
+
 ## 53.4.2
 
 - `pay`, `payViaPaymentRequest`: Fix support for `outgoing_channels` constraint

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
@@ -762,6 +763,9 @@ Requires unlocked lnd and unauthenticated LND API Object
     }
 
     @returns via cbk or Promise
+    {
+      macaroon: <Base64 Encoded Admin Macaroon String>
+    }
 
 Example:
 
@@ -3389,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.

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.2",
+    "lightning": "5.4.1",
     "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.1",
     "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.4.2"
+  "version": "53.6.0"
 }

package/test/integration/test_delete_pending_channel.js

@@ -8,6 +8,7 @@ const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
 const {broadcastChainTransaction} = require('./../../');
+const {cancelPendingChannel} = require('./../../');
 const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
 const {deletePendingChannel} = require('./../../');
@@ -30,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;
@@ -60,7 +61,7 @@ test(`Forfeit pending channel`, async ({end, equal}) => {
     // Sign the funding to the target
     const signTarget = await signPsbt({lnd, psbt: fundTarget.psbt});
 
-    // Fund the target channel
+    // Fund the target channel that will get stuck
     await fundPendingChannels({
       lnd,
       channels: proposeToTarget.pending.map(n => n.id),
@@ -124,16 +125,31 @@ test(`Forfeit pending channel`, async ({end, equal}) => {
 
     const stuckTx = extractTransaction({psbt: signTarget.psbt});
 
-    await deletePendingChannel({
-      lnd,
-      confirmed_transaction: transaction,
-      pending_transaction: stuckTx.transaction,
-      pending_transaction_vout: pending.transaction_vout,
-    });
+    const [stuckPending] = proposeToTarget.pending;
+
+    // Try to cancel the pending channel, it will fail
+    try {
+      await cancelPendingChannel({lnd, id: stuckPending.id});
+    } catch (err) {
+      const [code] = err;
+
+      equal(code, 503, 'Pending channel cannot be canceled');
+    }
+
+    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_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();
 });

package/test/integration/test_get_pending_force.js

@@ -177,7 +177,14 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(forceClose.partner_public_key, target.id, 'pk');
   equal(forceClose.received, 0, 'No receive amount');
   equal(forceClose.recovered_tokens, undefined, 'No recovered amount');
-  equal(forceClose.remote_balance, 0, 'No remote balance');
+
+  // LND 0.14.1 and below do not support remote balance info
+  if (!!forceClose.remote_balance) {
+    equal(forceClose.remote_balance, giftTokens, 'Got gift remote balance');
+  } else {
+    equal(forceClose.remote_balance, 0, 'No remote balance');
+  }
+
   equal(forceClose.sent, 0, 'No sent amount');
   equal(!!forceClose.timelock_blocks, true, 'Timelock blocks set');
   equal(forceClose.timelock_expiration, startHeight + 265, 'Funds timelock');

package/test/tower_clientrpc-integration/test_disconnect_watchtower.js

@@ -9,9 +9,9 @@ const {spawnLnd} = require('./../macros');
 const {waitForTermination} = require('./../macros');
 
 const all = promise => Promise.all(promise);
-const interval = 100;
+const interval = 200;
 const nodes = [{watchers: true}, {tower: true}];
-const times = 200;
+const times = 1000;
 
 // Disconnecting a watchtower should remove a watchtower
 test(`Disconnect watchtower`, async ({end, equal, match}) => {

package/test/walletrpc-integration/test_partially_sign_psbt.js

@@ -0,0 +1,209 @@
+const asyncEach = require('async/each');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {combinePsbts} = require('psbt');
+const {createPsbt} = require('psbt');
+const {decodePsbt} = require('psbt');
+const {extractTransaction} = require('psbt');
+const {finalizePsbt} = require('psbt');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+const {updatePsbt} = require('psbt');
+
+const {broadcastChainTransaction} = require('./../../');
+const {createChainAddress} = require('./../../');
+const {fundPsbt} = require('./../../');
+const {getChainBalance} = require('./../../');
+const {getChainTransactions} = require('./../../');
+const {getUtxos} = require('./../../');
+const {partiallySignPsbt} = require('./../../');
+const {sendToChainAddresses} = require('./../../');
+
+const count = 150;
+const flatten = arr => [].concat(...arr);
+const interval = 10;
+const size = 3;
+const startingFunds = 1e7;
+const times = 1000;
+const tokens = 1e6;
+
+// Partially signing a PSBT should result in a partially signed PSBT
+test(`Partially sign PSBT`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target, remote] = nodes;
+
+  try {
+    // Generate some funds for the control
+    await control.generate({count});
+
+    // Send starting coins to target and remote
+    await sendToChainAddresses({
+      lnd: control.lnd,
+      send_to: await asyncMap([target, remote], async ({lnd}) => {
+        return {
+          address: (await createChainAddress({lnd})).address,
+          tokens: startingFunds,
+        };
+      }),
+    });
+
+    // Make sure that the nodes have funds
+    await asyncRetry({interval, times}, async () => {
+      await asyncEach([control, target, remote], async ({lnd}) => {
+        await control.generate({});
+
+        if (!(await getChainBalance({lnd})).chain_balance) {
+          throw new Error('WaitingForChainBalance');
+        }
+      });
+    });
+
+    // Get UTXOs to spend
+    const [controlUtxo] = (await getUtxos({lnd: control.lnd})).utxos.reverse();
+    const [targetUtxo] = (await getUtxos({lnd: target.lnd})).utxos;
+    const [remoteUtxo] = (await getUtxos({lnd: remote.lnd})).utxos;
+
+    // Make addresses to spend to
+    const addresses = await asyncMap(nodes, async ({lnd}) => {
+      return await createChainAddress({lnd});
+    });
+
+    const [controlAddress, targetAddress, remoteAddress] = addresses;
+
+    // Fund the addresses using the selected UTXOs
+    const controlFund = await fundPsbt({
+      inputs: [{
+        transaction_id: controlUtxo.transaction_id,
+        transaction_vout: controlUtxo.transaction_vout,
+      }],
+      lnd: control.lnd,
+      outputs: [{tokens, address: controlAddress.address}],
+    });
+
+    const targetFund = await fundPsbt({
+      inputs: [{
+        transaction_id: targetUtxo.transaction_id,
+        transaction_vout: targetUtxo.transaction_vout,
+      }],
+      lnd: target.lnd,
+      outputs: [{tokens, address: targetAddress.address}],
+    });
+
+    const remoteFund = await fundPsbt({
+      inputs: [{
+        transaction_id: remoteUtxo.transaction_id,
+        transaction_vout: remoteUtxo.transaction_vout,
+      }],
+      lnd: remote.lnd,
+      outputs: [{tokens, address: remoteAddress.address}],
+    });
+
+    // Collect all inputs that are spending
+    const inputs = []
+      .concat(controlFund.inputs)
+      .concat(targetFund.inputs)
+      .concat(remoteFund.inputs);
+
+    // Collect all outputs being sent to
+    const outputs = []
+        .concat(controlFund.outputs)
+        .concat(targetFund.outputs)
+        .concat(remoteFund.outputs);
+
+    // Make a new PSBT that includes all the outputs and inputs
+    const base = createPsbt({
+      outputs: outputs.map(output => ({
+        script: output.output_script,
+        tokens: output.tokens,
+      })),
+      utxos: inputs.map(input => ({
+        id: input.transaction_id,
+        vout: input.transaction_vout,
+      })),
+    });
+
+    // Decode the PSBTs to get signing key details
+    const controlDecoded = decodePsbt({psbt: controlFund.psbt});
+    const targetDecoded = decodePsbt({psbt: targetFund.psbt});
+    const remoteDecoded = decodePsbt({psbt: remoteFund.psbt});
+
+    // Collect all the BIP32 derivations
+    const controlBip32Derivations = controlDecoded.inputs
+      .map(n => n.bip32_derivations);
+
+    const targetBip32Derivations = targetDecoded.inputs
+      .map(n => n.bip32_derivations);
+
+    const remoteBip32Derivations = remoteDecoded.inputs
+      .map(n => n.bip32_derivations);
+
+    const controlTransactions = controlDecoded.inputs
+      .map(n => n.non_witness_utxo);
+
+    const targetTransactions = targetDecoded.inputs
+      .map(n => n.non_witness_utxo);
+
+    const remoteTransactions = remoteDecoded.inputs
+      .map(n => n.non_witness_utxo);
+
+    const allDerivations = []
+      .concat(controlBip32Derivations)
+      .concat(targetBip32Derivations)
+      .concat(remoteBip32Derivations);
+
+    const bip32Derivations = flatten(allDerivations);
+
+    // Update the PSBT so that it has the consolidated details
+    const updated = updatePsbt({
+      bip32_derivations: bip32Derivations,
+      psbt: base.psbt,
+      sighashes: inputs.map(input => ({
+        id: input.transaction_id,
+        sighash: Transaction.SIGHASH_ALL,
+        vout: input.transaction_vout,
+      })),
+      transactions: controlTransactions.concat(targetTransactions),
+    });
+
+    await partiallySignPsbt({lnd: control.lnd, psbt: updated.psbt});
+
+    // Sign the PSBT
+    const psbts = await asyncMap(nodes, async ({lnd}) => {
+      return (await partiallySignPsbt({lnd, psbt: updated.psbt})).psbt;
+    });
+
+    // Finalize the signatures
+    const finalize = finalizePsbt({psbt: combinePsbts({psbts}).psbt});
+
+    // Pull out the transaction
+    const {transaction} = extractTransaction({psbt: finalize.psbt});
+
+    // Publish the transaction
+    await broadcastChainTransaction({lnd: control.lnd, transaction});
+
+    // Make sure that the transaction confirms into a block
+    await asyncEach(nodes, async ({lnd}) => {
+      return asyncRetry({interval, times}, async () => {
+        await control.generate({});
+
+        const {utxos} = await getUtxos({lnd});
+
+        const [confirmed] = utxos.filter(n => n.tokens === tokens);
+
+        if (!confirmed || !confirmed.confirmation_count) {
+          throw new Error('ExpectedConfirmedCoin');
+        }
+
+        equal(confirmed.tokens, tokens, 'Got confirmed funds');
+      });
+    });
+  } catch (err) {
+    strictSame(err, [501, 'PartiallySignPsbtMethodNotSupported'], 'NoSupport');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});