paid-services 3.13.2 → 3.14.2

package/trades/find_trade.js

@@ -1,34 +1,23 @@
 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 asyncReflect = require('async/reflect');
-const {getChannel} = require('ln-service');
-const {getNode} = require('ln-service');
-const {getPeers} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const connectToSeller = require('./connect_to_seller');
 const decodeBasicTrade = require('./decode_basic_trade');
 const {makePeerRequest} = require('./../p2p');
 const requestTradeById = require('./request_trade_by_id');
 const {servicePeerRequests} = require('./../p2p');
-const {serviceTypeReceiveChannelSale} = require('./../service_types');
-const {serviceTypeRequestChannelSale} = require('./../service_types');
 const {serviceTypeReceiveTrades} = require('./../service_types');
 const {serviceTypeRequestTrades} = require('./../service_types');
 
-const buyChannelAction = 'buy';
 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;
 
@@ -37,7 +26,6 @@ const waitForTradesMs = 1000 * 5;
   {
     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: [{
@@ -52,29 +40,21 @@ const waitForTradesMs = 1000 * 5;
 
   @returns via cbk or Promise
   {
-    auth: <Encrypted Payload Auth Hex String>
-    payload: <Preimage Encrypted Payload Hex String>
+    [auth]: <Encrypted Payload Auth Hex String>
+    [payload]: <Preimage Encrypted Payload Hex String>
     request: <BOLT 11 Payment Request String>
     trade: <Encoded Trade String>
   }
 */
-module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
+module.exports = ({ask, id, lnd, logger, nodes}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!action) {
-          return cbk([400, 'ExpectedActionTypeToFindTrade']);
-        }
-
         if (!ask) {
           return cbk([400, 'ExpectedAskMethodToFindTrade']);
         }
 
-        if (!identity) {
-          return cbk([400, 'ExpectedIdentityToFindTrade']);
-        }
-
         if (!lnd) {
           return cbk([400, 'ExpectedLndApiToFindTrade']);
         }
@@ -90,148 +70,13 @@ module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
         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 = res.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);
+      // Connect to the seller
+      connect: ['validate', ({}, cbk) => {
+        return connectToSeller({lnd, logger, nodes}, cbk);
       }],
 
-      // Get the list of connected peers
-      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
-
-      // Determine the receive type to listen for
-      receiveType: ['validate', ({}, cbk) => {
-        // Exit early when the action is to buy a channel
-        if (action === buyChannelAction) {
-          return cbk(null, serviceTypeReceiveChannelSale);
-        }
-
-        return cbk(null, serviceTypeReceiveTrades);
-      }],
-
-      // Determine the request type to send
-      requestType: ['validate', ({}, cbk) => {
-        // Exit early when the action is to buy a channel
-        if (action === buyChannelAction) {
-          return cbk(null, serviceTypeRequestChannelSale);
-        }
-
-        return cbk(null, serviceTypeRequestTrades);
-      }],
-
-      // 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);
-      }],
+      // Send request to node with public key identity
+      to: ['connect', ({connect}, cbk) => cbk(null, connect.id)],
 
       // Request a specific trade
       requestTrade: ['to', asyncReflect(({to}, cbk) => {
@@ -240,17 +85,11 @@ module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk();
         }
 
-        return requestTradeById({action, id, lnd, to}, cbk);
+        return requestTradeById({id, lnd, to}, cbk);
       })],
 
       // Request an inventory of trades
-      requestTrades: [
-        'receiveType',
-        'requestTrade',
-        'requestType',
-        'to',
-        ({receiveType, requestTrade, requestType, to}, cbk) =>
-      {
+      requestTrades: ['requestTrade', 'to', ({requestTrade, to}, cbk) => {
         // Exit early when there was a successful request for a specific id
         if (!!requestTrade.value) {
           return cbk();
@@ -267,7 +106,7 @@ module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
           return !!err ? cbk(err) : cbk(null, {trades});
         };
 
-        service.request({type: receiveType}, (req, res) => {
+        service.request({type: serviceTypeReceiveTrades}, (req, res) => {
           const requestIdRecord = findIdRecord(req.records);
 
           // Exit early when this is a request for something else
@@ -300,7 +139,7 @@ module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
           to,
           records: [{type: tradesRequestIdType, value: requestId}],
           timeout: requestTradesTimeoutMs,
-          type: requestType,
+          type: serviceTypeRequestTrades,
         },
         (err, res) => {
           if (!!err) {
@@ -355,7 +194,7 @@ module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk();
         }
 
-        return requestTradeById({action, lnd, to, id: selectTrade.id}, cbk);
+        return requestTradeById({lnd, to, id: selectTrade.id}, cbk);
       }],
 
       // Final trade details

package/trades/get_anchored_trade.js

@@ -15,10 +15,12 @@ const decodeAnchoredTrade = require('./decode_anchored_trade');
   @returns via cbk or Promise
   {
     [trade]: {
-      description: <Trade Description String>
+      [channel]: <Channel Sale Capacity Tokens Number>
+      [description]: <Description of Trade String>
       expires_at: <Trade Expires at ISO 8601 Date String>
-      secret: <Trade Secret String>
-      tokens: <Trade Price Tokens Number>
+      [price]: <Trade Price String>
+      [secret]: <Trade Secret String>
+      [tokens]: <Trade Price Tokens Number>
     }
   }
 */
@@ -59,10 +61,12 @@ module.exports = ({id, lnd}, cbk) => {
 
         return cbk(null, {
           trade: {
-            description: trade.description,
+            channel: trade.channel || undefined,
+            description: trade.description || undefined,
             expires_at: getInvoice.value.expires_at,
-            secret: trade.secret,
-            tokens: getInvoice.value.tokens,
+            price: trade.price || undefined,
+            secret: trade.secret || undefined,
+            tokens: getInvoice.value.tokens || undefined,
           },
         });
       }],

package/trades/manage_trade.js

@@ -21,7 +21,6 @@ const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 /** Manage an individual trade
 
   {
-    action: <Action Type String>
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
@@ -29,15 +28,11 @@ const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
   @returns via cbk or Promise
 */
-module.exports = ({action, ask, lnd, logger}, cbk) => {
+module.exports = ({ask, lnd, logger}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!action) {
-          return cbk([400, 'ExpectedActionTypeToManageTrade']);
-        }
-
         if (!ask) {
           return cbk([400, 'ExpectedAskFunctionToManageTrade']);
         }
@@ -95,7 +90,6 @@ module.exports = ({action, ask, lnd, logger}, cbk) => {
 
         // Get the trade details interactively
         return findTrade({
-          action,
           ask,
           lnd,
           logger,
@@ -376,7 +370,7 @@ module.exports = ({action, ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        logger.info({trade_complete: hexAsUtf8(decryptSecret.plain)});
+        logger.info({secret_purchased: hexAsUtf8(decryptSecret.plain)});
 
         return cbk();
       }],

package/trades/manage_trades.js

@@ -2,13 +2,13 @@ const asyncAuto = require('async/auto');
 const asyncUntil = require('async/until');
 const {cancelHodlInvoice} = require('ln-service');
 const {diffieHellmanComputeSecret} = require('ln-service');
-const {getChainBalance} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getInvoices} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getNodeAlias} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
+const buyChannel = require('./buy_channel');
 const createChannelSale = require('./create_channel_sale');
 const createTrade = require('./create_trade');
 const encodeTrade = require('./encode_trade');
@@ -33,15 +33,15 @@ const viewAction = 'view';
 
   {
     ask: <Ask Function>
-    experimental: <Experiment Mode Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    request: <Request Function>
     separator: <Create Separator Function>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
+module.exports = ({ask, lnd, logger, request, separator}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -58,6 +58,10 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
           return cbk([400, 'ExpectedLoggerToManageTrades']);
         }
 
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToManageTrades']);
+        }
+
         return cbk();
       },
 
@@ -71,23 +75,20 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
       select: ['validate', ({}, cbk) => {
         return ask({
           choices: [
-            separator(),
-            {name: 'Create Trade', value: createAction},
-            {name: 'Decode Trade', value: decodeAction},
-            separator(),
+            {name: 'Buy Secret', value: decodeAction},
             {
               name: 'Buy Channel (experimental)',
               value: buyAction,
-              disabled: !experimental,
             },
+            separator(),
+            {name: 'Sell Secret', value: createAction},
             {
               name: 'Sell Channel (experimental)',
               value: sellAction,
-              disabled: !experimental,
             },
             separator(),
-            {name: 'Open Trades', value: listAction},
-            {name: 'Serve Trades', value: serveAction},
+            {name: 'List Open Trades', value: listAction},
+            {name: 'Serve Open Trades', value: serveAction},
           ],
           loop: false,
           message: 'Trade?',
@@ -97,7 +98,7 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
         cbk);
       }],
 
-      // Confirm that signer RPC is enabled
+      // Confirm that signer RPC is enabled, this is required for trade secret
       checkSigner: ['getIdentity', ({getIdentity}, cbk) => {
         return diffieHellmanComputeSecret({
           lnd,
@@ -113,7 +114,7 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
           return cbk();
         }
 
-        return createTrade({ask, lnd, logger}, cbk);
+        return createTrade({ask, lnd, logger, request}, cbk);
       }],
 
       // Trade was created
@@ -131,14 +132,24 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
       // View an existing trade
       view: ['checkSigner', 'select', ({checkSigner, select}, cbk) => {
         // Exit early when not decoding a trade
-        if (select.action !== decodeAction && select.action !== buyAction) {
+        if (select.action !== decodeAction) {
+          return cbk();
+        }
+
+        return manageTrade({ask, lnd, logger}, cbk)
+      }],
+
+      // Buy a channel
+      buyChannel: ['select', ({select}, cbk) => {
+        // Exit early when not buying a channel
+        if (select.action !== buyAction) {
           return cbk();
         }
 
-        return manageTrade({ask, lnd, logger, action: select.action}, cbk)
+        return buyChannel({ask, lnd, logger}, cbk);
       }],
 
-      // Get open trades
+      // Get open trades that are being offered
       getTrades: ['validate', ({}, cbk) => {
         const paging = {trades: []};
 
@@ -189,11 +200,14 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
           return cbk([404, 'NoTradesCurrentlyOpen']);
         }
 
+        const trades = getTrades.filter(n => !!n.secret && !!n.description);
+
         return ask({
-          choices: getTrades.map(trade => ({
-            name: `${tokensAsBigUnit(trade.tokens)} ${trade.description}`,
-            value: trade.id,
-          })),
+          choices: trades.map(({description, id, price, tokens}) => {
+            const charging = !!tokens ? tokensAsBigUnit(tokens) : price;
+
+            return {name: `${charging} ${description}`, value: id};
+          }),
           message: 'Trade?',
           name: 'manage',
           type: 'list',
@@ -241,11 +255,13 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
         return serviceOpenTrade({
           lnd,
           logger,
+          request,
           channels: [],
           description: trade.description,
           expires_at: trade.expires_at,
           id: trade.id,
           network: getNetwork.network,
+          price: trade.price,
           public_key: getIdentity.public_key,
           secret: trade.secret,
           tokens: trade.tokens,
@@ -280,7 +296,7 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
           return cbk();
         }
 
-        const sub = serviceAnchoredTrades({lnd});
+        const sub = serviceAnchoredTrades({lnd, request});
 
         const {trade} = encodeTrade({
           connect: {
@@ -294,11 +310,15 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
         sub.on('settled', async ({description, to, tokens}) => {
           const {alias, id} = await getNodeAlias({lnd, id: to});
 
-          return logger.info(`sold: ${tokensAsBigUnit(tokens)} ${description} to ${alias} ${to}`);
+          const item = `${description} to ${alias} ${to}`;
+
+          return logger.info(`sold: ${tokensAsBigUnit(tokens)} ${item}`);
         });
 
         sub.on('start', ({description, tokens}) => {
-          return logger.info(`open: ${tokensAsBigUnit(tokens)} ${description}`);
+          const trade = `${tokensAsBigUnit(tokens)} ${description}`;
+
+          return logger.info(`open: ${trade}`);
         });
 
         sub.on('error', err => {
@@ -315,20 +335,7 @@ module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
           return cbk();
         }
 
-        return getChainBalance({lnd}, (err, res) => {
-          if (!!err) {
-            return cbk(err);
-          }
-
-          return createChannelSale({
-            ask,
-            lnd,
-            logger,
-            action: select.action,
-            balance: res.chain_balance,
-          },
-          cbk);
-        });
+        return createChannelSale({ask, lnd, logger, request}, cbk);
       }],
     },
     returnResult({reject, resolve}, cbk));

package/trades/request_trade_by_id.js

@@ -4,7 +4,6 @@ const {returnResult} = require('asyncjs-util');
 const decodeTrade = require('./decode_trade');
 const {makePeerRequest} = require('./../p2p');
 
-const buyChannelAction = 'buy';
 const findTradeRecord = records => records.find(n => n.type === '1');
 const requestTradeTimeoutMs = 1000 * 30;
 const {serviceTypeRequestChannelSale} = require('./../service_types');
@@ -14,7 +13,6 @@ const tradeIdRecordType = '0';
 /** Request a specific trade by its id
 
   {
-    action: <Purchase Action String>
     id: <Trade Identifier Hex String>
     lnd: <Authenticated LND API Object>
     to: <Make Request To Public Key Hex Encoded String>
@@ -28,15 +26,11 @@ const tradeIdRecordType = '0';
     trade: <Encoded Trade Record String>
   }
 */
-module.exports = ({action, id, lnd, to}, cbk) => {
+module.exports = ({id, lnd, to}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!action) {
-          return cbk([400, 'ExpectedActionTypeToRequestTradeById']);
-        }
-
         if (!id) {
           return cbk([400, 'ExpectedTradeIdentifierToRequestTradeById']);
         }
@@ -52,23 +46,14 @@ module.exports = ({action, id, lnd, to}, cbk) => {
         return cbk();
       },
 
-      // Derive request type
-      requestType: ['validate', ({}, cbk) => {
-        if (action === buyChannelAction) {
-          return cbk(null, serviceTypeRequestChannelSale);
-        }
-
-        return cbk(null, serviceTypeRequestTrades);
-      }],
-
       // Get trade
-      getTrade: ['requestType', ({requestType}, cbk) => {
+      getTrade: ['validate', ({}, cbk) => {
         return makePeerRequest({
           lnd,
           to,
           records: [{type: tradeIdRecordType, value: id}],
           timeout: requestTradeTimeoutMs,
-          type: requestType,
+          type: serviceTypeRequestTrades,
         },
         (err, res) => {
           if (!!err) {

package/trades/service_anchored_trades.js

@@ -19,6 +19,7 @@ const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 
   {
     lnd: <Authenticated LND API Object>
+    request: <Request Function>
   }
 
   // Returned details
@@ -65,7 +66,7 @@ const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
   @returns
   <EventEmitter Object>
 */
-module.exports = ({lnd}) => {
+module.exports = ({lnd, request}) => {
   const emitter = new EventEmitter();
   const listening = {};
   const paging = {};
@@ -79,9 +80,11 @@ module.exports = ({lnd}) => {
 
     const sub = serviceTradeRequests({
       lnd,
+      request,
       description: trade.description,
       expires_at: trade.expires_at,
       id: trade.id,
+      price: trade.price,
       secret: trade.secret,
       tokens: trade.tokens,
     });
@@ -195,6 +198,7 @@ module.exports = ({lnd}) => {
           .map(tradeFromInvoice)
           .map(n => n.trade)
           .filter(n => !!n)
+          .filter(n => !!n.description && !!n.secret)
           .forEach(serviceTrade);
 
         return cbk();