lightning 4.10.1 → 4.10.5

package/test/lnd_methods/macaroon/test_reject_rpc_request.js

@@ -0,0 +1,41 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../../lnd_methods/macaroon/reject_rpc_request');
+
+const tests = [
+  {
+    args: {},
+    description: 'A request id is required to reject an RPC request',
+    error: [400, 'ExpectedRequestIdToRejectRpcRequest'],
+  },
+  {
+    args: {id: 1},
+    description: 'A subscription is required to reject an RPC request',
+    error: [400, 'ExpectedRpcSubscriptionToRejectRpcRequest'],
+  },
+  {
+    args: {id: 1, subscription: {write: ({}, cbk) => cbk('err')}},
+    description: 'Request error passed back',
+    error: [503, 'UnexpectedErrorRejectingRpcRequest', {err: 'err'}],
+  },
+  {
+    args: {id: 1, subscription: {write: ({}, cbk) => cbk()}},
+    description: 'Request accepted',
+  },
+  {
+    args: {id: 1, message: 'msg', subscription: {write: ({}, cbk) => cbk()}},
+    description: 'Request accepted with message',
+  },
+];
+
+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_subscribe_to_rpc_requests.js

@@ -0,0 +1,242 @@
+const EventEmitter = require('events');
+const {promisify} = require('util');
+
+const {test} = require('@alexbosworth/tap');
+
+const nextTick = promisify(process.nextTick);
+const {subscribeToRpcRequests} = require('./../../../lnd_methods');
+
+const makeArgs = overrides => {
+  const args = {
+    lnd: {
+      default: {
+        RegisterRPCMiddleware: ({}) => {
+          const emitter = new EventEmitter();
+
+          emitter.cancel = () => {};
+          emitter.write = ({}, cbk) => cbk();
+
+          process.nextTick(() => {
+            emitter.emit('data', {
+              request_id: '1',
+              raw_macaroon: Buffer.alloc(0),
+              custom_caveat_condition: '',
+              stream_auth: {method_full_uri: 'method_full_uri'},
+              intercept_type: 'stream_auth',
+            });
+
+            emitter.emit('data', {});
+
+            emitter.emit('status', {status: 'status'});
+            emitter.emit('end', {});
+            emitter.emit('error', {details: 'Cancelled on client'});
+          });
+
+          return emitter;
+        },
+      },
+    },
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({id: '1234'}),
+    description: 'A long id is required to subscribe to RPC requests',
+    error: [400, 'ExpectedLongerIdLengthToSpecifyMiddlewareName'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required to subscribe to rpc requests',
+    error: [400, 'ExpectedLndToSubscribeToRpcRequests'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          RegisterRPCMiddleware: ({}) => ({
+            on: (event, cbk) => {},
+            write: ({}, cbk) => cbk('err'),
+          }),
+        },
+      },
+    }),
+    description: 'RPC write errors are passed back',
+    error: [503, 'UnexpectedErrInterceptingRpcRequests', {err: 'err'}],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          RegisterRPCMiddleware: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+            emitter.write = (args, cbk) => {
+              if (!!args.feedback) {
+                return cbk('err');
+              }
+
+              return cbk();
+            };
+
+            process.nextTick(() => {
+              emitter.emit('data', {
+                request_id: '1',
+                raw_macaroon: Buffer.alloc(0),
+                custom_caveat_condition: '',
+                stream_auth: {method_full_uri: 'method_full_uri'},
+                intercept_type: 'stream_auth',
+              });
+            });
+
+            return emitter;
+          },
+        },
+      },
+    }),
+    description: 'RPC write errors are passed back',
+    expected: {
+      events: [
+        {id: 1, macaroon: undefined, uri: 'method_full_uri'},
+        [503, 'UnexpectedErrorAcceptingRpcRequest', {err: 'err'}],
+      ],
+    },
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC request subscription is returned',
+    expected: {
+      events: [
+        {id: 1, macaroon: undefined, uri: 'method_full_uri'},
+        [503, 'ExpectedCustomCaveatConditionInRpcRequestUpdate'],
+        {details: 'Cancelled on client'},
+      ],
+    },
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          RegisterRPCMiddleware: ({}) => ({
+            on: (event, cbk) => {},
+            write: ({}, cbk) => cbk('err'),
+          }),
+        },
+      },
+    }),
+    description: 'RPC write errors are passed back',
+    error: [503, 'UnexpectedErrInterceptingRpcRequests', {err: 'err'}],
+  },
+  {
+    args: makeArgs({
+      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,
+            }),
+          },
+          RegisterRPCMiddleware: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+            emitter.write = ({}, cbk) => cbk();
+
+            process.nextTick(() => {
+              emitter.emit('data', {
+                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',
+              });
+            });
+
+            return emitter;
+          },
+        },
+      },
+    }),
+    description: 'An open channel request is intercepted',
+    expected: {
+      events: [],
+      intercepts: [{
+        accept: true,
+        id: 1,
+        macaroon: undefined,
+        reject: true,
+        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: '030303030303030303030303030303030303030303030303030303030303030303',
+          partner_csv_delay: 1,
+        },
+        uri: '/lnrpc.Lightning/OpenChannel',
+      }],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(() => subscribeToRpcRequests(args), error, 'Got err');
+    } else {
+      const events = [];
+      const intercepts = [];
+      const res = await subscribeToRpcRequests(args);
+
+      res.subscription.on('error', event => events.push(event));
+      res.subscription.on('request', event => events.push(event));
+
+      res.subscription.on('open_channel_request', openRequest => {
+        return intercepts.push({
+          accept: !!openRequest.accept,
+          id: openRequest.id,
+          macaroon: openRequest.macaroon,
+          reject: !!openRequest.reject,
+          uri: openRequest.uri,
+          request: openRequest.request,
+        });
+      });
+
+      await nextTick();
+
+      if (!!expected.intercepts) {
+        strictSame(intercepts, expected.intercepts, 'Got expected intercepts');
+      }
+
+      strictSame(events, expected.events, 'Got expected events');
+      strictSame(!!res.subscription, true, 'Got subscription');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/macaroon/test_uris_for_method.js

@@ -9,6 +9,16 @@ const tests = [
     description: 'A method is required',
     error: 'ExpectedMethodNameToDeriveMacaroonUris',
   },
+  {
+    args: {method: 'unknown'},
+    description: 'A known method is required',
+    error: 'ExpectedKnownMethodNameToDeriveMacaroonUris',
+  },
+  {
+    args: {method: 'getPayment'},
+    description: 'Router server URI is returned',
+    expected: {uris: ['/routerrpc.Router/TrackPaymentV2']},
+  },
   {
     args: {method: 'grantAccess'},
     description: 'Method URI is returned',

package/test/lnd_methods/offchain/test_get_failed_payments.js

@@ -0,0 +1,160 @@
+const {test} = require('@alexbosworth/tap');
+
+const {getPayments} = 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: 'FAILED',
+          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, 'UnexpectedLimitWhenPagingPaymentsWithToken'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedLndForGetPaymentsRequest'],
+  },
+  {
+    args: makeArgs({token: 'token'}),
+    description: 'A valid token is required',
+    error: [400, 'ExpectedValidPagingTokenForPaymentReq'],
+  },
+  {
+    args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk('err')}}}),
+    description: 'Errors from LND are passed back',
+    error: [503, 'UnexpectedGetPaymentsError', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: {default: {listPayments: ({}, cbk) => cbk()}}}),
+    description: 'A response is expected from LND',
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
+  },
+  {
+    args: makeArgs({
+      lnd: {default: {listPayments: ({}, cbk) => cbk(null, {})}},
+    }),
+    description: 'A response with payments is expected from LND',
+    error: [503, 'ExpectedPaymentsInListPaymentsResponse'],
+  },
+  {
+    args: makeArgs({
+      lnd: {default: {listPayments: ({}, cbk) => cbk(null, {payments: []})}},
+    }),
+    description: 'A response with payments and last index is expected',
+    error: [503, 'ExpectedLastIndexOffsetWhenRequestingPayments'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        default: {
+          listPayments: ({}, cbk) => cbk(null, {
+            last_index_offset: '1',
+            payments: [{}],
+          }),
+        },
+      },
+    }),
+    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(() => getPayments(args), error, 'Got expected error');
+    } else {
+      const {payments} = await getPayments(args);
+
+      const [payment] = payments;
+
+      strictSame(payment, expected.payment, 'Got expected payment');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/offchain/test_get_payments.js

@@ -39,7 +39,7 @@ const makeLnd = args => {
           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_preimage: Buffer.alloc(32, 1).toString('hex'),
           payment_request: '',
           status: 'SETTLED',
           value: '1',
@@ -99,7 +99,7 @@ const makeExpectedPayment = ({}) => {
     is_outgoing: true,
     mtokens: '1000',
     request: undefined,
-    secret: '0000000000000000000000000000000000000000000000000000000000000000',
+    secret: Buffer.alloc(32, 1).toString('hex'),
     safe_fee: 1,
     safe_tokens: 1,
     tokens: 1,

package/test/lnd_methods/onchain/test_close_channel.js

@@ -44,7 +44,6 @@ const makeLnd = ({err, data}) => {
           }
         });
 
-
         return emitter;
       },
       connectPeer: ({}, cbk) => cbk(null, {}),

package/test/lnd_responses/test_rpc_invoice_as_invoice.js

@@ -221,6 +221,40 @@ const tests = [
       request: undefined,
     }),
   },
+  {
+    args: makeInput({payment_addr: Buffer.alloc(32)}),
+    description: 'Empty payment address is not returned as a pay addr',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeInput({is_keysend: false}),
+    description: 'Non keysend is not push',
+    expected: makeExpected({is_push: undefined}),
+  },
+  {
+    args: makeInput({payment_addr: Buffer.alloc(32, 1)}),
+    description: 'Pay addr is returned as a payment id',
+    expected: makeExpected({
+      payment: '0101010101010101010101010101010101010101010101010101010101010101',
+    }),
+  },
+  {
+    args: makeInput({
+      fallback_addr: '',
+      description_hash: Buffer.alloc(0),
+      is_amp: true,
+      is_keysend: false,
+      payment_request: '',
+      settle_index: '0',
+    }),
+    description: 'Values are undefined',
+    expected: makeExpected({
+      chain_address: undefined,
+      confirmed_index: undefined,
+      description_hash: undefined,
+      request: undefined,
+    }),
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {

package/test/lnd_responses/test_rpc_payment_as_payment.js

@@ -57,9 +57,9 @@ const makeArgs = overrides => {
     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).toString('hex'),
+    payment_preimage: Buffer.alloc(32, 1).toString('hex'),
     payment_request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
-    status: 'FAILED',
+    status: 'SETTLED',
     value: '1',
     value_msat: '1000',
     value_sat: '1',
@@ -111,7 +111,7 @@ const makeExpected = overrides => {
     request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
     safe_fee: 1,
     safe_tokens: 1,
-    secret: Buffer.alloc(32).toString('hex'),
+    secret: Buffer.alloc(32, 1).toString('hex'),
     tokens: 1,
   };
 
@@ -141,11 +141,6 @@ const tests = [
     description: 'HTLC array is expected to be present',
     error: 'ExpectedHtlcsArrayInRpcPaymentDetails',
   },
-  {
-    args: makeArgs({htlcs: [], path: []}),
-    description: 'HTLC or path array is expected to be filled',
-    error: 'ExpectedAttemptInPaymentDetails',
-  },
   {
     args: makeArgs({path: undefined}),
     description: 'A path is expected to be present',
@@ -186,6 +181,46 @@ const tests = [
     description: 'A payment request is optional',
     expected: makeExpected({request: undefined}),
   },
+  {
+    args: makeArgs({htlcs: []}),
+    description: 'Attempts are optional',
+    expected: makeExpected({
+      attempts: [],
+      destination: '02212d3ec887188b284dbb7b2e6eb40629a6e14fb049673f22d2a0aa05f902090e',
+      fee: undefined,
+      fee_mtokens: undefined,
+      hops: [],
+      is_confirmed: false,
+      safe_fee: undefined,
+      secret: undefined,
+    }),
+  },
+  {
+    args: makeArgs({htlcs: [], payment_request: ''}),
+    description: 'Payment requests are optional when there are no attempts',
+    expected: makeExpected({
+      attempts: [],
+      destination: undefined,
+      fee: undefined,
+      fee_mtokens: undefined,
+      hops: [],
+      is_confirmed: false,
+      request: undefined,
+      safe_fee: undefined,
+      secret: undefined,
+    }),
+  },
+  {
+    args: makeArgs({payment_preimage: Buffer.alloc(32).toString('hex')}),
+    description: 'Empty preimage means not settled',
+    expected: makeExpected({
+      fee: undefined,
+      fee_mtokens: undefined,
+      is_confirmed: false,
+      safe_fee: undefined,
+      secret: undefined,
+    }),
+  },
   {
     args: makeArgs({
       creation_date: '1587410235',

package/test/protos/protos.json

@@ -1,10 +1,10 @@
 {
   "overrides": [
-    ["lightning", 1162],
     ["lightning", 1168],
-    ["lightning", 1176],
-    ["lightning", 1183],
-    ["lightning", 3358],
+    ["lightning", 1174],
+    ["lightning", 1182],
+    ["lightning", 1189],
+    ["lightning", 3378],
     ["router", 100],
     ["walletkit", 3],
     ["walletunlocker", 2]