ln-service 53.9.2 → 53.9.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 53.9.2
+## 53.9.3
 
 - `getPendingPayments`: Add method to get payments in flight
 

package/README.md

@@ -5433,6 +5433,8 @@ const {secret} = await once(sub, 'confirmed');
 
 Subscribe to successful outgoing payments
 
+Payments may be omitted if LND does not finalize the payment record
+
 Requires `offchain:read` permission
 
 Note: Method not supported on LND 0.13.4 and below

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.17.3",
     "invoices": "2.0.4",
-    "lightning": "5.8.1",
+    "lightning": "5.8.2",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.5.0"
@@ -29,7 +29,7 @@
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
     "ln-docker-daemons": "2.2.4",
-    "p2tr": "1.2.0",
+    "p2tr": "1.3.0",
     "portfinder": "1.0.28",
     "psbt": "2.0.0",
     "rimraf": "3.0.2",
@@ -69,5 +69,5 @@
     "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.9.2"
+  "version": "53.9.3"
 }

package/test/walletrpc-integration/test_fund_psbt.js

@@ -1,9 +1,16 @@
 const asyncRetry = require('async/retry');
 const {address} = require('bitcoinjs-lib');
+const {controlBlock} = require('p2tr');
 const {createPsbt} = require('psbt');
 const {decodePsbt} = require('psbt');
+const {hashForTree} = require('p2tr');
+const {leafHash} = require('p2tr');
 const {networks} = require('bitcoinjs-lib');
+const {pointAdd} = require('tiny-secp256k1');
+const {privateAdd} = require('tiny-secp256k1');
+const {script} = require('bitcoinjs-lib');
 const {signHash} = require('p2tr');
+const {signSchnorr} = require('tiny-secp256k1');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 const tinysecp = require('tiny-secp256k1');
@@ -20,14 +27,18 @@ const {sendToChainAddress} = require('./../../');
 const {signPsbt} = require('./../../');
 
 const chainAddressRowType = 'chain_address';
+const {compile} = script;
 const confirmationCount = 6;
 const count = 100;
+const defaultInternalKey = '0350929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0';
 const description = 'description';
+const {from} = Buffer;
 const {fromBech32} = address;
 const {fromHex} = Transaction;
 const {fromOutputScript} = address;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const interval = retryCount => 10 * Math.pow(2, retryCount);
+const OP_CHECKSIG = 172;
 const regtestBech32AddressHrp = 'bcrt';
 const smallTokens = 2e5;
 const times = 20;
@@ -108,7 +119,198 @@ test(`Fund PSBT`, async ({end, equal}) => {
   equal(!!decodedInput.witness_utxo.script_pub, true, 'PSBT input address');
   equal(decodedInput.witness_utxo.tokens, 5000000000, 'PSBT has input tokens');
 
-  // A Taproot output should be funded
+  // A Taproot script can be funded and spent with internal key + script hash
+  try {
+    await generate({count});
+
+    const keyPair1 = ecp.makeRandom({network: networks.regtest});
+    const keyPair2 = ecp.makeRandom({network: networks.regtest});
+    const unusedKey = ecp.makeRandom({network: networks.regtest});
+
+    const witnessScript = compile([unusedKey.publicKey.slice(1), OP_CHECKSIG]);
+
+    const branches = [{script: witnessScript.toString('hex')}];
+
+    const {hash} = hashForTree({branches});
+
+    // Create a combined key using public key material
+    const combinedPoint = pointAdd(keyPair1.publicKey, keyPair2.publicKey);
+
+    const output = v1OutputScript({
+      hash,
+      internal_key: Buffer.from(combinedPoint).toString('hex'),
+    });
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: output.script}],
+      utxos: [{id: utxo.transaction_id, vout: utxo.transaction_vout}],
+    });
+
+    // Sign the PSBT
+    const signed = await signPsbt({
+      lnd,
+      psbt: (await fundPsbt({lnd, psbt})).psbt,
+    });
+
+    // Send the tx to the chain
+    await broadcastChainTransaction({lnd, transaction: signed.transaction});
+
+    // Make a new tx that will spend the output back into the wallet
+    const tx = new Transaction();
+
+    // The new tx spends the Taproot output
+    tx.addInput(
+      fromHex(signed.transaction).getHash(),
+      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
+    );
+
+    // Make an output to pay back into the wallet
+    const chainOutput = toOutputScript(
+      (await createChainAddress({lnd})).address,
+      networks.regtest
+    );
+
+    // Add output to the pay back transaction
+    tx.addOutput(chainOutput, smallTokens);
+
+    const [hashToSign] = tx.ins.map((input, i) => {
+      return tx.hashForWitnessV1(
+        i,
+        [hexAsBuffer(output.script)],
+        [tokens],
+        Transaction.SIGHASH_DEFAULT,
+      );
+    });
+
+    // Ready for private key combining
+    const combinedKey = privateAdd(keyPair1.privateKey, keyPair2.privateKey);
+
+    const signedInput = signHash({
+      hash,
+      private_key: Buffer.from(combinedKey).toString('hex'),
+      public_key: Buffer.from(combinedPoint).toString('hex'),
+      sign_hash: hashToSign.toString('hex'),
+    });
+
+    const signature = hexAsBuffer(signedInput.signature);
+
+    // Add the signature to the input
+    tx.ins.forEach((input, i) => tx.setWitness(i, [signature]));
+
+    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {utxos} = await getUtxos({lnd});
+
+      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+
+      if (!utxo || !utxo.confirmation_count) {
+        throw new Error('ExpectedReceivedTaprootSpend');
+      }
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
+
+  // A Taproot script output should be funded and spent with script
+  try {
+    await generate({count});
+
+    const keyPair = ecp.makeRandom({network: networks.regtest});
+
+    const witnessScript = compile([keyPair.publicKey.slice(1), OP_CHECKSIG]);
+
+    const branches = [{script: witnessScript.toString('hex')}];
+
+    const {hash} = hashForTree({branches});
+
+    const output = v1OutputScript({hash, internal_key: defaultInternalKey});
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: output.script}],
+      utxos: [{id: utxo.transaction_id, vout: utxo.transaction_vout}],
+    });
+
+    // Sign the PSBT
+    const signed = await signPsbt({
+      lnd,
+      psbt: (await fundPsbt({lnd, psbt})).psbt,
+    });
+
+    // Send the tx to the chain
+    await broadcastChainTransaction({lnd, transaction: signed.transaction});
+
+    // Make a new tx that will spend the output back into the wallet
+    const tx = new Transaction();
+
+    // The new tx spends the Taproot output
+    tx.addInput(
+      fromHex(signed.transaction).getHash(),
+      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
+    );
+
+    // Make an output to pay back into the wallet
+    const chainOutput = toOutputScript(
+      (await createChainAddress({lnd})).address,
+      networks.regtest
+    );
+
+    // Add output to the pay back transaction
+    tx.addOutput(chainOutput, smallTokens);
+
+    const [hashToSign] = tx.ins.map((input, i) => {
+      return tx.hashForWitnessV1(
+        i,
+        [hexAsBuffer(output.script)],
+        [tokens],
+        Transaction.SIGHASH_DEFAULT,
+        hexAsBuffer(leafHash({script: witnessScript.toString('hex')}).hash),
+      );
+    });
+
+    const signature = from(signSchnorr(hashToSign, keyPair.privateKey));
+
+    const {block} = controlBlock({
+      external_key: output.external_key,
+      leaf_script: witnessScript.toString('hex'),
+      script_branches: branches,
+    });
+
+    // Add the signature to the input
+    tx.ins.forEach((input, i) => {
+      return tx.setWitness(i, [
+        signature,
+        witnessScript,
+        hexAsBuffer(block),
+      ]);
+    });
+
+    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {utxos} = await getUtxos({lnd});
+
+      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+
+      if (!utxo || !utxo.confirmation_count) {
+        throw new Error('ExpectedReceivedTaprootSpend');
+      }
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
+
+  // A Taproot output should be funded for a regular key spend
   try {
     await generate({count});