lightning 5.17.0 → 5.18.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## 5.18.0
+
+- `signBytes`: Add `type` and support for specifying `schnorr` type signing
+- `verifyBytesSignature`: Add support for verifying Schnorr signatures
+
 ## 5.17.0
 
 - `getChannels`: Add support for `is_trusted_funding` and `other_ids`

package/lnd_methods/signer/sign_bytes.js

@@ -4,23 +4,31 @@ const {returnResult} = require('asyncjs-util');
 const {isLnd} = require('./../../lnd_requests');
 
 const bufferAsHex = buffer => buffer.toString('hex');
+const defaultType = 'ecdsa';
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const isHex = n => !!n && !(n.length % 2) && /^[0-9A-F]*$/i.test(n);
+const isSchnorrSig = signature => signature.length === 64;
 const method = 'signMessage';
 const type = 'signer';
+const types = {ecdsa: 'ecdsa', schnorr: 'schnorr'};
 const unimplementedError = '12 UNIMPLEMENTED: unknown service signrpc.Signer';
 
 /** Sign a sha256 hash of arbitrary bytes
 
+  Supported signature types: `ecdsa`, `schnorr`
+
   Requires LND built with `signrpc` build tag
 
   Requires `signer:generate` permission
 
+  `schnorr` signature type is not supported on LND 0.15.0 and below
+
   {
     key_family: <Key Family Number>
     key_index: <Key Index Number>
     lnd: <Authenticated LND API Object>
     preimage: <Bytes To Hash and Sign Hex Encoded String>
+    [type]: <Signature Type String>
   }
 
   @returns via cbk or Promise
@@ -49,6 +57,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedHexDataToSignBytes']);
         }
 
+        if (!!args.type && !types[args.type]) {
+          return cbk([400, 'ExpectedKnownSignatureTypeToSignBytes']);
+        }
+
         return cbk();
       },
 
@@ -57,6 +69,7 @@ module.exports = (args, cbk) => {
         return args.lnd[type][method]({
           key_loc: {key_family: args.key_family, key_index: args.key_index},
           msg: hexAsBuffer(args.preimage),
+          schnorr_sig: args.type === types.schnorr || undefined,
         },
         (err, res) => {
           if (!!err && err.message === unimplementedError) {
@@ -79,6 +92,10 @@ module.exports = (args, cbk) => {
             return cbk([503, 'ExpectedSignatureInSignBytesResponse']);
           }
 
+          if (args.type === types.schnorr && !isSchnorrSig(res.signature)) {
+            return cbk([503, 'UnexpectedSignatureLengthInSignBytesResponse']);
+          }
+
           return cbk(null, {signature: bufferAsHex(res.signature)});
         });
       }],

package/lnd_methods/signer/verify_bytes_signature.js

@@ -4,14 +4,19 @@ const {returnResult} = require('asyncjs-util');
 const {isLnd} = require('./../../lnd_requests');
 
 const isHex = n => !(n.length % 2) && /^[0-9A-F]*$/i.test(n);
+const isSchnorrSignatureLength = signature => signature.length === 128;
 const unimplementedError = '12 UNIMPLEMENTED: unknown service signrpc.Signer';
 
 /** Verify signature of arbitrary bytes
 
+  When passing a schnorr signature, a BIP-340 x-only public key should be given
+
   Requires LND built with `signrpc` build tag
 
   Requires `signer:read` permission
 
+  Validating `schnorr` signatures is unsupported in LND 0.15.0 and below
+
   {
     lnd: <Authenticated LND API Object>
     preimage: <Message Preimage Bytes Hex Encoded String>
@@ -51,6 +56,7 @@ module.exports = (args, cbk) => {
       // Verify signature
       verify: ['validate', ({}, cbk) => {
         return args.lnd.signer.verifyMessage({
+          is_schnorr_sig: isSchnorrSignatureLength(args.signature),
           msg: Buffer.from(args.preimage, 'hex'),
           pubkey: Buffer.from(args.public_key, 'hex'),
           signature: Buffer.from(args.signature, 'hex'),

package/package.json

@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.17.0"
+  "version": "5.18.0"
 }

package/test/lnd_methods/signer/test_sign_bytes.js

@@ -6,12 +6,13 @@ const makeLnd = (err, res) => {
   return {signer: {signMessage: ({}, cbk) => cbk(err, res)}};
 };
 
-const makeArgs = ({override}) => {
+const makeArgs = ({override, signature}) => {
   const args = {
     key_family: 0,
     key_index: 0,
-    lnd: makeLnd(null, {signature: '00'}),
+    lnd: makeLnd(null, {signature: Buffer.from(signature || '00', 'hex')}),
     preimage: '00',
+    type: 'ecdsa',
   };
 
   Object.keys(override || {}).forEach(key => args[key] = override[key]);
@@ -40,6 +41,11 @@ const tests = [
     description: 'A preimage to hash and sign is required',
     error: [400, 'ExpectedHexDataToSignBytes'],
   },
+  {
+    args: makeArgs({override: {type: 'type'}}),
+    description: 'A known signature type is required',
+    error: [400, 'ExpectedKnownSignatureTypeToSignBytes'],
+  },
   {
     args: makeArgs({
       override: {
@@ -71,11 +77,23 @@ const tests = [
     description: 'A non empty signature is expected',
     error: [503, 'ExpectedSignatureInSignBytesResponse'],
   },
+  {
+    args: makeArgs({override: {type: 'schnorr'}}),
+    description: 'Schnorr signature is expected to be schnorr sized',
+    error: [503, 'UnexpectedSignatureLengthInSignBytesResponse'],
+  },
   {
     args: makeArgs({}),
     description: 'Signature is returned for preimage',
     expected: {signature: '00'},
   },
+  {
+    args: makeArgs({
+      override: {type: 'schnorr'}, signature: Buffer.alloc(64).toString('hex'),
+    }),
+    description: 'Schnorr signature is supported',
+    expected: {signature: Buffer.alloc(64).toString('hex')},
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {