ln-service 53.5.0 → 53.7.0

package/test/routerrpc-integration/test_subscribe_to_forward_requests.js

@@ -20,8 +20,8 @@ const {waitForRoute} = require('./../macros');
 const size = 3;
 const tokens = 100;
 
-// Paying an invoice should settle the invoice
-test(`Pay via payment request`, async ({end, equal, rejects, strictSame}) => {
+// Subscribing to forward requests should intercept forwards
+test(`Subscribe to requests`, async ({end, equal, rejects, strictSame}) => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;

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();
+});