ln-service 53.5.2 → 53.7.2

package/test/walletrpc-integration/test_fund_psbt.js

@@ -3,6 +3,7 @@ const {address} = require('bitcoinjs-lib');
 const {decodePsbt} = require('psbt');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 
 const {createChainAddress} = require('./../../');
 const {fundPsbt} = require('./../../');
@@ -24,6 +25,8 @@ const txIdHexByteLength = 64;
 
 // Funding a transaction should result in a funded PSBT
 test(`Fund PSBT`, async ({end, equal}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
   const {kill, nodes} = await spawnLightningCluster({});
 
   const [{generate, lnd}] = nodes;
@@ -86,7 +89,7 @@ test(`Fund PSBT`, async ({end, equal}) => {
 
   equal(output.output_script, expectedOutput, 'Got expected output script');
 
-  const decoded = decodePsbt({psbt: funded.psbt});
+  const decoded = decodePsbt({ecp, psbt: funded.psbt});
 
   const [decodedInput] = decoded.inputs;
 

package/test/walletrpc-integration/test_partially_sign_psbt.js

@@ -0,0 +1,216 @@
+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 tinysecp = require('tiny-secp256k1');
+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 ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
+  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({ecp, psbt: controlFund.psbt});
+    const targetDecoded = decodePsbt({ecp, psbt: targetFund.psbt});
+    const remoteDecoded = decodePsbt({ecp, 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({
+      ecp,
+      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({
+      ecp,
+      psbt: combinePsbts({ecp, psbts}).psbt,
+    });
+
+    // Pull out the transaction
+    const {transaction} = extractTransaction({ecp, 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();
+});

package/test/walletrpc-integration/test_sign_psbt.js

@@ -3,6 +3,7 @@ const {address} = require('bitcoinjs-lib');
 const {decodePsbt} = require('psbt');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 
 const {broadcastChainTransaction} = require('./../../');
@@ -29,6 +30,8 @@ const txIdHexByteLength = 64;
 
 // Signing a PSBT should result in a finalized PSBT
 test(`Sign PSBT`, async ({end, equal}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target] = nodes;
@@ -72,7 +75,7 @@ test(`Sign PSBT`, async ({end, equal}) => {
 
   const tx = Transaction.fromHex(finalized.transaction);
 
-  const decoded = decodePsbt({psbt: finalized.psbt});
+  const decoded = decodePsbt({ecp, psbt: finalized.psbt});
 
   equal(!!decoded, true, 'Got a finalized PSBT');
   equal(!!tx, true, 'Got a raw signed transaction');