astra-lightning 1.0.0

package/test/lnd_methods/macaroon/test_handle_rpc_request_update.js

@@ -0,0 +1,249 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+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_vbyte: '1',
+              target_conf: 1,
+            }),
+          },
+        },
+      },
+      subscription: {},
+      update: {
+        msg_id: '1',
+        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,
+          max_tokens_per_vbyte: undefined,
+          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: {
+        msg_id: '1',
+        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: {
+          base_fee_mtokens: undefined,
+          chain_fee_tokens_per_vbyte: 1,
+          cooperative_close_address: 'close_address',
+          description: undefined,
+          fee_rate: undefined,
+          give_tokens: 1,
+          is_max_funding: undefined,
+          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: {
+        msg_id: '1',
+        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: {
+        msg_id: '1',
+        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 () => {
+    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) {}
+      }
+
+      deepStrictEqual(id, expected.data.id, 'Got expected id');
+      deepStrictEqual(res.event, expected.event, 'Got expected event');
+      deepStrictEqual(macaroon, expected.data.macaroon, 'Got macaroon');
+      deepStrictEqual(request, expected.data.request, 'Got expected request');
+      deepStrictEqual(uri, expected.data.uri, 'Got expected uri');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/macaroon/test_reject_rpc_request.js

@@ -0,0 +1,42 @@
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+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 () => {
+    if (!!error) {
+      await rejects(() => method(args), error, 'Got expected error');
+    } else {
+      await method(args);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/macaroon/test_revoke_access.js

@@ -0,0 +1,82 @@
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {revokeAccess} = require('./../../../');
+
+const id = '1';
+
+const tests = [
+  {
+    args: {},
+    description: 'An id is required to revoke access',
+    error: [400, 'ExpectedPositiveMacaroonRootIdToRevoke'],
+  },
+  {
+    args: {id},
+    description: 'An LND Object is required to revoke access',
+    error: [400, 'ExpectedAuthenticatedLndApiObjectToRevokeAccess'],
+  },
+  {
+    args: {
+      id,
+      lnd: {default: {deleteMacaroonId: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Errors from the RPC are relayed',
+    error: [503, 'UnexpectedErrorFromRevokeMacaroon', {err: 'err'}],
+  },
+  {
+    args: {
+      id,
+      lnd: {
+        default: {
+          deleteMacaroonId: ({}, cbk) => cbk({
+            details: 'unknown method DeleteMacaroonID for service lnrpc.Lightning',
+          }),
+        },
+      },
+    },
+    description: 'Not supported is returned',
+    error: [501, 'RevokeAccessMethodNotSupported'],
+  },
+  {
+    args: {
+      id,
+      lnd: {default: {deleteMacaroonId: ({}, cbk) => cbk()}},
+    },
+    description: 'A response is expected',
+    error: [503, 'ExpectedResponseFromRevokeMacaroonRequest'],
+  },
+  {
+    args: {
+      id,
+      lnd: {default: {deleteMacaroonId: ({}, cbk) => cbk(null, {})}},
+    },
+    description: 'Deletion confirmation is expected',
+    error: [503, 'ExpectedDeletionConfirmationForRevokeMacaroon'],
+  },
+  {
+    args: {
+      id,
+      lnd: {
+        default: {
+          deleteMacaroonId: (args, cbk) => {
+            return cbk(null, {deleted: true});
+          },
+        },
+      },
+    },
+    description: 'Macaroon revoked',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => revokeAccess(args), error, 'Got expected error');
+    } else {
+      await revokeAccess(args);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/macaroon/test_subscribe_to_rpc_requests.js

@@ -0,0 +1,250 @@
+const EventEmitter = require('events');
+const {promisify} = require('util');
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+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', {
+              msg_id: '1',
+              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', {
+                msg_id: '1',
+                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: [
+        {call: 1, id: 1, macaroon: undefined, uri: 'method_full_uri'},
+        [503, 'UnexpectedErrorAcceptingRpcRequest', {err: 'err'}],
+      ],
+    },
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC request subscription is returned',
+    expected: {
+      events: [
+        {call: 1, 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', {
+                msg_id: '1',
+                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: {
+          base_fee_mtokens: undefined,
+          chain_fee_tokens_per_vbyte: 1,
+          cooperative_close_address: 'close_address',
+          description: undefined,
+          fee_rate: undefined,
+          give_tokens: 1,
+          is_max_funding: undefined,
+          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 () => {
+    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) {
+        deepStrictEqual(intercepts, expected.intercepts, 'Got intercepts');
+      }
+
+      deepStrictEqual(events, expected.events, 'Got expected events');
+      deepStrictEqual(!!res.subscription, true, 'Got subscription');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/macaroon/test_uris_for_method.js

@@ -0,0 +1,46 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const method = require('./../../../lnd_methods/macaroon/uris_for_method');
+const methods = require('./../../../lnd_methods/macaroon/methods');
+
+const tests = [
+  {
+    args: {},
+    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',
+    expected: {uris: ['/lnrpc.Lightning/BakeMacaroon']},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => method(args), new Error(error), 'Got expected error');
+    } else {
+      const res = method(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    // Run through all the methods to make sure they can be derived
+    Object.keys(methods).forEach(n => method({method: n}));
+
+    return end();
+  });
+});