paid-services 3.0.0 → 3.2.0

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

@@ -7,16 +7,17 @@
     "url": "https://github.com/alexbosworth/paid-services/issues"
   },
   "dependencies": {
-    "async": "3.2.1",
-    "asyncjs-util": "1.2.6",
-    "bolt01": "1.2.2",
-    "invoices": "2.0.0",
-    "ln-service": "52.6.0"
+    "async": "3.2.2",
+    "asyncjs-util": "1.2.7",
+    "bolt01": "1.2.3",
+    "invoices": "2.0.2",
+    "ln-service": "53.1.2"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.10",
-    "mock-lnd": "1.4.0",
+    "ln-docker-daemons": "2.1.0",
+    "mock-lnd": "1.4.1",
     "secp256k1": "4.0.2"
   },
   "engines": {
@@ -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.0.0"
+  "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();
+});

package/trades/buy_preimage.js

@@ -0,0 +1,145 @@
+const asyncAuto = require('async/auto');
+const {parsePaymentRequest} = require('ln-service');
+const {payViaRoutes} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+const {subscribeToProbeForRoute} = require('ln-service');
+
+const cltvDeltaBuffer = 5;
+
+/** Buy the preimage for a trade
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+    request: <BOLT 11 Encoded Payment Request String>
+  }
+
+  @returns via cbk or Promise
+  {
+    fee: <Fee Paid Number>
+    secret: <Payment Preimage Hex String>
+    tokens: <Tokens Paid Number>
+  }
+*/
+module.exports = ({ask, lnd, logger, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToBuyTradePreimage']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToBuyTradePreimage']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToBuyTradePreimage']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedPaymentRequestToPurchaseTradePreimage']);
+        }
+
+        return cbk();
+      },
+
+      // Decode the payment request
+      parseRequest: ['validate', ({}, cbk) => {
+        try {
+          const details = parsePaymentRequest({request});
+
+          return cbk(null, {
+            cltv_delta: details.cltv_delta,
+            destination: details.destination,
+            features: details.features,
+            id: details.id,
+            mtokens: details.mtokens,
+            payment: details.payment,
+            routes: details.routes,
+            tokens: details.tokens,
+          });
+        } catch (err) {
+          return cbk([400, 'ExpectedValidPaymentRequestToBuyPreimage', {err}]);
+        }
+      }],
+
+      // Subscribe to a probe to a route
+      getRoute: ['parseRequest', ({parseRequest}, cbk) => {
+        const sub = subscribeToProbeForRoute({
+          lnd,
+          cltv_delta: parseRequest.cltv_delta + cltvDeltaBuffer,
+          destination: parseRequest.destination,
+          features: parseRequest.features,
+          mtokens: parseRequest.mtokens,
+          payment: parseRequest.payment,
+          routes: parseRequest.routes,
+          total_mtokens: !!parseRequest.payment ? parseRequest.mtokens : null,
+        });
+
+        const done = (err, res) => {
+          sub.removeAllListeners();
+
+          return cbk(err, res);
+        };
+
+        sub.once('end', () => done([503, 'FailedToFindPathToDestination']));
+        sub.once('error', err => done(err));
+        sub.once('probe_success', ({route}) => done(null, route));
+
+        sub.on('probing', ({route}) => {
+          return logger.info({checking_path_with_fee: route.fee});
+        });
+
+        return;
+      }],
+
+      // Confirm transaction fee
+      confirmFee: [
+        'getRoute',
+        'parseRequest',
+        ({getRoute, parseRequest}, cbk) =>
+      {
+        return ask({
+          name: 'pay',
+          message: `Pay ${parseRequest.tokens} and ${getRoute.fee} fee?`,
+          type: 'confirm',
+        },
+        cbk);
+      }],
+
+      // Pay the request
+      pay: [
+        'confirmFee',
+        'getRoute',
+        'parseRequest',
+        ({confirmFee, getRoute, parseRequest}, cbk) =>
+      {
+        if (!confirmFee.pay) {
+          return cbk([400, 'PaymentCanceled']);
+        }
+
+        logger.info({paying: getRoute.tokens});
+
+        return payViaRoutes({
+          lnd,
+          id: parseRequest.id,
+          routes: [getRoute],
+        },
+        cbk);
+      }],
+
+      // Final payment
+      paid: ['parseRequest', 'pay', ({parseRequest, pay}, cbk) => {
+        return cbk(null, {
+          fee: pay.fee,
+          secret: pay.secret,
+          tokens: parseRequest.tokens,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'paid'}, cbk));
+  });
+};

package/trades/create_trade.js

@@ -0,0 +1,188 @@
+const asyncAuto = require('async/auto');
+const {createInvoice} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const encodeTrade = require('./encode_trade');
+const encryptTradeSecret = require('./encrypt_trade_secret');
+
+const asNumber = n => parseFloat(n, 10);
+const {floor} = Math;
+const isNumber = n => !isNaN(n);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const maxDescriptionLength = 100;
+const maxSecretLength = 100;
+const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
+
+/** Create a new trade
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = ({ask, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToCreateTrade']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToCreateTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Get the node identity key
+      getNodeId: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Ask for the public key of the node to trade with
+      askForNodeId: ['getNodeId', ({getNodeId}, cbk) => {
+        return ask({
+          name: 'id',
+          message: 'Public key of node you are trading with?',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (!isPublicKey(input)) {
+              return 'Expected public key of node to trade with';
+            }
+
+            if (input === getNodeId.public_key) {
+              return 'Expected public key of other node';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Ask for how to describe the payload
+      askForDescription: ['askForNodeId', ({}, cbk) => {
+        return ask({
+          name: 'description',
+          message: `Describe the secret you are offering:`,
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (input.length > maxDescriptionLength) {
+              return 'Expected shorter description';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Ask for the actual payload of the trade
+      askForSecret: ['askForDescription', ({askForDescription}, cbk) => {
+        return ask({
+          name: 'secret',
+          message: 'Enter the secret you want to sell',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (input.length > maxSecretLength) {
+              return 'Expected shorter secret value';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Ask for the price of the secret
+      askForPrice: ['askForSecret', ({}, cbk) => {
+        return ask({
+          name: 'tokens',
+          message: 'How much do you want to charge?',
+          validate: input => {
+            // Only allow numeric input
+            if (!isNumber(input)) {
+              return false;
+            }
+
+            // Disallow fractional values
+            if (floor(input) !== asNumber(input)) {
+              return 'Specified precision not supported';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Encrypt the secret data
+      encryptPayload: [
+        'askForNodeId',
+        'askForSecret',
+        ({askForNodeId, askForSecret}, cbk) =>
+      {
+        return encryptTradeSecret({
+          lnd,
+          secret: utf8AsHex(askForSecret.secret),
+          to: askForNodeId.id,
+        },
+        cbk);
+      }],
+
+      // Create the invoice to purchase the unlocking secret
+      createPurchaseInvoice: [
+        'askForDescription',
+        'askForPrice',
+        'encryptPayload',
+        ({askForDescription, askForPrice, encryptPayload}, cbk) =>
+      {
+        return createInvoice({
+          lnd,
+          description: askForDescription.description,
+          secret: encryptPayload.payment_secret,
+          tokens: asNumber(askForPrice.tokens),
+        },
+        cbk);
+      }],
+
+      // Encode all the trade data into wire format
+      encodeTradeToWireFormat: [
+        'createPurchaseInvoice',
+        'encryptPayload',
+        ({createPurchaseInvoice, encryptPayload}, cbk) =>
+      {
+        try {
+          const {trade} = encodeTrade({
+            auth: encryptPayload.trade_auth_tag,
+            payload: encryptPayload.trade_cipher,
+            request: createPurchaseInvoice.request,
+          });
+
+          return cbk(null, {trade});
+        } catch (err) {
+          return cbk([500, err.message]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'encodeTradeToWireFormat'}, cbk));
+  });
+};

package/trades/decode_trade.js

@@ -0,0 +1,108 @@
+const {decodeTlvStream} = require('bolt01');
+
+const networkFromNetworkRecord = require('./network_from_network_record');
+const {requestRecordsAsRequest} = require('./../records');
+
+const findAuth = records => records.find(n => n.type === '1');
+const findCipher = records => records.find(n => n.type === '0');
+const findDetails = records => records.find(n => n.type === '3');
+const findEncrypt = records => records.find(n => n.type === '0');
+const findNetwork = records => records.find(n => n.type === '1');
+const findRequest = records => records.find(n => n.type === '2');
+const findVersion = records => records.find(n => n.type === '0');
+const isTrade = trade => trade.toLowerCase().startsWith('626f73ff');
+const tradeData = trade => trade.slice('626f73ff'.length);
+
+/** Encode a trade
+
+  {
+    trade: <Hex Encoded Trade String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    auth: <Encrypted Payload Auth Hex String>
+    payload: <Preimage Encrypted Payload Hex String>
+    request: <BOLT 11 Payment Request String>
+  }
+*/
+module.exports = ({trade}) => {
+  if (!trade) {
+    throw new Error('ExpectedTradeToDecode');
+  }
+
+  if (!isTrade(trade)) {
+    throw new Error('UnexpectedFormatOfTradeToDecode');
+  }
+
+  try {
+    decodeTlvStream({encoded: tradeData(trade)});
+  } catch (err) {
+    throw new Error('ExpectedValidTlvStreamForTradeData');
+  }
+
+  // Decode the overall packet
+  const tradeRecords = decodeTlvStream({encoded: tradeData(trade)}).records;
+
+  // Get the trade version
+  const version = findVersion(tradeRecords);
+
+  if (!!version) {
+    throw new Error('UnexpectedVersionOfTradeData');
+  }
+
+  // Get the network record
+  const networkRecord = findNetwork(tradeRecords) || {};
+
+  // Get the payment request record
+  const requestRecord = findRequest(tradeRecords);
+
+  if (!requestRecord) {
+    throw new Error('ExpectedRequestRecordInTradeData');
+  }
+
+  const {request} = requestRecordsAsRequest({
+    network: networkFromNetworkRecord({value: networkRecord.value}),
+    encoded: requestRecord.value,
+  });
+
+  // Get the trade details
+  const detailsRecord = findDetails(tradeRecords);
+
+  if (!detailsRecord) {
+    throw new Error('ExpctedDetailsRecordToDecodeTrade');
+  }
+
+  // Trade details
+  const details = decodeTlvStream({encoded: detailsRecord.value}).records;
+
+  // Encode the encrypted data
+  const encryptedRecord = findEncrypt(details);
+
+  if (!encryptedRecord) {
+    throw new Error('ExpectedEncryptedRecordToDecodeTrade');
+  }
+
+  const encrypted = decodeTlvStream({encoded: encryptedRecord.value}).records;
+
+  const encryptedDataRecord = findCipher(encrypted);
+
+  if (!encryptedDataRecord) {
+    throw new Error('ExpectedEncryptedDataRecordToDecodeTrade');
+  }
+
+  const authDataRecord = findAuth(encrypted);
+
+  if (!authDataRecord) {
+    throw new Error('ExpectedAuthDataRecordToDecodeTrade');
+  }
+
+  return {
+    request,
+    auth: authDataRecord.value,
+    payload: encryptedDataRecord.value,
+  };
+};