lightning 5.21.2 → 6.1.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Versions
 
+## 6.1.0
+
+- `subscribeToPayments`: Add method to listen to all outgoing payments
+
+## 6.0.0
+
+### Breaking Changes
+
+- Node.js version 14 or higher is now required
+
 ## 5.21.2
 
 - `getChainFeeEstimate`: Add support for specifying min `utxo_confirmations`

package/README.md

@@ -315,6 +315,8 @@ variables set:
     Make an off-chain payment using a payment request and subscribe to the payment status.
 - [subscribeToPayViaRoutes](https://github.com/alexbosworth/ln-service#subscribetopayviaroutes):
     Start an off-chain payment using specific payment routes and subscribe to the payment result.
+- [subscribeToPayments](https://github.com/alexbosworth/ln-service#subscribetopayments):
+    Subscribe to off-chain payments going out and being resolved
 - [subscribeToPeerMessages](https://github.com/alexbosworth/ln-service#subscribetopeermessages):
     Listen for incoming peer messages.
 - [subscribeToPeers](https://github.com/alexbosworth/ln-service#subscribetopeers): Listen to peer

package/grpc/protos/lightning.proto

@@ -637,6 +637,7 @@ enum OutputScriptType {
     SCRIPT_TYPE_NULLDATA = 6;
     SCRIPT_TYPE_NON_STANDARD = 7;
     SCRIPT_TYPE_WITNESS_UNKNOWN = 8;
+    SCRIPT_TYPE_WITNESS_V1_TAPROOT = 9;
 }
 
 message OutputDetail {
@@ -2563,9 +2564,17 @@ message PendingChannelsResponse {
 
         repeated PendingHTLC pending_htlcs = 8;
 
+        /*
+          There are three resolution states for the anchor:
+          limbo, lost and recovered. Derive the current state
+          from the limbo and recovered balances.
+        */
         enum AnchorState {
+            // The recovered_balance is zero and limbo_balance is non-zero.
             LIMBO = 0;
+            // The recovered_balance is non-zero.
             RECOVERED = 1;
+            // A state that is neither LIMBO nor RECOVERED.
             LOST = 2;
         }
 
@@ -3646,7 +3655,7 @@ message Payment {
     // Deprecated, use creation_time_ns
     int64 creation_date = 3 [deprecated = true];
 
-    repeated string path = 4 [deprecated = true];
+    reserved 4;
 
     // Deprecated, use fee_sat or fee_msat.
     int64 fee = 5 [deprecated = true];

package/grpc/protos/router.proto

@@ -22,6 +22,16 @@ service Router {
     */
     rpc TrackPaymentV2 (TrackPaymentRequest) returns (stream lnrpc.Payment);
 
+    /*
+    TrackPayments returns an update stream for every payment that is not in a
+    terminal state. Note that if payments are in-flight while starting a new
+    subscription, the start of the payment stream could produce out-of-order
+    and/or duplicate events. In order to get updates for every in-flight
+    payment attempt make sure to subscribe to this method before initiating any
+    payments.
+    */
+    rpc TrackPayments (TrackPaymentsRequest) returns (stream lnrpc.Payment);
+
     /*
     EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
     may cost to send an HTLC to the target end destination.
@@ -303,6 +313,14 @@ message TrackPaymentRequest {
     bool no_inflight_updates = 2;
 }
 
+message TrackPaymentsRequest {
+    /*
+    If set, only the final payment updates are streamed back. Intermediate
+    updates that show which htlcs are still in flight are suppressed.
+    */
+    bool no_inflight_updates = 1;
+}
+
 message RouteFeeRequest {
     /*
     The destination once wishes to obtain a routing fee quote to.
@@ -697,7 +715,7 @@ enum PaymentState {
     FAILED_NO_ROUTE = 3;
 
     /*
-    A non-recoverable error has occured.
+    A non-recoverable error has occurred.
     */
     FAILED_ERROR = 4;
 

package/grpc/protos/stateservice.proto

@@ -36,14 +36,25 @@ service State {
 }
 
 enum WalletState {
+    // NON_EXISTING means that the wallet has not yet been initialized.
     NON_EXISTING = 0;
+
+    // LOCKED means that the wallet is locked and requires a password to unlock.
     LOCKED = 1;
+
+    // UNLOCKED means that the wallet was unlocked successfully, but RPC server
+    // isn't ready.
     UNLOCKED = 2;
+
+    // RPC_ACTIVE means that the lnd server is active but not fully ready for
+    // calls.
     RPC_ACTIVE = 3;
 
     // SERVER_ACTIVE means that the lnd server is ready to accept calls.
     SERVER_ACTIVE = 4;
 
+    // WAITING_TO_START means that node is waiting to become the leader in a
+    // cluster and is not started yet.
     WAITING_TO_START = 255;
 }
 

package/index.js

@@ -123,6 +123,7 @@ const {subscribeToPastPayments} = require('./lnd_methods');
 const {subscribeToPayViaDetails} = require('./lnd_methods');
 const {subscribeToPayViaRequest} = require('./lnd_methods');
 const {subscribeToPayViaRoutes} = require('./lnd_methods');
+const {subscribeToPayments} = require('./lnd_methods');
 const {subscribeToPeerMessages} = require('./lnd_methods');
 const {subscribeToPeers} = require('./lnd_methods');
 const {subscribeToProbeForRoute} = require('./lnd_methods');
@@ -271,6 +272,7 @@ module.exports = {
   subscribeToPayViaDetails,
   subscribeToPayViaRequest,
   subscribeToPayViaRoutes,
+  subscribeToPayments,
   subscribeToPeerMessages,
   subscribeToPeers,
   subscribeToProbeForRoute,

package/lnd_methods/index.js

@@ -120,6 +120,7 @@ const {subscribeToPastPayments} = require('./offchain');
 const {subscribeToPayViaDetails} = require('./offchain');
 const {subscribeToPayViaRequest} = require('./offchain');
 const {subscribeToPayViaRoutes} = require('./offchain');
+const {subscribeToPayments} = require('./offchain');
 const {subscribeToPeerMessages} = require('./offchain');
 const {subscribeToPeers} = require('./peers');
 const {subscribeToProbeForRoute} = require('./offchain');
@@ -264,6 +265,7 @@ module.exports = {
   subscribeToPayViaDetails,
   subscribeToPayViaRequest,
   subscribeToPayViaRoutes,
+  subscribeToPayments,
   subscribeToPeerMessages,
   subscribeToPeers,
   subscribeToProbeForRoute,

package/lnd_methods/macaroon/methods.json

@@ -485,6 +485,10 @@
     "method": "SendToRouteV2",
     "type": "router"
   },
+  "subscribeToPayments": {
+    "method": "TrackPayments",
+    "type": "router"
+  },
   "subscribeToPeerMessages": {
     "method": "SubscribeCustomMessages",
     "type": "default"

package/lnd_methods/offchain/index.js

@@ -46,6 +46,7 @@ const subscribeToPastPayments = require('./subscribe_to_past_payments');
 const subscribeToPayViaDetails = require('./subscribe_to_pay_via_details');
 const subscribeToPayViaRequest = require('./subscribe_to_pay_via_request');
 const subscribeToPayViaRoutes = require('./subscribe_to_pay_via_routes');
+const subscribeToPayments = require('./subscribe_to_payments');
 const subscribeToPeerMessages = require('./subscribe_to_peer_messages');
 const subscribeToProbeForRoute = require('./subscribe_to_probe_for_route');
 const updateConnectedWatchtower = require('./update_connected_watchtower');
@@ -103,6 +104,7 @@ module.exports = {
   subscribeToPayViaDetails,
   subscribeToPayViaRequest,
   subscribeToPayViaRoutes,
+  subscribeToPayments,
   subscribeToPeerMessages,
   subscribeToProbeForRoute,
   updateConnectedWatchtower,

package/lnd_methods/offchain/subscribe_to_payments.js

@@ -0,0 +1,119 @@
+const EventEmitter = require('events');
+
+const emitPayment = require('./emit_payment');
+const {emitSubscriptionError} = require('./../../grpc');
+const {handleRemoveListener} = require('./../../grpc');
+const {isLnd} = require('./../../lnd_requests');
+
+const events = ['confirmed', 'failed', 'paying'];
+const method = 'trackPayments';
+const type = 'router';
+
+/** Subscribe to outgoing payments
+
+  Requires `offchain:read` permission
+
+  Note: Method not supported on LND 0.15.2 and below
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @throws
+  <Error>
+
+
+  @returns
+  <Subscription EventEmitter Object>
+
+  @event 'confirmed'
+  {
+    confirmed_at: <Payment Confirmed At ISO 8601 Date String>
+    created_at: <Payment Created At ISO 8601 Date String>
+    destination: <Payment Destination Hex String>
+    fee: <Total Fee Tokens Paid Rounded Down Number>
+    fee_mtokens: <Total Fee Millitokens Paid String>
+    id: <Payment Hash Hex String>
+    mtokens: <Total Millitokens Paid String>
+    paths: [{
+      fee: <Total Fee Tokens Paid Number>
+      fee_mtokens: <Total Fee Millitokens Paid String>
+      hops: [{
+        channel: <Standard Format Channel Id String>
+        channel_capacity: <Channel Capacity Tokens Number>
+        fee: <Fee Tokens Rounded Down Number>
+        fee_mtokens: <Fee Millitokens String>
+        forward: <Forward Tokens Number>
+        forward_mtokens: <Forward Millitokens String>
+        public_key: <Public Key Hex String>
+        timeout: <Timeout Block Height Number>
+      }]
+      mtokens: <Total Millitokens Paid String>
+      safe_fee: <Total Fee Tokens Paid Rounded Up Number>
+      safe_tokens: <Total Tokens Paid, Rounded Up Number>
+      timeout: <Expiration Block Height Number>
+    }]
+    [request]: <BOLT 11 Encoded Payment Request String>
+    safe_fee: <Total Fee Tokens Paid Rounded Up Number>
+    safe_tokens: <Total Tokens Paid, Rounded Up Number>
+    secret: <Payment Preimage Hex String>
+    timeout: <Expiration Block Height Number>
+    tokens: <Total Tokens Paid Rounded Down Number>
+  }
+
+  @event 'failed'
+  {
+    is_insufficient_balance: <Failed Due To Lack of Balance Bool>
+    is_invalid_payment: <Failed Due to Payment Rejected At Destination Bool>
+    is_pathfinding_timeout: <Failed Due to Pathfinding Timeout Bool>
+    is_route_not_found: <Failed Due to Absence of Path Through Graph Bool>
+  }
+
+  @event 'paying'
+  {
+    created_at: <Payment Created At ISO 8601 Date String>
+    destination: <Payment Destination Hex String>
+    id: <Payment Hash Hex String>
+    mtokens: <Total Millitokens Pending String>
+    paths: [{
+      fee: <Total Fee Tokens Pending Number>
+      fee_mtokens: <Total Fee Millitokens Pending String>
+      hops: [{
+        channel: <Standard Format Channel Id String>
+        channel_capacity: <Channel Capacity Tokens Number>
+        fee: <Fee Tokens Rounded Down Number>
+        fee_mtokens: <Fee Millitokens String>
+        forward: <Forward Tokens Number>
+        forward_mtokens: <Forward Millitokens String>
+        public_key: <Public Key Hex String>
+        timeout: <Timeout Block Height Number>
+      }]
+      mtokens: <Total Millitokens Pending String>
+      safe_fee: <Total Fee Tokens Pending Rounded Up Number>
+      safe_tokens: <Total Tokens Pending, Rounded Up Number>
+      timeout: <Expiration Block Height Number>
+    }]
+    [request]: <BOLT 11 Encoded Payment Request String>
+    safe_tokens: <Total Tokens Pending, Rounded Up Number>
+    [timeout]: <Expiration Block Height Number>
+    tokens: <Total Tokens Pending Rounded Down Number>
+  }
+*/
+module.exports = ({lnd}) => {
+  if (!isLnd({lnd, method, type})) {
+    throw new Error('ExpectedAuthenticatedLndToSubscribeToCurrentPayments');
+  }
+
+  const emitter = new EventEmitter();
+  const sub = lnd[type][method]({});
+
+  const emitErr = emitSubscriptionError({emitter, subscription: sub});
+
+  // Terminate subscription when all listeners are removed
+  handleRemoveListener({emitter, events, subscription: sub});
+
+  sub.on('data', data => emitPayment({data, emitter}));
+  sub.on('error', err => emitErr([503, 'UnexpectedPaymentsSubErr', {err}]));
+
+  return emitter;
+};

package/lnd_responses/pending_from_payment.js

@@ -49,7 +49,6 @@ const nsAsDate = ns => new Date(Number(BigInt(ns) / BigInt(1e6)));
       }
       status: <HTLC Status String>
     }]
-    path: [<Hop Public Key Hex String>]
     payment_hash: <Preimage SHA256 Hash Hex String>
     payment_index: <Payment Index String>
     payment_preimage: <Payment Secret Preimage Hex String>

package/lnd_responses/rpc_payment_as_payment.js

@@ -64,7 +64,6 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
       }
       status: <HTLC Status String>
     }]
-    path: [<Hop Public Key Hex String>]
     payment_hash: <Preimage SHA256 Hash Hex String>
     payment_index: <Payment Index String>
     payment_preimage: <Payment Secret Preimage Hex String>
@@ -171,18 +170,6 @@ module.exports = payment => {
     throw new Error('ExpectedHtlcsArrayInRpcPaymentDetails');
   }
 
-  if (!isArray(payment.path)) {
-    throw new Error('ExpectedPaymentPathInRpcPaymentDetails');
-  }
-
-  payment.path.forEach(key => {
-    if (!key) {
-      throw new Error('ExpectedPathHopKeyInRpcPaymentDetails');
-    }
-
-    return;
-  });
-
   if (!payment.payment_hash) {
     throw new Error('ExpectedPaymentHashInRpcPaymentDetails');
   }
@@ -233,13 +220,12 @@ module.exports = payment => {
     };
   }
 
-  const hasPath = !!payment.path.length;
   const hasPreimage = payment.payment_preimage !== emptyHash;
   const [attempt] = attempts;
   const successes = attempts.filter(n => n.is_confirmed);
 
-  const path = !hasPath ? routePublicKeys(attempt.route) : payment.path;
   const [confirmedAt] = successes.map(n => n.confirmed_at).sort().reverse();
+  const path = routePublicKeys(attempt.route);
 
   const [destination, ...hops] = path.reverse();
 

package/package.json

@@ -7,10 +7,10 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.7.0",
-    "@grpc/proto-loader": "0.7.2",
+    "@grpc/grpc-js": "1.7.1",
+    "@grpc/proto-loader": "0.7.3",
     "@types/express": "4.17.14",
-    "@types/node": "18.7.18",
+    "@types/node": "18.7.23",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.4",
@@ -21,12 +21,12 @@
     "bolt07": "1.8.2",
     "bolt09": "0.2.3",
     "cbor": "8.1.0",
-    "ecpair": "2.0.1",
+    "ecpair": "2.1.0",
     "express": "4.18.1",
     "invoices": "2.2.0",
     "psbt": "2.7.1",
     "tiny-secp256k1": "2.2.1",
-    "type-fest": "2.19.0"
+    "type-fest": "3.0.0"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -34,10 +34,10 @@
     "@alexbosworth/tap": "15.0.11",
     "tsd": "0.24.1",
     "typescript": "4.8.3",
-    "ws": "8.8.1"
+    "ws": "8.9.0"
   },
   "engines": {
-    "node": ">=12.20"
+    "node": ">=14"
   },
   "keywords": [
     "grpc",
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.21.2"
+  "version": "6.1.0"
 }

package/test/lnd_methods/offchain/test_get_payments.js

@@ -25,7 +25,7 @@ const makeLnd = args => {
                 expiry: 1,
                 fee: 1,
                 fee_msat: '1000',
-                pub_key: Buffer.alloc(33).toString('hex'),
+                pub_key: Buffer.alloc(33, 2).toString('hex'),
                 tlv_payload: false,
               }],
               total_amt: '1',
@@ -80,7 +80,7 @@ const makeExpectedPayment = ({}) => {
           fee_mtokens: '1000',
           forward: 1,
           forward_mtokens: '1000',
-          public_key: '000000000000000000000000000000000000000000000000000000000000000000',
+          public_key: Buffer.alloc(33, 2).toString('hex'),
           timeout: 1,
         }],
         mtokens: '1000',

package/test/lnd_methods/offchain/test_subscribe_to_payments.js

@@ -0,0 +1,167 @@
+const EventEmitter = require('events');
+
+const {test} = require('@alexbosworth/tap');
+
+const {subscribeToPayments} = require('./../../../');
+
+const tick = () => new Promise(resolve => process.nextTick(resolve));
+
+const tests = [
+  {
+    args: {},
+    description: 'LND is required',
+    error: 'ExpectedAuthenticatedLndToSubscribeToCurrentPayments',
+  },
+  {
+    args: {
+      lnd: {
+        router: {
+          trackPayments: () => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('error', 'error'));
+
+            return emitter;
+          },
+        },
+      },
+    },
+    description: 'An error is emitted',
+    expected: {
+      confirmed: [],
+      errors: [[503, 'UnexpectedPaymentsSubErr', {err: 'error'}]],
+    },
+  },
+  {
+    args: {
+      lnd: {
+        router: {
+          trackPayments: () => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('data', {
+              creation_date: '1',
+              creation_time_ns: '1',
+              failure_reason: 'FAILURE_REASON_NONE',
+              fee: '1',
+              fee_msat: '1000',
+              fee_sat: '1',
+              htlcs: [{
+                attempt_time_ns: '1',
+                status: 'SUCCEEDED',
+                resolve_time_ns: '1',
+                route: {
+                  hops: [{
+                    amt_to_forward: '1',
+                    amt_to_forward_msat: '1000',
+                    chan_capacity: '1',
+                    chan_id: '1',
+                    custom_records: {'1': Buffer.alloc(1)},
+                    expiry: 1,
+                    fee: '1',
+                    fee_msat: '1000',
+                    mpp_record: {payment_addr: Buffer.alloc(32), total_amt_msat: '1000'},
+                    pub_key: Buffer.alloc(33).toString('hex'),
+                    tlv_payload: true,
+                  }],
+                  total_amt: '1',
+                  total_amt_msat: '1000',
+                  total_time_lock: 1,
+                  total_fees: '1',
+                  total_fees_msat: '1000',
+                },
+              }],
+              path: [Buffer.alloc(33).toString('hex')],
+              payment_hash: Buffer.alloc(32).toString('hex'),
+              payment_index: '1',
+              payment_preimage: Buffer.alloc(32).toString('hex'),
+              payment_request: '',
+              status: 'SUCCEEDED',
+              value: '1',
+              value_msat: '1000',
+              value_sat: '1',
+            }));
+
+            return emitter;
+          },
+        },
+      },
+    },
+    description: 'A payment is made',
+    expected: {
+      confirmed: [{
+        confirmed_at: '1970-01-01T00:00:00.000Z',
+        created_at: '1970-01-01T00:00:00.000Z',
+        destination: Buffer.alloc(33).toString('hex'),
+        fee: 1,
+        fee_mtokens: '1000',
+        hops: [{
+          channel: '0x0x1',
+          channel_capacity: 1,
+          fee: 1,
+          fee_mtokens: '1000',
+          forward: 1,
+          forward_mtokens: '1000',
+          public_key: Buffer.alloc(33).toString('hex'),
+          timeout: 1,
+        }],
+        id: Buffer.alloc(32).toString('hex'),
+        mtokens: '2000',
+        paths: [{
+          fee: 1,
+          fee_mtokens: '1000',
+          hops: [{
+            channel: '0x0x1',
+            channel_capacity: 1,
+            fee: 1,
+            fee_mtokens: '1000',
+            forward: 1,
+            forward_mtokens: '1000',
+            public_key: Buffer.alloc(33).toString('hex'),
+            timeout: 1,
+          }],
+          mtokens: '1000',
+          payment: '0000000000000000000000000000000000000000000000000000000000000000',
+          timeout: 1,
+          tokens: 1,
+          total_mtokens: '1000',
+        }],
+        request: undefined,
+        safe_fee: 1,
+        safe_tokens: 2,
+        secret: Buffer.alloc(32).toString('hex'),
+        timeout: 1,
+        tokens: 2,
+      }],
+      errors: [],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => subscribeToPayments(args), new Error(error), 'Got err');
+    } else {
+      const sub = subscribeToPayments(args);
+
+      const confirmed = [];
+      const errors = [];
+
+      sub.on('confirmed', payment => confirmed.push(payment));
+      sub.on('error', err => errors.push(err));
+
+      await tick();
+      await tick();
+
+      strictSame(confirmed, expected.confirmed, 'Got expected payments');
+      strictSame(errors, expected.errors, 'Got expected errors');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_payment_as_payment.js

@@ -33,19 +33,34 @@ const makeArgs = overrides => {
       },
       resolve_time_ns: '1000000',
       route: {
-        hops: [{
-          amt_to_forward_msat: '1000',
-          chan_id: '1',
-          chan_capacity: 1,
-          expiry: 1,
-          fee_msat: '1000',
-          mpp_record: {
-            payment_addr: Buffer.alloc(32),
-            total_amt_msat: '1000',
+        hops: [
+          {
+            amt_to_forward_msat: '1000',
+            chan_id: '1',
+            chan_capacity: 1,
+            expiry: 1,
+            fee_msat: '1000',
+            mpp_record: {
+              payment_addr: Buffer.alloc(32),
+              total_amt_msat: '1000',
+            },
+            pub_key: Buffer.alloc(33).toString('hex'),
+            tlv_payload: true,
           },
-          pub_key: Buffer.alloc(33).toString('hex'),
-          tlv_payload: true,
-        }],
+          {
+            amt_to_forward_msat: '1000',
+            chan_id: '1',
+            chan_capacity: 1,
+            expiry: 1,
+            fee_msat: '1000',
+            mpp_record: {
+              payment_addr: Buffer.alloc(32),
+              total_amt_msat: '1000',
+            },
+            pub_key: Buffer.alloc(33).toString('hex'),
+            tlv_payload: true,
+          },
+        ],
         total_amt: '1',
         total_amt_msat: '1000',
         total_fees: '1',
@@ -54,7 +69,6 @@ const makeArgs = overrides => {
       },
       status: 'FAILED',
     }],
-    path: [Buffer.alloc(33).toString('hex'), Buffer.alloc(33).toString('hex')],
     payment_hash: Buffer.alloc(32).toString('hex'),
     payment_index: '1',
     payment_preimage: Buffer.alloc(32, 1).toString('hex'),
@@ -82,16 +96,28 @@ const makeExpected = overrides => {
       route: {
         fee: 1,
         fee_mtokens: '1000',
-        hops: [{
-          channel: '0x0x1',
-          channel_capacity: 1,
-          fee: 1,
-          fee_mtokens: '1000',
-          forward: 1,
-          forward_mtokens: '1000',
-          public_key: Buffer.alloc(33).toString('hex'),
-          timeout: 1,
-        }],
+        hops: [
+          {
+            channel: '0x0x1',
+            channel_capacity: 1,
+            fee: 1,
+            fee_mtokens: '1000',
+            forward: 1,
+            forward_mtokens: '1000',
+            public_key: Buffer.alloc(33).toString('hex'),
+            timeout: 1,
+          },
+          {
+            channel: '0x0x1',
+            channel_capacity: 1,
+            fee: 1,
+            fee_mtokens: '1000',
+            forward: 1,
+            forward_mtokens: '1000',
+            public_key: Buffer.alloc(33).toString('hex'),
+            timeout: 1,
+          },
+        ],
         mtokens: '1000',
         payment: Buffer.alloc(32).toString('hex'),
         timeout: 1,
@@ -143,16 +169,6 @@ const tests = [
     description: 'HTLC array is expected to be present',
     error: 'ExpectedHtlcsArrayInRpcPaymentDetails',
   },
-  {
-    args: makeArgs({path: undefined}),
-    description: 'A path is expected to be present',
-    error: 'ExpectedPaymentPathInRpcPaymentDetails',
-  },
-  {
-    args: makeArgs({path: [null]}),
-    description: 'Hops are expected to have elements',
-    error: 'ExpectedPathHopKeyInRpcPaymentDetails',
-  },
   {
     args: makeArgs({payment_hash: undefined}),
     description: 'A payment hash is expected',
@@ -175,7 +191,7 @@ const tests = [
   },
   {
     args: makeArgs({creation_time_ns: '1000000'}),
-    description: 'RPC Payment is mapped to payment details',
+    description: 'RPC Payment with date is mapped to payment details',
     expected: makeExpected({created_at: '1970-01-01T00:00:00.001Z'}),
   },
   {