paid-services 3.3.0 → 3.6.0

package/trades/finalize_trade_secret.js

@@ -0,0 +1,123 @@
+const {createHash} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const {createHodlInvoice} = require('ln-service');
+const {createInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const encodeTradeSecret = require('./encode_trade_secret');
+const encryptTradeSecret = require('./encrypt_trade_secret');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+
+/** Create a trade secret for a node
+
+  {
+    description: <Trade Description String>
+    expires_at: <Trade Expires At ISO 8601 Date String>
+    is_hold: <Create Hold Invoice Bool>
+    lnd: <Authenticated LND API Object>
+    secret: <Clear Secret String>
+    to: <To Public Key Hex Encoded String>
+    tokens: <Price Tokens Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    id: <Payment Hash Hex String>
+    secret: <Hex Encoded Payment Secret String>
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.description) {
+          return cbk([400, 'ExpectedDescriptionToFinalizeTradeSecret']);
+        }
+
+        if (!args.expires_at) {
+          return cbk([400, 'ExpectedExpiresAtDateToFinalizeTradeSecret']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToFinalizeTradeSecret']);
+        }
+
+        if (!args.secret) {
+          return cbk([400, 'ExpectedSecretValueToFinalizeTradeSecret']);
+        }
+
+        if (!args.to) {
+          return cbk([400, 'ExpectedToPublicKeyToFinalizeTradeSecret']);
+        }
+
+        if (!args.tokens) {
+          return cbk([400, 'ExpectedTokensPriceToFinalizeTradeSecret']);
+        }
+
+        return cbk();
+      },
+
+      // Encrypt the secret data
+      encrypt: ['validate', ({}, cbk) => {
+        return encryptTradeSecret({
+          lnd: args.lnd,
+          secret: utf8AsHex(args.secret),
+          to: args.to,
+        },
+        cbk);
+      }],
+
+      // Create the invoice to purchase the unlocking secret
+      createInvoice: ['encrypt', ({encrypt}, cbk) => {
+        // Exit early when this is a hold invoice
+        if (!!args.is_hold) {
+          return createHodlInvoice({
+            description: args.description,
+            expires_at: args.expires_at,
+            id: bufferAsHex(sha256(hexAsBuffer(encrypt.payment_secret))),
+            lnd: args.lnd,
+            secret: encrypt.payment_secret,
+            tokens: args.tokens,
+          },
+          cbk);
+        }
+
+        return createInvoice({
+          description: args.description,
+          expires_at: args.expires_at,
+          lnd: args.lnd,
+          secret: encrypt.payment_secret,
+          tokens: args.tokens,
+        },
+        cbk);
+      }],
+
+      // Encode all the trade data into wire format
+      encode: ['createInvoice', 'encrypt', ({createInvoice, encrypt}, cbk) => {
+        try {
+          const {trade} = encodeTradeSecret({
+            auth: encrypt.trade_auth_tag,
+            payload: encrypt.trade_cipher,
+            request: createInvoice.request,
+          });
+
+          return cbk(null, {
+            trade,
+            id: createInvoice.id,
+            secret: encrypt.payment_secret,
+          });
+        } catch (err) {
+          return cbk([500, err.message]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'encode'}, cbk));
+  });
+};

package/trades/find_trade.js

@@ -0,0 +1,339 @@
+const {randomBytes} = require('crypto');
+
+const {addPeer} = require('ln-service');
+const asyncAuto = require('async/auto');
+const asyncDetect = require('async/detect');
+const asyncDetectSeries = require('async/detectSeries');
+const asyncMap = require('async/map');
+const {getChannel} = require('ln-service');
+const {getNode} = require('ln-service');
+const {getPeers} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const decodeBasicTrade = require('./decode_basic_trade');
+const {makePeerRequest} = require('./../p2p');
+const requestTradeById = require('./request_trade_by_id');
+const {servicePeerRequests} = require('./../p2p');
+const {serviceTypeReceiveTrades} = require('./../service_types');
+const {serviceTypeRequestTrades} = require('./../service_types');
+
+const findBasicRecord = records => records.find(n => n.type === '1');
+const findIdRecord = records => records.find(n => n.type === '0');
+const {isArray} = Array;
+const makeRequestId = () => randomBytes(32).toString('hex');
+const requestTradeType = '805005';
+const requestTradesTimeoutMs = 1000 * 30;
+const tradesRequestIdType = '1';
+const uniq = arr => Array.from(new Set(arr));
+const uniqBy = (a,b) => a.filter((e,i) => a.findIndex(n => n[b] == e[b]) == i);
+const waitForTradesMs = 1000 * 5;
+
+/** Find a trade to purchase
+
+  {
+    ask: <Inquirer Ask Function>
+    [id]: <Trade Id Encoded Hex String>
+    identity: <Own Node Identity Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+    nodes: [{
+      [high_channel]: <High Key Channel Id String>
+      [low_channel]: <Low Key Channel Id String>
+      [node]: {
+        id: <Node Public Key Id Hex String>
+        sockets: [<Peer Socket String>]
+      }
+    }]
+  }
+
+  @returns via cbk or Promise
+  {
+    auth: <Encrypted Payload Auth Hex String>
+    payload: <Preimage Encrypted Payload Hex String>
+    request: <BOLT 11 Payment Request String>
+    trade: <Encoded Trade String>
+  }
+*/
+module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskMethodToFindTrade']);
+        }
+
+        if (!identity) {
+          return cbk([400, 'ExpectedIdentityToFindTrade']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndApiToFindTrade']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedLoggerObjectToFindTrade']);
+        }
+
+        if (!isArray(nodes)) {
+          return cbk([400, 'ExpectedNodesArrayToFindTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Find node connect info to connect to
+      getNodes: ['validate', ({}, cbk) => {
+        return asyncMap(nodes, (connect, cbk) => {
+          // Exit early when the node is self
+          if (!!connect.node && connect.node.id === identity) {
+            return cbk();
+          }
+
+          // Exit early when the node id and sockets is specified directly
+          if (!!connect.node) {
+            return getNode({
+              lnd,
+              is_omitting_channels: true,
+              public_key: connect.node.id,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(null, connect.node);
+              }
+
+              const sockets = connect.node.sockets.map(n => n.socket);
+
+              return cbk(null, {
+                id: connect.node.id,
+                sockets: uniq([].concat(sockets).concat(connect.node.sockets)),
+              });
+            });
+          }
+
+          // Exit early when there is no landmark channel
+          if (!connect.high_channel && !connect.low_channel) {
+            return cbk();
+          }
+
+          const channelId = connect.high_channel || connect.low_channel;
+
+          // Get the public keys of the landmark channel
+          return getChannel({lnd, id: channelId}, (err, res) => {
+            // Exit early when the channel cannot be fetched
+            if (!!err) {
+              return cbk();
+            }
+
+            const [low, high] = res.policies.map(n => n.public_key);
+
+            // The node key is either the lower or the higher public key
+            const nodeId = !!connect.low_channel ? low : high;
+
+            // Exit early when the node is self
+            if (nodeId === identity) {
+              return cbk();
+            }
+
+            // Find the sockets for the node
+            return getNode({
+              lnd,
+              is_omitting_channels: true,
+              public_key: nodeId,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk();
+              }
+
+              return cbk(null, {
+                id: nodeId,
+                sockets: res.sockets.map(n => n.socket),
+              });
+            });
+          });
+        },
+        cbk);
+      }],
+
+      // Get the list of connected peers
+      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
+
+      // Try and connect to a node in order to do p2p messaging
+      connect: ['getNodes', 'getPeers', ({getNodes, getPeers}, cbk) => {
+        const connected = getPeers.peers.map(n => n.public_key);
+
+        // Look for a node that is already a connected peer
+        const [alreadyConnected] = getNodes.filter(node => {
+          return !!node && connected.includes(node.id);
+        });
+
+        // Exit early when already connected to a node
+        if (!!alreadyConnected) {
+          return cbk(null, alreadyConnected);
+        }
+
+        // Try and connect to a referenced node
+        return asyncDetect(getNodes.filter(n => !!n), (node, cbk) => {
+          logger.info({connecting_to: node.id});
+
+          // Attempt referenced sockets to establish p2p connection
+          return asyncDetectSeries(node.sockets, (socket, cbk) => {
+            return addPeer({lnd, socket, public_key: node.id}, err => {
+              // Stop trying sockets when there is no error
+              return cbk(null, !err);
+            });
+          },
+          (err, socket) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            // The node is connected if one of the sockets worked
+            return cbk(null, !!socket);
+          });
+        },
+        cbk);
+      }],
+
+      // Node to request trades from
+      to: ['connect', ({connect}, cbk) => {
+        if (!connect) {
+          return cbk([503, 'FailedToConnectToNode']);
+        }
+
+        return cbk(null, connect.id);
+      }],
+
+      // Request a specific trade
+      requestTrade: ['to', ({to}, cbk) => {
+        // Exit early when this is an open ended trade request with no id
+        if (!id) {
+          return cbk();
+        }
+
+        return requestTradeById({id, lnd, to}, cbk);
+      }],
+
+      // Request an inventory of trades
+      requestTrades: ['to', ({to}, cbk) => {
+        // Exit early when this is a trade request for a specific id
+        if (!!id) {
+          return cbk();
+        }
+
+        const requestId = makeRequestId();
+        const service = servicePeerRequests({lnd});
+        const trades = [];
+
+        // When the requesting period is over, return the received trades
+        const finished = err => {
+          service.stop({});
+
+          return !!err ? cbk(err) : cbk(null, {trades});
+        };
+
+        // Listen for trades
+        service.request({type: serviceTypeReceiveTrades}, (req, res) => {
+          const requestIdRecord = findIdRecord(req.records);
+
+          // Exit early when this is a request for something else
+          if (!requestIdRecord || requestIdRecord.value !== requestId) {
+            return;
+          }
+
+          // Make sure there is a basic trade record in the records
+          if (!findBasicRecord(req.records)) {
+            return res.failure([400, 'ExpectedBasicTradeRecord']);
+          }
+
+          // Make sure the basic trade record is valid
+          try {
+            decodeBasicTrade({records: req.records});
+          } catch (err) {
+            return res.failure([400, 'ExpectedValidBasicTradeRecord']);
+          }
+
+          trades.push(decodeBasicTrade({records: req.records}));
+
+          return res.success({});
+        });
+
+        logger.info({requesting_trade_details: true});
+
+        // Once connected, ask for the trade details
+        return makePeerRequest({
+          lnd,
+          to,
+          records: [{type: tradesRequestIdType, value: requestId}],
+          timeout: requestTradesTimeoutMs,
+          type: serviceTypeRequestTrades,
+        },
+        (err, res) => {
+          if (!!err) {
+            return finished(err);
+          }
+
+          return setTimeout(finished, waitForTradesMs);
+        });
+      }],
+
+      // Select the desired basic trade
+      selectTrade: [
+        'requestTrade',
+        'requestTrades',
+        ({requestTrade, requestTrades}, cbk) =>
+      {
+        // Exit early when the trade was already selected
+        if (!!requestTrade) {
+          return cbk();
+        }
+
+        if (!requestTrades.trades.length) {
+          return cbk([404, 'NoTradesFound']);
+        }
+
+        const uniqueTrades = uniqBy(requestTrades.trades, 'description');
+
+        const [trade, other] = uniqueTrades;
+
+        // Exit early when there is only a single trade
+        if (!other) {
+          return cbk(null, trade);
+        }
+
+        // Present the possible choices
+        return ask({
+          choices: uniqueTrades.map(trade => ({
+            name: trade.description,
+            value: trade.id,
+          })),
+          message: 'What would you like to buy?',
+          name: 'id',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Fetch the full trade-secret that was selected
+      fetchSelectedTrade: ['selectTrade', 'to', ({selectTrade, to}, cbk) => {
+        // Exit early when trade is already known
+        if (!selectTrade) {
+          return cbk();
+        }
+
+        return requestTradeById({lnd, to, id: selectTrade.id}, cbk);
+      }],
+
+      // Final trade details
+      trade: [
+        'fetchSelectedTrade',
+        'requestTrade',
+        ({fetchSelectedTrade, requestTrade}, cbk) =>
+      {
+        return cbk(null, fetchSelectedTrade || requestTrade);
+      }],
+    },
+    returnResult({reject, resolve, of: 'trade'}, cbk));
+  });
+};

package/trades/manage_trade.js

@@ -11,10 +11,12 @@ const {returnResult} = require('asyncjs-util');
 const buyPreimage = require('./buy_preimage');
 const decodeTrade = require('./decode_trade');
 const decryptTradeSecret = require('./decrypt_trade_secret');
+const findTrade = require('./find_trade');
 
 const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
 const {isArray} = Array;
 const isHexPreimage = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Manage an individual trade
 
@@ -52,13 +54,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           name: 'trade',
           message: 'Enter encoded trade',
           type: 'input',
-          validate: input => {
-            if (!input) {
-              return false;
-            }
-
-            return true;
-          },
+          validate: input => !!input,
         },
         cbk);
       }],
@@ -71,22 +67,43 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         try {
           const details = decodeTrade({trade: askForTrade.trade});
 
-          return cbk(null, {
-            auth: details.auth,
-            payload: details.payload,
-            request: details.request,
-          });
+          return cbk(null, details);
         } catch (err) {
           return cbk([400, err.message]);
         }
       }],
 
-      // Parse the trade payment request
-      requestDetails: ['decodeDetails', ({decodeDetails}, cbk) => {
-        const {request} = decodeDetails;
+      // Get details about an open ended trade
+      findTrade: [
+        'decodeDetails',
+        'getIdentity',
+        ({decodeDetails, getIdentity}, cbk) =>
+      {
+        // Exit early when there is a known trade
+        if (!!decodeDetails.secret) {
+          return cbk(null, {
+            auth: decodeDetails.secret.auth,
+            payload: decodeDetails.secret.payload,
+            request: decodeDetails.secret.request,
+          });
+        }
 
+        // Get the trade details interactively
+        return findTrade({
+          ask,
+          lnd,
+          logger,
+          id: decodeDetails.connect.id,
+          identity: getIdentity.public_key,
+          nodes: decodeDetails.connect.nodes,
+        },
+        cbk);
+      }],
+
+      // Parse the trade payment request
+      requestDetails: ['findTrade', ({findTrade}, cbk) => {
         try {
-          return cbk(null, parsePaymentRequest({request}));
+          return cbk(null, parsePaymentRequest({request: findTrade.request}));
         } catch (err) {
           return cbk([400, err.message]);
         }
@@ -125,7 +142,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           is_canceled: invoice.is_canceled || undefined,
           is_purchased: invoice.is_confirmed || undefined,
         });
@@ -153,7 +170,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
         });
 
         return ask({
@@ -179,16 +196,24 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        return cancelHodlInvoice({lnd, id: requestDetails.id}, cbk);
+        return cancelHodlInvoice({lnd, id: requestDetails.id}, err => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          logger.info({trade_canceled: true});
+
+          return cbk();
+        });
       }],
 
       // Select a purchase option for the trade
       selectPurchaseAction: [
-        'decodeDetails',
+        'findTrade',
         'getPurchase',
         'getRequest',
         'requestDetails',
-        ({decodeDetails, getPurchase, getRequest, requestDetails}, cbk) =>
+        ({findTrade, getPurchase, getRequest, requestDetails}, cbk) =>
       {
         // Exit early when the trade was already purchased
         if (!!getPurchase.value && !!getPurchase.value.is_confirmed) {
@@ -200,10 +225,12 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        logger.info({trade: findTrade.trade});
+
         logger.info({
-          request: decodeDetails.request,
+          request: findTrade.request,
           purchase: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           to: requestDetails.destination,
         });
 
@@ -257,9 +284,9 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
       // Pay and get the preimage through paying for it
       payForPreimage: [
-        'decodeDetails',
+        'findTrade',
         'selectPurchaseAction',
-        ({decodeDetails, selectPurchaseAction}, cbk) =>
+        ({findTrade, selectPurchaseAction}, cbk) =>
       {
         // Exit early when this is an offer
         if (!selectPurchaseAction) {
@@ -271,32 +298,25 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        const {request} = findTrade;
+
         return asyncRetry({
           errorFilter: err => !!isArray(err) && err.slice().shift() >= 500,
         },
-        cbk => {
-          return buyPreimage({
-            ask,
-            lnd,
-            logger,
-            request: decodeDetails.request,
-          },
-          cbk);
-        },
-        cbk);
+        cbk => buyPreimage({ask, lnd, logger, request}, cbk), cbk);
       }],
 
       // Use the preimage to decrypt the trade secret
       decryptSecret: [
         'askForPreimage',
-        'decodeDetails',
+        'findTrade',
         'getPurchase',
         'payForPreimage',
         'requestDetails',
         'selectPurchaseAction',
         ({
           askForPreimage,
-          decodeDetails,
+          findTrade,
           getPurchase,
           payForPreimage,
           requestDetails,
@@ -327,11 +347,13 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
         const paid = payForPreimage || askForPreimage || payment;
 
+        const {auth, payload} = findTrade;
+
         return decryptTradeSecret({
+          auth,
           lnd,
-          auth: decodeDetails.auth,
+          payload,
           from: requestDetails.destination,
-          payload: decodeDetails.payload,
           secret: paid.secret,
         },
         cbk);