paid-services 3.1.2 → 3.2.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## Version 3.2.0
+
+- `makePeerRequest`: Add method to make peer messaging requests
+- `servicePeerRequests`: Add method to handle peer messaging requests
+
 ## Version 3.1.2
 
 - `manageTrades`: Add method to create and interact with secret trades

package/index.js

@@ -1,10 +1,12 @@
 const {confirmServiceUse} = require('./client');
 const {getServiceSchema} = require('./client');
 const {getServicesList} = require('./client');
+const {makePeerRequest} = require('./p2p');
 const {makeServiceRequest} = require('./client');
 const {manageTrades} = require('./trades');
 const {schema} = require('./services');
 const {servicePaidRequests} = require('./server');
+const {servicePeerRequests} = require('./p2p');
 
 const serviceIds = schema.types;
 
@@ -12,8 +14,10 @@ module.exports = {
   confirmServiceUse,
   getServiceSchema,
   getServicesList,
+  makePeerRequest,
   makeServiceRequest,
   manageTrades,
   serviceIds,
   servicePaidRequests,
+  servicePeerRequests,
 };

package/p2p/encode_peer_request.js

@@ -0,0 +1,59 @@
+const {encodeBigSize} = require('bolt01');
+const {encodeTlvStream} = require('bolt01');
+
+const bigSize = number => encodeBigSize({number}).encoded;
+const code = null;
+const encodeMessage = message => `626f73ff${message}`;
+const headers = null;
+const {isArray} = Array;
+const recordsAsTlvStream = records => encodeTlvStream({records}).encoded;
+const version = null;
+
+/** Encode a peer request
+
+  {
+    id: <Request Id Hex String>
+    [records]: [{
+      type: <Type Number String>
+      value: <Value Hex String>
+    }]
+    type: <Type Number String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    message: <Hex Encoded Mesage String>
+  }
+*/
+module.exports = ({id, records, type}) => {
+  if (!id) {
+    throw new Error('ExpectedRequestIdHexStringToEncodePeerRequest');
+  }
+
+  if (!!records && !isArray(records)) {
+    throw new Error('ExpectedRecordsArrayToEncodePeerRequest');
+  }
+
+  if (!type) {
+    throw new Error('ExpectedRequestTypeToEncodePeerRequest');
+  }
+
+  // Encode the request records
+  const response = [version, id, code, bigSize(type), headers, records]
+    .map((value, type) => ({type, value}))
+    .filter(n => !!n.value)
+    .map(({type, value}) => {
+      if (!isArray(value)) {
+        return {type, value};
+      }
+
+      return {type, value: recordsAsTlvStream(value)};
+    })
+    .map(({value, type}) => ({value, type: type.toString()}));
+
+  // Return the encoded request message
+  return {message: encodeMessage(recordsAsTlvStream(response))};
+};

package/p2p/encode_peer_response.js

@@ -0,0 +1,45 @@
+const {encodeBigSize} = require('bolt01');
+const {encodeTlvStream} = require('bolt01');
+
+const encodeMessage = message => `626f73ff${message}`;
+const encodeResponseCode = require('./encode_response_code');
+
+const headers = null;
+const params = null;
+const present = n => !!n;
+const version = null;
+
+/** Encode a response to a peer
+
+  {
+    [failure]: [
+      <Failure Code Number>
+      <Failure Message String>
+    ]
+    id: <Request Id Hex String>
+    [records]: [{
+      type: <Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    message: <Encoded Hex String>
+  }
+*/
+module.exports = ({failure, id, records}) => {
+  const code = encodeResponseCode({failure}).encoded;
+  const {encoded} = !!records ? encodeTlvStream({records}) : {};
+
+  const response = [version, id, code, params, headers, encoded]
+    .map((value, type) => ({type, value}))
+    .filter(n => !!n.value);
+
+  const message = encodeMessage(encodeTlvStream({records: response}).encoded);
+
+  return {message};
+};

package/p2p/encode_response_code.js

@@ -0,0 +1,49 @@
+const {encodeBigSize} = require('bolt01');
+const {encodeTlvStream} = require('bolt01');
+
+const codeForSuccess = 200;
+const {isArray} = Array;
+const string = n => n.toString();
+const success = n => [{type: '0', value: encodeBigSize({number: n}).encoded}];
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+
+/** Encode a response code
+
+  {
+    [failure]: [
+      <Failure Code Number>
+      <Failure Message String>
+    ]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    encoded: <Encoded Hex String>
+  }
+*/
+module.exports = ({failure}) => {
+  if (!failure) {
+    return encodeTlvStream({records: success(codeForSuccess)});
+  }
+
+  if (!isArray(failure)) {
+    throw new Error('ExpectedFailureArrayToEncodeResponseCode');
+  }
+
+  const [code, message] = failure;
+
+  if (!code) {
+    throw new Error('ExpectedErrorCodeToEncodeResponseCode');
+  }
+
+  const number = code.toString();
+
+  const elements = [encodeBigSize({number}).encoded, utf8AsHex(message)];
+
+  const records = elements.map((value, type) => ({value, type: string(type)}));
+
+  return encodeTlvStream({records});
+};

package/p2p/index.js

@@ -0,0 +1,4 @@
+const makePeerRequest = require('./make_peer_request');
+const servicePeerRequests = require('./service_peer_requests');
+
+module.exports = {makePeerRequest, servicePeerRequests};

package/p2p/make_peer_request.js

@@ -0,0 +1,151 @@
+const {randomBytes} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+const {sendMessageToPeer} = require('ln-service');
+const {subscribeToPeerMessages} = require('ln-service');
+
+const encodePeerRequest = require('./encode_peer_request');
+const parseRequestFailure = (msg, cbk) => { cbk([503, msg]); return {}; };
+const parseRequestMessage = require('./parse_request_message');
+
+const makeId = () => randomBytes(32).toString('hex');
+
+/** Make a peer request
+
+  {
+    lnd: <Authenticated LND API Object>
+    [records]: [{
+      type: <Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+    [timeout]: <Peer Response Timeout Milliseconds>
+    to: <Node Id Public Key Hex String>
+    type: <Request Type Number String>
+  }
+
+   @throws error via cbk or Promise
+  [408, PeerRequestTimeout]
+
+  @returns via cbk or Promise
+  {
+    [records]: [{
+      type: <Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+*/
+module.exports = ({lnd, records, timeout, to, type}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToMakePeerRequest']);
+        }
+
+        if (!to) {
+          return cbk([400, 'ExpectedPublicKeyToMakePeerRequestTo']);
+        }
+
+        if (!type) {
+          return cbk([400, 'ExpectedTypeToMakePeerRequest']);
+        }
+
+        return cbk();
+      },
+
+      // Generate an id for the request
+      id: ['validate', ({}, cbk) => cbk(null, makeId())],
+
+      // Encode the request message
+      message: ['id', ({id}, cbk) => {
+        try {
+          // Encode the peer request elements into an encoded request
+          const {message} = encodePeerRequest({id, records, type});
+
+          return cbk(null, message);
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Make the request to the peer
+      request: ['id', 'message', ({id, message}, cbk) => {
+        // Listen to incoming peer messages
+        const sub = subscribeToPeerMessages({lnd});
+
+        // Stop waiting for a response if things have gone on too long
+        const timer = (() => {
+          return !timeout ? null : setTimeout(() => {
+            sub.removeAllListeners();
+
+            return cbk([408, 'PeerRequestTimeout']);
+          },
+          timeout);
+        })();
+
+        // An error on the subscription
+        sub.on('error', err => {
+          // Stop listening
+          sub.removeAllListeners();
+
+          // Stop the timeout timer
+          clearTimeout(timer);
+
+          return cbk([503, 'PeerRequestResponseListenerFailed', {err}]);
+        });
+
+        // Wait for a message on the request id
+        sub.on('message_received', received => {
+          // Exit early on messages from other nodes
+          if (received.public_key !== to) {
+            return;
+          }
+
+          const {response} = (() => {
+            try {
+              return parseRequestMessage(received);
+            } catch (err) {
+              return parseRequestFailure(err.message, cbk);
+            }
+          })();
+
+          // Exit early when this message is not a reponse to the request
+          if (!response || response.id !== id) {
+            return;
+          }
+
+          // Stop the timeout timer
+          clearTimeout(timer);
+
+          // Remove listener for response
+          sub.removeAllListeners();
+
+          // Exit early when the server responds with a failure code
+          if (!!response.failure) {
+            return cbk(response.failure);
+          }
+
+          return cbk(null, {records: response.records});
+        });
+
+        // Send the peer request
+        return sendMessageToPeer({lnd, message, public_key: to}, err => {
+          if (!!err) {
+            // Stop timeout when there was an error sending
+            clearTimeout(timer);
+
+            // Stop listening for a response when there was an error
+            sub.removeAllListeners();
+
+            return cbk(err);
+          }
+
+          return;
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'request'}, cbk));
+  });
+};

package/p2p/parse_request_message.js

@@ -0,0 +1,103 @@
+const {decodeBigSize} = require('bolt01');
+const {decodeTlvStream} = require('bolt01');
+
+const parseResponseCode = require('./parse_response_code');
+
+const defaultRecords = {value: ''};
+const findRequestRecords = records => records.find(n => n.type === '5');
+const findResponseCodeRecord = records => records.find(n => n.type === '2');
+const findRequestIdRecord = records => records.find(n => n.type === '1');
+const findTypeRecord = records => records.find(n => n.type === '3');
+const findVersionRecord = records => records.find(n => n.type === '0');
+const idHexLength = 32 * 2;
+const isRequest = message => message.toLowerCase().startsWith('626f73ff');
+const requestData = message => message.slice('626f73ff'.length);
+const requestType = 32768;
+const res = records => records.map(({type, value}) => ({type, value}));
+
+/** Parse a peer request format message
+
+  Messages can either be requests or responses
+
+  {
+    message: <Encoded Request Message Hex String>
+    type: <Type Number String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [response]: {
+      [failure]: [
+        <Failure Code Number>
+        <Failure Code String>
+      ]
+      id: <Request Id Hex String>
+      records: [{
+        type: <Type Number String>
+        value: <Value Hex Encoded String>
+      }]
+    }
+    [request]: {
+      id: <Request Id Hex String>
+      records: [{
+        type: <Type Number String>
+        value: <Value Hex Encoded String>
+      }]
+      type: <Type Number String>
+    }
+  }
+*/
+module.exports = ({message, type}) => {
+  // Exit early when the message type or message content is not request type
+  if (type !== requestType || !isRequest(message)) {
+    return {};
+  }
+
+  const {records} = decodeTlvStream({encoded: requestData(message)});
+
+  const version = findVersionRecord(records);
+
+  if (!!version) {
+    throw new Error('UnexpectedVersionNumberOfRequestMessage');
+  }
+
+  const idRecord = findRequestIdRecord(records);
+
+  if (!idRecord || idRecord.value.length !== idHexLength) {
+    throw new Error('ExpectedRequestIdInRequestMessage');
+  }
+
+  const recordsRecord = findRequestRecords(records) || defaultRecords;
+
+  const responseCodeRecord = findResponseCodeRecord(records);
+  const typeRecord = findTypeRecord(records);
+
+  // Requests have request types and responses have response codes
+  if (!typeRecord && !responseCodeRecord) {
+    throw new Error('ExpectedEitherRequestParametersOrResponseCode');
+  }
+
+  // Exit early when this is a response to a request
+  if (!!responseCodeRecord) {
+    const {failure} = parseResponseCode({encoded: responseCodeRecord.value});
+
+    return {
+      response: {
+        failure,
+        id: idRecord.value,
+        records: res(decodeTlvStream({encoded: recordsRecord.value}).records),
+      },
+    };
+  }
+
+  return {
+    request: {
+      id: idRecord.value,
+      records: res(decodeTlvStream({encoded: recordsRecord.value}).records),
+      type: decodeBigSize({encoded: typeRecord.value}).decoded,
+    },
+  };
+};

package/p2p/parse_response_code.js

@@ -0,0 +1,60 @@
+const {decodeBigSize} = require('bolt01');
+const {decodeTlvStream} = require('bolt01');
+
+const defaultRecord = {value: ''};
+const findCodeRecord = records => records.find(n => n.type === '0');
+const findMessageRecord = records => records.find(n => n.type === '1');
+const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString('utf8');
+const isFailure = n => n > BigInt(400);
+const isTooBig = n => n > BigInt(Number.MAX_SAFE_INTEGER);
+const isTooSmall = n => n < BigInt(100);
+
+/** Parse a response code TLV stream
+
+  {
+    encoded: <Encoded Response Code Value Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [failure]: [
+      <Failure Code Number>
+      <Failure Code String>
+    ]
+  }
+*/
+module.exports = ({encoded}) => {
+  if (!encoded) {
+    throw new Error('ExpectedResponseCodeValueToParseResponseCode');
+  }
+
+  const {records} = decodeTlvStream({encoded});
+
+  const codeRecord = findCodeRecord(records);
+
+  if (!codeRecord) {
+    throw new Error('ExpectedCodeRecordToParseResponseCode');
+  }
+
+  const code = BigInt(decodeBigSize({encoded: codeRecord.value}).decoded);
+
+  if (isTooBig(code)) {
+    throw new Error('UnexpectedlyLargeResponseCodeInResponse');
+  }
+
+  if (isTooSmall(code)) {
+    throw new Error('UnexpectedlySmallResponseCodeInResponse');
+  }
+
+  // Exit early when the response code is not a failure
+  if (!isFailure(code)) {
+    return {};
+  }
+
+  const messageRecord = findMessageRecord(records) || defaultRecord;
+
+  return {failure: [Number(code), hexAsUtf8(messageRecord.value)]};
+};

package/p2p/return_failure_response.js

@@ -0,0 +1,43 @@
+const {sendMessageToPeer} = require('ln-service');
+
+const encodePeerResponse = require('./encode_peer_response');
+
+const defaultServerError = [500, 'InternalServiceError'];
+
+/** Return a failure response handler
+
+  {
+    from: <Requst From Node Id Public Key Hex String>
+    id: <Request Id Hex String>
+    lnd: <Authenticated LND API Object>
+    service: {
+      error: <Report Error Function>
+    }
+  }
+
+  @returns
+  <Handle Failure Response Function>
+*/
+module.exports = ({from, id, lnd, service}) => {
+  return failure => {
+    // Encode the message to send to the peer
+    const {message} = (() => {
+      try {
+        return encodePeerResponse({id, failure});
+      } catch (err) {
+        service.error([503, err.message]);
+
+        return encodePeerResponse({id, failure: defaultServerError});
+      }
+    })();
+
+    // Tell the peer about the failure
+    return sendMessageToPeer({lnd, message, public_key: from}, err => {
+      if (!!err) {
+        return service.error([503, 'ErrorSendingFailureMessage', {err}]);
+      }
+
+      return;
+    });
+  };
+};

package/p2p/return_success_response.js

@@ -0,0 +1,47 @@
+const {sendMessageToPeer} = require('ln-service');
+
+const encodePeerResponse = require('./encode_peer_response');
+
+const defaultServerError = [500, 'InternalServiceError'];
+
+/** Return handler for success response
+
+  {
+    from: <Requst From Node Id Public Key Hex String>
+    id: <Request Id Hex String>
+    lnd: <Authenticated LND API Object>
+    service: {
+      error: <Report Error Function>
+    }
+  }
+
+  @returns
+  <Handle Success Response Function>
+*/
+module.exports = ({from, id, lnd, service}) => {
+  return args => {
+    if (!args) {
+      throw new Error('ExpectedSuccessArgumentsToReturnSuccessPeerResponse');
+    }
+
+    // Encode the message to send to the peer
+    const {message} = (() => {
+      try {
+        return encodePeerResponse({id, records: args.records});
+      } catch (err) {
+        service.error([503, err.message]);
+
+        return encodePeerResponse({id, failure: defaultServerError});
+      }
+    })();
+
+    // Tell the peer about the success
+    return sendMessageToPeer({lnd, message, public_key: from}, err => {
+      if (!!err) {
+        return service.error([503, 'ErrorSendingSuccessMessage', {err}]);
+      }
+
+      return;
+    });
+  };
+};

package/p2p/service_peer_requests.js

@@ -0,0 +1,100 @@
+const {sendMessageToPeer} = require('ln-service');
+const {subscribeToPeerMessages} = require('ln-service');
+
+const defaultServerError = [500, 'InternalServiceError'];
+const encodePeerResponse = require('./encode_peer_response');
+const parseRequestFailure = (report, n) => { report([503, n]); return {}; };
+const parseRequestMessage = require('./parse_request_message');
+const returnFailureResponse = require('./return_failure_response');
+const returnSuccessResponse = require('./return_success_response');
+
+/** Get a p2p message listener
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns
+  {
+    error: <Add an Error Listener Function>
+    request: <Add A Request Listener For Type Function>
+    stop: <Stop Listening Function> ({}) => {};
+  }
+
+    request:
+    {
+      type: <Type Number String>
+    }
+
+    @returns via cbk
+    {
+      from: <Request From Node Id Hex Encoded Public Key String>
+      [records]: [{
+        type: <Type Number String>
+        value: <Value Hex String>
+      }]
+    }
+    {
+      failure: <Return Failure Function>
+      success: <Return Success Function>
+    }
+
+      failure:
+      [
+        <Return Error Code Number>
+        <Return Error Message String>
+      ]
+
+      success:
+      {
+        [records]: [{
+          type: <Type Number String>
+          value: <Value Hex String>
+        }]
+      }
+*/
+module.exports = ({lnd}) => {
+  const listeners = {};
+  const service = {error: () => {}};
+  const sub = subscribeToPeerMessages({lnd});
+
+  sub.on('message_received', received => {
+    const from = received.public_key;
+    const {message} = received;
+    const {type} = received;
+
+    // Parse out the p2p request message details
+    const {request} = (() => {
+      try {
+        return parseRequestMessage({message, type});
+      } catch (err) {
+        return parseRequestFailure(service.error, err.message);
+      }
+    })();
+
+    // Exit early when the received message isn't actually a p2p request
+    if (!request) {
+      return;
+    }
+
+    // Exit early when nothing is listening for this type
+    if (!listeners[request.type]) {
+      return;
+    }
+
+    const {id} = request;
+    const req = {from, records: request.records};
+
+    const failure = returnFailureResponse({from, id, lnd, service});
+    const success = returnSuccessResponse({from, id, lnd, service});
+
+    // Call the listener to tell it about the request
+    return listeners[request.type](req, {failure, success});
+  });
+
+  return {
+    error: cbk => service[error] = cbk,
+    request: ({type}, cbk) => listeners[type] = cbk,
+    stop: ({}) => sub.removeAllListeners(),
+  };
+};

package/package.json

@@ -11,11 +11,12 @@
     "asyncjs-util": "1.2.7",
     "bolt01": "1.2.3",
     "invoices": "2.0.2",
-    "ln-service": "52.16.0"
+    "ln-service": "53.1.2"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.10",
+    "ln-docker-daemons": "2.1.0",
     "mock-lnd": "1.4.1",
     "secp256k1": "4.0.2"
   },
@@ -36,5 +37,5 @@
   "scripts": {
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/client/*.js test/config/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js"
   },
-  "version": "3.1.2"
+  "version": "3.2.0"
 }

package/test/integration/test_service_peer_requests.js

@@ -0,0 +1,59 @@
+const {addPeer} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const {makePeerRequest} = require('./../../');
+const {servicePeerRequests} = require('./../../');
+
+const failure = [402, 'PurchaseRequired'];
+const failureType = '1';
+const records = [{type: '1', value: '01'}];
+const size = 2;
+const type = '0';
+
+// Adding a listener for peer requests should allow responding to peer requests
+test(`Listen for peer requests`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{id, lnd}, target] = nodes;
+
+  await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+  // Start the server and respond to requests
+  const listener = servicePeerRequests({lnd});
+
+  listener.request({type}, (req, res) => res.success({records}));
+  listener.request({type: failureType}, (req, res) => res.failure(failure));
+
+  // Make a request to the server and get a success response
+  try {
+    const got = await makePeerRequest({
+      type,
+      lnd: target.lnd,
+      timeout: 1000,
+      to: id,
+    });
+
+    strictSame(records, got.records, 'Got response records');
+  } catch (err) {
+    equal(err, null, 'Expected no error making peer request');
+  }
+
+  // Make a request to the server and get a failure response
+  try {
+    const got = await makePeerRequest({
+      type: failureType,
+      lnd: target.lnd,
+      timeout: 1000,
+      to: id,
+    });
+
+    strictSame(got, null, 'Expected failure response for failure type');
+  } catch (err) {
+    strictSame(err, failure, 'Got failure response for failure type');
+  }
+
+  await kill({});
+
+  return end();
+});