paid-services 3.4.0 → 3.7.0

package/trades/create_trade.js

@@ -1,21 +1,23 @@
 const asyncAuto = require('async/auto');
+const {createInvoice} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getNetwork} = require('ln-sync');
-const {getNodeAlias} = require('ln-sync');
 const {getWalletInfo} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
-const encodeOpenTrade = require('./encode_open_trade');
+const encodeAnchoredTrade = require('./encode_anchored_trade');
 const finalizeTradeSecret = require('./finalize_trade_secret');
-const serviceTradeRequests = require('./service_trade_requests');
+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 {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 nodeName = (alias, id) => `${alias} ${id}`;
 const uriAsSocket = n => n.substring(67);
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
 
@@ -164,20 +166,76 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         cbk);
       }],
 
+      // Ask for the expiration of the trade
+      askForExpiration: ['askForPrice', ({}, cbk) => {
+        return ask({
+          default: defaultExpirationDays,
+          name: 'days',
+          message: 'Days to offer this for?',
+          validate: input => {
+            if (!isNumber(input) || !Number(input)) {
+              return false;
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Create an anchor invoice for the trade
+      createAnchor: [
+        'askForDescription',
+        'askForExpiration',
+        'askForNodeId',
+        'askForPrice',
+        'askForSecret',
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
+      {
+        // Exit early if this is a closed trade
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        const {encoded} = encodeAnchoredTrade({
+          description: askForDescription.description,
+          secret: askForSecret.secret,
+        });
+
+        return createInvoice({
+          lnd,
+          description: encoded,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          tokens: asNumber(askForPrice.tokens),
+        },
+        cbk);
+      }],
+
       // Wait for a peer to connect and ask for the trade details
       serviceTradeRequests: [
         'askForDescription',
+        'askForExpiration',
         'askForNodeId',
         'askForPrice',
         'askForSecret',
+        'createAnchor',
         'getChannels',
         'getIdentity',
         'getNetwork',
         ({
           askForDescription,
+          askForExpiration,
           askForNodeId,
           askForPrice,
           askForSecret,
+          createAnchor,
           getChannels,
           getIdentity,
           getNetwork,
@@ -189,64 +247,37 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        // Encode the open trade details to give out
-        const openTrade = encodeOpenTrade({
-          network: getNetwork.network,
-          nodes: [{
-            channels: getChannels.channels,
-            id: getIdentity.public_key,
-            sockets: (getIdentity.uris || []).map(uriAsSocket),
-          }],
-        });
-
-        const settled = [];
-
-        const sub = serviceTradeRequests({
+        return serviceOpenTrade({
           lnd,
+          logger,
+          channels: getChannels.channels,
           description: askForDescription.description,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          id: createAnchor.id,
+          network: getNetwork.network,
+          public_key: getIdentity.public_key,
           secret: askForSecret.secret,
           tokens: asNumber(askForPrice.tokens),
-        });
-
-        sub.on('details', async ({to}) => {
-          const {alias, id} = await getNodeAlias({lnd, id: to});
-
-          return logger.info({return_trade_info_to: nodeName(alias, id)});
-        });
-
-        sub.once('end', async () => {
-          const [to] = settled;
-
-          if (!!to) {
-            const {alias, id} = await getNodeAlias({lnd, id: to});
-
-            return logger.info({finished_trade_with: nodeName(alias, id)});
-          }
-
-          return cbk();
-        });
-
-        sub.on('failure', failure => logger.error({failure}));
-
-        sub.on('settled', ({to}) => settled.push(to));
-
-        sub.on('trade', async ({to}) => {
-          const {alias, id} = await getNodeAlias({lnd, id: to});
-
-          return logger.info({make_trade_invoice_for: nodeName(alias, id)});
-        });
-
-        // Show the trade details blob
-        return logger.info({waiting_for_trade_request_to: openTrade.trade});
+          uris: (getIdentity.uris || []),
+        },
+        cbk);
       }],
 
       // Finalize the trade with an encrypted secret and an invoice
       finalize: [
         'askForDescription',
+        'askForExpiration',
         'askForNodeId',
         'askForPrice',
         'askForSecret',
-        ({askForDescription, askForNodeId, askForPrice, askForSecret}, cbk) =>
+        ({
+          askForDescription,
+          askForExpiration,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+        },
+        cbk) =>
       {
         // Exit early when there is no node to finalize the trade to
         if (!askForNodeId.id) {
@@ -256,6 +287,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         return finalizeTradeSecret({
           lnd,
           description: askForDescription.description,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
           secret: askForSecret.secret,
           to: askForNodeId.id,
           tokens: asNumber(askForPrice.tokens),

package/trades/decode_anchored_trade.js

@@ -0,0 +1,56 @@
+const {decodeTlvStream} = require('bolt01');
+
+const anchorPrefix = 'anchor-trade-secret:';
+const base64AsHex = base64 => Buffer.from(base64, 'base64').toString('hex');
+const findDescription = records => records.find(n => n.type === '1');
+const findSecret = records => records.find(n => n.type === '0');
+const hexAsUtf = n => !n ? '' : Buffer.from(n.value, 'hex').toString('utf8');
+
+/** Decode an anchored trade data blob
+
+  Data blobs look like anchored-trade-secret:<base64-encoded-data>
+
+  Inside the base64 is encoded TLV data:
+  0: <Trade Secret>
+  [1]: <Trade Description>
+
+  {
+    encoded: <Encoded Trade Data String>
+  }
+
+  @returns
+  {
+    [trade]: {
+      description: <Description of Trade String>
+      secret: <Trade Secret String>
+    }
+  }
+*/
+module.exports = ({encoded}) => {
+  if (!encoded.startsWith(anchorPrefix)) {
+    return {};
+  }
+
+  const data = encoded.slice(anchorPrefix.length);
+
+  try {
+    decodeTlvStream({encoded: base64AsHex(data)});
+  } catch (err) {
+    return {};
+  }
+
+  const {records} = decodeTlvStream({encoded: base64AsHex(data)});
+
+  const secret = findSecret(records);
+
+  if (!secret.value) {
+    return {};
+  }
+
+  return {
+    trade: {
+      description: hexAsUtf(findDescription(records)),
+      secret: hexAsUtf(secret),
+    },
+  };
+};

package/trades/encode_anchored_trade.js

@@ -0,0 +1,35 @@
+const {encodeTlvStream} = require('bolt01');
+
+const anchorPrefix = 'anchor-trade-secret:';
+const descriptionRecord = value => !!value ? ({value, type: '1'}) : undefined;
+const secretRecord = value => ({value, type: '0'});
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
+
+/** Encode a trade into an anchor blob
+
+  This will look like anchored-trade-secret:<base64-encoded-data>
+
+  The data encodes a TLV:
+  0: <Trade Secret>
+  [1]: <Trade Description>
+
+  {
+    [description]: <Open Trade Description String>
+    secret: <Open Trade Secret String>
+  }
+
+  @returns
+  {
+    encoded: <Encoded Anchor Trade Data Blob String>
+  }
+*/
+module.exports = ({description, secret}) => {
+  const records = [secretRecord(secret), descriptionRecord(description)]
+    .filter(n => !!n)
+    .map(({type, value}) => ({type, value: utf8AsHex(value)}));
+
+  const {encoded} = encodeTlvStream({records});
+
+  return {encoded: withPrefix(anchorPrefix, encoded)};
+};

package/trades/finalize_trade_secret.js

@@ -17,6 +17,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
 
   {
     description: <Trade Description String>
+    expires_at: <Trade Expires At ISO 8601 Date String>
     is_hold: <Create Hold Invoice Bool>
     lnd: <Authenticated LND API Object>
     secret: <Clear Secret String>
@@ -40,6 +41,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedDescriptionToFinalizeTradeSecret']);
         }
 
+        if (!args.expires_at) {
+          return cbk([400, 'ExpectedExpiresAtDateToFinalizeTradeSecret']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToFinalizeTradeSecret']);
         }
@@ -75,6 +80,7 @@ module.exports = (args, cbk) => {
         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,
@@ -85,6 +91,7 @@ module.exports = (args, cbk) => {
 
         return createInvoice({
           description: args.description,
+          expires_at: args.expires_at,
           lnd: args.lnd,
           secret: encrypt.payment_secret,
           tokens: args.tokens,

package/trades/find_trade.js

@@ -24,6 +24,8 @@ 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;
 
 /** Find a trade to purchase
@@ -49,6 +51,7 @@ const waitForTradesMs = 1000 * 5;
     auth: <Encrypted Payload Auth Hex String>
     payload: <Preimage Encrypted Payload Hex String>
     request: <BOLT 11 Payment Request String>
+    trade: <Encoded Trade String>
   }
 */
 module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
@@ -89,7 +92,23 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
           // Exit early when the node id and sockets is specified directly
           if (!!connect.node) {
-            return cbk(null, 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 = connect.node.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
@@ -156,6 +175,8 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
         // 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 => {
@@ -238,6 +259,8 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return res.success({});
         });
 
+        logger.info({requesting_trade_details: true});
+
         // Once connected, ask for the trade details
         return makePeerRequest({
           lnd,
@@ -270,7 +293,9 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk([404, 'NoTradesFound']);
         }
 
-        const [trade, other] = requestTrades.trades;
+        const uniqueTrades = uniqBy(requestTrades.trades, 'description');
+
+        const [trade, other] = uniqueTrades;
 
         // Exit early when there is only a single trade
         if (!other) {
@@ -279,7 +304,7 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
 
         // Present the possible choices
         return ask({
-          choices: requestTrades.trades.map(trade => ({
+          choices: uniqueTrades.map(trade => ({
             name: trade.description,
             value: trade.id,
           })),

package/trades/manage_trade.js

@@ -16,6 +16,7 @@ const findTrade = require('./find_trade');
 const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
 const {isArray} = Array;
 const isHexPreimage = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Manage an individual trade
 
@@ -141,7 +142,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           is_canceled: invoice.is_canceled || undefined,
           is_purchased: invoice.is_confirmed || undefined,
         });
@@ -169,7 +170,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         logger.info({
           id: requestDetails.id,
           offering: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
         });
 
         return ask({
@@ -195,7 +196,15 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
-        return cancelHodlInvoice({lnd, id: requestDetails.id}, cbk);
+        return cancelHodlInvoice({lnd, id: requestDetails.id}, err => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          logger.info({trade_canceled: true});
+
+          return cbk();
+        });
       }],
 
       // Select a purchase option for the trade
@@ -216,10 +225,12 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        logger.info({trade: findTrade.trade});
+
         logger.info({
           request: findTrade.request,
           purchase: requestDetails.description,
-          price: requestDetails.tokens,
+          price: tokensAsBigUnit(requestDetails.tokens),
           to: requestDetails.destination,
         });