ln-service 53.16.1 → 53.17.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 53.17.2
+
+- `signTransaction`: Add `root_hash` to support Taproot signatures with scripts
+
 ## 53.16.1
 
 - `getFailedPayments`, `getPayments`, `getPendingPayments`: Remove

package/README.md

@@ -3400,6 +3400,7 @@ const {app, server, wss} = grpcProxyServer({
 // Create an authenticated LND for the gRPC REST gateway
 const {lnd} = lndGateway({
   request,
+  websocket,
   macaroon: base64EncodedMacaroonFileString,
   url: `http://localhost:${port}${path}`,
 });
@@ -4781,6 +4782,7 @@ Requires LND built with `signrpc` build tag
 
 Requires `signer:generate` permission
 
+`root_hash` is not supported in LND 0.14.3 and below
 `spending` is not supported in LND 0.14.3 and below
 
     {
@@ -4789,9 +4791,10 @@ Requires `signer:generate` permission
         key_index: <Key Index Number>
         output_script: <Output Script Hex String>
         output_tokens: <Output Tokens Number>
+        [root_hash]: <Taproot Root Hash Hex String>
         sighash: <Sighash Type Number>
         vin: <Input Index To Sign Number>
-        witness_script: <Witness Script Hex String>
+        [witness_script]: <Witness Script Hex String>
       }]
       lnd: <Authenticated LND API Object>
       [spending]: [{

package/package.json

@@ -7,14 +7,14 @@
     "url": "https://github.com/alexbosworth/ln-service/issues"
   },
   "dependencies": {
-    "bolt07": "1.8.1",
+    "bolt07": "1.8.2",
     "cors": "2.8.5",
     "express": "4.18.1",
-    "invoices": "2.0.6",
-    "lightning": "5.15.1",
+    "invoices": "2.0.7",
+    "lightning": "5.16.2",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
-    "ws": "8.6.0"
+    "ws": "8.7.0"
   },
   "description": "Interaction helper for your Lightning Network daemon",
   "devDependencies": {
@@ -25,13 +25,13 @@
     "bip32": "3.0.1",
     "bip66": "1.1.5",
     "bitcoinjs-lib": "6.0.1",
-    "bn.js": "5.2.0",
+    "bn.js": "5.2.1",
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.2.10",
+    "ln-docker-daemons": "2.2.12",
     "p2tr": "1.3.1",
     "portfinder": "1.0.28",
-    "psbt": "2.0.1",
+    "psbt": "2.4.0",
     "rimraf": "3.0.2",
     "secp256k1": "4.0.3",
     "tiny-secp256k1": "2.2.1",
@@ -70,5 +70,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/peersrpc-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.16.1"
+  "version": "53.17.2"
 }

package/test/integration/test_create_chain_address.js

@@ -41,6 +41,9 @@ test(`Create address results in address creation`, async ({end, equal}) => {
     equal(address.startsWith(prefixForV1), true, 'A taproot address is made');
   } catch (err) {
     // LND 0.14.3 and below do not support TR addresses
+    const [code] = err;
+
+    equal(code, 501, 'Taproot addresses are unsupported');
   }
 
   await kill({});

package/test/integration/test_delete_pending_channel.js

@@ -126,7 +126,7 @@ test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
 
     const [pending] = (await getPendingChannels({lnd})).pending_channels;
 
-    const stuckTx = extractTransaction({psbt: signTarget.psbt});
+    const stuckTx = extractTransaction({ecp, psbt: signTarget.psbt});
 
     const [stuckPending] = proposeToTarget.pending;
 

package/test/integration/test_get_network_info.js

@@ -2,22 +2,28 @@ const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getNetworkInfo} = require('./../../');
+const {setupChannel} = require('./../macros');
+
+const size = 2;
+const tokens = 1e6;
 
 // Getting the network info should return basic network statistics
 test(`Get network info`, async ({end, equal}) => {
-  const {kill, nodes} = await spawnLightningCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, lnd}, target] = nodes;
 
-  const [{lnd}] = nodes;
+  await setupChannel({generate, lnd, to: target});
 
   const result = await getNetworkInfo({lnd});
 
-  equal(result.average_channel_size, 0, 'Average channel size');
-  equal(result.channel_count, 0, 'Channel count');
-  equal(result.max_channel_size, 0, 'Maximum channel size');
-  equal(result.median_channel_size, 0, 'Median channel size');
-  equal(result.min_channel_size, 0, 'Minimum channel size');
+  equal(result.average_channel_size, tokens, 'Average channel size');
+  equal(result.channel_count, 1, 'Channel count');
+  equal(result.max_channel_size, tokens, 'Maximum channel size');
+  equal(result.median_channel_size, tokens, 'Median channel size');
+  equal(result.min_channel_size, tokens, 'Minimum channel size');
   equal(result.not_recently_updated_policy_count, 0, 'Not updated count');
-  equal(result.total_capacity, 0, 'Total capacity');
+  equal(result.total_capacity, tokens, 'Total capacity');
 
   await kill({});
 

package/test/macros/wait_for_channel.js

@@ -5,7 +5,7 @@ const {returnResult} = require('asyncjs-util');
 const {getChannel} = require('./../../');
 const {getChannels} = require('./../../');
 
-const interval = 10;
+const interval = 20;
 const times = 10000;
 
 /** Wait for channel to be open

package/test/signerrpc-integration/test_sign_taproot.js

@@ -0,0 +1,359 @@
+const asyncRetry = require('async/retry');
+const {address} = require('bitcoinjs-lib');
+const {controlBlock} = require('p2tr');
+const {createPsbt} = require('psbt');
+const {hashForTree} = require('p2tr');
+const {networks} = require('bitcoinjs-lib');
+const {script} = require('bitcoinjs-lib');
+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 {beginGroupSigningSession} = require('./../../');
+const {broadcastChainTransaction} = require('./../../');
+const {createChainAddress} = require('./../../');
+const {fundPsbt} = require('./../../');
+const {getPublicKey} = require('./../../');
+const {getUtxos} = require('./../../');
+const {signPsbt} = require('./../../');
+const {signTransaction} = require('./../../');
+
+const {compile} = script;
+const count = 100;
+const defaultInternalKey = '0350929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0';
+const {fromHex} = Transaction;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const interval = retryCount => 10 * Math.pow(2, retryCount);
+const OP_CHECKSIG = 172;
+const smallTokens = 2e5;
+const times = 20;
+const {toOutputScript} = address;
+const tokens = 1e6;
+
+// Signing a taproot transaction should result in a valid signature
+test(`Sign a taproot transaction`, async ({end, equal}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+  const {kill, nodes} = await spawnLightningCluster({});
+
+  const [{generate, lnd}] = nodes;
+
+  try {
+    await beginGroupSigningSession({
+      lnd,
+      is_key_spend: true,
+      key_family: 0,
+      key_index: 0,
+      public_keys: [Buffer.alloc(33, 2).toString('hex')],
+    });
+  } catch (err) {
+    // On LND 0.14.3 and below, taproot signing is not supported
+    if (err.slice().shift() === 501) {
+      await kill({});
+
+      return end();
+    }
+
+    throw err;
+  }
+
+  await generate({count});
+
+  const {address} = await createChainAddress({lnd});
+  const [utxo] = (await getUtxos({lnd})).utxos;
+
+  const funded = await asyncRetry({interval, times}, async () => {
+    try {
+      return await fundPsbt({
+        lnd,
+        inputs: [{
+          transaction_id: utxo.transaction_id,
+          transaction_vout: utxo.transaction_vout,
+        }],
+        outputs: [{address, tokens}],
+      });
+    } catch (err) {
+      // On LND 0.11.1 and below, funding a PSBT is not supported
+      if (err.slice().shift() === 501) {
+        return;
+      }
+
+      throw err;
+    }
+  });
+
+  // A Taproot script output should be funded and spent with script
+  try {
+    await generate({count});
+
+    const scriptKey = await getPublicKey({lnd, family: 805});
+
+    const publicKey = hexAsBuffer(scriptKey.public_key);
+
+    const witnessScript = compile([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 {signatures} = await signTransaction({
+      lnd,
+      inputs: [{
+        key_family: 805,
+        key_index: scriptKey.index,
+        output_script: output.script,
+        output_tokens: tokens,
+        root_hash: hash,
+        sighash: Transaction.SIGHASH_DEFAULT,
+        vin: 0,
+        witness_script: witnessScript.toString('hex'),
+      }],
+      transaction: tx.toHex(),
+    });
+
+    const [signature] = signatures.map(hexAsBuffer);
+
+    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 script can be funded and spent with internal key + script hash
+  try {
+    await generate({count});
+
+    const topLevelKey = await getPublicKey({lnd, family: 805});
+
+    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});
+
+    const output = v1OutputScript({
+      hash,
+      internal_key: topLevelKey.public_key,
+    });
+
+    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 {signatures} = await signTransaction({
+      lnd,
+      inputs: [{
+        key_family: 805,
+        key_index: topLevelKey.index,
+        output_script: output.script,
+        output_tokens: tokens,
+        root_hash: hash,
+        sighash: Transaction.SIGHASH_DEFAULT,
+        vin: 0,
+      }],
+      transaction: tx.toHex(),
+    });
+
+    const [signature] = signatures.map(hexAsBuffer);
+
+    // 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 can be funded and spent with bip86 internal key
+  try {
+    await generate({count});
+
+    const topLevelKey = await getPublicKey({lnd, family: 805});
+
+    const output = v1OutputScript({
+      internal_key: topLevelKey.public_key,
+    });
+
+    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 {signatures} = await signTransaction({
+      lnd,
+      inputs: [{
+        key_family: 805,
+        key_index: topLevelKey.index,
+        output_script: output.script,
+        output_tokens: tokens,
+        sighash: Transaction.SIGHASH_DEFAULT,
+        vin: 0,
+      }],
+      transaction: tx.toHex(),
+    });
+
+    const [signature] = signatures.map(hexAsBuffer);
+
+    // 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');
+  }
+
+  await kill({});
+
+  return end();
+});

package/test/signerrpc-integration/test_sign_transaction.js

@@ -15,7 +15,7 @@ test(`Sign transaction`, async ({end, equal}) => {
     inputs: [{
       key_family: 6,
       key_index: 1,
-      output_script: '00',
+      output_script: '00147ab105a90ccd7e49d96672abcac2995bdb852baa',
       output_tokens: 1e8,
       sighash: Transaction.SIGHASH_ALL,
       vin: 0,