lightning 9.13.4 → 10.0.0

package/lnd_gateway/grpc_router.d.ts

@@ -1,13 +0,0 @@
-import {Router} from 'express';
-
-export type Credentials = {
-  /** Base64 or Hex Serialized LND TLS Cert String */
-  cert?: string;
-  /** Host:Port Network Address String */
-  socket?: string;
-};
-
-/**
- * Get a gRPC gateway router
- */
-export function grpcRouter(credentials: Credentials): Router;

package/lnd_gateway/grpc_router.js

@@ -1,45 +0,0 @@
-const {raw} = require('body-parser');
-const {Router} = require('express');
-
-const bearerToken = require('./bearer_token');
-const decodeCborBody = require('./decode_cbor_body');
-const grpcResponse = require('./grpc_response');
-const handleErrors = require('./handle_errors');
-
-const caseSensitive = true;
-const cborType = 'application/cbor';
-const path = '/:service/:method';
-const strict = true;
-
-/** Get a gRPC gateway router
-
-  {
-    [cert]: <Base64 or Hex Serialized LND TLS Cert String>
-    [socket]: <Host:Port Network Address String>
-  }
-
-  @returns
-  <Router Object>
-*/
-module.exports = ({cert, socket}) => {
-  const credentials = {cert, socket};
-  const router = Router({caseSensitive, strict});
-
-  // Parse out the bearer token
-  router.use(bearerToken({}).middleware);
-
-  // Decode body into binary buffer
-  router.use(raw({type: cborType}));
-
-  // Decode CBOR binary body into object
-  router.use(decodeCborBody({}).middleware);
-
-  // Proxy CBOR arguments into an LND request
-  router.post(path, grpcResponse({credentials}).middleware);
-
-  // Handle any errors that pop up along the way
-  router.use(handleErrors({}).middleware);
-
-  return router;
-};
-

package/lnd_gateway/handle_errors.js

@@ -1,37 +0,0 @@
-const {isArray} = Array;
-const serverErrorCode = 500;
-
-/** Handle errors
-
-  {
-    err: <Error Object>
-    next: <Next Express Middleware Function>
-    res: {
-      headersSent: <Headers Already Sent Bool>
-      send: <Send Response Function>
-      status: <Set Status Function>
-    }
-  }
-
-  @returns
-  {
-    middleware: <Express Middleware Function>
-  }
-*/
-module.exports = ({}) => {
-  const middleware = (err, req, res, next) => {
-    if (res.headersSent) {
-      return next(err)
-    }
-
-    if (isArray(err)) {
-      const [statusCode] = err;
-
-      return res.status(statusCode || serverErrorCode) && res.send();
-    }
-
-    return res.status(serverErrorCode) && res.send();
-  };
-
-  return {middleware};
-};

package/lnd_gateway/index.d.ts

@@ -1,3 +0,0 @@
-export * from './emit_grpc_events';
-export * from './grpc_router';
-export * from './lnd_gateway';

package/lnd_gateway/index.js

@@ -1,5 +0,0 @@
-const emitGrpcEvents = require('./emit_grpc_events');
-const grpcRouter = require('./grpc_router');
-const lndGateway = require('./lnd_gateway');
-
-module.exports = {emitGrpcEvents, grpcRouter, lndGateway};

package/lnd_gateway/lnd_gateway.d.ts

@@ -1,37 +0,0 @@
-import * as request from 'request';
-import WebSocket = require('ws');
-import {AuthenticatedLnd} from '../lnd_grpc/authenticated_lnd_grpc';
-import {UnauthenticatedLnd} from '../lnd_grpc/unauthenticated_lnd_grpc';
-
-export type UnauthenticatedLndGatewayServer = {
-  /** Base64 or Hex Serialized Gateway TLS Cert String */
-  cert?: string;
-  /** Request Function */
-  request: (
-    options: request.Options,
-    callback: request.RequestCallback
-  ) => request.Request;
-  /** LND Gateway URL String */
-  url: string;
-  /** Websocket Constructor Function */
-  websocket: typeof WebSocket;
-};
-
-export type AuthenticatedLndGatewayServer = UnauthenticatedLndGatewayServer & {
-  /** Use Base 64 Encoded Macaroon String */
-  macaroon: string;
-};
-
-/**
- * Interface to an LND gateway server.
- */
-export function lndGateway(
-  server: AuthenticatedLndGatewayServer
-): {lnd: AuthenticatedLnd};
-
-/**
- * Interface to an LND gateway server.
- */
-export function lndGateway(
-  server: UnauthenticatedLndGatewayServer
-): {lnd: UnauthenticatedLnd};

package/lnd_gateway/lnd_gateway.js

@@ -1,118 +0,0 @@
-const {join} = require('path');
-
-const {loadPackageDefinition} = require('@grpc/grpc-js');
-const {loadSync} = require('@grpc/proto-loader');
-
-const gatewayRequest = require('./gateway_request');
-const gatewaySubscribe = require('./gateway_subscribe');
-const {packageTypes} = require('./../grpc');
-const {protoFiles} = require('./../grpc');
-const {protosDir} = require('./../grpc');
-const {serviceTypes} = require('./../grpc');
-const {unauthenticatedPackageTypes} = require('./../grpc');
-const {unauthenticatedServiceTypes} = require('./../grpc');
-
-const {keys} = Object;
-
-/** Interface to an LND gateway server.
-
-  {
-    [cert]: <Base64 or Hex Serialized Gateway TLS Cert String>
-    [macaroon]: <Use Base 64 Encoded Macaroon String>
-    request: <Request Function>
-    url: <LND Gateway URL String>
-    websocket: <Websocket Constructor Object>
-  }
-
-  @throws
-  <Error>
-
-  @returns
-  {
-    lnd: <LND gRPC Gateway Object>
-  }
-*/
-module.exports = ({cert, macaroon, request, url, websocket}) => {
-  if (!(request instanceof Function)) {
-    throw new Error('ExpectedRequestMethodForLndGateway');
-  }
-
-  if (!url) {
-    throw new Error('ExpectedUrlForLndGateway');
-  }
-
-  if (!websocket) {
-    throw new Error('ExpectedWebSocketConstructorForLndGateway');
-  }
-
-  const {services, types} = (() => {
-    const services = !macaroon ? unauthenticatedPackageTypes : packageTypes;
-    const types = !macaroon ? unauthenticatedServiceTypes : serviceTypes;
-
-    return {types, services: keys(services)};
-  })();
-
-  const servers = keys(types).reduce((sum, n) => {
-    sum[types[n]] = n;
-
-    return sum;
-  },
-  {});
-
-  const lnd = services.reduce((clients, service) => {
-    const protoFile = protoFiles[service];
-    const server = servers[service];
-
-    const protoPath = join(__dirname, protosDir, protoFile);
-
-    const rpc = loadPackageDefinition(loadSync(protoPath));
-
-    const packageService = rpc[packageTypes[service]][service];
-
-    const definitions = packageService.service;
-
-    const directResponseMethods = keys(definitions)
-      .filter(n => !definitions[n].requestStream)
-      .filter(n => !definitions[n].responseStream)
-      .map(n => definitions[n].originalName);
-
-    const streamingResponseMethods = keys(definitions)
-      .filter(n => !definitions[n].requestStream)
-      .filter(n => definitions[n].responseStream)
-      .map(n => definitions[n].originalName);
-
-    const streaming = streamingResponseMethods.reduce((client, method) => {
-      client[method] = (params, cbk) => {
-        return gatewaySubscribe({
-          url,
-          websocket,
-          bearer: macaroon,
-          call: {method, params, server},
-        });
-      }
-
-      return client;
-    },
-    {});
-
-    clients[server] = directResponseMethods.reduce((client, method) => {
-      client[method] = (params, cbk) => {
-        return gatewayRequest({
-          request,
-          url,
-          bearer: macaroon,
-          call: {method, params, server},
-        },
-        cbk);
-      };
-
-      return client;
-    },
-    streaming);
-
-    return clients;
-  },
-  {});
-
-  return {lnd};
-};

package/lnd_gateway/return_response.js

@@ -1,38 +0,0 @@
-const {encodeAsync} = require('cbor');
-const {decodeFirst} = require('cbor');
-
-const cborType = 'application/cbor';
-const serverErrorCode = 500;
-
-/** Return response
-
-  {
-    res: {
-      send: <Send Response Body Function>
-      status: <Set Response Status Code Function>
-      type: <Set Response Content Type Header Function>
-    }
-  }
-
-  @returns
-  {
-    responder: <Responder Function>
-  }
-*/
-module.exports = ({res}) => {
-  const responder = async (err, response) => {
-    if (!!err) {
-      return res.status(serverErrorCode) && res.send();
-    }
-
-    try {
-      const result = {err: response.err, res: response.res};
-
-      return res.type(cborType) && res.send(await encodeAsync(result));
-    } catch (err) {
-      return res.status(serverErrorCode) && res.send();
-    }
-  };
-
-  return {responder};
-};

package/lnd_gateway/subscribe_to_response.js

@@ -1,40 +0,0 @@
-const {encodeAsync} = require('cbor');
-
-/** Make a request to LND that returns subscription events
-
-  {
-    lnd: <LND API Object>
-    method: <LND Method Name String>
-    params: <Method Arguments Object>
-    server: <LND RPC Server Name String>
-    ws: {
-      on: <Websocket Attach Listener Function>
-      send: <Send Response Function>
-    }
-  }
-
-  @returns
-  {
-    cancel: <Cancel Request Function>
-  }
-*/
-module.exports = ({lnd, method, params, server, ws}) => {
-  const sub = lnd[server][method](params);
-
-  const sendResponse = async (ws, event, data) => {
-    return ws.send(await encodeAsync({data, event}));
-  };
-
-  sub.on('data', data => sendResponse(ws, 'data', data));
-  sub.on('end', () => sendResponse(ws, 'end'));
-  sub.on('status', s => sendResponse(ws, 'status', s));
-
-  sub.on('error', err => sendResponse(ws, 'error', {
-    details: err.details,
-    message: err.message,
-  }));
-
-  ws.on('close', () => sub.cancel());
-
-  return {cancel: () => sub.cancel()};
-};

package/lnd_gateway/ws_url.js

@@ -1,34 +0,0 @@
-const encryptedProtocol = 'https:';
-const encryptedWsProtocol = 'wss:';
-const plaintextProtocol = 'http:';
-const plaintextWsProtocol = 'ws:';
-
-/** Websocket URL for URL
-
-  {
-    url: <Gateway Server URL String>
-  }
-
-  @returns
-  {
-    url: <WebSocket URL String>
-  }
-*/
-module.exports = ({url}) => {
-  const remote = new URL(url);
-
-  switch (remote.protocol) {
-  case encryptedProtocol:
-    remote.protocol = encryptedWsProtocol;
-    break;
-
-  case plaintextProtocol:
-    remote.protocol = plaintextWsProtocol;
-    break;
-  
-  default:
-    break;
-  }
-
-  return {url: remote.toString()};
-};

package/test/lnd_gateway/test_bearer_token.js

@@ -1,31 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const bearerToken = require('./../../lnd_gateway/bearer_token');
-
-const tests = [
-  {
-    args: {},
-    description: 'Bearer token middleware skips when there is no auth',
-    expected: {locals: {}},
-  },
-  {
-    args: {header: 'Bearer macaroon'},
-    description: 'Bearer token middleware returns auth token',
-    expected: {locals: {auth: {bearer: 'macaroon'}}},
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const {middleware} = bearerToken({});
-    const res = {locals: {}};
-
-    return middleware({get: key => args.header}, res, () => {
-      deepStrictEqual(res.locals, expected.locals, 'Got expected locals');
-
-      return end();
-    });
-  });
-});

package/test/lnd_gateway/test_decode_cbor_body.js

@@ -1,37 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const test = require('node:test');
-const {throws} = require('node:assert').strict;
-
-const {encode} = require('cbor');
-
-const decodeCborBody = require('./../../lnd_gateway/decode_cbor_body');
-
-const tests = [
-  {
-    args: {body: Buffer.alloc(3)},
-    description: 'CBOR middleware expects CBOR encoded data',
-    error: [400, 'ExpectedCborRequestArgs'],
-  },
-  {
-    args: {body: encode({arguments: 'arguments'})},
-    description: 'CBOR middleware decodes cbor encoded data',
-    expected: {body: {arguments: 'arguments'}},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, (t, end) => {
-    const {middleware} = decodeCborBody({});
-    const req = {body: args.body};
-
-    return middleware(req, null, err => {
-      if (!!error) {
-        deepStrictEqual(err, error, 'Got expected error');
-      } else {
-        deepStrictEqual(req.body, expected.body, 'Got expected body');
-      }
-
-      return end();
-    });
-  });
-});

package/test/lnd_gateway/test_emit_event.js

@@ -1,51 +0,0 @@
-const EventEmitter = require('events');
-const {deepStrictEqual} = require('node:assert').strict;
-const {once} = require('events');
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const {encode} = require('cbor');
-
-const emitEvent = require('./../../lnd_gateway/emit_event');
-
-const all = promise => Promise.all(promise);
-
-const tests = [
-  {
-    args: {message: encode({event: 'event', data: 'data'})},
-    description: 'Emitter emits CBOR encoded event data',
-    expected: {event: 'event', emitted: 'data'},
-  },
-  {
-    args: {message: Buffer.alloc(3)},
-    description: 'Emitter emits error when CBOR is invalid',
-    error: new Error('FailedToDecodeGatewayResponse'),
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    const emitter = new EventEmitter();
-    const message = args.message;
-
-    const emit = new Promise((resolve, reject) => {
-      emitEvent({emitter, message});
-
-      return resolve();
-    });
-
-    const waitForError = new Promise((resolve, reject) => {
-      emitter.on('error', err => reject(err));
-    });
-
-    if (!!error) {
-      await rejects(all([emit, waitForError]), error, 'Got error');
-    } else {
-      const [, [emitted]] = await all([emit, once(emitter, expected.event)]);
-
-      deepStrictEqual(emitted, expected.emitted, 'Got expected emitted data');
-    }
-
-    return;
-  });
-});

package/test/lnd_gateway/test_emit_grpc_events.js

@@ -1,31 +0,0 @@
-const {equal} = require('node:assert').strict;
-const EventEmitter = require('events');
-const test = require('node:test');
-
-const {emitGrpcEvents} = require('./../../');
-
-const tests = [
-  {
-    args: {message: Buffer.alloc(3)},
-    description: 'Event is emitted',
-    expected: {
-      message: 'a26464617461a16764657461696c73781a457870656374656456616c696443626f7257734d657373616765656576656e74656572726f72',
-    },
-  },
-];
-
-tests.forEach(({args, description, expected}) => {
-  return test(description, (t, end) => {
-    const ws = new EventEmitter();
-
-    ws.send = message => {
-      equal(message.toString('hex'), expected.message, 'Got expected msg');
-
-      return end();
-    };
-
-    emitGrpcEvents({ws});
-
-    ws.emit('message', args.message);
-  });
-});

package/test/lnd_gateway/test_encode_response.js

@@ -1,37 +0,0 @@
-const {equal} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const encodeResponse = require('./../../lnd_gateway/encode_response');
-
-const tests = [
-  {
-    args: {},
-    description: 'Data is required to encode',
-    error: [400, 'ExpectedDataToEncodeResponse'],
-  },
-  {
-    args: {data: {}},
-    description: 'Event is required to encode',
-    error: [400, 'ExpectedEventToEncodeResponse'],
-  },
-  {
-    args: {data: {}, event: 'event'},
-    description: 'Encoded data and event',
-    expected: {response: 'a26464617461a0656576656e74656576656e74'},
-  },
-];
-
-tests.forEach(({args, description, error, expected}) => {
-  return test(description, async () => {
-    if (!!error) {
-      await rejects(encodeResponse(args), error, 'Got expected error');
-    } else {
-      const {response} = await encodeResponse(args);
-
-      equal(response.toString('hex'), expected.response, 'Encoded response');
-    }
-
-    return;
-  });
-});