lightning 5.15.2 → 5.16.0

package/CHANGELOG.md

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

package/grpc/protos/lightning.proto

@@ -2369,9 +2369,6 @@ message PendingChannelsResponse {
         // The pending channel
         PendingChannel channel = 1;
 
-        // The height at which this channel will be confirmed
-        uint32 confirmation_height = 2;
-
         /*
         The amount calculated to be paid in fees for the current set of
         commitment transactions. The fee amount is persisted with the channel
@@ -2390,6 +2387,9 @@ message PendingChannelsResponse {
         transaction. This value can later be updated once the channel is open.
         */
         int64 fee_per_kw = 6;
+
+        // Previously used for confirmation_height. Do not reuse.
+        reserved 2;
     }
 
     message WaitingCloseChannel {
@@ -3633,6 +3633,14 @@ message ListPaymentsRequest {
     of the returned payments is always oldest first (ascending index order).
     */
     bool reversed = 4;
+
+    /*
+    If set, all payments (complete and incomplete, independent of the
+    max_payments parameter) will be counted. Note that setting this to true will
+    increase the run time of the call significantly on systems that have a lot
+    of payments, as all of them have to be iterated through to be counted.
+    */
+    bool count_total_payments = 5;
 }
 
 message ListPaymentsResponse {
@@ -3650,6 +3658,14 @@ message ListPaymentsResponse {
     as the index_offset to continue seeking forwards in the next request.
     */
     uint64 last_index_offset = 3;
+
+    /*
+    Will only be set if count_total_payments in the request was set. Represents
+    the total number of payments (complete and incomplete, independent of the
+    number of payments requested in the query) currently present in the payments
+    database.
+    */
+    uint64 total_num_payments = 4;
 }
 
 message DeletePaymentRequest {

package/grpc/protos/signer.proto

@@ -137,6 +137,7 @@ service Signer {
     MuSig2Cleanup (experimental!) allows a caller to clean up a session early in
     cases where it's obvious that the signing session won't succeed and the
     resources can be released.
+
     NOTE: The MuSig2 BIP is not final yet and therefore this API must be
     considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
     releases. Backward compatibility is not guaranteed!
@@ -174,6 +175,32 @@ message TxOut {
     bytes pk_script = 2;
 }
 
+enum SignMethod {
+    /*
+    Specifies that a SegWit v0 (p2wkh, np2wkh, p2wsh) input script should be
+    signed.
+    */
+    SIGN_METHOD_WITNESS_V0 = 0;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be signed by using the
+    BIP0086 method (commit to internal key only).
+    */
+    SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086 = 1;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be signed by using a given
+    taproot hash to commit to in addition to the internal key.
+    */
+    SIGN_METHOD_TAPROOT_KEY_SPEND = 2;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be spent using the script
+    path and that a specific leaf script should be signed for.
+    */
+    SIGN_METHOD_TAPROOT_SCRIPT_SPEND = 3;
+}
+
 message SignDescriptor {
     /*
     A descriptor that precisely describes *which* key to use for signing. This
@@ -208,12 +235,23 @@ message SignDescriptor {
     */
     bytes double_tweak = 3;
 
+    /*
+    The 32 byte input to the taproot tweak derivation that is used to derive
+    the output key from an internal key: outputKey = internalKey +
+    tagged_hash("tapTweak", internalKey || tapTweak).
+
+    When doing a BIP 86 spend, this field can be an empty byte slice.
+
+    When doing a normal key path spend, with the output key committing to an
+    actual script root, then this field should be: the tapscript root hash.
+    */
+    bytes tap_tweak = 10;
+
     /*
     The full script required to properly redeem the output. This field will
-    only be populated if a p2tr, p2wsh or a p2sh output is being signed. In case
-    taproot_key_spend is set to true then this value must correspond to the
-    taproot root hash (in case of a tapscript output) or the tap hashed internal
-    public key (in case of a BIP-0086 output).
+    only be populated if a p2tr, p2wsh or a p2sh output is being signed. If a
+    taproot script path spend is being attempted, then this should be the raw
+    leaf script.
     */
     bytes witness_script = 4;
 
@@ -235,12 +273,12 @@ message SignDescriptor {
     int32 input_index = 8;
 
     /*
-    Indicates that this should produce a signature that can be used for the key
-    spend path of a taproot input. This requires the witness_script field to be
-    set to the taproot root hash (in case of a tapscript output) or the tap
-    hashed internal public key (in case of a BIP-0086 output).
+    The sign method specifies how the input should be signed. Depending on the
+    method, either the tap_tweak, witness_script or both need to be specified.
+    Defaults to SegWit v0 signing to be backward compatible with older RPC
+    clients.
     */
-    bool taproot_key_spend = 9;
+    SignMethod sign_method = 9;
 }
 
 message SignReq {

package/lnd_methods/signer/input_signing_method.js

@@ -0,0 +1,42 @@
+const v0SpendMethod = 0;
+const v1Bip86Method = 1;
+const v1SpendMethod = 2;
+const v1ScriptSpend = 3;
+
+/** Determine a signing method for an input
+
+  {
+    input: [{
+      [root_hash]: <Taproot Root Hash Hex String>
+      [witness_script]: <Witness Script Hex String>
+    }]
+    [outputs]: [{
+      pk_script: <UTXO Output Script Buffer Object>
+      value: <UTXO Tokens Number>
+    }]
+  }
+
+  @returns
+  {
+    method: <Signing Method Number>
+  }
+*/
+module.exports = ({input, outputs}, cbk) => {
+  // Exit early when lack of previous outputs indicates a v0 spend
+  if (!outputs) {
+    return {method: v0SpendMethod};
+  }
+
+  // Exit early when no leaf script or script commitment is present
+  if (!input.root_hash && !input.witness_script) {
+    return {method: v1Bip86Method};
+  }
+
+  // Exit early when there is no leaf script, just a top level key spend
+  if (!input.witness_script) {
+    return {method: v1SpendMethod};
+  }
+
+  // Sign for a leaf script for a key that commits to the scripts root hash
+  return {method: v1ScriptSpend};
+};

package/lnd_methods/signer/sign_transaction.js

@@ -1,10 +1,11 @@
 const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
 
+const inputSigningMethod = require('./input_signing_method');
 const {isLnd} = require('./../../lnd_requests');
 
 const bufferAsHex = buffer => buffer.toString('hex');
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const hexAsBuffer = hex => Buffer.from(hex || '', 'hex');
 const {isArray} = Array;
 const isV1 = scriptHex => scriptHex.length === 68 && /5120/.test(scriptHex);
 const method = 'signOutputRaw';
@@ -28,9 +29,10 @@ const unimplementedError = '12 UNIMPLEMENTED: unknown service signrpc.Signer';
       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]: [{
@@ -65,8 +67,8 @@ module.exports = ({inputs, lnd, spending, transaction}, cbk) => {
         return cbk();
       },
 
-      // Derive the previous outputs set
-      previousOutputs: ['validate', ({}, cbk) => {
+      // Derive the previous outputs set for Taproot spends
+      outputs: ['validate', ({}, cbk) => {
         const outputs = [].concat(inputs).concat(spending || []).map(utxo => ({
           pk_script: hexAsBuffer(utxo.output_script),
           value: utxo.output_tokens,
@@ -83,25 +85,29 @@ module.exports = ({inputs, lnd, spending, transaction}, cbk) => {
       }],
 
       // Get signatures
-      signTransaction: ['previousOutputs', ({previousOutputs}, cbk) => {
+      signTransaction: ['outputs', ({outputs}, cbk) => {
         return lnd[type][method]({
-          prev_outputs: previousOutputs,
+          prev_outputs: outputs,
           raw_tx_bytes: hexAsBuffer(transaction),
-          sign_descs: inputs.map(input => ({
-            input_index: input.vin,
-            key_desc: {
-              key_loc: {
-                key_family: input.key_family,
-                key_index: input.key_index,
+          sign_descs: inputs.map(input => {
+            return {
+              input_index: input.vin,
+              key_desc: {
+                key_loc: {
+                  key_family: input.key_family,
+                  key_index: input.key_index,
+                },
               },
-            },
-            output: {
-              pk_script: hexAsBuffer(input.output_script),
-              value: input.output_tokens,
-            },
-            sighash: input.sighash,
-            witness_script: hexAsBuffer(input.witness_script),
-          })),
+              output: {
+                pk_script: hexAsBuffer(input.output_script),
+                value: input.output_tokens,
+              },
+              sighash: input.sighash,
+              sign_method: inputSigningMethod({input, outputs}).method,
+              tap_tweak: hexAsBuffer(input.root_hash),
+              witness_script: hexAsBuffer(input.witness_script),
+            };
+          }),
         },
         (err, res) => {
           if (!!err && err.message === unimplementedError) {

package/package.json

@@ -10,7 +10,7 @@
     "@grpc/grpc-js": "1.6.7",
     "@grpc/proto-loader": "0.6.12",
     "@types/express": "4.17.13",
-    "@types/node": "17.0.32",
+    "@types/node": "17.0.33",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.3",
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.15.2"
+  "version": "5.16.0"
 }

package/test/lnd_methods/signer/test_input_signing_method.js

@@ -0,0 +1,53 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../../lnd_methods/signer/input_signing_method');
+
+const makeArgs = override => {
+  const args = {
+    input: {
+      root_hash: '00',
+      witness_script: '00',
+    },
+    outputs: [{
+      pk_script: Buffer.alloc(1),
+      value: 1,
+    }],
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Input signing method is returned for a leaf spend',
+    expected: {method: 3},
+  },
+  {
+    args: makeArgs({input: {}, outputs: undefined}),
+    description: 'Input signing method is returned for a regular spend',
+    expected: {method: 0},
+  },
+  {
+    args: makeArgs({input: {}}),
+    description: 'Input signing method is returned for a bip86 spend',
+    expected: {method: 1},
+  },
+  {
+    args: makeArgs({input: {root_hash: '00'}}),
+    description: 'Input signing method is returned for a top key script spend',
+    expected: {method: 2},
+  },
+];
+
+tests.forEach(({args, description, expected}) => {
+  return test(description, async ({end, strictSame}) => {
+    const res = method(args);
+
+    strictSame(res, expected, 'Got expected result');
+
+    return end();
+  });
+});