paid-services 3.3.0 → 3.4.0

package/trades/encode_trade.js

@@ -1,50 +1,65 @@
-const {encodeTlvStream} = require('bolt01');
+const encodeOpenTrade = require('./encode_open_trade');
+const encodeTradeSecret = require('./encode_trade_secret');
 
-const networkRecordFromRequest = require('./network_record_from_request');
-const {requestAsRequestRecords} = require('./../records');
+/** Encode v1 trade records
 
-const asTrade = hex => `626f73ff${hex}`;
+  A v1 trade is either a qualified trade with a request, or an open ended trade
+  with connection details.
 
-/** Encode a trade
+  0: version (v1)
+  [1]: network
+  [2]: payment request
+  [3]: trade details
+  [4]: nodes records
+  [5]: trade identifier
 
   {
-    auth: <Encrypted Payload Auth Hex String>
-    payload: <Preimage Encrypted Payload Hex String>
-    request: <BOLT 11 Payment Request String>
+    [connect]: {
+      [id]: <Reference Trade Id Hex String>
+      network: <Network Name String>
+      nodes: [{
+        channels: [<Standard Format Channel Id String>]
+        id: <Node Public Key Id Hex String>
+        [sockets]: [<Peer Socket String>]
+      }]
+    }
+    [secret]: {
+      auth: <Encrypted Payload Auth Hex String>
+      payload: <Preimage Encrypted Payload Hex String>
+      request: <BOLT 11 Payment Request String>
+    }
   }
 
+  @throws
+  <Error>
+
   @returns
   {
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({auth, payload, request}, cbk) => {
-  // Encode the trade record
-  const tradeRecords = [{
-    type: '2',
-    value: requestAsRequestRecords({request}).encoded,
-  }];
-
-  // Add a network name record if required
-  if (!!networkRecordFromRequest({request}).value) {
-    tradeRecords.push({
-      type: '1',
-      value: networkRecordFromRequest({request}).value,
-    });
+module.exports = ({connect, secret}) => {
+  if (!connect && !secret) {
+    throw new Error('ExpectedEitherConnectDetailsOrTradeSecret');
   }
 
-  // Encode the encrypted data
-  const encryptionRecords = encodeTlvStream({
-    records: [{type: '0', value: payload}, {type: '1', value: auth}],
-  });
-
-  // Encode the details of the trade
-  const detailsRecords = encodeTlvStream({
-    records: [{type: '0', value: encryptionRecords.encoded}],
-  });
+  if (!!connect && !!secret) {
+    throw new Error('ExpectedEitherConnectDetailsOrTradeSecretNotBoth');
+  }
 
-  // Add the trade details to the trade
-  tradeRecords.push({type: '3', value: detailsRecords.encoded});
+  // Exit early when this is an open ended trade
+  if (!!connect) {
+    return encodeOpenTrade({
+      id: connect.id,
+      network: connect.network,
+      nodes: connect.nodes,
+    });
+  }
 
-  return {trade: asTrade(encodeTlvStream({records: tradeRecords}).encoded)};
+  // Encode the trade secret
+  return encodeTradeSecret({
+    auth: secret.auth,
+    payload: secret.payload,
+    request: secret.request,
+  });
 };

package/trades/encode_trade_secret.js

@@ -0,0 +1,50 @@
+const {encodeTlvStream} = require('bolt01');
+
+const networkRecordFromRequest = require('./network_record_from_request');
+const {requestAsRequestRecords} = require('./../records');
+
+const asTrade = hex => `626f73ff${hex}`;
+
+/** Encode a trade
+
+  {
+    auth: <Encrypted Payload Auth Hex String>
+    payload: <Preimage Encrypted Payload Hex String>
+    request: <BOLT 11 Payment Request String>
+  }
+
+  @returns
+  {
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = ({auth, payload, request}, cbk) => {
+  // Encode the trade record
+  const tradeRecords = [{
+    type: '2',
+    value: requestAsRequestRecords({request}).encoded,
+  }];
+
+  // Add a network name record if required
+  if (!!networkRecordFromRequest({request}).value) {
+    tradeRecords.push({
+      type: '1',
+      value: networkRecordFromRequest({request}).value,
+    });
+  }
+
+  // Encode the encrypted data
+  const encryptionRecords = encodeTlvStream({
+    records: [{type: '0', value: payload}, {type: '1', value: auth}],
+  });
+
+  // Encode the details of the trade
+  const detailsRecords = encodeTlvStream({
+    records: [{type: '0', value: encryptionRecords.encoded}],
+  });
+
+  // Add the trade details to the trade
+  tradeRecords.push({type: '3', value: detailsRecords.encoded});
+
+  return {trade: asTrade(encodeTlvStream({records: tradeRecords}).encoded)};
+};

package/trades/finalize_trade_secret.js

@@ -0,0 +1,116 @@
+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>
+    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.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,
+            id: bufferAsHex(sha256(hexAsBuffer(encrypt.payment_secret))),
+            lnd: args.lnd,
+            secret: encrypt.payment_secret,
+            tokens: args.tokens,
+          },
+          cbk);
+        }
+
+        return createInvoice({
+          description: args.description,
+          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,314 @@
+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 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>
+  }
+*/
+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 cbk(null, connect.node);
+          }
+
+          // 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) => {
+          // 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({});
+        });
+
+        // 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 [trade, other] = requestTrades.trades;
+
+        // Exit early when there is only a single trade
+        if (!other) {
+          return cbk(null, trade);
+        }
+
+        // Present the possible choices
+        return ask({
+          choices: requestTrades.trades.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));
+  });
+};