paid-services 3.13.2 → 3.14.2

package/trades/create_channel_sale.js

@@ -1,56 +1,50 @@
-const {randomBytes} = require('crypto');
-
 const asyncAuto = require('async/auto');
-const asyncReflect = require('async/reflect');
-const {getChainFeeRate} = require('ln-service');
+const {getChainBalance} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getWalletInfo} = require('ln-service');
-const {signMessage} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const convertFiat = require('./convert_fiat');
 const createAnchoredTrade = require('./create_anchored_trade');
 const serviceOpenTrade = require('./service_open_trade');
 
 const asNumber = n => parseFloat(n, 10);
 const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
+const defaultChannelSize = 5000000;
 const defaultExpirationDays = 1;
+const {floor} = Math;
 const futureDate = ms => new Date(Date.now() + ms).toISOString();
 const isNumber = n => !isNaN(n);
+const {min} = Math;
+const minChannelSize = 20000;
+const ppmCost = (amount, rate) => Math.ceil(amount * rate / 1000000);
+const priceFiat = 'price-in-fiat';
+const pricePpm = 'price-in-ppm';
+const priceTokens = 'price-in-tokens';
 const query = 'How much would you like to sell?';
-const saleCost = (amount, rate) => (amount * rate / 1000000).toFixed(0);
-const saleSecret = randomBytes(48).toString('hex');
-const tradeDescription = (alias, tokens) => `channelsale:${alias}-${tokens}`;
+const usdAsPrice = usd => `${usd}*USD`;
 
 /** Create a new channel sale
 
   {
-    action: <Channel Sale Action String>
     ask: <Ask Function>
-    balance: <Total Available Chain Confirmed Balance Tokens Number>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    request: <Request Function>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
+module.exports = ({ask, lnd, logger, request}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!action) {
-          return cbk([400, 'ExpectedActionTypeToCreateChannelSale']);
-        }
-
         if (!ask) {
           return cbk([400, 'ExpectedAskFunctionToCreateChannelSale']);
         }
 
-        if (balance === undefined) {
-          return cbk([400, 'ExpectedOnChainBalanceToCreateChannelSale']);
-        }
-
         if (!lnd) {
           return cbk([400, 'ExpectedLndToCreateChannelSale']);
         }
@@ -59,9 +53,16 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
           return cbk([400, 'ExpectedLoggerToCreateChannelSale']);
         }
 
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToCreateChannelSale']);
+        }
+
         return cbk();
       },
 
+      // Get the current chain balance to set the limit for a channel sale
+      getBalance: ['validate', ({}, cbk) => getChainBalance({lnd}, cbk)],
+
       // Get the public channels to use for an open trade
       getChannels: ['validate', ({}, cbk) => {
         return getChannels({lnd, is_public: true}, cbk);
@@ -73,10 +74,15 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
       // Get the network name to use for an open trade
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
 
-      // Ask for sale amount
-      askForAmount: ['validate', ({}, cbk) => {
+      // Ask for channel capacity to sell
+      askForAmount: ['getBalance', ({getBalance}, cbk) => {
+        if (getBalance.chain_balance < minChannelSize) {
+          return cbk([400, 'InsufficientOnChainFundsToSellChannel']);
+        }
+
         return ask({
-          message: `${query} (Available balance: ${balance})`,
+          default: min(defaultChannelSize, getBalance.chain_balance),
+          message: `${query} (Available balance: ${getBalance.chain_balance})`,
           name: 'amount',
           type: 'input',
           validate: input => {
@@ -86,31 +92,56 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
 
             // The token amount should be numeric
             if (!isNumber(input)) {
-              return 'Expected numeric amount for sale';
+              return 'Expected numeric amount for channel capacity';
             }
 
-            if (input > balance) {
-              return 'Sale amount cannot be more than available balance';
+            // Avoid listing more coins than are present on-chain
+            if (Number(input) > getBalance.chain_balance) {
+              return 'Capacity cannot be more than available balance';
+            }
+
+            if (Number(input) < minChannelSize) {
+              return `Channel capacity must be larger than ${minChannelSize}`;
+            }
+
+            // Disallow fractional values
+            if (!!isNumber(input) && floor(input) !== asNumber(input)) {
+              return 'Decimal capacities are not supported';
             }
 
             return true;
           },
         },
-        (err, result) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorAskingForSaleAmount', {err}]);
-          }
+        cbk);
+      }],
 
-          return cbk(null, result);
-        });
+      // Select method of pricing
+      selectPricing: ['askForAmount', ({}, cbk) => {
+        return ask({
+          choices: [
+            {name: 'Set absolute price', value: priceTokens},
+            {name: 'Set price by PPM (parts per million)', value: pricePpm},
+            {name: 'Set price in fiat (USD)', value: priceFiat},
+          ],
+          default: pricePpm,
+          message: '?',
+          name: 'action',
+          type: 'list',
+        },
+        cbk);
       }],
 
-      // Ask for the rate
-      askForRate: ['askForAmount', ({}, cbk) => {
+      // Ask for fiat based cost
+      askForFiat: ['selectPricing', ({selectPricing}, cbk) => {
+        // Exit early when the pricing is not in fiat
+        if (selectPricing.action !== priceFiat) {
+          return cbk();
+        }
+
         return ask({
-          default: '1',
-          message: 'Price of channel (in ppm)?',
-          name: 'rate',
+          default: '0.01',
+          message: 'Dollars USD to charge?',
+          name: 'usd',
           type: 'input',
           validate: input => {
             if (!input) {
@@ -119,23 +150,83 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
 
             // Price of sale should be numeric
             if (!isNumber(input)) {
-              return 'Expected numeric fee rate for sale';
+              return 'Not a number of dollars, try a number?';
             }
 
             return true;
           },
         },
-        (err, result) => {
-          if (!!err) {
-            return cbk([503, 'UnexpectedErrorAskingForRate', err]);
-          }
+        cbk);
+      }],
+
+      // Ask for absolute cost
+      askForPrice: ['selectPricing', ({selectPricing}, cbk) => {
+        // Exit early when the pricing is not absolute
+        if (selectPricing.action !== priceTokens) {
+          return cbk();
+        }
+
+        return ask({
+          default: '1337',
+          message: 'Amount to charge?',
+          name: 'tokens',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // Price of sale should be numeric
+            if (!isNumber(input)) {
+              return 'Not a number, try a number?';
+            }
+
+            // Disallow fractional values
+            if (!!isNumber(input) && floor(input) !== asNumber(input)) {
+              return 'Specified precision not supported';
+            }
 
-          return cbk(null, result);
-        });
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Ask for rate-based cost
+      askForRate: ['askForAmount', 'selectPricing', ({selectPricing}, cbk) => {
+        // Exit early when the pricing is not in ppm
+        if (selectPricing.action !== pricePpm) {
+          return cbk();
+        }
+
+        return ask({
+          default: '350',
+          message: 'Price in PPM?',
+          name: 'rate',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // Price of sale should be in numeric ppm
+            if (!isNumber(input)) {
+              return 'Unable to parse rate, try a numeric ppm rate?';
+            }
+
+            // Disallow fractional values
+            if (!!isNumber(input) && floor(input) !== asNumber(input)) {
+              return 'Specified precision not supported';
+            }
+
+            return true;
+          },
+        },
+        cbk);
       }],
 
       // Ask for the expiration of the channel sale
-      askForExpiration: ['askForRate', ({}, cbk) => {
+      askForDays: ['askForFiat', 'askForPrice', 'askForRate', ({}, cbk) => {
         return ask({
           default: defaultExpirationDays,
           name: 'days',
@@ -151,40 +242,54 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
         cbk);
       }],
 
-      // Calculate sale cost
-      saleCost: [
-        'askForAmount',
-        'askForRate',
-        ({askForRate, askForAmount}, cbk) =>
-      {
-        return cbk(null, saleCost(askForAmount.amount, askForRate.rate));
+      // Check ability to get fiat prices
+      checkCostLookup: ['askForFiat', ({askForFiat}, cbk) => {
+        // Exit early when no fiat is referenced
+        if (!askForFiat) {
+          return cbk();
+        }
+
+        return convertFiat({request, price: usdAsPrice(askForFiat.usd)}, cbk);
       }],
 
-      // Description of sale
-      description: [
+      // Determine the tokens value of the trade
+      cost: [
         'askForAmount',
-        'getIdentity',
-        ({askForAmount, getIdentity}, cbk) =>
+        'askForFiat',
+        'askForPrice',
+        'askForRate',
+        ({askForAmount, askForFiat, askForPrice, askForRate}, cbk) =>
       {
-        const alias = getIdentity.alias || getIdentity.public_key;
+        // Exit early when price is in fiat, not tokens
+        if (!!askForFiat) {
+          return cbk(null, {price: usdAsPrice(askForFiat.usd)});
+        }
 
-        return cbk(null, tradeDescription(alias, askForAmount.amount));
+        // Exit early when the price is specified directly
+        if (!!askForPrice) {
+          return cbk(null, {tokens: askForPrice.tokens});
+        }
+
+        // Calculate the rate that was specified in PPM
+        const tokens = ppmCost(Number(askForAmount.amount), askForRate.rate);
+
+        return cbk(null, {tokens});
       }],
 
       // Create an anchor invoice for the channel sale
       createAnchor: [
-        'askForExpiration',
-        'askForRate',
-        'description',
-        'saleCost',
-        ({askForExpiration, description, saleCost}, cbk) =>
+        'askForAmount',
+        'askForDays',
+        'checkCostLookup',
+        'cost',
+        ({askForAmount, askForDays, askForRate, cost}, cbk) =>
       {
         return createAnchoredTrade({
-          description,
           lnd,
-          expires_at: futureDate(daysAsMs(askForExpiration.days)),
-          secret: saleSecret,
-          tokens: asNumber(saleCost),
+          channel: Number(askForAmount.amount),
+          expires_at: futureDate(daysAsMs(askForDays.days)),
+          price: cost.price,
+          tokens: cost.tokens,
         },
         cbk);
       }],
@@ -192,37 +297,36 @@ module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
       // Wait for a peer to connect and ask for the channel sale details
       serviceSaleRequests: [
         'askForAmount',
-        'askForExpiration',
+        'askForDays',
+        'cost',
         'createAnchor',
-        'description',
         'getChannels',
         'getNetwork',
         'getIdentity',
         ({
           askForAmount,
-          askForExpiration,
+          askForDays,
+          askForRate,
+          cost,
           createAnchor,
-          description,
           getChannels,
           getNetwork,
           getIdentity,
-          saleCost,
         },
         cbk) =>
       {
         return serviceOpenTrade({
-          action,
-          description,
           lnd,
           logger,
-          capacity: askForAmount.amount,
+          request,
+          channel: Number(askForAmount.amount),
           channels: getChannels.channels,
-          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          expires_at: futureDate(daysAsMs(askForDays.days)),
           id: createAnchor.id,
           network: getNetwork.network,
+          price: cost.price,
           public_key: getIdentity.public_key,
-          secret: saleSecret,
-          tokens: asNumber(saleCost),
+          tokens: cost.tokens,
           uris: (getIdentity.uris || []),
         },
         cbk);

package/trades/create_trade.js

@@ -4,20 +4,25 @@ const {getNetwork} = require('ln-sync');
 const {getWalletInfo} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const convertFiat = require('./convert_fiat');
 const createAnchoredTrade = require('./create_anchored_trade');
-const finalizeTradeSecret = require('./finalize_trade_secret');
+const finalizeTrade = require('./finalize_trade');
 const serviceOpenTrade = require('./service_open_trade');
 
 const asNumber = n => parseFloat(n, 10);
 const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
-const defaultExpirationDays = 14;
+const defaultExpirationDays = 1;
+const defaultFiatInvoiceExpiryMs = 1000 * 60 * 30;
 const {floor} = Math;
 const futureDate = ms => new Date(Date.now() + ms).toISOString();
 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 priceFiat = 'set-price-fiat';
+const priceTokens = 'set-price-tokens';
 const uriAsSocket = n => n.substring(67);
+const usdAsPrice = ({usd}) => `${usd}*USD`;
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
 
 /** Create a new trade
@@ -26,6 +31,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    request: <Request Function>
   }
 
   @returns via cbk or Promise
@@ -33,7 +39,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({ask, lnd, logger}, cbk) => {
+module.exports = ({ask, lnd, logger, request}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -50,6 +56,10 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk([400, 'ExpectedWinstonLoggerToCreateTrade']);
         }
 
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToCreateTrade']);
+        }
+
         return cbk();
       },
 
@@ -126,7 +136,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
       askForSecret: ['askForDescription', ({askForDescription}, cbk) => {
         return ask({
           name: 'secret',
-          message: 'Enter the secret you want to sell',
+          message: 'What is the secret you want to sell?',
           type: 'input',
           validate: input => {
             if (!input) {
@@ -143,19 +153,81 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         cbk);
       }],
 
+      // Select pricing type
+      selectPriceType: [
+        'askForNodeId',
+        'askForSecret',
+        ({askForNodeId}, cbk) =>
+      {
+        // Exit early and force absolute price when this is a direct trade
+        if (!!askForNodeId.id) {
+          return cbk(null, {type: priceTokens});
+        }
+
+        return ask({
+          choices: [
+            {name: 'Set absolute price', value: priceTokens},
+            {name: 'Set dynamic price in fiat terms (USD)', value: priceFiat},
+          ],
+          message: '?',
+          name: 'type',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Ask for the fiat price of the secret
+      askForFiatPrice: ['selectPriceType', ({selectPriceType}, cbk) => {
+        // Exit early when not setting a fiat price
+        if (selectPriceType.type !== priceFiat) {
+          return cbk();
+        }
+
+        return ask({
+          default: '0.01',
+          message: 'Dollars USD to charge?',
+          name: 'usd',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // Price of sale should be numeric
+            if (!isNumber(input)) {
+              return 'Not a number of dollars, try a number?';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
       // Ask for the price of the secret
-      askForPrice: ['askForSecret', ({}, cbk) => {
+      askForTokensPrice: ['selectPriceType', ({selectPriceType}, cbk) => {
+        // Exit early when not asking for an absolute price
+        if (selectPriceType.type !== priceTokens) {
+          return cbk();
+        }
+
         return ask({
+          default: '1',
+          message: 'Amount to charge?',
           name: 'tokens',
-          message: 'How much do you want to charge?',
+          type: 'input',
           validate: input => {
-            // Only allow numeric input
-            if (!isNumber(input)) {
+            if (!input) {
               return false;
             }
 
+            // Price of sale should be numeric
+            if (!isNumber(input)) {
+              return 'Not a number, try a number?';
+            }
+
             // Disallow fractional values
-            if (floor(input) !== asNumber(input)) {
+            if (!!isNumber(input) && floor(input) !== asNumber(input)) {
               return 'Specified precision not supported';
             }
 
@@ -166,12 +238,13 @@ module.exports = ({ask, lnd, logger}, cbk) => {
       }],
 
       // Ask for the expiration of the trade
-      askForExpiration: ['askForPrice', ({}, cbk) => {
+      askForExpiration: ['askForFiatPrice', 'askForTokensPrice', ({}, cbk) => {
         return ask({
           default: defaultExpirationDays,
           name: 'days',
           message: 'Days to offer this for?',
           validate: input => {
+            // Days must be a number
             if (!isNumber(input) || !Number(input)) {
               return false;
             }
@@ -182,19 +255,33 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         cbk);
       }],
 
+      // Get the conversion to tokens for fiat
+      getTokens: ['askForFiatPrice', ({askForFiatPrice}, cbk) => {
+        // Exit early if not using fiat
+        if (!askForFiatPrice) {
+          return cbk();
+        }
+
+        // Check that the fiat price can be converted
+        return convertFiat({request, price: usdAsPrice(askForFiatPrice)}, cbk);
+      }],
+
       // Create an anchor invoice for the trade
       createAnchor: [
         'askForDescription',
         'askForExpiration',
+        'askForFiatPrice',
         'askForNodeId',
-        'askForPrice',
         'askForSecret',
+        'askForTokensPrice',
+        'getTokens',
         ({
           askForDescription,
           askForExpiration,
+          askForFiatPrice,
           askForNodeId,
-          askForPrice,
           askForSecret,
+          askForTokensPrice,
         },
         cbk) =>
       {
@@ -203,12 +290,16 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        // Tokens may be undefined when fiat price is set
+        const {tokens} = !!askForTokensPrice ? askForTokensPrice : {};
+
         return createAnchoredTrade({
           lnd,
+          tokens,
           description: askForDescription.description,
           expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          price: !!askForFiatPrice ? usdAsPrice(askForFiatPrice) : undefined,
           secret: askForSecret.secret,
-          tokens: asNumber(askForPrice.tokens),
         },
         cbk);
       }],
@@ -217,9 +308,10 @@ module.exports = ({ask, lnd, logger}, cbk) => {
       serviceTradeRequests: [
         'askForDescription',
         'askForExpiration',
+        'askForFiatPrice',
         'askForNodeId',
-        'askForPrice',
         'askForSecret',
+        'askForTokensPrice',
         'createAnchor',
         'getChannels',
         'getIdentity',
@@ -227,9 +319,10 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         ({
           askForDescription,
           askForExpiration,
+          askForFiatPrice,
           askForNodeId,
-          askForPrice,
           askForSecret,
+          askForTokensPrice,
           createAnchor,
           getChannels,
           getIdentity,
@@ -245,14 +338,16 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         return serviceOpenTrade({
           lnd,
           logger,
+          request,
           channels: getChannels.channels,
           description: askForDescription.description,
           expires_at: futureDate(daysAsMs(askForExpiration.days)),
           id: createAnchor.id,
           network: getNetwork.network,
+          price: !!askForFiatPrice ? usdAsPrice(askForFiatPrice) : undefined,
           public_key: getIdentity.public_key,
           secret: askForSecret.secret,
-          tokens: asNumber(askForPrice.tokens),
+          tokens: (!!askForTokensPrice ? askForTokensPrice : {}).tokens,
           uris: (getIdentity.uris || []),
         },
         cbk);
@@ -263,14 +358,14 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         'askForDescription',
         'askForExpiration',
         'askForNodeId',
-        'askForPrice',
         'askForSecret',
+        'askForTokensPrice',
         ({
           askForDescription,
           askForExpiration,
           askForNodeId,
-          askForPrice,
           askForSecret,
+          askForTokensPrice,
         },
         cbk) =>
       {
@@ -279,13 +374,13 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        return finalizeTradeSecret({
+        return finalizeTrade({
           lnd,
           description: askForDescription.description,
           expires_at: futureDate(daysAsMs(askForExpiration.days)),
           secret: askForSecret.secret,
           to: askForNodeId.id,
-          tokens: asNumber(askForPrice.tokens),
+          tokens: asNumber(askForTokensPrice.tokens),
         },
         cbk);
       }],