lightning 4.10.1 → 4.10.5

package/lnd_responses/rpc_payment_as_payment.js

@@ -1,6 +1,9 @@
+const {parsePaymentRequest} = require('invoices');
+
 const rpcAttemptHtlcAsAttempt = require('./rpc_attempt_htlc_as_attempt');
 const {safeTokens} = require('./../bolt00');
 
+const emptyHash = Buffer.alloc(32).toString('hex');
 const {isArray} = Array;
 const msPerSecond = 1e3;
 const nanoSecsPerMillisecond = BigInt(1e6);
@@ -129,9 +132,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
       }
     }]
     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>
+    [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>
@@ -139,9 +142,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
     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>
+    [safe_fee]: <Payment Forwarding Fee Rounded Up Tokens Number>
+    safe_tokens: <Payment Tokens Sent to Destination Rounded Up Number>
+    [secret]: <Payment Preimage Hex String>
     tokens: <Rounded Down Tokens Sent to Destination Number>
   }
 */
@@ -186,13 +189,46 @@ module.exports = payment => {
     throw new Error('ExpectedPaymentValueInRpcPaymentDetails');
   }
 
+  const creationDateEpochMs = (() => {
+    // Exit early when creation time nanoseconds is not defined
+    if (payment.creation_time_ns === Number().toString()) {
+      return Number(payment.creation_date) * msPerSecond;
+    }
+
+    return Number(BigInt(payment.creation_time_ns) / nanoSecsPerMillisecond);
+  })();
+
   const attempts = payment.htlcs.map(htlc => rpcAttemptHtlcAsAttempt(htlc));
+  const index = Number(payment.payment_index) || undefined;
+  const request = payment.payment_request || undefined;
+
+  // Exit early when there were no attempts
+  if (!attempts.length) {
+    const {destination} = !!request ? parsePaymentRequest({request}) : {};
 
-  if (!payment.path.length && !attempts.length) {
-    throw new Error('ExpectedAttemptInPaymentDetails');
+    return {
+      attempts,
+      destination,
+      index,
+      request,
+      confirmed_at: undefined,
+      created_at: new Date(creationDateEpochMs).toISOString(),
+      fee: undefined,
+      fee_mtokens: undefined,
+      hops: [],
+      id: payment.payment_hash,
+      is_confirmed: false,
+      is_outgoing: true,
+      mtokens: payment.value_msat,
+      safe_fee: undefined,
+      safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
+      secret: undefined,
+      tokens: safeTokens({mtokens: payment.value_msat}).tokens,
+    };
   }
 
   const hasPath = !!payment.path.length;
+  const hasPreimage = payment.payment_preimage !== emptyHash;
   const [attempt] = attempts;
   const successes = attempts.filter(n => n.is_confirmed);
 
@@ -201,32 +237,46 @@ module.exports = payment => {
 
   const [destination, ...hops] = path.reverse();
 
-  const creationDateEpochMs = (() => {
-    // Exit early when creation time nanoseconds is not defined
-    if (payment.creation_time_ns === Number().toString()) {
-      return Number(payment.creation_date) * msPerSecond;
-    }
-
-    return Number(BigInt(payment.creation_time_ns) / nanoSecsPerMillisecond);
-  })();
+  // Exit early when the payment was never settled
+  if (!hasPreimage) {
+    return {
+      attempts,
+      destination,
+      index,
+      request,
+      confirmed_at: undefined,
+      created_at: new Date(creationDateEpochMs).toISOString(),
+      fee: undefined,
+      fee_mtokens: undefined,
+      hops: hops.reverse(),
+      id: payment.payment_hash,
+      is_confirmed: false,
+      is_outgoing: true,
+      mtokens: payment.value_msat,
+      safe_fee: undefined,
+      safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
+      secret: undefined,
+      tokens: safeTokens({mtokens: payment.value_msat}).tokens,
+    };
+  }
 
   return {
+    attempts,
     destination,
-    attempts: payment.htlcs.map(htlc => rpcAttemptHtlcAsAttempt(htlc)),
+    index,
+    request,
     confirmed_at: confirmedAt || undefined,
     created_at: new Date(creationDateEpochMs).toISOString(),
     fee: safeTokens({mtokens: payment.fee_msat}).tokens,
     fee_mtokens: payment.fee_msat,
     hops: hops.reverse(),
     id: payment.payment_hash,
-    index: Number(payment.payment_index) || undefined,
-    is_confirmed: payment.value_msat !== Number().toString(),
+    is_confirmed: true,
     is_outgoing: true,
     mtokens: payment.value_msat,
-    request: payment.payment_request || undefined,
-    secret: payment.payment_preimage,
     safe_fee: safeTokens({mtokens: payment.fee_msat}).safe,
     safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
+    secret: payment.payment_preimage,
     tokens: safeTokens({mtokens: payment.value_msat}).tokens,
   };
 };

package/package.json

@@ -10,7 +10,7 @@
     "@grpc/grpc-js": "1.3.7",
     "@grpc/proto-loader": "0.6.5",
     "@types/express": "4.17.13",
-    "@types/node": "16.10.2",
+    "@types/node": "16.10.3",
     "@types/request": "2.48.7",
     "@types/ws": "8.2.0",
     "async": "3.2.1",
@@ -49,12 +49,12 @@
     "url": "https://github.com/alexbosworth/lightning.git"
   },
   "scripts": {
-    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 120 test/arrays/*.js test/bolt00/*.js test/bolt02/*.js test/grpc/*.js test/lnd_gateway/*.js test/lnd_grpc/*.js test/lnd_methods/address/*.js test/lnd_methods/generic/*.js test/lnd_methods/info/*.js test/lnd_methods/invoices/*.js test/lnd_methods/macaroon/*.js test/lnd_methods/message/*.js test/lnd_methods/offchain/*.js test/lnd_methods/onchain/*.js test/lnd_methods/peers/*.js test/lnd_methods/signer/*.js test/lnd_methods/unauthenticated/*.js test/lnd_requests/*.js test/lnd_responses/*.js && npm run test:types",
+    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 120 test/arrays/*.js test/bolt00/*.js test/bolt02/*.js test/grpc/*.js test/lnd_gateway/*.js test/lnd_grpc/*.js test/lnd_messages/*.js test/lnd_methods/address/*.js test/lnd_methods/generic/*.js test/lnd_methods/info/*.js test/lnd_methods/invoices/*.js test/lnd_methods/macaroon/*.js test/lnd_methods/message/*.js test/lnd_methods/offchain/*.js test/lnd_methods/onchain/*.js test/lnd_methods/peers/*.js test/lnd_methods/signer/*.js test/lnd_methods/unauthenticated/*.js test/lnd_requests/*.js test/lnd_responses/*.js && npm run test:types",
     "test:types": "tsd"
   },
   "tsd": {
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "4.10.1"
+  "version": "4.10.5"
 }

package/test/lnd_messages/test_close_channel_request.js

@@ -0,0 +1,72 @@
+const {test} = require('@alexbosworth/tap');
+
+const {closeChannelRequest} = require('./../../lnd_messages');
+
+const makeArgs = overrides => {
+  const args = {
+    channel_point: {
+      funding_txid_bytes: Buffer.from('010203', 'hex'),
+      output_index: 0,
+    },
+    delivery_address: 'delivery_address',
+    force: true,
+    sat_per_byte: '1',
+    target_conf: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const args = {
+    address: 'delivery_address',
+    is_force_close: true,
+    target_confirmations: 1,
+    tokens_per_vbyte: 1,
+    transaction_id: '030201',
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Close request is converted to close request details',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      delivery_address: '',
+      force: false,
+      sat_per_byte: '0',
+      target_conf: 0,
+    }),
+    description: 'Defaults are selected',
+    expected: makeExpected({
+      address: undefined,
+      is_force_close: undefined,
+      target_confirmations: undefined,
+      tokens_per_vbyte: undefined,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, equal, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => closeChannelRequest(args), new Error(error), 'Got error');
+    } else {
+      const res = closeChannelRequest(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_messages/test_open_channel_request.js

@@ -0,0 +1,87 @@
+const {test} = require('@alexbosworth/tap');
+
+const {openChannelRequest} = require('./../../lnd_messages');
+
+const makeArgs = overrides => {
+  const args = {
+    close_address: 'close_address',
+    local_funding_amount: '1',
+    min_htlc_msat: '1',
+    node_pubkey: Buffer.alloc(33, 3),
+    node_pubkey_string: Buffer.alloc(33, 3).toString('hex'),
+    private: false,
+    push_sat: '1',
+    remote_csv_delay: 1,
+    sat_per_byte: '1',
+    sat_per_vbyte: '1',
+    spend_unconfirmed: true,
+    target_conf: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const args = {
+    chain_fee_tokens_per_vbyte: 1,
+    cooperative_close_address: 'close_address',
+    give_tokens: 1,
+    is_private: undefined,
+    local_tokens: 1,
+    min_confirmations: 0,
+    min_htlc_mtokens: '1',
+    partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+    partner_csv_delay: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Open request is converted to open request details',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      close_address: undefined,
+      min_htlc_msat: '0',
+      node_pubkey: Buffer.alloc(0),
+      private: true,
+      push_sat: '0',
+      remote_csv_delay: 0,
+      sat_per_byte: '0',
+      sat_per_vbyte: '0',
+      spend_unconfirmed: false,
+    }),
+    description: 'Defaults are selected',
+    expected: makeExpected({
+      chain_fee_tokens_per_vbyte: undefined,
+      cooperative_close_address: undefined,
+      give_tokens: undefined,
+      is_private: true,
+      min_confirmations: undefined,
+      min_htlc_mtokens: undefined,
+      partner_csv_delay: undefined,
+    }),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, equal, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => openChannelRequest(args), new Error(error), 'Got error');
+    } else {
+      const res = openChannelRequest(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_messages/test_pay_via_route_request.js

@@ -0,0 +1,79 @@
+const {test} = require('@alexbosworth/tap');
+
+const {payViaRouteRequest} = require('./../../lnd_messages');
+
+const makeArgs = overrides => {
+  const args = {
+    payment_hash: Buffer.alloc(32),
+    route: {
+      hops: [{
+        amt_to_forward_msat: '1',
+        chan_id: '1',
+        chan_capacity: 1,
+        custom_records: {},
+        expiry: 1,
+        pub_key: Buffer.alloc(33, 3).toString('hex'),
+        fee_msat: '1',
+        tlv_payload: true,
+      }],
+      total_amt_msat: '1',
+      total_fees_msat: '1',
+      total_time_lock: 1,
+    },
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const args = {
+    id: Buffer.alloc(32).toString('hex'),
+    route: {
+      fee: 0,
+      fee_mtokens: '1',
+      hops: [{
+        channel: '0x0x1',
+        channel_capacity: 1,
+        fee: 0,
+        fee_mtokens: '1',
+        forward: 0,
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 3).toString('hex'),
+        timeout: 1,
+      }],
+      mtokens: '1',
+      payment: undefined,
+      timeout: 1,
+      tokens: 0,
+      total_mtokens: undefined,
+    },
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Pay via route request is converted to pay details',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, equal, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => payViaRouteRequest(args), new Error(error), 'Got error');
+    } else {
+      const res = payViaRouteRequest(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/macaroon/test_accept_rpc_request.js

@@ -0,0 +1,37 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../../lnd_methods/macaroon/accept_rpc_request');
+
+const tests = [
+  {
+    args: {},
+    description: 'A request id is required to accept an RPC request',
+    error: [400, 'ExpectedRequestIdToAcceptRpcRequest'],
+  },
+  {
+    args: {id: 1},
+    description: 'A subscription is required to accept an RPC request',
+    error: [400, 'ExpectedRpcSubscriptionToAcceptRpcRequest'],
+  },
+  {
+    args: {id: 1, subscription: {write: ({}, cbk) => cbk('err')}},
+    description: 'Request error passed back',
+    error: [503, 'UnexpectedErrorAcceptingRpcRequest', {err: 'err'}],
+  },
+  {
+    args: {id: 1, subscription: {write: ({}, cbk) => cbk()}},
+    description: 'Request accepted',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, equal, rejects}) => {
+    if (!!error) {
+      await rejects(() => method(args), error, 'Got expected error');
+    } else {
+      await method(args);
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/macaroon/test_handle_rpc_request_update.js

@@ -0,0 +1,237 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../../lnd_methods/macaroon/handle_rpc_request_update');
+
+const tests = [
+  {
+    args: {
+      is_intercepting_close_channel_requests: true,
+      lnd: {
+        default: {
+          CloseChannel: {
+            requestDeserialize: () => ({
+              channel_point: {
+                funding_txid_bytes: Buffer.from('010203', 'hex'),
+                output_index: 0,
+              },
+              delivery_address: 'delivery_address',
+              force: true,
+              sat_per_byte: '1',
+              target_conf: 1,
+            }),
+          },
+        },
+      },
+      subscription: {},
+      update: {
+        request_id: '1',
+        raw_macaroon: Buffer.alloc(0),
+        custom_caveat_condition: '',
+        request: {
+          method_full_uri: '/lnrpc.Lightning/CloseChannel',
+          serialized: Buffer.alloc(0),
+          stream_rpc: false,
+          type_name: '',
+        },
+        intercept_type: 'request',
+      },
+    },
+    description: 'A RPC request update is handled',
+    expected: {
+      data: {
+        id: 1,
+        macaroon: undefined,
+        request: {
+          address: 'delivery_address',
+          is_force_close: true,
+          target_confirmations: 1,
+          tokens_per_vbyte: 1,
+          transaction_id: '030201',
+          transaction_vout: 0,
+        },
+        uri: '/lnrpc.Lightning/CloseChannel',
+      },
+      event: 'close_channel_request',
+    },
+  },
+  {
+    args: {
+      is_intercepting_open_channel_requests: true,
+      lnd: {
+        default: {
+          OpenChannel: {
+            requestDeserialize: () => ({
+              close_address: 'close_address',
+              local_funding_amount: '1',
+              min_htlc_msat: '1',
+              node_pubkey: Buffer.alloc(33, 3),
+              node_pubkey_string: Buffer.alloc(33, 3).toString('hex'),
+              private: false,
+              push_sat: '1',
+              remote_csv_delay: 1,
+              sat_per_byte: '1',
+              sat_per_vbyte: '1',
+              spend_unconfirmed: true,
+              target_conf: 1,
+            }),
+          },
+        },
+      },
+      subscription: {},
+      update: {
+        request_id: '1',
+        raw_macaroon: Buffer.alloc(0),
+        custom_caveat_condition: '',
+        request: {
+          method_full_uri: '/lnrpc.Lightning/OpenChannel',
+          serialized: Buffer.alloc(0),
+          stream_rpc: false,
+          type_name: '',
+        },
+        intercept_type: 'request',
+      },
+    },
+    description: 'A RPC request update is handled',
+    expected: {
+      data: {
+        id: 1,
+        macaroon: undefined,
+        request: {
+          chain_fee_tokens_per_vbyte: 1,
+          cooperative_close_address: 'close_address',
+          give_tokens: 1,
+          is_private: undefined,
+          local_tokens: 1,
+          min_confirmations: 0,
+          min_htlc_mtokens: '1',
+          partner_public_key: Buffer.alloc(33, 3).toString('hex'),
+          partner_csv_delay: 1,
+        },
+        uri: '/lnrpc.Lightning/OpenChannel',
+      },
+      event: 'open_channel_request',
+    },
+  },
+  {
+    args: {
+      is_intercepting_pay_via_routes_requests: true,
+      lnd: {
+        router: {
+          SendToRouteV2: {
+            requestDeserialize: () => ({
+              payment_hash: Buffer.alloc(32),
+              route: {
+                hops: [{
+                  amt_to_forward_msat: '1',
+                  chan_id: '1',
+                  chan_capacity: 1,
+                  custom_records: {},
+                  expiry: 1,
+                  pub_key: Buffer.alloc(33, 3).toString('hex'),
+                  fee_msat: '1',
+                  tlv_payload: true,
+                }],
+                total_amt_msat: '1',
+                total_fees_msat: '1',
+                total_time_lock: 1,
+              },
+            }),
+          },
+        },
+      },
+      subscription: {},
+      update: {
+        request_id: '1',
+        raw_macaroon: Buffer.alloc(0),
+        custom_caveat_condition: '',
+        request: {
+          method_full_uri: '/routerrpc.Router/SendToRouteV2',
+          serialized: Buffer.alloc(0),
+          stream_rpc: false,
+          type_name: '',
+        },
+        intercept_type: 'request',
+      },
+    },
+    description: 'A RPC request update is handled',
+    expected: {
+      data: {
+        id: 1,
+        macaroon: undefined,
+        request: {
+          id: Buffer.alloc(32).toString('hex'),
+          route: {
+            fee: 0,
+            fee_mtokens: '1',
+            hops: [{
+              channel: '0x0x1',
+              channel_capacity: 1,
+              fee: 0,
+              fee_mtokens: '1',
+              forward: 0,
+              forward_mtokens: '1',
+              public_key: Buffer.alloc(33, 3).toString('hex'),
+              timeout: 1,
+            }],
+            mtokens: '1',
+            payment: undefined,
+            timeout: 1,
+            tokens: 0,
+            total_mtokens: undefined,
+          },
+        },
+        uri: '/routerrpc.Router/SendToRouteV2',
+      },
+      event: 'pay_via_route_request',
+    },
+  },
+  {
+    args: {
+      subscription: {},
+      update: {
+        request_id: '1',
+        raw_macaroon: Buffer.alloc(0),
+        custom_caveat_condition: '',
+        stream_auth: {method_full_uri: 'method_full_uri'},
+        intercept_type: 'stream_auth',
+      },
+    },
+    description: 'A RPC request update is handled',
+    expected: {
+      data: {
+        id: 1,
+        macaroon: undefined,
+        uri: 'method_full_uri',
+      },
+      event: 'request',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => method(args), new Error(error), 'Got expected error');
+    } else {
+      const res = method(args);
+
+      const {accept, id, macaroon, reject, request, uri} = res.data;
+
+      if (!!accept) {
+        try { await accept({}); } catch (err) {}
+      }
+
+      if (!!reject) {
+        try { await reject({}); } catch (err) {}
+      }
+
+      strictSame(id, expected.data.id, 'Got expected id');
+      strictSame(res.event, expected.event, 'Got expected event');
+      strictSame(macaroon, expected.data.macaroon, 'Got expected macaroon');
+      strictSame(request, expected.data.request, 'Got expected request');
+      strictSame(uri, expected.data.uri, 'Got expected uri');
+    }
+
+    return end();
+  });
+});