lightning 6.4.1 → 6.5.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Versions
 
+## 6.5.0
+
+- `getFailedPayments`, `getInvoices`, `getPayments`, `getPendingPayments`: add
+    support for date based filtering with `created_after` and `created_before`
+    arguments
+
 ## 6.4.1
 
 - `subscribeToRpcRequests`: `open_channel_request` add support for

package/grpc/protos/lightning.proto

@@ -3351,7 +3351,7 @@ message Invoice {
     int64 value_msat = 23;
 
     /*
-    Whether this invoice has been fulfilled
+    Whether this invoice has been fulfilled.
 
     The field is deprecated. Use the state field instead (compare to SETTLED).
     */
@@ -3359,12 +3359,14 @@ message Invoice {
 
     /*
     When this invoice was created.
+    Measured in seconds since the unix epoch.
     Note: Output only, don't specify for creating an invoice.
     */
     int64 creation_date = 7;
 
     /*
     When this invoice was settled.
+    Measured in seconds since the unix epoch.
     Note: Output only, don't specify for creating an invoice.
     */
     int64 settle_date = 8;
@@ -3631,7 +3633,16 @@ message ListInvoiceRequest {
     specified index offset. This can be used to paginate backwards.
     */
     bool reversed = 6;
+
+    // If set, returns all invoices with a creation date greater than or equal
+    // to it. Measured in seconds since the unix epoch.
+    uint64 creation_date_start = 7;
+
+    // If set, returns all invoices with a creation date less than or equal to
+    // it. Measured in seconds since the unix epoch.
+    uint64 creation_date_end = 8;
 }
+
 message ListInvoiceResponse {
     /*
     A list of invoices from the time slice of the time series specified in the
@@ -3830,6 +3841,14 @@ message ListPaymentsRequest {
     of payments, as all of them have to be iterated through to be counted.
     */
     bool count_total_payments = 5;
+
+    // If set, returns all invoices with a creation date greater than or equal
+    // to it. Measured in seconds since the unix epoch.
+    uint64 creation_date_start = 6;
+
+    // If set, returns all invoices with a creation date less than or equal to
+    // it. Measured in seconds since the unix epoch.
+    uint64 creation_date_end = 7;
 }
 
 message ListPaymentsResponse {

package/lnd_methods/invoices/get_invoices.js

@@ -1,5 +1,3 @@
-const {createHash} = require('crypto');
-
 const asyncAuto = require('async/auto');
 const asyncRetry = require('async/retry');
 const {returnResult} = require('asyncjs-util');
@@ -9,6 +7,8 @@ const {isLnd} = require('./../../lnd_requests');
 const {rpcInvoiceAsInvoice} = require('./../../lnd_responses');
 const {sortBy} = require('./../../arrays');
 
+const asStart = n => !!n ? Math.floor(new Date(n).getTime() / 1e3) : undefined;
+const asEnd = n => !!n ? Math.ceil(new Date(n).getTime() / 1e3) : undefined;
 const createdAtSort = array => sortBy({array, attribute: 'created_at'});
 const defaultLimit = 100;
 const {isArray} = Array;
@@ -27,7 +27,12 @@ const type = 'default';
 
   Invoice `payment` is not supported on LND 0.11.1 and below
 
+  `created_after` is not supported on LND 0.15.5 and below
+  `created_before` is not supported on LND 0.15.5 and below
+
   {
+    [created_after]: <Creation Date After or Equal to ISO 8601 Date String>
+    [created_before]: <Creation Date Before or Equal to ISO 8601 Date String>
     [is_unconfirmed]: <Omit Canceled and Settled Invoices Bool>
     [limit]: <Page Result Limit Number>
     lnd: <Authenticated LND API Object>
@@ -106,16 +111,20 @@ module.exports = (args, cbk) => {
 
       // Get the list of invoices
       listInvoices: ['validate', ({}, cbk) => {
+        let after = asStart(args.created_after);
+        let before = asEnd(args.created_before);
+        let limit = args.limit || defaultLimit;
         let offset;
-        let resultsLimit = args.limit || defaultLimit;
 
         // When there is a token, parse it out into an offset and a limit
         if (!!args.token) {
           try {
             const pagingToken = parse(args.token);
 
+            after = pagingToken.after;
+            before = pagingToken.before;
             offset = pagingToken.offset;
-            resultsLimit = pagingToken.limit;
+            limit = pagingToken.limit;
           } catch (err) {
             return cbk([400, 'ExpectedValidPagingTokenForInvoicesReq', {err}]);
           }
@@ -123,8 +132,10 @@ module.exports = (args, cbk) => {
 
         return asyncRetry({}, cbk => {
           return args.lnd[type][method]({
+            creation_date_start: after,
+            creation_date_end: before,
             index_offset: offset || Number(),
-            num_max_invoices: resultsLimit,
+            num_max_invoices: limit,
             pending_only: args.is_unconfirmed === true || undefined,
             reversed: true,
           },
@@ -151,7 +162,7 @@ module.exports = (args, cbk) => {
 
             const offset = Number(res.first_index_offset);
 
-            const token = stringify({offset, limit: resultsLimit});
+            const token = stringify({after, before, limit, offset});
 
             return cbk(null, {
               invoices: res.invoices,

package/lnd_methods/offchain/get_failed_payments.js

@@ -2,23 +2,21 @@ 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 listPayments = require('./list_payments');
 
-const defaultLimit = 250;
-const {isArray} = Array;
-const isFailed = payment => !!payment && payment.status === 'FAILED';
-const lastPageFirstIndexOffset = 1;
 const method = 'listPayments';
-const {parse} = JSON;
-const {stringify} = JSON;
 const type = 'default';
 
 /** Get failed payments made through channels.
 
   Requires `offchain:read` permission
 
+  `created_after` is not supported on LND 0.15.5 and below
+  `created_before` is not supported on LND 0.15.5 and below
+
   {
+    [created_after]: <Creation Date After or Equal to ISO 8601 Date String>
+    [created_before]: <Creation Date Before or Equal to ISO 8601 Date String>
     [limit]: <Page Result Limit Number>
     lnd: <Authenticated LND API Object>
     [token]: <Opaque Paging Token String>
@@ -96,16 +94,16 @@ const type = 'default';
     [next]: <Next Opaque Paging Token String>
   }
 */
-module.exports = ({limit, lnd, token}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!!limit && !!token) {
+        if (!!args.limit && !!args.token) {
           return cbk([400, 'ExpectedNoLimitWhenPagingPayFailuresWithToken']);
         }
 
-        if (!isLnd({lnd, method, type})) {
+        if (!isLnd({method, type, lnd: args.lnd})) {
           return cbk([400, 'ExpectedLndForGetFailedPaymentsRequest']);
         }
 
@@ -114,79 +112,17 @@ module.exports = ({limit, lnd, token}, 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, 'ExpectedValidPagingTokenForGetFailed', {err}]);
-          }
-        }
-
-        return lnd[type][method]({
-          include_incomplete: true,
-          index_offset: offset || Number(),
-          max_payments: resultsLimit,
-          reversed: true,
+        return listPayments({
+          created_after: args.created_after,
+          created_before: args.created_before,
+          is_failed: true,
+          limit: args.limit,
+          lnd: args.lnd,
+          token: args.token,
         },
-        (err, res) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedGetFailedPaymentsError', {err}]);
-          }
-
-          if (!res || !isArray(res.payments)) {
-            return cbk([503, 'ExpectedFailedPaymentsInListPaymentsResponse']);
-          }
-
-          if (typeof res.last_index_offset !== 'string') {
-            return cbk([503, 'ExpectedLastIndexOffsetWhenRequestingFailed']);
-          }
-
-          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(isFailed),
-            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 failed 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(),
-        });
+        cbk);
       }],
     },
-    returnResult({reject, resolve, of: 'payments'}, cbk));
+    returnResult({reject, resolve, of: 'listPayments'}, cbk));
   });
 };

package/lnd_methods/offchain/get_payments.js

@@ -2,22 +2,21 @@ 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 listPayments = require('./list_payments');
 
-const defaultLimit = 250;
-const {isArray} = Array;
-const lastPageFirstIndexOffset = 1;
 const method = 'listPayments';
-const {parse} = JSON;
-const {stringify} = JSON;
 const type = 'default';
 
 /** Get payments made through channels.
 
   Requires `offchain:read` permission
 
+  `created_after` is not supported on LND 0.15.5 and below
+  `created_before` is not supported on LND 0.15.5 and below
+
   {
+    [created_after]: <Creation Date After or Equal to ISO 8601 Date String>
+    [created_before]: <Creation Date Before or Equal to ISO 8601 Date String>
     [limit]: <Page Result Limit Number>
     lnd: <Authenticated LND API Object>
     [token]: <Opaque Paging Token String>
@@ -101,16 +100,16 @@ const type = 'default';
     [next]: <Next Opaque Paging Token String>
   }
 */
-module.exports = ({limit, lnd, token}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!!limit && !!token) {
+        if (!!args.limit && !!args.token) {
           return cbk([400, 'UnexpectedLimitWhenPagingPaymentsWithToken']);
         }
 
-        if (!isLnd({lnd, method, type})) {
+        if (!isLnd({method, type, lnd: args.lnd})) {
           return cbk([400, 'ExpectedLndForGetPaymentsRequest']);
         }
 
@@ -119,79 +118,16 @@ module.exports = ({limit, lnd, token}, 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, 'ExpectedValidPagingTokenForPaymentReq', {err}]);
-          }
-        }
-
-        return lnd[type][method]({
-          include_incomplete: false,
-          index_offset: offset || Number(),
-          max_payments: resultsLimit,
-          reversed: true,
+        return listPayments({
+          created_after: args.created_after,
+          created_before: args.created_before,
+          limit: args.limit,
+          lnd: args.lnd,
+          token: args.token,
         },
-        (err, res) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedGetPaymentsError', {err}]);
-          }
-
-          if (!res || !isArray(res.payments)) {
-            return cbk([503, 'ExpectedPaymentsInListPaymentsResponse']);
-          }
-
-          if (typeof res.last_index_offset !== 'string') {
-            return cbk([503, 'ExpectedLastIndexOffsetWhenRequestingPayments']);
-          }
-
-          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,
-            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 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(),
-        });
+        cbk);
       }],
     },
-    returnResult({reject, resolve, of: 'payments'}, cbk));
+    returnResult({reject, resolve, of: 'listPayments'}, cbk));
   });
 };

package/lnd_methods/offchain/get_pending_payments.js

@@ -2,23 +2,21 @@ 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 listPayments = require('./list_payments');
 
-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
 
+  `created_after` is not supported on LND 0.15.5 and below
+  `created_before` is not supported on LND 0.15.5 and below
+
   {
+    [created_after]: <Creation Date After or Equal to ISO 8601 Date String>
+    [created_before]: <Creation Date Before or Equal to ISO 8601 Date String>
     [limit]: <Page Result Limit Number>
     lnd: <Authenticated LND API Object>
     [token]: <Opaque Paging Token String>
@@ -96,16 +94,16 @@ const type = 'default';
     [next]: <Next Opaque Paging Token String>
   }
 */
-module.exports = ({limit, lnd, token}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!!limit && !!token) {
+        if (!!args.limit && !!args.token) {
           return cbk([400, 'ExpectedNoLimitPagingPendingPaymentsWithToken']);
         }
 
-        if (!isLnd({lnd, method, type})) {
+        if (!isLnd({method, type, lnd: args.lnd})) {
           return cbk([400, 'ExpectedLndForGetPendingPaymentsRequest']);
         }
 
@@ -114,79 +112,17 @@ module.exports = ({limit, lnd, token}, 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,
+        return listPayments({
+          created_after: args.created_after,
+          created_before: args.created_before,
+          is_pending: true,
+          limit: args.limit,
+          lnd: args.lnd,
+          token: args.token,
         },
-        (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(),
-        });
+        cbk);
       }],
     },
-    returnResult({reject, resolve, of: 'payments'}, cbk));
+    returnResult({reject, resolve, of: 'listPayments'}, cbk));
   });
 };

package/lnd_methods/offchain/list_payments.js

@@ -0,0 +1,218 @@
+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 asStart = n => !!n ? Math.floor(new Date(n).getTime() / 1e3) : undefined;
+const asEnd = n => !!n ? Math.ceil(new Date(n).getTime() / 1e3) : undefined;
+const defaultLimit = 250;
+const {isArray} = Array;
+const isFailed = payment => !!payment && payment.status === 'FAILED';
+const isPending = payment => !!payment && payment.status === 'IN_FLIGHT';
+const lastPageFirstIndexOffset = 1;
+const method = 'listPayments';
+const {parse} = JSON;
+const {stringify} = JSON;
+const type = 'default';
+
+/** Fetch payments
+
+  {
+    [created_after]: <Creation Date After or Equal to ISO 8601 Date String>
+    [created_before]: <Creation Date Before or Equal to ISO 8601 Date String>
+    [is_failed]: <Fetch Failed Payments Bool>
+    [is_pending]: <Fetch Pending Payments Bool>
+    [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 Attempt Succeeded At ISO 8601 Date String>
+        created_at: <Attempt Was Started At ISO 8601 Date String>
+        [failed_at]: <Payment Attempt Failed 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>
+        }
+      }]
+      confirmed_at: <Payment Confirmed At ISO 8601 Date String>
+      created_at: <Payment at ISO-8601 Date String>
+      destination: <Destination Node Public Key Hex String>
+      fee: <Paid Routing Fee Rounded Down Tokens Number>
+      fee_mtokens: <Paid Routing Fee in Millitokens String>
+      hops: [<First Route Hop 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 Sent to Destination String>
+      [request]: <BOLT 11 Payment Request String>
+      safe_fee: <Payment Forwarding Fee Rounded Up Tokens Number>
+      safe_tokens: <Payment Tokens Rounded Up Number>
+      secret: <Payment Preimage Hex String>
+      tokens: <Rounded Down Tokens Sent to Destination Number>
+    }]
+    [next]: <Next Opaque Paging Token String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!!args.is_failed && !!args.is_pending) {
+          return cbk([400, 'EitherFailedOrPendingPaymentsIsSupportedNotBoth']);
+        }
+
+        return cbk();
+      },
+
+      // Get all payments
+      listPayments: ['validate', ({}, cbk) => {
+        let after = asStart(args.created_after);
+        let before = asEnd(args.created_before);
+        let limit = args.limit || defaultLimit;
+        let offset;
+
+        if (!!args.token) {
+          try {
+            const pagingToken = parse(args.token);
+
+            after = pagingToken.after;
+            before = pagingToken.before;
+            limit = pagingToken.limit;
+            offset = pagingToken.offset;
+          } catch (err) {
+            return cbk([400, 'ExpectedValidPagingTokenForPaymentReq', {err}]);
+          }
+        }
+
+        return args.lnd[type][method]({
+          creation_date_start: after,
+          creation_date_end: before,
+          include_incomplete: !!args.is_failed || !!args.is_pending,
+          index_offset: offset || Number(),
+          max_payments: limit,
+          reversed: true,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedGetPaymentsError', {err}]);
+          }
+
+          if (!res || !isArray(res.payments)) {
+            return cbk([503, 'ExpectedPaymentsInListPaymentsResponse']);
+          }
+
+          if (typeof res.last_index_offset !== 'string') {
+            return cbk([503, 'ExpectedLastIndexOffsetWhenRequestingPayments']);
+          }
+
+          const offset = Number(res.first_index_offset);
+
+          const token = stringify({before, after, limit, offset});
+
+          return cbk(null, {
+            payments: res.payments,
+            token: offset <= lastPageFirstIndexOffset ? undefined : token,
+          });
+        });
+      }],
+
+      // Check and map payments
+      foundPayments: ['listPayments', ({listPayments}, cbk) => {
+        try {
+          const payments = listPayments.payments
+            .filter(payment => {
+              // Exit early when looking for failed payments only
+              if (!!args.is_failed) {
+                return isFailed(payment);
+              }
+
+              // Exit early when looking for pending payments only
+              if (!!args.is_pending) {
+                return isPending(payment);
+              }
+
+              return true;
+            })
+            .map(rpcPaymentAsPayment);
+
+          return cbk(null, payments);
+        } catch (err) {
+          return cbk([503, err.message]);
+        }
+      }],
+
+      // Final found 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/package.json

@@ -10,7 +10,7 @@
     "@grpc/grpc-js": "1.8.0",
     "@grpc/proto-loader": "0.7.4",
     "@types/express": "4.17.14",
-    "@types/node": "18.11.12",
+    "@types/node": "18.11.13",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.4",
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "6.4.1"
+  "version": "6.5.0"
 }

package/test/lnd_methods/invoices/test_get_invoices.js

@@ -114,7 +114,7 @@ const tests = [
         secret: '0000000000000000000000000000000000000000000000000000000000000000',
         tokens: 1,
       }],
-      next: '{"offset":2,"limit":100}',
+      next: '{"limit":100,"offset":2}',
     },
   },
   {
@@ -132,6 +132,23 @@ const tests = [
     description: 'Empty invoices are returned',
     expected: {invoices: [], next: undefined},
   },
+  {
+    args: {
+      created_after: new Date().toISOString(),
+      created_before: new Date().toISOString(),
+      lnd: {
+        default: {
+          listInvoices: ({}, cbk) => cbk(null, {
+            first_index_offset: '2',
+            invoices: [],
+            last_index_offset: '2',
+          }),
+        },
+      },
+    },
+    description: 'A date range is supported',
+    expected: {invoices: [], next: undefined},
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {

package/test/lnd_methods/offchain/test_get_failed_payments.js

@@ -74,31 +74,31 @@ const tests = [
   {
     args: makeArgs({token: 'token'}),
     description: 'A valid token is required',
-    error: [400, 'ExpectedValidPagingTokenForGetFailed'],
+    error: [400, 'ExpectedValidPagingTokenForPaymentReq'],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}}),
     description: 'Errors from LND are passed back',
-    error: [503, 'UnexpectedGetFailedPaymentsError', {err: 'err'}],
+    error: [503, 'UnexpectedGetPaymentsError', {err: 'err'}],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk()}}}),
     description: 'A response is expected from LND',
-    error: [503, 'ExpectedFailedPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {})}},
     }),
     description: 'A response with payments is expected from LND',
-    error: [503, 'ExpectedFailedPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {payments: []})}},
     }),
     description: 'A response with payments and last index is expected',
-    error: [503, 'ExpectedLastIndexOffsetWhenRequestingFailed'],
+    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPayments'],
   },
   {
     args: makeArgs({

package/test/lnd_methods/offchain/test_get_payments.js

@@ -189,6 +189,15 @@ const tests = [
     description: 'A payment is returned when a token is specified',
     expected: {payment: makeExpectedPayment({})},
   },
+  {
+    args: makeArgs({
+      created_after: new Date().toISOString(),
+      created_before: new Date().toISOString(),
+      lnd: makeLnd({first_index_offset: '2'}),
+    }),
+    description: 'Date range can be passed',
+    expected: {payment: makeExpectedPayment({})},
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {

package/test/lnd_methods/offchain/test_get_pending_payments.js

@@ -74,31 +74,31 @@ const tests = [
   {
     args: makeArgs({token: 'token'}),
     description: 'A valid token is required',
-    error: [400, 'ExpectedValidPagingTokenForGetPending'],
+    error: [400, 'ExpectedValidPagingTokenForPaymentReq'],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}}),
     description: 'Errors from LND are passed back',
-    error: [503, 'UnexpectedGetPendingPaymentsError', {err: 'err'}],
+    error: [503, 'UnexpectedGetPaymentsError', {err: 'err'}],
   },
   {
     args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk()}}}),
     description: 'A response is expected from LND',
-    error: [503, 'ExpectedPendingPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {})}},
     }),
     description: 'A response with payments is expected from LND',
-    error: [503, 'ExpectedPendingPaymentsInListPaymentsResponse'],
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
   },
   {
     args: makeArgs({
       lnd: {default: {listPayments: ({}, cbk) => cbk(null, {payments: []})}},
     }),
     description: 'A response with payments and last index is expected',
-    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPending'],
+    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPayments'],
   },
   {
     args: makeArgs({

package/test/lnd_methods/offchain/test_list_payments.js

@@ -0,0 +1,45 @@
+const {test} = require('@alexbosworth/tap');
+
+const listPayments = require('./../../../lnd_methods/offchain/list_payments');
+
+const makeLnd = args => {
+  return {
+    default: {
+      listPayments: ({}, cbk) => cbk(null, {
+        first_index_offset: args.first_index_offset || '1',
+        payments: [],
+        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 tests = [
+  {
+    args: makeArgs({is_failed: true, is_pending: true}),
+    description: 'Both failed and pending cannot be set',
+    error: [400, 'EitherFailedOrPendingPaymentsIsSupportedNotBoth'],
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(() => listPayments(args), error, 'Got expected error');
+    } else {
+      const res = await listPayments(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});