lightning 4.10.7 → 4.12.1

package/test/lnd_methods/offchain/test_subscribe_to_peer_messages.js

@@ -0,0 +1,132 @@
+const EventEmitter = require('events');
+
+const {test} = require('@alexbosworth/tap');
+
+const {subscribeToPeerMessages} = require('./../../../lnd_methods');
+
+const makeLnd = overrides => {
+  const data = {
+    data: Buffer.alloc(1),
+    peer: Buffer.alloc(33, 3),
+    type: 44444,
+  };
+
+  Object.keys(overrides).forEach(k => data[k] = overrides[k]);
+
+  return {
+    default: {
+      SubscribeCustomMessages: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        if (overrides.data === undefined) {
+          process.nextTick(() => emitter.emit('data', data));
+        } else {
+          process.nextTick(() => emitter.emit('data', overrides.data));
+        }
+
+        return emitter;
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {
+      lnd: {
+        default: {
+          SubscribeCustomMessages: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('end'));
+            process.nextTick(() => emitter.emit('status'));
+            process.nextTick(() => emitter.emit('error', 'err'));
+
+            return emitter;
+          },
+        },
+      },
+    },
+    description: 'Errors are returned',
+    error: 'err',
+  },
+  {
+    args: {
+      lnd: {
+        default: {
+          SubscribeCustomMessages: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('error', {
+              details: 'Cancelled on client',
+            }));
+
+            return emitter;
+          },
+        },
+      },
+    },
+    description: 'Errors are returned',
+    error: {details: 'Cancelled on client'},
+  },
+  {
+    args: {lnd: makeLnd({peer: null})},
+    description: 'A peer is expected',
+    error: [503, 'ExpectedPeerPublicKeyBytesToDerivePeerMessage'],
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Peer message event emitted',
+    expected: {
+      message: '00',
+      public_key: Buffer.alloc(33, 3).toString('hex'),
+      type: 44444,
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, equal, strictSame, throws}) => {
+    try {
+      subscribeToPeerMessages({});
+    } catch (err) {
+      strictSame(
+        err,
+        new Error('ExpectedLndToSubscribeToPeerMessages'), 'Needs lnd');
+    }
+
+    const sub = subscribeToPeerMessages(args);
+
+    if (!!error) {
+      sub.once('error', err => {
+        strictSame(err, error, 'Got expected error');
+
+        subscribeToPeerMessages(args);
+
+        process.nextTick(() => {
+          sub.removeAllListeners();
+
+          return end();
+        });
+      });
+    } else {
+      if (!expected) {
+        return end();
+      }
+
+      sub.once('message_received', message => {
+        strictSame(message, expected, 'Got message received');
+
+        return end();
+      });
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_subscribe_to_probe_for_route.js

@@ -4,6 +4,8 @@ const {getInfoResponse} = require('./../fixtures');
 const {queryRoutesResponse} = require('./../fixtures');
 const {subscribeToProbeForRoute} = require('./../../../');
 
+const deletePayment = ({}, cbk) => cbk();
+
 const expectedRoute = {
   confidence: 1000000,
   fee: 0,
@@ -41,6 +43,7 @@ const makeLnd = ({count, getInfo, sendToRouteV2}) => {
 
   const lnd = {
     default: {
+      deletePayment,
       getInfo: getInfo || (({}, cbk) => cbk(null, getInfoResponse)),
       queryRoutes: ({}, cbk) => {
         if (returnedRoutes === (count || 1)) {

package/test/lnd_responses/test_rpc_peer_message_as_message.js

@@ -0,0 +1,67 @@
+const {test} = require('@alexbosworth/tap');
+
+const {rpcPeerMessageAsMessage} = require('./../../lnd_responses');
+
+const makeArgs = overrides => {
+  const response = {
+    data: Buffer.alloc(1),
+    peer: Buffer.alloc(33, 3),
+    type: 44444,
+  };
+
+  Object.keys(overrides || {}).forEach(key => response[key] = overrides[key]);
+
+  return response;
+};
+
+
+const makeExpected = overrides => {
+  const expected = {
+    message: '00',
+    public_key: '030303030303030303030303030303030303030303030303030303030303030303',
+    type: 44444,
+  };
+
+  Object.keys(overrides || {}).forEach(key => expected[key] = overrides[key]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    description: 'RPC peer message is expected',
+    error: 'ExpectedRpcMessageToDerivePeerMessage',
+  },
+  {
+    args: makeArgs({data: undefined}),
+    description: 'data is expected',
+    error: 'ExpectedPeerMessageDataToDerivePeerMessage',
+  },
+  {
+    args: makeArgs({peer: undefined}),
+    description: 'peer public key is expected',
+    error: 'ExpectedPeerPublicKeyBytesToDerivePeerMessage',
+  },
+  {
+    args: makeArgs({type: undefined}),
+    description: 'type is expected',
+    error: 'ExpectedCustomMessageTypeNumberToDeriveMessage',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC peer message is mapped to message',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => rpcPeerMessageAsMessage(args), new Error(error), 'Got err');
+    } else {
+      strictSame(rpcPeerMessageAsMessage(args), expected, 'Mapped to message');
+    }
+
+    return end();
+  });
+});

package/test/protos/protos.json

@@ -1,10 +1,10 @@
 {
   "overrides": [
-    ["lightning", 1168],
-    ["lightning", 1174],
-    ["lightning", 1182],
-    ["lightning", 1189],
-    ["lightning", 3378],
+    ["lightning", 1212],
+    ["lightning", 1218],
+    ["lightning", 1226],
+    ["lightning", 1233],
+    ["lightning", 3431],
     ["router", 100],
     ["walletkit", 3],
     ["walletunlocker", 2]

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

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

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

@@ -0,0 +1,46 @@
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {
+  subscribeToRpcRequests,
+  SubscribeToRpcRequestsResult,
+} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+const id = 'id';
+const is_intercepting_close_channel_requests = true;
+const is_intercepting_open_channel_requests = true;
+const is_intercepting_pay_via_routes_requests = true;
+
+expectError(subscribeToRpcRequests());
+expectError(subscribeToRpcRequests({}));
+
+expectType<SubscribeToRpcRequestsResult>(await subscribeToRpcRequests({lnd}));
+expectType<SubscribeToRpcRequestsResult>(
+  await subscribeToRpcRequests({
+    lnd,
+    id,
+    is_intercepting_close_channel_requests,
+    is_intercepting_open_channel_requests,
+    is_intercepting_pay_via_routes_requests,
+  })
+);
+
+expectType<void>(
+  subscribeToRpcRequests({lnd}, (err, res) => {
+    expectType<SubscribeToRpcRequestsResult>(res);
+  })
+);
+expectType<void>(
+  subscribeToRpcRequests(
+    {
+      lnd,
+      id,
+      is_intercepting_close_channel_requests,
+      is_intercepting_open_channel_requests,
+      is_intercepting_pay_via_routes_requests,
+    },
+    (err, res) => {
+      expectType<SubscribeToRpcRequestsResult>(res);
+    }
+  )
+);