ln-service 53.9.1 → 53.9.4

package/CHANGELOG.md

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

package/README.md

@@ -3685,7 +3685,7 @@ Requires `offchain:write` permission
       [outgoing_channels]: [<Pay Out of Outgoing Channel Ids String>]
       [pathfinding_timeout]: <Time to Spend Finding a Route Milliseconds Number>
       [payment]: <Payment Identifier Hex String>
-      routes: [[{
+      [routes]: [[{
         [base_fee_mtokens]: <Base Routing Fee In Millitokens String>
         [channel]: <Standard Format Channel Id String>
         [cltv_delta]: <CLTV Blocks Delta Number>
@@ -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

@@ -9,16 +9,16 @@
   "dependencies": {
     "bolt07": "1.8.0",
     "cors": "2.8.5",
-    "express": "4.17.2",
+    "express": "4.17.3",
     "invoices": "2.0.4",
-    "lightning": "5.8.1",
+    "lightning": "5.8.6",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.5.0"
   },
   "description": "Interaction helper for your Lightning Network daemon",
   "devDependencies": {
-    "@alexbosworth/tap": "15.0.10",
+    "@alexbosworth/tap": "15.0.11",
     "@alexbosworth/node-fetch": "2.6.2",
     "async": "3.2.3",
     "asyncjs-util": "1.2.8",
@@ -28,12 +28,13 @@
     "bn.js": "5.2.0",
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.2.4",
+    "ln-docker-daemons": "2.2.5",
+    "p2tr": "1.3.0",
     "portfinder": "1.0.28",
     "psbt": "2.0.0",
     "rimraf": "3.0.2",
     "secp256k1": "4.0.3",
-    "tiny-secp256k1": "2.2.0",
+    "tiny-secp256k1": "2.2.1",
     "uuid": "8.3.2",
     "varuint-bitcoin": "1.1.2"
   },
@@ -68,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.1"
+  "version": "53.9.4"
 }

package/test/walletrpc-integration/test_fund_psbt.js

@@ -1,14 +1,21 @@
 const asyncRetry = require('async/retry');
 const {address} = require('bitcoinjs-lib');
+const {controlBlock} = require('p2tr');
 const {createPsbt} = require('psbt');
-const {crypto} = require('bitcoinjs-lib');
 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');
 const {Transaction} = require('bitcoinjs-lib');
+const {v1OutputScript} = require('p2tr');
 
 const {broadcastChainTransaction} = require('./../../');
 const {createChainAddress} = require('./../../');
@@ -23,25 +30,17 @@ const chainAddressRowType = 'chain_address';
 const {compile} = script;
 const confirmationCount = 6;
 const count = 100;
+const defaultInternalKey = '0350929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0';
 const description = 'description';
-const extra = Buffer.alloc(32);
+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 isLowPublicKey = keyPair => keyPair.publicKey[0] === 2;
-const makeTaprootKey = (k, h) => tinysecp.xOnlyPointAddTweak(k, h).xOnlyPubkey;
-const nLess1 = 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140';
-const one256BitBigEndian = '0000000000000000000000000000000000000000000000000000000000000001';
-const OP_1 = 81;
-const {privateAdd} = tinysecp;
-const {privateSub} = tinysecp;
+const OP_CHECKSIG = 172;
 const regtestBech32AddressHrp = 'bcrt';
-const shortKey = keyPair =>  keyPair.publicKey.slice(1, 33);
-const {signSchnorr} = tinysecp;
 const smallTokens = 2e5;
-const tapHash = k => crypto.taggedHash('TapTweak', k.publicKey.slice(1, 33));
 const times = 20;
 const {toOutputScript} = address;
 const tokens = 1e6;
@@ -120,22 +119,123 @@ 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 outputKey = makeTaprootKey(shortKey(keyPair), tapHash(keyPair));
-    const tweakHash = tapHash(keyPair);
+    const witnessScript = compile([keyPair.publicKey.slice(1), OP_CHECKSIG]);
+
+    const branches = [{script: witnessScript.toString('hex')}];
+
+    const {hash} = hashForTree({branches});
 
-    const outputScript = compile([OP_1, Buffer.from(outputKey)]);
+    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: outputScript.toString('hex')}],
+      outputs: [{tokens, script: output.script}],
       utxos: [{id: utxo.transaction_id, vout: utxo.transaction_vout}],
     });
 
@@ -169,22 +269,110 @@ test(`Fund PSBT`, async ({end, equal}) => {
     const [hashToSign] = tx.ins.map((input, i) => {
       return tx.hashForWitnessV1(
         i,
-        [outputScript],
+        [hexAsBuffer(output.script)],
         [tokens],
         Transaction.SIGHASH_DEFAULT,
+        hexAsBuffer(leafHash({script: witnessScript.toString('hex')}).hash),
       );
     });
 
-    const isLow = isLowPublicKey(keyPair);
-    const ONE = hexAsBuffer(one256BitBigEndian);
-    const subtract = privateSub(hexAsBuffer(nLess1), keyPair.privateKey);
+    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});
+
+    const keyPair = ecp.makeRandom({network: networks.regtest});
+
+    const output = v1OutputScript({
+      internal_key: keyPair.publicKey.toString('hex'),
+    });
+
+    const outputScript = hexAsBuffer(output.script);
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: outputScript.toString('hex')}],
+      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
+    );
 
-    const privateKey = isLow ? keyPair.privateKey : privateAdd(subtract, ONE);
+    // Add output to the pay back transaction
+    tx.addOutput(chainOutput, smallTokens);
 
-    // Only low keys are allowed to save a leading byte on the public key
-    const lowPrivateKey = privateAdd(privateKey, tweakHash);
+    const [hashToSign] = tx.ins.map((input, i) => {
+      return tx.hashForWitnessV1(
+        i,
+        [outputScript],
+        [tokens],
+        Transaction.SIGHASH_DEFAULT,
+      );
+    });
+
+    const signedInput = signHash({
+      private_key: keyPair.privateKey.toString('hex'),
+      public_key: keyPair.publicKey.toString('hex'),
+      sign_hash: hashToSign.toString('hex'),
+    });
 
-    const signature = signSchnorr(hashToSign, lowPrivateKey, extra);
+    const signature = hexAsBuffer(signedInput.signature);
 
     // Add the signature to the input
     tx.ins.forEach((input, i) => tx.setWitness(i, [Buffer.from(signature)]));