paid-services 3.13.2 → 3.14.2

package/trades/connect_to_seller.js

@@ -0,0 +1,183 @@
+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 {getIdentity} = require('ln-service');
+const {getNode} = require('ln-service');
+const {getPeers} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {isArray} = Array;
+const uniq = arr => Array.from(new Set(arr));
+
+/** Connect to a seller
+
+  {
+    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
+  {
+    id: <Seller Public Key Hex String>
+  }
+*/
+module.exports = ({lnd, logger, nodes}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToConnectToSeller']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToConnectToSeller']);
+        }
+
+        if (!isArray(nodes)) {
+          return cbk([400, 'ExpectedArrayOfNodesToConnectToSeller']);
+        }
+
+        return cbk();
+      },
+
+      // Derive the self public key
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Get the list of connected peers
+      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
+
+      // Find node connect info to connect to
+      getNodes: ['getIdentity', ({getIdentity}, cbk) => {
+        return asyncMap(nodes, (connect, cbk) => {
+          // Exit early when the node is self
+          if (!!connect.node && connect.node.id === getIdentity.public_key) {
+            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 === getIdentity.public_key) {
+              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);
+      }],
+
+      // 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);
+      }],
+
+      // Connected to seller
+      connected: ['connect', ({connect}, cbk) => {
+        if (!connect) {
+          return cbk([503, 'FailedToConnectToNode']);
+        }
+
+        return cbk(null, {id: connect.id});
+      }],
+    },
+    returnResult({reject, resolve, of: 'connected'}, cbk));
+  });
+};

package/trades/convert_fiat.js

@@ -0,0 +1,112 @@
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {getPrices} = require('@alexbosworth/fiat');
+const {returnResult} = require('asyncjs-util');
+
+const cached = {};
+const convert = (price, rate) => Math.round((price * 1e8) / (rate / 100));
+const defaultFiatRateProvider = 'coingecko';
+const interval = 1000;
+const isFresh = date => Date.now() - date > 1000 * 60 * 10;
+let isLocked = false;
+const isNumber = n => !isNaN(n);
+const {now} = Date;
+const parseFiat = n => n.split('*')[1];
+const parseFiatPrice = n => Number(n.split('*')[0]);
+const removeSpaces = s => s.replace(/\s/g, '');
+
+/** Converts fiat to tokens
+
+  A fiat price expression looks like AMOUNT*USD
+
+  {
+    price: <Fiat Price Expression String>
+    request: <Request Function>
+  }
+
+  @returns
+  {
+    cost: <Price of Trade in Tokens>
+  }
+*/
+module.exports = ({price, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!price) {
+          return cbk([400, 'ExpectedFiatPriceToConvertFiat']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToConvertFiat']);
+        }
+
+        if (!isNumber(parseFiatPrice(price))) {
+          return cbk([400, 'ExpectedFiatPriceNumberToConvert']);
+        }
+
+        return cbk();
+      },
+
+      // Wait for request lock to unlock
+      waitForLock: ['validate', ({}, cbk) => {
+        return asyncRetry({interval}, cbk => {
+          if (isLocked) {
+            return cbk([503, 'FailedToGetFiatRatesDueToBusyRateLookups']);
+          }
+
+          return cbk();
+        },
+        cbk);
+      }],
+
+      // Get the current exchange rate
+      getRate: ['waitForLock', ({}, cbk) => {
+        const fiat = parseFiat(removeSpaces(price));
+
+        // Exit early when the rate has a fresh cache
+        if (!!cached[fiat] && isFresh(cached[fiat].date)) {
+          return cbk(null, cached[fiat].rate);
+        }
+
+        // Enable the request lock to avoid making simultaneous requests
+        isLocked = true;
+
+        return getPrices({
+          request,
+          from: defaultFiatRateProvider,
+          symbols: [fiat],
+        },
+        (err, res) => {
+          // Disable the request lock to allow another request through
+          isLocked = false;
+
+          if (!!err) {
+            return cbk(err);
+          }
+
+          const [{rate}] = res.tickers;
+
+          if (!rate) {
+            return cbk([503, 'ExpectedFiatRateFromRateProvider']);
+          }
+
+          // Update the value cache to avoid hammering the service
+          cached[fiat] = {rate, date: now()};
+
+          // Return the fresh value
+          return cbk(null, rate);
+        });
+      }],
+
+      // Convert the price into a tokens cost
+      cost: ['getRate', ({getRate}, cbk) => {
+        const cost = convert(parseFiatPrice(price), getRate);
+
+        return cbk(null, {cost});
+      }],
+    },
+    returnResult({reject, resolve, of: 'cost'}, cbk));
+  });
+};

package/trades/create_anchored_trade.js

@@ -4,17 +4,23 @@ const {returnResult} = require('asyncjs-util');
 
 const encodeAnchoredTrade = require('./encode_anchored_trade');
 
-const maxDescriptionLength = 100;
+const maxDescLength = 100;
 const maxSecretLength = 100;
 
 /** Create an anchored trade
 
+  Either a channel or description and secret is required
+
+  Either a price or tokens is required
+
   {
-    description: <Trade Description String>
+    [channel]: <Channel Sale Capacity Tokens Number>
+    [description]: <Trade Description String>
     expires_at: <Trade Expires at ISO 8601 Date String>
     lnd: <Authenticated LND API Object>
-    secret: <Trade Secret String>
-    tokens: <Trade Price Tokens Number>
+    [price]: <Trade Price String>
+    [secret]: <Trade Secret String>
+    [tokens]: <Trade Price Tokens Number>
   }
 
   @returns via cbk or Promise
@@ -27,11 +33,15 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (args.description === undefined) {
+        if (!args.channel && !args.description) {
           return cbk([400, 'ExpectedTradeDescriptionToCreateAnchoredTrade']);
         }
 
-        if (args.description.length > maxDescriptionLength) {
+        if (!args.channel && !args.secret) {
+          return cbk([400, 'ExpectedEitherChannelOrSecretToTrade']);
+        }
+
+        if (!!args.description && args.description.length > maxDescLength) {
           return cbk([400, 'ExpectedShorterTradeDescriptionToCreateTrade']);
         }
 
@@ -47,28 +57,27 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedAuthenticatedLndToCreateAnchoredTrade']);
         }
 
-        if (!args.secret) {
-          return cbk([400, 'ExpectedTradeSecretToCreateAnchoredTrade']);
+        if (!args.price && !args.tokens) {
+          return cbk([400, 'ExpectedTokensPriceToCreateAnchoredTrade']);
         }
 
-        if (args.secret.length > maxSecretLength) {
+        if (!!args.secret && args.secret.length > maxSecretLength) {
           return cbk([400, 'ExpectedShorterTradeSecretToCreateAnchoredTrade']);
         }
 
-        if (!args.tokens) {
-          return cbk([400, 'ExpectedTokensPriceToCreateAnchoredTrade']);
-        }
-
         return cbk();
       },
 
       // Create the trade
       create: ['validate', ({}, cbk) => {
         const {encoded} = encodeAnchoredTrade({
+          channel: args.channel,
           description: args.description,
+          price: args.price,
           secret: args.secret,
         });
 
+        // The anchor invoice description will contain the trade details
         return createInvoice({
           description: encoded,
           expires_at: args.expires_at,