paid-services 3.13.2 → 3.14.2

package/trades/service_open_trade.js

@@ -14,21 +14,22 @@ const uriAsSocket = n => n.substring(67);
 /** Service an individual trade
 
   {
-    [action]: <Trade Action String>
-    [capacity]: <Channel Open Capacity Tokens Number>
+    [channel]: <Sell Channel With Capacity Tokens Number>
     channels: [{
       id: <Standard Format Channel Id String>
       partner_public_key: <Node Public Key Hex String>
     }]
-    description: <Trade Description String>
+    [description]: <Trade Description String>
     expires_at: <Expires At ISO 8601 Date String>
     id: <Trade Anchor Id Hex String>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     network: <Network Name String>
+    [price]: <Price Expression String>
     public_key: <Identity Public Key Hex String>
-    secret: <Secret to Sell String>
-    tokens: <Trade Price Tokens Number>
+    request: <Request Function>
+    [secret]: <Secret to Sell String>
+    [tokens]: <Trade Price Tokens Number>
     uris: [<Node URI String>]
   }
 
@@ -39,12 +40,16 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!args.channel && !args.secret) {
+          return cbk([400, 'ExpectedSecretOrChannelToSellToServiceTrade']);
+        }
+
         if (!isArray(args.channels)) {
           return cbk([400, 'ExpectedArrayOfChannelsToServiceTrade']);
         }
 
-        if (!args.description) {
-          return cbk([400, 'ExpectedDescriptionToServiceTrade']);
+        if (!args.channel && !args.description) {
+          return cbk([400, 'ExpectedChannelOrDescriptionToServiceTrade']);
         }
 
         if (!args.expires_at) {
@@ -67,16 +72,16 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedNetworkNameToServiceTrade']);
         }
 
-        if (!args.public_key) {
-          return cbk([400, 'ExpectedIdentityPublicKeyToServiceTrade']);
+        if (!args.price && !args.tokens) {
+          return cbk([400, 'ExpectedTokensOrPriceExpressionToServiceTrade']);
         }
 
-        if (!args.secret) {
-          return cbk([400, 'ExpectedSecretToSellToServiceTrade']);
+        if (!args.public_key) {
+          return cbk([400, 'ExpectedIdentityPublicKeyToServiceTrade']);
         }
 
-        if (!args.tokens) {
-          return cbk([400, 'ExpectedTokensPriceToServiceTrade']);
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToServiceTrade']);
         }
 
         if (!isArray(args.uris)) {
@@ -104,15 +109,15 @@ module.exports = (args, cbk) => {
         args.logger.info({trade_expiry: new Date(args.expires_at)});
 
         const sub = serviceTradeRequests({
-          action: args.action,
-          capacity: args.capacity,
+          channel: args.channel,
           description: args.description,
           expires_at: args.expires_at,
           id: args.id,
           lnd: args.lnd,
-          logger: args.logger,
+          price: args.price,
+          request: args.request,
           secret: args.secret,
-          tokens: asNumber(args.tokens),
+          tokens: args.tokens,
         });
 
         // Someone asked for trade details
@@ -130,6 +135,8 @@ module.exports = (args, cbk) => {
 
         sub.on('failure', failure => args.logger.error({failure}));
 
+        sub.on('opening_channel', opening => args.logger.info({opening}));
+
         sub.on('settled', ({to}) => settled.push(to));
 
         sub.on('trade', async ({to}) => {

package/trades/service_trade_requests.js

@@ -6,7 +6,7 @@ const {getInvoice} = require('ln-service');
 const {subscribeToInvoice} = require('ln-service');
 
 const acceptTrade = require('./accept_trade');
-const finalizeTradeSecret = require('./finalize_trade_secret');
+const finalizeTrade = require('./finalize_trade');
 const {makePeerRequest} = require('./../p2p');
 const {servicePeerRequests} = require('./../p2p');
 const {serviceTypeReceiveChannelSale} = require('./../service_types');
@@ -14,16 +14,15 @@ const {serviceTypeRequestChannelSale} = require('./../service_types');
 const {serviceTypeRequestTrades} = require('./../service_types');
 const {serviceTypeReceiveTrades} = require('./../service_types');
 
+const chanDescription = capacity => `${(capacity / 1e8).toFixed(8)} channel`;
 const descRecord = description => ({type: '2', value: description});
-const events = ['details', 'end', 'failure', 'settled', 'trade'];
+const events = 'details end failure opening_channel settled trade'.split(' ');
 const findIdRecord = records => records.find(n => n.type === '0');
 const findRequestIdRecord = records => records.find(n => n.type === '1');
 const hashHexLength = 64;
 const idBackType = '0';
 const idRecord = id => ({type: '1', value: id});
-const msRemainingToTime = time => time - Date.now();
 const postOpenTradeTimeoutMs = 1000 * 30;
-const sellAction = 'sell';
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const tradeSecretType = '1';
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
@@ -32,15 +31,19 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
 
   The maximum expiration date is three weeks
 
+  Either a channel or secret to sell is required
+  Either a direct price in tokens or a price expression is required
+
   {
-    action: <Trade Action String>
-    description: <Trade Description String>
+    [channel]: <Sell Channel With Capacity Tokens Number>
+    [description]: <Trade Description String>
     expires_at: <Trade Expires At ISO 8601 Date String>
     id: <Trade Id Hex String>
     lnd: <Authenticated LND API Object>
-    logger: <Winston Logger Object>
-    secret: <Secret Payload String>
-    tokens: <Tokens Number>
+    [price]: <Trade Price String>
+    request: <Request Function>
+    [secret]: <Secret Payload String>
+    [tokens]: <Trade Price Tokens Number>
   }
 
   // Return details
@@ -56,6 +59,14 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
   @event 'failure'
   [<Failure Code Number>, <Failure Code String>]
 
+  // Traded a channel open
+  @event 'opening_channel'
+  {
+    fee_tokens_per_vbyte: <Chain Fee Rate Number>
+    transaction_id: <Channel Funding Transaction Id Hex String>
+    transaction_vout: <Channel Funding Transaction Output Index Number>
+  }
+
   // Received payment
   @event 'settled'
   {
@@ -72,7 +83,11 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
   <Service Event Emitter Object>
 */
 module.exports = args => {
-  if (!args.description) {
+  if (!args.channel && !args.secret) {
+    throw new Error('ExpectedChannelOrSecretToEncryptToServiceTradeRequests');
+  }
+
+  if (!args.channel && !args.description) {
     throw new Error('ExpectedTradeDescriptionToServiceTradeRequests');
   }
 
@@ -88,16 +103,15 @@ module.exports = args => {
     throw new Error('ExpectedAuthenticatedLndToServiceTradeRequests');
   }
 
-  if (!args.secret) {
-    throw new Error('ExpectedSecretToEncryptToServiceTradeRequests');
+  if (!args.price && !args.tokens) {
+    throw new Error('ExpectedTokensOrPriceForTradeToServiceTradeRequests');
   }
 
-  if (!args.tokens) {
-    throw new Error('ExpectedTokensPriceForTradeToServiceTradeRequests');
+  if (!args.request) {
+    throw new Error('ExpectedRequestFunctionToServiceTradeRequests');
   }
 
   const emitter = new EventEmitter();
-
   const holds = [];
   const service = servicePeerRequests({lnd: args.lnd});
 
@@ -129,10 +143,10 @@ module.exports = args => {
   // Basic trade description
   const basicTradeRecords = [
     idRecord(args.id),
-    descRecord(utf8AsHex(args.description)),
+    descRecord(utf8AsHex(args.description || chanDescription(args.channel))),
   ];
 
-  const requestType = !!args.action ?
+  const requestType = !!args.channel ?
     serviceTypeRequestChannelSale :
     serviceTypeRequestTrades;
 
@@ -173,7 +187,7 @@ module.exports = args => {
           return;
         }
 
-        const receiveType = args.action === sellAction ?
+        const receiveType = !!args.channel ?
           serviceTypeReceiveChannelSale :
           serviceTypeReceiveTrades;
 
@@ -204,13 +218,15 @@ module.exports = args => {
     emitter.emit('trade', ({to: req.from}));
 
     // Create a trade secret for the requesting peer and return that
-    return finalizeTradeSecret({
-      action: args.action,
+    return finalizeTrade({
+      channel: args.channel,
       description: args.description,
       expires_at: args.expires_at,
+      id: args.id,
       is_hold: true,
       lnd: args.lnd,
-      logger: args.logger,
+      price: args.price,
+      request: args.request,
       secret: args.secret,
       to: req.from,
       tokens: args.tokens,
@@ -219,7 +235,7 @@ module.exports = args => {
       if (!!err) {
         emitter.emit('failure', err);
 
-        return failure([503, 'FailedToFinalizeTradeSecret']);
+        return failure([503, 'FailedToFinalizeTrade']);
       }
 
       // Create a record for the encoded trade
@@ -246,36 +262,40 @@ module.exports = args => {
 
         // Settle the held invoice with the preimage
         return acceptTrade({
-          action: args.action,
-          capacity: args.capacity,
           cancel: holds.filter(n => n.id !== updated.id).map(n => n.id),
+          channel: args.channel,
+          from: req.from,
           id: args.id,
           lnd: args.lnd,
-          logger: args.logger,
-          partner_public_key: req.from,
           secret: res.secret,
         },
-        err => {
+        (err, res) => {
           if (!!err) {
             return emitter.emit('failure', err);
           }
 
           emitter.emit('settled', {to: req.from});
 
+          if (!!res.opening_channel) {
+            emitter.emit('opening_channel', res.opening_channel);
+          }
+
           return emitter.emit('end', {});
         });
       });
 
-      // Exit early on channel sale, confirming acceptance
-      if (args.action === sellAction) {
+      // Exit early on channel sale, make sure a channel can be opened first
+      if (!!args.channel) {
         return acceptsChannelOpen({
-          capacity: args.capacity,
+          capacity: args.channel,
           lnd: args.lnd,
           partner_public_key: req.from,
         },
         err => {
           if (!!err) {
-            return failure([503, 'FailedToAcceptChannelOpen', {err}]);
+            emitter.emit('failure', [503, 'FailedOpenAttempt', {err}]);
+
+            return failure([503, 'CannotOpenChannel']);
           }
 
           // Return details about the trade

package/trades/trade_from_invoice.js

@@ -16,12 +16,14 @@ const decodeAnchoredTrade = require('./decode_anchored_trade');
   @returns
   {
     [trade]: {
+      [channel]: <Channel Sale Tokens Number>
       created_at: <Open Trade Created At ISO 8601 Date String>
-      description: <Trade Description String>
+      [description]: <Trade Description String>
       expires_at: <Trade Expires at ISO 8601 Date String>
       id: <Trade Id Hex String>
-      secret: <Secret Payload String>
-      tokens: <Tokens Number>
+      [price]: <Price Expression String>
+      [secret]: <Secret Payload String>
+      [tokens]: <Tokens Number>
     }
   }
 */
@@ -30,7 +32,7 @@ module.exports = args => {
     return {};
   }
 
-  if (!!args.is_push || !args.tokens) {
+  if (!!args.is_push) {
     return {};
   }
 
@@ -43,12 +45,14 @@ module.exports = args => {
 
   return {
     trade: {
+      channel: trade.channel || undefined,
       created_at: args.created_at,
-      description: trade.description,
+      description: trade.description || undefined,
       expires_at: args.expires_at,
       id: args.id,
-      secret: trade.secret,
-      tokens: args.tokens,
+      price: trade.price || undefined,
+      secret: trade.secret || undefined,
+      tokens: args.tokens || undefined,
     },
   };
 };

package/trades/finalize_trade_secret.js

@@ -1,158 +0,0 @@
-const {createHash} = require('crypto');
-
-const asyncAuto = require('async/auto');
-const {createHodlInvoice} = require('ln-service');
-const {createInvoice} = require('ln-service');
-const {getChainFeeRate} = 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 {ceil} = Math;
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
-const openSizeVbytes = 250;
-const sellAction = 'sell';
-const sha256 = preimage => createHash('sha256').update(preimage).digest();
-const slowConf = 144;
-const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
-
-/** Create a trade secret for a node
-
-  {
-    action: <Trade Action String>
-    description: <Trade Description String>
-    expires_at: <Trade Expires At ISO 8601 Date String>
-    is_hold: <Create Hold Invoice Bool>
-    lnd: <Authenticated LND API Object>
-    logger: <Winston Logger 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();
-      },
-
-      // Calculate dynamic sale price for channel sales
-      salePrice: ['validate', ({}, cbk) => {
-        // Exit early when this is not a channel sale
-        if (args.action !== sellAction) {
-          return cbk(null, {});
-        }
-
-        // Get a chain fee rate to dynamically price vs the chain cost
-        return getChainFeeRate({
-          confirmation_target: slowConf,
-          lnd: args.lnd,
-        },
-        (err, res) => {
-          if (!!err) {
-            return cbk(err);
-          }
-
-          const chainSurcharge = ceil(res.tokens_per_vbyte * openSizeVbytes);
-
-          const price = chainSurcharge + args.tokens;
-
-          args.logger.info({total_channel_sale_cost: price});
-
-          return cbk(null, {price});
-        },
-        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', 'salePrice', ({encrypt, salePrice}, 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: salePrice.price || 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/open_channel.js

@@ -1,60 +0,0 @@
-const asyncAuto = require('async/auto');
-const {getPeers} = require('ln-service');
-const {getChainFeeRate} = require('ln-service');
-const {openChannel} = require('ln-service');
-const {returnResult} = require('asyncjs-util');
-
-const slowConf = 144;
-
-/** Opens channel on invoice payment
-  {
-    id: <Partner Public Key Hex String>
-    lnd: <Authenticated LND API Object>
-    tokens: <Capacity of Channel To Open Tokens Number>
-  }
-
-  @returns via cbk or Promise
-  {
-    transaction_id: <Funding Transaction Id String>
-    transaction_vout: <Funding Transaction Output Index Number>
-  }
-*/
-module.exports = ({id, lnd, tokens}, cbk) => {
-  return new Promise((resolve, reject) => {
-    return asyncAuto({
-      // Check arguments
-      validate: cbk => {
-        if (!id) {
-          return cbk([400, 'ExpectedPartnerPublicKeyToOpenNewChannel']);
-        }
-
-        if (!lnd) {
-          return cbk([400, 'ExpectedLndObjectToOpenNewChannel']);
-        }
-
-        if (!tokens) {
-          return cbk([400, 'ExpectedCapacityToOpenNewChannel']);
-        }
-
-        return cbk();
-      },
-
-      // Get low fee rate
-      getSlowFee: ['validate', ({}, cbk) => {
-        return getChainFeeRate({lnd, confirmation_target: slowConf}, cbk);
-      }],
-
-      // Select a peer and open a channel
-      openChannel: ['getSlowFee', ({getSlowFee}, cbk) => {
-        return openChannel({
-          lnd,
-          chain_fee_rate: getSlowFee.tokens_per_vbyte,
-          local_tokens: tokens,
-          partner_public_key: id,
-        },
-        cbk);
-      }],
-    },
-    returnResult({reject, resolve, of: 'openChannel'}, cbk));
-  });
-};