lightning 5.6.2 → 5.8.0

package/.github/workflows/unit-test.yml

@@ -0,0 +1,20 @@
+name: "Unit test"
+
+on:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  unit-test:
+    name: Node ${{ matrix.node }} unit test on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        node: ['12', '14', '16']
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+    - run: npm install
+    - name: Run unit tests
+      run: npm test

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Versions
 
-## 5.6.2
+## 5.8.0
+
+- `getMasterPublicKeys`: Add method to lookup wallet extended public keys
+
+## 5.7.1
+
+- `fundPsbt`: Correct ECPair import dependency in control flow
+
+## 5.7.0
+
+- `getPendingPayments`: Add method to get a list of in-flight payments
+
+## 5.6.3
 
 - `payViaRoutes`, `subscribeToPayViaRoutes`: Add support for relay messages
 

package/README.md

@@ -42,8 +42,8 @@ Run `base64` on the tls.cert and admin.macaroon files to get the encoded
 authentication data to create the LND connection. You can find these files in
 the LND directory. (~/.lnd or ~/Library/Application Support/Lnd)
 
-    base64 ~/.lnd/tls.cert | tr -d '\n'
-    base64 ~/.lnd/data/chain/bitcoin/mainnet/admin.macaroon | tr -d '\n'
+    base64 -w0 ~/.lnd/tls.cert
+    base64 -w0 ~/.lnd/data/chain/bitcoin/mainnet/admin.macaroon
 
 You can then use these to interact with your LND node directly:
 
@@ -157,6 +157,8 @@ To access unauthenticated methods like the wallet unlocker, use
     open invoices and received payments.
 - [getLockedUtxos](https://github.com/alexbosworth/ln-service#getlockedutxos): List the UTXOs
     that are currently reserved and unavailable to coin selection.
+- [getMasterPublicKeys](https://github.com/alexbosworth/ln-service#getmasterpublickeys):
+    List out master seed derived extended public keys and derivation paths.
 - [getMethods](https://github.com/alexbosworth/ln-service#getmethods): List RPC methods and
     permissions required to use them.
 - [getNetworkCentrality](https://github.com/alexbosworth/ln-service#getnetworkcentrality):
@@ -178,6 +180,8 @@ To access unauthenticated methods like the wallet unlocker, use
     Calculate the unconfirmed on-chain balance.
 - [getPendingChannels](https://github.com/alexbosworth/ln-service#getpendingchannels): List
     details of opening or closing channels.
+- [getPendingPayments](https://github.com/alexbosworth/ln-service#getpendingpayments): List out
+    past pending payments.
 - [getPublicKey](https://github.com/alexbosworth/ln-service#getpublickey): Derive a public key at
     a given index.
 - [getRouteConfidence](https://github.com/alexbosworth/ln-service#getrouteconfidence): Check a

package/grpc/protos/lightning.proto

@@ -753,7 +753,8 @@ message SendRequest {
     The maximum number of satoshis that will be paid as a fee of the payment.
     This value can be represented either as a percentage of the amount being
     sent, or as a fixed amount of the maximum fee the user is willing the pay to
-    send the payment.
+    send the payment. If not specified, lnd will use a default value of 100%
+    fees for small amounts (<=1k sat) or 5% fees for larger amounts.
     */
     FeeLimit fee_limit = 8;
 
@@ -2574,7 +2575,8 @@ message QueryRoutesRequest {
     The maximum number of satoshis that will be paid as a fee of the payment.
     This value can be represented either as a percentage of the amount being
     sent, or as a fixed amount of the maximum fee the user is willing the pay to
-    send the payment.
+    send the payment. If not specified, lnd will use a default value of 100%
+    fees for small amounts (<=1k sat) or 5% fees for larger amounts.
     */
     FeeLimit fee_limit = 5;
 

package/grpc/protos/router.proto

@@ -781,6 +781,21 @@ message ForwardHtlcInterceptResponse {
 
     // The preimage in case the resolve action is Settle.
     bytes preimage = 3;
+
+    // Encrypted failure message in case the resolve action is Fail.
+    //
+    // If failure_message is specified, the failure_code field must be set
+    // to zero.
+    bytes failure_message = 4;
+
+    // Return the specified failure code in case the resolve action is Fail. The
+    // message data fields are populated automatically.
+    //
+    // If a non-zero failure_code is specified, failure_message must not be set.
+    //
+    // For backwards-compatibility reasons, TEMPORARY_CHANNEL_FAILURE is the
+    // default value for this field.
+    lnrpc.Failure.FailureCode failure_code = 5;
 }
 
 enum ResolveHoldForwardAction {

package/index.js

@@ -48,6 +48,7 @@ const {getIdentity} = require('./lnd_methods');
 const {getInvoice} = require('./lnd_methods');
 const {getInvoices} = require('./lnd_methods');
 const {getLockedUtxos} = require('./lnd_methods');
+const {getMasterPublicKeys} = require('./lnd_methods');
 const {getMethods} = require('./lnd_methods');
 const {getNetworkCentrality} = require('./lnd_methods');
 const {getNetworkGraph} = require('./lnd_methods');
@@ -59,6 +60,7 @@ const {getPayments} = require('./lnd_methods');
 const {getPeers} = require('./lnd_methods');
 const {getPendingChainBalance} = require('./lnd_methods');
 const {getPendingChannels} = require('./lnd_methods');
+const {getPendingPayments} = require('./lnd_methods');
 const {getPublicKey} = require('./lnd_methods');
 const {getRouteConfidence} = require('./lnd_methods');
 const {getRouteThroughHops} = require('./lnd_methods');
@@ -186,6 +188,7 @@ module.exports = {
   getInvoice,
   getInvoices,
   getLockedUtxos,
+  getMasterPublicKeys,
   getMethods,
   getNetworkCentrality,
   getNetworkGraph,
@@ -197,6 +200,7 @@ module.exports = {
   getPeers,
   getPendingChainBalance,
   getPendingChannels,
+  getPendingPayments,
   getPublicKey,
   getRouteConfidence,
   getRouteThroughHops,

package/lnd_methods/index.js

@@ -46,6 +46,7 @@ const {getIdentity} = require('./info');
 const {getInvoice} = require('./invoices');
 const {getInvoices} = require('./invoices');
 const {getLockedUtxos} = require('./onchain');
+const {getMasterPublicKeys} = require('./onchain');
 const {getMethods} = require('./info');
 const {getNetworkCentrality} = require('./info');
 const {getNetworkGraph} = require('./info');
@@ -57,6 +58,7 @@ const {getPayments} = require('./offchain');
 const {getPeers} = require('./peers');
 const {getPendingChainBalance} = require('./onchain');
 const {getPendingChannels} = require('./offchain');
+const {getPendingPayments} = require('./offchain');
 const {getPublicKey} = require('./address');
 const {getRouteConfidence} = require('./generic');
 const {getRouteThroughHops} = require('./offchain');
@@ -180,6 +182,7 @@ module.exports = {
   getInvoice,
   getInvoices,
   getLockedUtxos,
+  getMasterPublicKeys,
   getMethods,
   getNetworkCentrality,
   getNetworkGraph,
@@ -191,6 +194,7 @@ module.exports = {
   getPeers,
   getPendingChainBalance,
   getPendingChannels,
+  getPendingPayments,
   getPublicKey,
   getRouteConfidence,
   getRouteThroughHops,

package/lnd_methods/macaroon/methods.json

@@ -181,6 +181,10 @@
     "method": "ListLeases",
     "type": "wallet"
   },
+  "getMasterPublicKeys": {
+    "method": "ListAccounts",
+    "type": "wallet"
+  },
   "getMethods": {
     "method": "ListPermissions",
     "type": "default"
@@ -226,6 +230,10 @@
     "method": "PendingChannels",
     "type": "default"
   },
+  "getPendingPayments": {
+    "method": "ListPayments",
+    "type": "default"
+  },
   "getPublicKey": {
     "methods": ["DeriveKey", "DeriveNextKey"],
     "type": "wallet"

package/lnd_methods/offchain/get_pending_payments.d.ts

@@ -0,0 +1,136 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+  PaginationArgs,
+} from '../../typescript';
+
+export type GetPendingPaymentsArgs = AuthenticatedLightningArgs<PaginationArgs>;
+
+export type GetPendingPaymentsResult = {
+  payments: {
+    attempts: {
+      failure?: {
+        /** Error Type Code Number */
+        code: number;
+        details?: {
+          /** Standard Format Channel Id String */
+          channel?: string;
+          /** Error Associated Block Height Number */
+          height?: number;
+          /** Pending Hop Index Number */
+          index?: number;
+          /** Error Millitokens String */
+          mtokens?: string;
+          policy?: {
+            /** Base Fee Millitokens String */
+            base_fee_mtokens: string;
+            /** Locktime Delta Number */
+            cltv_delta: number;
+            /** Fees Charged in Millitokens Per Million Number */
+            fee_rate: number;
+            /** Channel is Disabled Bool */
+            is_disabled?: boolean;
+            /** Maximum HLTC Millitokens Value String */
+            max_htlc_mtokens: string;
+            /** Minimum HTLC Millitokens Value String */
+            min_htlc_mtokens: string;
+            /** Updated At ISO 8601 Date String */
+            updated_at: string;
+          };
+          /** Error CLTV Timeout Height Number */
+          timeout_height?: number;
+          update?: {
+            /** Chain Id Hex String */
+            chain: string;
+            /** Channel Flags Number */
+            channel_flags: number;
+            /** Extra Opaque Data Hex String */
+            extra_opaque_data: string;
+            /** Message Flags Number */
+            message_flags: number;
+            /** Channel Update Signature Hex String */
+            signature: string;
+          };
+        };
+        /** Error Message String */
+        message: string;
+      };
+      /** Payment Add Index Number */
+      index?: number;
+      /** Payment Confirmed At ISO 8601 Date String */
+      confirmed_at?: string;
+      /** Payment Attempt Succeeded Bool */
+      is_confirmed: boolean;
+      /** Payment Attempt Pending Bool */
+      is_failed: boolean;
+      /** Payment Attempt is Waiting For Resolution Bool */
+      is_pending: boolean;
+      route: {
+        /** Route Fee Tokens Number */
+        fee: number;
+        /** Route Fee Millitokens String */
+        fee_mtokens: string;
+        hops: {
+          /** Standard Format Channel Id String */
+          channel: string;
+          /** Channel Capacity Tokens Number */
+          channel_capacity: number;
+          /** Fee Number */
+          fee: number;
+          /** Fee Millitokens String */
+          fee_mtokens: string;
+          /** Forward Tokens Number */
+          forward: number;
+          /** Forward Millitokens String */
+          forward_mtokens: string;
+          /** Forward Edge Public Key Hex String */
+          public_key?: string;
+          /** Timeout Block Height Number */
+          timeout?: number;
+        }[];
+        /** Total Fee-Inclusive Millitokens String */
+        mtokens: string;
+        /** Payment Identifier Hex String */
+        payment?: string;
+        /** Timeout Block Height Number */
+        timeout: number;
+        /** Total Fee-Inclusive Tokens Number */
+        tokens: number;
+        /** Total Millitokens String */
+        total_mtokens?: string;
+      };
+    }[];
+    /** Payment at ISO-8601 Date String */
+    created_at: string;
+    /** Destination Node Public Key Hex String */
+    destination?: string;
+    /** Payment Preimage Hash String */
+    id: string;
+    /** Payment Add Index Number */
+    index?: number;
+    /** Payment is Confirmed Bool */
+    is_confirmed: boolean;
+    /** Transaction Is Outgoing Bool */
+    is_outgoing: boolean;
+    /** Millitokens Attempted to Pay to Destination String */
+    mtokens: string;
+    /** BOLT 11 Payment Request String */
+    request?: string;
+    /** Payment Tokens Attempted to Pay Rounded Up Number */
+    safe_tokens: number;
+    /** Rounded Down Tokens Attempted to Pay to Destination Number */
+    tokens: number;
+  }[];
+  /** Next Opaque Paging Token String */
+  next?: string;
+};
+
+/**
+ * Get pending payments made through channels.
+ *
+ * Requires `offchain:read` permission
+ */
+export const getPendingPayments: AuthenticatedLightningMethod<
+  GetPendingPaymentsArgs,
+  GetPendingPaymentsResult
+>;

package/lnd_methods/offchain/get_pending_payments.js

@@ -0,0 +1,190 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+const {rpcPaymentAsPayment} = require('./../../lnd_responses');
+const {sortBy} = require('./../../arrays');
+
+const defaultLimit = 250;
+const {isArray} = Array;
+const isPending = payment => !!payment && payment.status === 'IN_FLIGHT';
+const lastPageFirstIndexOffset = 1;
+const method = 'listPayments';
+const {parse} = JSON;
+const {stringify} = JSON;
+const type = 'default';
+
+/** Get pending payments made through channels.
+
+  Requires `offchain:read` permission
+
+  {
+    [limit]: <Page Result Limit Number>
+    lnd: <Authenticated LND API Object>
+    [token]: <Opaque Paging Token String>
+  }
+
+  @returns via cbk or Promise
+  {
+    payments: [{
+      attempts: [{
+        [failure]: {
+          code: <Error Type Code Number>
+          [details]: {
+            [channel]: <Standard Format Channel Id String>
+            [height]: <Error Associated Block Height Number>
+            [index]: <Failed Hop Index Number>
+            [mtokens]: <Error Millitokens String>
+            [policy]: {
+              base_fee_mtokens: <Base Fee Millitokens String>
+              cltv_delta: <Locktime Delta Number>
+              fee_rate: <Fees Charged in Millitokens Per Million Number>
+              [is_disabled]: <Channel is Disabled Bool>
+              max_htlc_mtokens: <Maximum HLTC Millitokens Value String>
+              min_htlc_mtokens: <Minimum HTLC Millitokens Value String>
+              updated_at: <Updated At ISO 8601 Date String>
+            }
+            [timeout_height]: <Error CLTV Timeout Height Number>
+            [update]: {
+              chain: <Chain Id Hex String>
+              channel_flags: <Channel Flags Number>
+              extra_opaque_data: <Extra Opaque Data Hex String>
+              message_flags: <Message Flags Number>
+              signature: <Channel Update Signature Hex String>
+            }
+          }
+          message: <Error Message String>
+        }
+        [index]: <Payment Add Index Number>
+        [confirmed_at]: <Payment Confirmed At ISO 8601 Date String>
+        is_confirmed: <Payment Attempt Succeeded Bool>
+        is_failed: <Payment Attempt Failed Bool>
+        is_pending: <Payment Attempt is Waiting For Resolution Bool>
+        route: {
+          fee: <Route Fee Tokens Number>
+          fee_mtokens: <Route Fee Millitokens String>
+          hops: [{
+            channel: <Standard Format Channel Id String>
+            channel_capacity: <Channel Capacity Tokens Number>
+            fee: <Fee Number>
+            fee_mtokens: <Fee Millitokens String>
+            forward: <Forward Tokens Number>
+            forward_mtokens: <Forward Millitokens String>
+            [public_key]: <Forward Edge Public Key Hex String>
+            [timeout]: <Timeout Block Height Number>
+          }]
+          mtokens: <Total Fee-Inclusive Millitokens String>
+          [payment]: <Payment Identifier Hex String>
+          timeout: <Timeout Block Height Number>
+          tokens: <Total Fee-Inclusive Tokens Number>
+          [total_mtokens]: <Total Millitokens String>
+        }
+      }]
+      created_at: <Payment at ISO-8601 Date String>
+      [destination]: <Destination Node Public Key Hex String>
+      id: <Payment Preimage Hash String>
+      [index]: <Payment Add Index Number>
+      is_confirmed: <Payment is Confirmed Bool>
+      is_outgoing: <Transaction Is Outgoing Bool>
+      mtokens: <Millitokens Attempted to Pay to Destination String>
+      [request]: <BOLT 11 Payment Request String>
+      safe_tokens: <Payment Tokens Attempted to Pay Rounded Up Number>
+      tokens: <Rounded Down Tokens Attempted to Pay to Destination Number>
+    }]
+    [next]: <Next Opaque Paging Token String>
+  }
+*/
+module.exports = ({limit, lnd, token}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!!limit && !!token) {
+          return cbk([400, 'ExpectedNoLimitPagingPendingPaymentsWithToken']);
+        }
+
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedLndForGetPendingPaymentsRequest']);
+        }
+
+        return cbk();
+      },
+
+      // Get all payments
+      listPayments: ['validate', ({}, cbk) => {
+        let offset;
+        let resultsLimit = limit || defaultLimit;
+
+        if (!!token) {
+          try {
+            const pagingToken = parse(token);
+
+            offset = pagingToken.offset;
+            resultsLimit = pagingToken.limit;
+          } catch (err) {
+            return cbk([400, 'ExpectedValidPagingTokenForGetPending', {err}]);
+          }
+        }
+
+        return lnd[type][method]({
+          include_incomplete: true,
+          index_offset: offset || Number(),
+          max_payments: resultsLimit,
+          reversed: true,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedGetPendingPaymentsError', {err}]);
+          }
+
+          if (!res || !isArray(res.payments)) {
+            return cbk([503, 'ExpectedPendingPaymentsInListPaymentsResponse']);
+          }
+
+          if (typeof res.last_index_offset !== 'string') {
+            return cbk([503, 'ExpectedLastIndexOffsetWhenRequestingPending']);
+          }
+
+          const lastOffset = Number(res.last_index_offset);
+          const offset = Number(res.first_index_offset);
+
+          const token = stringify({offset, limit: resultsLimit});
+
+          return cbk(null, {
+            payments: res.payments.filter(isPending),
+            token: offset <= lastPageFirstIndexOffset ? undefined : token,
+          });
+        });
+      }],
+
+      // Check and map payments
+      foundPayments: ['listPayments', ({listPayments}, cbk) => {
+        try {
+          const payments = listPayments.payments.map(rpcPaymentAsPayment);
+
+          return cbk(null, payments);
+        } catch (err) {
+          return cbk([503, err.message]);
+        }
+      }],
+
+      // Final found pending payments
+      payments: [
+        'foundPayments',
+        'listPayments',
+        ({foundPayments, listPayments}, cbk) =>
+      {
+        const payments = sortBy({
+          array: foundPayments,
+          attribute: 'created_at',
+        });
+
+        return cbk(null, {
+          next: listPayments.token || undefined,
+          payments: payments.sorted.reverse(),
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'payments'}, cbk));
+  });
+};

package/lnd_methods/offchain/index.d.ts

@@ -24,6 +24,7 @@ export * from './get_pathfinding_settings';
 export * from './get_payment';
 export * from './get_payments';
 export * from './get_pending_channels';
+export * from './get_pending_payments';
 export * from './get_route_through_hops';
 export * from './is_destination_payable';
 export * from './pay_via_payment_details';

package/lnd_methods/offchain/index.js

@@ -24,6 +24,7 @@ const getPathfindingSettings = require('./get_pathfinding_settings');
 const getPayment = require('./get_payment');
 const getPayments = require('./get_payments');
 const getPendingChannels = require('./get_pending_channels');
+const getPendingPayments = require('./get_pending_payments');
 const getRouteThroughHops = require('./get_route_through_hops');
 const isDestinationPayable = require('./is_destination_payable');
 const pay = require('./pay');
@@ -79,6 +80,7 @@ module.exports = {
   getPayment,
   getPayments,
   getPendingChannels,
+  getPendingPayments,
   getRouteThroughHops,
   isDestinationPayable,
   pay,

package/lnd_methods/onchain/fund_psbt.js

@@ -205,7 +205,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Derive the raw transaction from the funded PSBT
-      tx: ['fund', ({ecp, fund}, cbk) => {
+      tx: ['ecp', 'fund', ({ecp, fund}, cbk) => {
         const {psbt} = fund;
 
         try {

package/lnd_methods/onchain/get_master_public_keys.d.ts

@@ -0,0 +1,28 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type GetMasterPublicKeysArgs = AuthenticatedLightningArgs;
+
+export type GetMasterPublicKeysResult = {
+  keys: {
+    /** Key Derivation Path String> */
+    derivation_path: string;
+    /** Base58 Encoded Master Public Key String> */
+    extended_public_key: string;
+    /** Used External Keys Count Number> */
+    external_key_count: number;
+    /** Used Internal Keys Count Number> */
+    internal_key_count: number;
+    /** Node has Master Private Key Bool> */
+    is_watch_only: boolean;
+    /** Account Name String> */
+    named: string;
+  }[];
+};
+
+export const getMasterPublicKeys: AuthenticatedLightningMethod<
+  GetMasterPublicKeysArgs,
+  GetMasterPublicKeysResult
+>;

package/lnd_methods/onchain/get_master_public_keys.js

@@ -0,0 +1,83 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+
+const {isArray} = Array;
+const method = 'listAccounts';
+const notSupported = /unknown.*walletrpc.WalletKit/;
+const type = 'wallet';
+
+/** Get the currently tracked master public keys
+
+  Requires LND compiled with `walletrpc` build tag
+
+  Requires `onchain:read` permission
+
+  This method is not supported in LND 0.13.3 and below
+
+  {
+    lnd: <Authenticated API LND Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    keys: [{
+      derivation_path: <Key Derivation Path String>
+      extended_public_key: <Base58 Encoded Master Public Key String>
+      external_key_count: <Used External Keys Count Number>
+      internal_key_count: <Used Internal Keys Count Number>
+      is_watch_only: <Node has Master Private Key Bool>
+      named: <Account Name String>
+    }]
+  }
+*/
+module.exports = ({lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetMasterPublicKeys']);
+        }
+
+        return cbk();
+      },
+
+      // Get master public keys
+      getKeys: ['validate', ({}, cbk) => {
+        return lnd[type][method]({}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'GetMasterPublicKeysMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorGettingMasterPublicKeys', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResultForMasterPublicKeyListRequest']);
+          }
+
+          if (!isArray(res.accounts)) {
+            return cbk([503, 'ExpectedArrayOfAccountsInMasterPublicKeysList']);
+          }
+
+          const keys = res.accounts
+            .filter(account => !!account.extended_public_key)
+            .map(account => ({
+              derivation_path: account.derivation_path,
+              extended_public_key: account.extended_public_key,
+              external_key_count: account.external_key_count,
+              internal_key_count: account.internal_key_count,
+              is_watch_only: account.watch_only,
+              named: account.name,
+            }));
+
+          return cbk(null, {keys});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getKeys'}, cbk));
+  });
+};

package/lnd_methods/onchain/index.d.ts

@@ -8,6 +8,7 @@ export * from './get_chain_fee_estimate';
 export * from './get_chain_fee_rate';
 export * from './get_chain_transactions';
 export * from './get_locked_utxos';
+export * from './get_master_public_keys';
 export * from './get_pending_chain_balance';
 export * from './get_sweep_transactions';
 export * from './get_utxos';

package/lnd_methods/onchain/index.js

@@ -8,6 +8,7 @@ const getChainFeeEstimate = require('./get_chain_fee_estimate');
 const getChainFeeRate = require('./get_chain_fee_rate');
 const getChainTransactions = require('./get_chain_transactions');
 const getLockedUtxos = require('./get_locked_utxos');
+const getMasterPublicKeys = require('./get_master_public_keys');
 const getPendingChainBalance = require('./get_pending_chain_balance');
 const getSweepTransactions = require('./get_sweep_transactions');
 const getUtxos = require('./get_utxos');
@@ -41,6 +42,7 @@ module.exports = {
   getChainFeeRate,
   getChainTransactions,
   getLockedUtxos,
+  getMasterPublicKeys,
   getPendingChainBalance,
   getSweepTransactions,
   getUtxos,

package/lnd_methods/onchain/open_channels.js

@@ -23,8 +23,8 @@ const type = 'default';
 
   Requires `offchain:write`, `onchain:write` permissions
 
-  After getting the addresses and tokens to fund, use `fundChannels` within ten
-  minutes to fund the channels.
+  After getting the addresses and tokens to fund, use `fundPendingChannels`
+  within ten minutes to fund the channels.
 
   If you do not fund the channels, be sure to `cancelPendingChannel` on each
   channel that was not funded.

package/package.json

@@ -7,10 +7,10 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.5.4",
+    "@grpc/grpc-js": "1.5.5",
     "@grpc/proto-loader": "0.6.9",
     "@types/express": "4.17.13",
-    "@types/node": "17.0.15",
+    "@types/node": "17.0.17",
     "@types/request": "2.48.8",
     "@types/ws": "8.2.2",
     "async": "3.2.3",
@@ -23,10 +23,10 @@
     "cbor": "8.1.0",
     "ecpair": "2.0.1",
     "express": "4.17.2",
-    "invoices": "2.0.3",
+    "invoices": "2.0.4",
     "psbt": "2.0.0",
     "tiny-secp256k1": "2.2.0",
-    "type-fest": "2.11.1"
+    "type-fest": "2.11.2"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -34,7 +34,7 @@
     "@alexbosworth/tap": "15.0.10",
     "tsd": "0.19.1",
     "typescript": "4.5.5",
-    "ws": "8.4.2"
+    "ws": "8.5.0"
   },
   "engines": {
     "node": ">=12.20"
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.6.2"
+  "version": "5.8.0"
 }

package/test/lnd_methods/offchain/test_get_failed_payments.js

@@ -1,6 +1,6 @@
 const {test} = require('@alexbosworth/tap');
 
-const {getPayments} = require('./../../../');
+const {getFailedPayments} = require('./../../../');
 
 const makeLnd = args => {
   return {
@@ -64,41 +64,41 @@ const tests = [
   {
     args: makeArgs({limit: 1, token: 'token'}),
     description: 'A limit cannot be passed with a token',
-    error: [400, 'UnexpectedLimitWhenPagingPaymentsWithToken'],
+    error: [400, 'ExpectedNoLimitWhenPagingPayFailuresWithToken'],
   },
   {
     args: makeArgs({lnd: undefined}),
     description: 'LND is required',
-    error: [400, 'ExpectedLndForGetPaymentsRequest'],
+    error: [400, 'ExpectedLndForGetFailedPaymentsRequest'],
   },
   {
     args: makeArgs({token: 'token'}),
     description: 'A valid token is required',
-    error: [400, 'ExpectedValidPagingTokenForPaymentReq'],
+    error: [400, 'ExpectedValidPagingTokenForGetFailed'],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}}),
     description: 'Errors from LND are passed back',
-    error: [503, 'UnexpectedGetPaymentsError', {err: 'err'}],
+    error: [503, 'UnexpectedGetFailedPaymentsError', {err: 'err'}],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk()}}}),
     description: 'A response is expected from LND',
-    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedFailedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {})}},
     }),
     description: 'A response with payments is expected from LND',
-    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedFailedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {payments: []})}},
     }),
     description: 'A response with payments and last index is expected',
-    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPayments'],
+    error: [503, 'ExpectedLastIndexOffsetWhenRequestingFailed'],
   },
   {
     args: makeArgs({
@@ -106,7 +106,7 @@ const tests = [
         default: {
           listPayments: ({}, cbk) => cbk(null, {
             last_index_offset: '1',
-            payments: [{}],
+            payments: [{ status: 'FAILED' }],
           }),
         },
       },
@@ -146,9 +146,9 @@ const tests = [
 tests.forEach(({args, description, error, expected}) => {
   return test(description, async ({end, rejects,  strictSame}) => {
     if (!!error) {
-      await rejects(() => getPayments(args), error, 'Got expected error');
+      await rejects(() => getFailedPayments(args), error, 'Got expected error');
     } else {
-      const {payments} = await getPayments(args);
+      const {payments} = await getFailedPayments(args);
 
       const [payment] = payments;
 

package/test/lnd_methods/offchain/test_get_pending_payments.js

@@ -0,0 +1,160 @@
+const {test} = require('@alexbosworth/tap');
+
+const {getPendingPayments} = require('./../../../');
+
+const makeLnd = args => {
+  return {
+    default: {
+      listPayments: ({}, cbk) => cbk(null, {
+        first_index_offset: args.first_index_offset || '1',
+        payments: [{
+          creation_date: '1',
+          creation_time_ns: '1',
+          failure_reason: '',
+          fee_msat: '1000',
+          fee_sat: '1',
+          htlcs: [],
+          path: [Buffer.alloc(33, 2).toString('hex')],
+          payment_hash: Buffer.alloc(32).toString('hex'),
+          payment_index: '1',
+          payment_preimage: Buffer.alloc(32).toString('hex'),
+          payment_request: '',
+          status: 'IN_FLIGHT',
+          value: '1',
+          value_msat: '1000',
+          value_sat: '1',
+        }],
+        last_index_offset: args.last_index_offset || '1',
+      }),
+    },
+  };
+};
+
+const makeArgs = overrides => {
+  const args = {lnd: makeLnd({})};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpectedPayment = ({}) => {
+  return {
+    destination: undefined,
+    attempts: [],
+    confirmed_at: undefined,
+    created_at: '1970-01-01T00:00:00.000Z',
+    fee: undefined,
+    fee_mtokens: undefined,
+    hops: [],
+    id: '0000000000000000000000000000000000000000000000000000000000000000',
+    index: 1,
+    is_confirmed: false,
+    is_outgoing: true,
+    mtokens: '1000',
+    request: undefined,
+    secret: undefined,
+    safe_fee: undefined,
+    safe_tokens: 1,
+    tokens: 1,
+  };
+};
+
+const tests = [
+  {
+    args: makeArgs({limit: 1, token: 'token'}),
+    description: 'A limit cannot be passed with a token',
+    error: [400, 'ExpectedNoLimitPagingPendingPaymentsWithToken'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedLndForGetPendingPaymentsRequest'],
+  },
+  {
+    args: makeArgs({token: 'token'}),
+    description: 'A valid token is required',
+    error: [400, 'ExpectedValidPagingTokenForGetPending'],
+  },
+  {
+    args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}}),
+    description: 'Errors from LND are passed back',
+    error: [503, 'UnexpectedGetPendingPaymentsError', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk()}}}),
+    description: 'A response is expected from LND',
+    error: [503, 'ExpectedPendingPaymentsInListPaymentsResponse'],
+  },
+  {
+    args: makeArgs({
+      lnd: {default: {listPayments: ({}, cbk) => cbk(null, {})}},
+    }),
+    description: 'A response with payments is expected from LND',
+    error: [503, 'ExpectedPendingPaymentsInListPaymentsResponse'],
+  },
+  {
+    args: makeArgs({
+      lnd: {default: {listPayments: ({}, cbk) => cbk(null, {payments: []})}},
+    }),
+    description: 'A response with payments and last index is expected',
+    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPending'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          listPayments: ({}, cbk) => cbk(null, {
+            last_index_offset: '1',
+            payments: [{status: 'IN_FLIGHT'}],
+          }),
+        },
+      },
+    }),
+    description: 'A response with valid payments is expected',
+    error: [503, 'ExpectedCreationDateInRpcPaymentDetails'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A payment is returned',
+    expected: {payment: makeExpectedPayment({})},
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          listPayments: ({}, cbk) => cbk(null, {
+            last_index_offset: '1',
+            payments: [],
+          }),
+        },
+      },
+    }),
+    description: 'No payments are returned',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({first_index_offset: '2'}),
+      token: JSON.stringify({limit: 1, offset: 1})
+    }),
+    description: 'A payment is returned when a token is specified',
+    expected: {payment: makeExpectedPayment({})},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects,  strictSame}) => {
+    if (!!error) {
+      await rejects(() => getPendingPayments(args), error, 'Got error');
+    } else {
+      const {payments} = await getPendingPayments(args);
+
+      const [payment] = payments;
+
+      strictSame(payment, expected.payment, 'Got expected payment');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/onchain/test_get_master_public_keys.js

@@ -0,0 +1,94 @@
+const {test} = require('@alexbosworth/tap');
+
+const {getMasterPublicKeys} = require('./../../../lnd_methods');
+
+const makeExpected = overrides => {
+  const res = {
+    derivation_path: 'derivation_path',
+    extended_public_key: 'extended_public_key',
+    external_key_count: 0,
+    internal_key_count: 1,
+    is_watch_only: true,
+    named: 'name',
+  };
+
+  Object.keys(overrides).forEach(k => res[k] = overrides[k]);
+
+  return {keys: [res]};
+};
+
+const makeLnd = overrides => {
+  return {
+    wallet: {
+      listAccounts: ({}, cbk) => {
+        const account = {
+          derivation_path: 'derivation_path',
+          extended_public_key: 'extended_public_key',
+          external_key_count: 0,
+          internal_key_count: 1,
+          name: 'name',
+          watch_only: true,
+        };
+
+        Object.keys(overrides).forEach(k => account[k] = overrides[k]);
+
+        return cbk(null, {accounts: [account]});
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'LND Object is required to get master public keys',
+    error: [400, 'ExpectedAuthenticatedLndToGetMasterPublicKeys'],
+  },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          listAccounts: ({}, cbk) => cbk({
+            details: 'unknown walletrpc.WalletKit',
+          }),
+        },
+      },
+    },
+    description: 'LND unsupported errors are passed back',
+    error: [501, 'GetMasterPublicKeysMethodNotSupported'],
+  },
+  {
+    args: {lnd: {wallet: {listAccounts: ({}, cbk) => cbk('err')}}},
+    description: 'LND errors are passed back',
+    error: [503, 'UnexpectedErrorGettingMasterPublicKeys', {err: 'err'}],
+  },
+  {
+    args: {lnd: {wallet: {listAccounts: ({}, cbk) => cbk()}}},
+    description: 'A response is expected',
+    error: [503, 'ExpectedResultForMasterPublicKeyListRequest'],
+  },
+  {
+    args: {lnd: {wallet: {listAccounts: ({}, cbk) => cbk(null, {})}}},
+    description: 'A response with accounts is expected',
+    error: [503, 'ExpectedArrayOfAccountsInMasterPublicKeysList'],
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Get a list of master public keys',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(() => getMasterPublicKeys(args), error, 'Got error');
+    } else {
+      const {keys} = await getMasterPublicKeys(args);
+
+      strictSame(keys, expected.keys, 'Got keys');
+    }
+
+    return end();
+  });
+});

package/test/protos/protos.json

@@ -1,6 +1,6 @@
 {
   "overrides": [
-    ["lightning", 3468],
+    ["lightning", 3470],
     ["router", 100],
     ["walletkit", 3],
     ["walletunlocker", 2]

package/test/typescript/get_master_public_keys.test-d.ts

@@ -0,0 +1,19 @@
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {
+  getMasterPublicKeys,
+  GetMasterPublicKeysResult,
+} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+
+expectError(getMasterPublicKeys());
+expectError(getMasterPublicKeys({}));
+
+expectType<GetMasterPublicKeysResult>(await getMasterPublicKeys({lnd}));
+
+expectType<void>(
+  getMasterPublicKeys({lnd}, (error, result) => {
+    expectType<GetMasterPublicKeysResult>(result);
+  })
+);

package/test/typescript/get_pending_payments.test-d.ts

@@ -0,0 +1,31 @@
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {getPendingPayments, GetPendingPaymentsResult} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+const limit = 1;
+const token = 'token';
+
+expectError(getPendingPayments());
+expectError(getPendingPayments({}));
+expectError(getPendingPayments({lnd, limit, token})); // ExpectedNoLimitPagingPendingPaymentsWithToken
+
+expectType<GetPendingPaymentsResult>(await getPendingPayments({lnd}));
+expectType<GetPendingPaymentsResult>(await getPendingPayments({lnd, limit}));
+expectType<GetPendingPaymentsResult>(await getPendingPayments({lnd, token}));
+
+expectType<void>(
+  getPendingPayments({lnd}, (error, result) => {
+    expectType<GetPendingPaymentsResult>(result);
+  })
+);
+expectType<void>(
+  getPendingPayments({lnd, limit}, (error, result) => {
+    expectType<GetPendingPaymentsResult>(result);
+  })
+);
+expectType<void>(
+  getPendingPayments({lnd, token}, (error, result) => {
+    expectType<GetPendingPaymentsResult>(result);
+  })
+);