lightning 7.1.1 → 7.1.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 7.1.1
+## 7.1.3
 
 - `signChainAddressMessage`: Add method to sign a message given a chain address
 - `verifyChainAddressMessage`: Add method to verify a chain address message

package/grpc/protos/lightning.proto

@@ -582,16 +582,22 @@ service Lightning {
     */
     rpc ListAliases (ListAliasesRequest) returns (ListAliasesResponse);
 
-    rpc LookupHtlc (LookupHtlcRequest) returns (LookupHtlcResponse);
+    /*
+    LookupHtlcResolution retrieves a final htlc resolution from the database.
+    If the htlc has no final resolution yet, a NotFound grpc status code is
+    returned.
+    */
+    rpc LookupHtlcResolution (LookupHtlcResolutionRequest)
+        returns (LookupHtlcResolutionResponse);
 }
 
-message LookupHtlcRequest {
+message LookupHtlcResolutionRequest {
     uint64 chan_id = 1;
 
     uint64 htlc_index = 2;
 }
 
-message LookupHtlcResponse {
+message LookupHtlcResolutionResponse {
     bool settled = 1;
 
     bool offchain = 2;
@@ -1531,6 +1537,9 @@ message Channel {
 
     // This is the confirmed / on-chain zero-conf SCID.
     uint64 zero_conf_confirmed_scid = 33;
+
+    // The configured alias name of our peer.
+    string peer_alias = 34;
 }
 
 message ListChannelsRequest {
@@ -1544,6 +1553,11 @@ message ListChannelsRequest {
     empty, all channels will be returned.
     */
     bytes peer = 5;
+
+    // Informs the server if the peer alias lookup per channel should be
+    // enabled. It is turned off by default in order to avoid degradation of
+    // performance for existing clients.
+    bool peer_alias_lookup = 6;
 }
 message ListChannelsResponse {
     // The list of active channels

package/lnd_methods/macaroon/methods.json

@@ -285,7 +285,7 @@
     "type": "default"
   },
   "getSettlementStatus": {
-    "method": "LookupHtlc",
+    "method": "LookupHtlcResolution",
     "type": "default"
   },
   "getSweepTransactions": {

package/lnd_methods/offchain/get_settlement_status.d.ts

@@ -22,6 +22,8 @@ export type GetSettlementStatusResult = {
  *
  * Note: this method is not supported in LND versions 0.15.5 and below
  *
+ * Requires LND running with `--store-final-htlc-resolutions` flag
+ *
  * Requires `offchain:read` permissions
  */
 export const getSettlementStatus: AuthenticatedLightningMethod<

package/lnd_methods/offchain/get_settlement_status.js

@@ -5,15 +5,18 @@ const {returnResult} = require('asyncjs-util');
 const {isLnd} = require('./../../lnd_requests');
 
 const errorNotFound = 'htlc unknown';
-const errorUnimplemented = 'unknown method LookupHtlc for service lnrpc.Lightning';
+const errorUninitiated = 'cannot lookup with flag --store-final-htlc-resolutions=false';
+const errorUnimplemented = 'unknown method LookupHtlcResolution for service lnrpc.Lightning';
 const isBoolean = n => n === false || n === true;
-const method = 'lookupHtlc';
+const method = 'lookupHtlcResolution';
 const type = 'default';
 
 /** Get the settlement status of a received HTLC
 
   Note: this method is not supported in LND versions 0.15.5 and below
 
+  Requires LND running with `--store-final-htlc-resolutions` flag
+
   Requires `offchain:read` permissions
 
   {
@@ -60,7 +63,11 @@ module.exports = ({channel, lnd, payment}, cbk) => {
           }
 
           if (!!err && err.details === errorUnimplemented) {
-            return cbk([501, 'LookupHtlcMethodUnsupported']);
+            return cbk([501, 'LookupHtlcResolutionMethodUnsupported']);
+          }
+
+          if (!!err && err.details == errorUninitiated) {
+            return cbk([404, 'LookupHtlcResolutionMethodUninitiated']);
           }
 
           if (!!err) {

package/lnd_methods/onchain/broadcast_chain_transaction.js

@@ -7,6 +7,7 @@ const {isLnd} = require('./../../lnd_requests');
 const bufFromHex = hex => Buffer.from(hex, 'hex');
 const {fromHex} = Transaction;
 const method = 'publishTransaction';
+const minRelayFeeError = /^unmatched backend error: -26: mempool min fee not met, (\d*) < (\d*)$/;
 const type = 'wallet';
 
 /** Publish a raw blockchain transaction to Blockchain network peers
@@ -51,6 +52,19 @@ module.exports = ({description, lnd, transaction}, cbk) => {
           tx_hex: bufFromHex(transaction),
         },
         (err, res) => {
+          if (!!err && minRelayFeeError.test(err.details)) {
+            const [, got, expected] = err.details.match(minRelayFeeError);
+
+            return cbk([
+              503,
+              'ChainBackendMinimumRelayFeeNotMet',
+              {
+                fee: Number(got),
+                minimum: Number(expected),
+              }
+            ]);
+          }
+
           if (!!err) {
             return cbk([503, 'UnexpectedErrBroadcastingRawTx', {err}]);
           }

package/package.json

@@ -7,10 +7,10 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.8.11",
+    "@grpc/grpc-js": "1.8.12",
     "@grpc/proto-loader": "0.7.5",
     "@types/express": "4.17.17",
-    "@types/node": "18.14.1",
+    "@types/node": "18.14.6",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.4",
     "async": "3.2.4",
@@ -32,7 +32,7 @@
   "devDependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
     "@alexbosworth/tap": "15.0.12",
-    "tsd": "0.25.0",
+    "tsd": "0.26.1",
     "typescript": "4.9.5",
     "ws": "8.12.1"
   },
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "7.1.1"
+  "version": "7.1.3"
 }

package/test/lnd_methods/offchain/test_get_settlement_status.js

@@ -5,7 +5,7 @@ const {getSettlementStatus} = require('./../../../');
 const makeLnd = ({err, res}) => {
   const result = res === undefined ? {offchain: true, settled: true} : res;
 
-  return {default: {lookupHtlc: ({}, cbk) => cbk(err, result)}};
+  return {default: {lookupHtlcResolution: ({}, cbk) => cbk(err, result)}};
 };
 
 const makeArgs = overrides => {
@@ -38,9 +38,26 @@ const tests = [
     error: [404, 'PaymentNotFound'],
   },
   {
-    args: makeArgs({lnd: makeLnd({err: {details: 'unknown method LookupHtlc for service lnrpc.Lightning'}})}),
+    args: makeArgs({
+      lnd: makeLnd({
+        err: {
+          details: 'unknown method LookupHtlcResolution for service lnrpc.Lightning',
+        },
+      }),
+    }),
     description: 'A method not supported error is returned',
-    error: [501, 'LookupHtlcMethodUnsupported'],
+    error: [501, 'LookupHtlcResolutionMethodUnsupported'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({
+        err: {
+          details: 'cannot lookup with flag --store-final-htlc-resolutions=false',
+        },
+      }),
+    }),
+    description: 'A method not supported error is returned',
+    error: [404, 'LookupHtlcResolutionMethodUninitiated'],
   },
   {
     args: makeArgs({lnd: makeLnd({err: 'err'})}),

package/test/lnd_methods/onchain/test_broadcast_chain_transaction.js

@@ -46,6 +46,27 @@ const tests = [
       {res: {publish_error: 'err'}},
     ],
   },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          publishTransaction: ({}, cbk) => cbk({
+            details: 'unmatched backend error: -26: mempool min fee not met, 123 < 1234',
+          }),
+        },
+      },
+      transaction: new Transaction().toHex(),
+    },
+    description: 'Minimum relay fee not met',
+    error: [
+      503,
+      'ChainBackendMinimumRelayFeeNotMet',
+      {
+        fee: 123,
+        minimum: 1234,
+      },
+    ],
+  },
   {
     args: {
       lnd: {wallet: {publishTransaction: ({}, cbk) => cbk(null, {})}},

package/test/lnd_methods/signer/test_begin_group_signing_session.js

@@ -5,7 +5,7 @@ const {beginGroupSigningSession} = require('./../../../');
 const makeLnd = (err, res) => {
   return {
     signer: {
-      muSig2CreateSession: ({}, cbk) => cbk(err, res)
+      muSig2CreateSession: ({}, cbk) => cbk(err, res),
     },
     wallet: {
       deriveKey: ({}, cbk) => cbk(null, {
@@ -84,6 +84,153 @@ const tests = [
     description: 'A valid response is expected',
     error: [503, 'ExpectedCombinedPublicKeyInMuSig2SessionResponse'],
   },
+  {
+    args: makeArgs({
+      lnd: {
+        signer: {
+          muSig2CreateSession: (args, cbk) => {
+            if (args.version === 'MUSIG2_VERSION_V100RC2') {
+              return cbk({
+                details: 'error parsing signer public key 0: bad pubkey byte string size (want 32, have 33)',
+              });
+            }
+
+            return cbk({
+              details: 'unknown method MuSig2CreateSession for service signrpc.Signer',
+            });
+          },
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk(null, {
+            key_loc: {key_index: 0},
+            raw_key_bytes: Buffer.alloc(1),
+          }),
+        },
+      },
+    }),
+    description: 'Just in case unsupported message is supported',
+    error: [501, 'MuSig2BeginSigningSessionNotSupported'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        signer: {
+          muSig2CreateSession: (args, cbk) => {
+            if (args.version === 'MUSIG2_VERSION_V100RC2') {
+              return cbk({
+                details: 'error parsing signer public key 0: bad pubkey byte string size (want 32, have 33)',
+              });
+            }
+
+            return cbk('err');
+          },
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk(null, {
+            key_loc: {key_index: 0},
+            raw_key_bytes: Buffer.alloc(1),
+          }),
+        },
+      },
+    }),
+    description: 'Errors are passed back',
+    error: [503, 'UnexpectedErrorCreatingMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        signer: {
+          muSig2CreateSession: (args, cbk) => {
+            if (args.version === 'MUSIG2_VERSION_V100RC2') {
+              return cbk({
+                details: 'error parsing signer public key 0: bad pubkey byte string size (want 32, have 33)',
+              });
+            }
+
+            return cbk(null, {});
+          },
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk(null, {
+            key_loc: {key_index: 0},
+            raw_key_bytes: Buffer.alloc(1),
+          }),
+        },
+      },
+    }),
+    description: 'A valid response is expected',
+    error: [503, 'ExpectedCombinedPublicKeyInMuSig2SessionResponse'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        signer: {
+          muSig2CreateSession: (args, cbk) => {
+            if (args.version === 'MUSIG2_VERSION_V100RC2') {
+              return cbk({
+                details: 'error parsing signer public key 0: bad pubkey byte string size (want 32, have 33)',
+              });
+            }
+
+            return cbk(null, {
+              combined_key: Buffer.alloc(32, 1),
+              local_public_nonces: Buffer.alloc(66, 1),
+              session_id: Buffer.alloc(32, 1),
+              taproot_internal_key: Buffer.alloc(0),
+            });
+          },
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk(null, {
+            key_loc: {key_index: 0},
+            raw_key_bytes: Buffer.alloc(1),
+          }),
+        },
+      },
+    }),
+    description: 'Legacy signer is supported',
+    expected: {
+      external_key: '0101010101010101010101010101010101010101010101010101010101010101',
+      id: '0101010101010101010101010101010101010101010101010101010101010101',
+      internal_key: undefined,
+      nonce: '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101',
+    },
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        signer: {
+          muSig2CreateSession: (args, cbk) => {
+            if (args.version === 'MUSIG2_VERSION_V100RC2') {
+              return cbk({
+                details: 'error parsing all signer public keys: error parsing signer public key 0 for v1.0.0rc2 (compressed format): malformed public key: invalid length: 32',
+              });
+            }
+
+            return cbk(null, {
+              combined_key: Buffer.alloc(32, 1),
+              local_public_nonces: Buffer.alloc(66, 1),
+              session_id: Buffer.alloc(32, 1),
+              taproot_internal_key: Buffer.alloc(0),
+            });
+          },
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk(null, {
+            key_loc: {key_index: 0},
+            raw_key_bytes: Buffer.alloc(1),
+          }),
+        },
+      },
+    }),
+    description: 'Legacy signer is supported when invalid keys specified',
+    expected: {
+      external_key: '0101010101010101010101010101010101010101010101010101010101010101',
+      id: '0101010101010101010101010101010101010101010101010101010101010101',
+      internal_key: undefined,
+      nonce: '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101',
+    },
+  },
   {
     args: makeArgs({}),
     description: 'A group signing session is started',