paid-services 3.4.0 → 3.7.0

package/trades/manage_trades.js

@@ -1,11 +1,29 @@
 const asyncAuto = require('async/auto');
+const asyncUntil = require('async/until');
+const {cancelHodlInvoice} = require('ln-service');
+const {diffieHellmanComputeSecret} = 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 createTrade = require('./create_trade');
+const encodeTrade = require('./encode_trade');
 const manageTrade = require('./manage_trade');
+const serviceAnchoredTrades = require('./service_anchored_trades');
+const serviceOpenTrade = require('./service_open_trade');
+const tradeFromInvoice = require('./trade_from_invoice');
 
+const cancelAction = 'cancel-';
 const createAction = 'create';
 const decodeAction = 'decode';
+const defaultInvoicesLimit = 100;
+const listAction = 'list';
+const serveAction = 'serve';
+const serveTradeAction = 'serve-trade-';
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const viewAction = 'view';
 
 /** Create, view, and accept trades
 
@@ -13,11 +31,12 @@ const decodeAction = 'decode';
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    separator: <Create Separator Function>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger}, cbk) => {
+module.exports = ({ask, lnd, logger, separator}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -37,12 +56,21 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         return cbk();
       },
 
+      // Get node identity
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Get the network name
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+
       // Select a trade option
       select: ['validate', ({}, cbk) => {
         return ask({
           choices: [
             {name: 'Create Trade', value: createAction},
             {name: 'Decode Trade', value: decodeAction},
+            separator(),
+            {name: 'Open Trades', value: listAction},
+            {name: 'Serve Trades', value: serveAction},
           ],
           message: 'Trade?',
           name: 'action',
@@ -51,6 +79,15 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         cbk);
       }],
 
+      // Confirm that signer RPC is enabled
+      checkSigner: ['getIdentity', ({getIdentity}, cbk) => {
+        return diffieHellmanComputeSecret({
+          lnd,
+          partner_public_key: getIdentity.public_key,
+        },
+        cbk);
+      }],
+
       // Create a new trade
       create: ['select', ({select}, cbk) => {
         // Exit early when not creating a new trade
@@ -74,7 +111,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
       }],
 
       // View an existing trade
-      view: ['select', ({select}, cbk) => {
+      view: ['checkSigner', 'select', ({checkSigner, select}, cbk) => {
         // Exit early when not decoding a trade
         if (select.action !== decodeAction) {
           return cbk();
@@ -82,6 +119,176 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
         return manageTrade({ask, lnd, logger}, cbk)
       }],
+
+      // Get open trades
+      getTrades: ['validate', ({}, cbk) => {
+        const paging = {trades: []};
+
+        // Find open anchored trades
+        asyncUntil(
+          cbk => cbk(null, paging.token === false),
+          cbk => {
+            return getInvoices({
+              lnd,
+              is_unconfirmed: true,
+              limit: !paging.token ? defaultInvoicesLimit : undefined,
+              token: paging.token,
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(err);
+              }
+
+              paging.token = res.next || false;
+
+              res.invoices
+                .map(tradeFromInvoice)
+                .map(n => n.trade)
+                .filter(n => !!n)
+                .forEach(n => paging.trades.push(n));
+
+              return cbk();
+            });
+          },
+          err => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return cbk(null, paging.trades);
+          }
+        );
+      }],
+
+      // List open trades
+      list: ['getTrades', 'select', ({getTrades, select}, cbk) => {
+        // Exit early when not viewing open trades
+        if (select.action !== listAction) {
+          return cbk();
+        }
+
+        if (!getTrades.length) {
+          return cbk([404, 'NoTradesCurrentlyOpen']);
+        }
+
+        return ask({
+          choices: getTrades.map(trade => ({
+            name: `${tokensAsBigUnit(trade.tokens)} ${trade.description}`,
+            value: trade.id,
+          })),
+          message: 'Trade?',
+          name: 'manage',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Manage an open trades
+      manage: ['getTrades', 'list', ({getTrades, list}, cbk) => {
+        // Exit early when not viewing open trades
+        if (!list) {
+          return cbk();
+        }
+
+        return ask({
+          choices: [
+            {name: 'Serve Trade', value: `${serveTradeAction}${list.manage}`},
+            separator(),
+            {name: 'Cancel Trade', value: `${cancelAction}${list.manage}`},
+          ],
+          message: 'Trade?',
+          name: 'trade',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Service an open trade
+      serviceTrade: [
+        'getIdentity',
+        'getNetwork',
+        'getTrades',
+        'manage',
+        ({getIdentity, getNetwork, getTrades, manage}, cbk) =>
+      {
+        // Exit early when this is not cancel of an open trade
+        if (!manage || !manage.trade.startsWith(serveTradeAction)) {
+          return cbk();
+        }
+
+        const id = manage.trade.slice(serveTradeAction.length);
+
+        const trade = getTrades.find(n => n.id === id);
+
+        return serviceOpenTrade({
+          lnd,
+          logger,
+          channels: [],
+          description: trade.description,
+          expires_at: trade.expires_at,
+          id: trade.id,
+          network: getNetwork.network,
+          public_key: getIdentity.public_key,
+          secret: trade.secret,
+          tokens: trade.tokens,
+          uris: [],
+        },
+        cbk);
+      }],
+
+      // Cancel an open trade
+      cancelTrade: ['manage', ({manage}, cbk) => {
+        // Exit early when this is not cancel of an open trade
+        if (!manage || !manage.trade.startsWith(cancelAction)) {
+          return cbk();
+        }
+
+        return cancelHodlInvoice({
+          lnd,
+          id: manage.trade.slice(cancelAction.length),
+        },
+        cbk);
+      }],
+
+      // Serve open trades
+      service: [
+        'getIdentity',
+        'getNetwork',
+        'select',
+        ({getIdentity, getNetwork, select}, cbk) =>
+      {
+        // Exit early when not serving trades
+        if (select.action !== serveAction) {
+          return cbk();
+        }
+
+        const sub = serviceAnchoredTrades({lnd});
+
+        const {trade} = encodeTrade({
+          connect: {
+            network: getNetwork.network,
+            nodes: [{channels: [], id: getIdentity.public_key, sockets: []}],
+          },
+        });
+
+        logger.info({servicing_all_open_trades: trade});
+
+        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}`);
+        });
+
+        sub.on('start', ({description, tokens}) => {
+          return logger.info(`open: ${tokensAsBigUnit(tokens)} ${description}`);
+        });
+
+        sub.on('error', err => {
+          sub.removeAllListeners();
+
+          return cbk(err);
+        });
+      }],
     },
     returnResult({reject, resolve}, cbk));
   });

package/trades/request_trade_by_id.js

@@ -22,6 +22,7 @@ const tradeIdRecordType = '0';
     auth: <Encrypted Payload Auth Hex String>
     payload: <Preimage Encrypted Payload Hex String>
     request: <BOLT 11 Payment Request String>
+    trade: <Encoded Trade Record String>
   }
 */
 module.exports = ({id, lnd, to}, cbk) => {
@@ -77,7 +78,12 @@ module.exports = ({id, lnd, to}, cbk) => {
           }
 
           try {
-            return cbk(null, secret);
+            return cbk(null, {
+              auth: secret.auth,
+              payload: secret.payload,
+              request: secret.request,
+              trade: tradeRecord.value,
+            });
           } catch (err) {
             return cbk([503, 'ExpectedValidTradeRecordFromPeer', {err}]);
           }

package/trades/service_anchored_trades.js

@@ -0,0 +1,181 @@
+const EventEmitter = require('events');
+
+const asyncUntil = require('async/until');
+const {getInvoices} = require('ln-service');
+const {subscribeToInvoice} = require('ln-service');
+const {subscribeToInvoices} = require('ln-service');
+
+const decodeAnchoredTrade = require('./decode_anchored_trade');
+const serviceTradeRequests = require('./service_trade_requests');
+const tradeFromInvoice = require('./trade_from_invoice');
+
+const defaultInvoicesLimit = 100;
+const events = ['details', 'error', 'failure', 'settled', 'trade'];
+const fromNow = date => new Date(date) - new Date();
+const {keys} = Object;
+
+/** Service trades represented by anchored invoices
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  // Returned details
+  @event 'details'
+  {
+    to: <Public Key Id Hex String>
+  }
+
+  // Terminal failure
+  @event 'error'
+  <Error Object>
+
+  // Encountered a failure
+  @event 'failure'
+  [<Failure Code Number>, <Failure Code String>]
+
+  // Received payment
+  @event 'settled'
+  {
+    description: <Trade Description String>
+    id: <Trade Id Hex String>
+    secret: <Secret Payload String>
+    to: <Public Key Id Hex String>
+    tokens: <Tokens Number>
+  }
+
+  // Starting service for trade
+  @event 'start'
+  {
+    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>
+  }
+
+  // Return finalized trade
+  @event 'trade'
+  {
+    to: <Public Key Id Hex String>
+  }
+
+  @returns
+  <EventEmitter Object>
+*/
+module.exports = ({lnd}) => {
+  const emitter = new EventEmitter();
+  const listening = {};
+  const paging = {};
+
+  // Service a trade until it's paid or canceled
+  const serviceTrade = trade => {
+    // Exit early when already listening to this trade
+    if (!!listening[trade.id]) {
+      return;
+    }
+
+    const sub = serviceTradeRequests({
+      lnd,
+      description: trade.description,
+      expires_at: trade.expires_at,
+      id: trade.id,
+      secret: trade.secret,
+      tokens: trade.tokens,
+    });
+
+    // Pick up the trade to service
+    emitter.emit('start', {
+      description: trade.description,
+      expires_at: trade.expires_at,
+      id: trade.id,
+      secret: trade.secret,
+      tokens: trade.tokens,
+    });
+
+    // Settled a trade
+    sub.on('settled', ({to}) => {
+      return emitter.emit('settled', {
+        to,
+        id: trade.id,
+        description: trade.description,
+        secret: trade.secret,
+        tokens: trade.tokens,
+      });
+    });
+
+    // Remember this listener to avoid double-listening to the same trade
+    listening[trade.id] = sub;
+
+    sub.on('details', ({to}) => emitter.emit('details', {to, id: trade.id}));
+    sub.on('failure', err => emitter.emit('failure', {err, id: trade.id}));
+    sub.on('trade', ({to}) => emitter.emit('trade', {to, id: trade.id}));
+
+    sub.once('end', () => sub.removeAllListeners());
+
+    const invoiceUpdates = subscribeToInvoice({lnd, id: trade.id});
+
+    invoiceUpdates.on('invoice_updated', updated => {
+      if (!updated.is_canceled) {
+        return;
+      }
+
+      return invoiceUpdates.removeAllListeners();
+    });
+
+    return;
+  };
+
+  // Listen for any new invoices that represent anchored trades
+  const sub = subscribeToInvoices({lnd});
+
+  // Listen for new trades to appear
+  sub.on('invoice_updated', invoice => {
+    const {trade} = tradeFromInvoice(invoice);
+
+    // Exit early when there is no anchored trade found in the description
+    if (!trade) {
+      return;
+    }
+
+    return serviceTrade(trade);
+  });
+
+  // Find open anchored trades
+  asyncUntil(
+    cbk => cbk(null, paging.token === false),
+    cbk => {
+      return getInvoices({
+        lnd,
+        is_unconfirmed: true,
+        limit: !paging.token ? defaultInvoicesLimit : undefined,
+        token: paging.token,
+      },
+      (err, res) => {
+        if (!!err) {
+          emitter.emit(err);
+
+          // Stop listening to all invoices
+          sub.removeAllListeners();
+
+          // Stop listening to all anchor invoices
+          keys(listening).forEach(id => listening[id].removeAllListeners());
+
+          return;
+        }
+
+        paging.token = res.next || false;
+
+        res.invoices
+          .map(tradeFromInvoice)
+          .map(n => n.trade)
+          .filter(n => !!n)
+          .forEach(serviceTrade);
+
+        return cbk();
+      });
+    }
+  );
+
+  return emitter;
+};

package/trades/service_open_trade.js

@@ -0,0 +1,172 @@
+const asyncAuto = require('async/auto');
+const {getNodeAlias} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const encodeOpenTrade = require('./encode_open_trade');
+const serviceTradeRequests = require('./service_trade_requests');
+
+const asNumber = n => parseFloat(n, 10);
+const {isArray} = Array;
+const nodeName = (alias, id) => `${alias} ${id}`;
+const slowTradeDate = () => new Date(Date.now() + (86400000*15)).toISOString();
+const uriAsSocket = n => n.substring(67);
+
+/** Service an individual trade
+
+  {
+    channels: [{
+      id: <Standard Format Channel Id String>
+      partner_public_key: <Node Public Key Hex 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>
+    public_key: <Identity Public Key Hex String>
+    secret: <Secret to Sell String>
+    tokens: <Trade Price Tokens Number>
+    uris: [<Node URI String>]
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(args.channels)) {
+          return cbk([400, 'ExpectedArrayOfChannelsToServiceTrade']);
+        }
+
+        if (!args.description) {
+          return cbk([400, 'ExpectedDescriptionToServiceTrade']);
+        }
+
+        if (!args.expires_at) {
+          return cbk([400, 'ExpectedExpiresAtDateToServiceTrade']);
+        }
+
+        if (!args.id) {
+          return cbk([400, 'ExpectedTradeAnchorIdToServiceTrade']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToServiceTrade']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToServiceTrade']);
+        }
+
+        if (!args.network) {
+          return cbk([400, 'ExpectedNetworkNameToServiceTrade']);
+        }
+
+        if (!args.public_key) {
+          return cbk([400, 'ExpectedIdentityPublicKeyToServiceTrade']);
+        }
+
+        if (!args.secret) {
+          return cbk([400, 'ExpectedSecretToSellToServiceTrade']);
+        }
+
+        if (!args.tokens) {
+          return cbk([400, 'ExpectedTokensPriceToServiceTrade']);
+        }
+
+        if (!isArray(args.uris)) {
+          return cbk([400, 'ExpectedArrayOfNodeSocketUrisToServiceTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Serve the trade
+      serve: ['validate', ({}, cbk) => {
+        const isSlowTrade = args.expires_at > slowTradeDate();
+        const settled = [];
+
+        // Encode the open trade details to give out
+        const openTrade = encodeOpenTrade({
+          network: args.network,
+          nodes: [{
+            channels: isSlowTrade ? [] : args.channels,
+            id: args.public_key,
+            sockets: !args.channels.length ? args.uris.map(uriAsSocket) : [],
+          }],
+        });
+
+        args.logger.info({trade_expiry: new Date(args.expires_at)});
+
+        const sub = serviceTradeRequests({
+          description: args.description,
+          expires_at: args.expires_at,
+          id: args.id,
+          lnd: args.lnd,
+          secret: args.secret,
+          tokens: asNumber(args.tokens),
+        });
+
+        // Someone asked for trade details
+        sub.on('details', async ({to}) => {
+          try {
+            const {alias, id} = await getNodeAlias({id: to, lnd: args.lnd});
+
+            const toName = nodeName(alias, id);
+
+            return args.logger.info({return_trade_info_to: toName});
+          } catch (err) {
+            return args.logger.error({err});
+          }
+        });
+
+        sub.on('failure', failure => args.logger.error({failure}));
+
+        sub.on('settled', ({to}) => settled.push(to));
+
+        sub.on('trade', async ({to}) => {
+          try {
+            const {alias, id} = await getNodeAlias({id: to, lnd: args.lnd});
+
+            const toName = nodeName(alias, id);
+
+            return args.logger.info({make_trade_invoice_for: toName});
+          } catch (err) {
+            return args.logger.error({err});
+          }
+        });
+
+        // Show the trade details blob
+        return args.logger.info({
+          waiting_for_trade_request_to: openTrade.trade,
+        });
+
+        // Wait for the trade to end
+        sub.once('end', async () => {
+          try {
+            const [to] = settled;
+
+            // Exit early when there was no settlement
+            if (!to) {
+              args.logger.info({trade_ended: true});
+
+              return cbk();
+            }
+
+            const {alias, id} = await getNodeAlias({id: to, lnd: args.lnd});
+
+            args.logger.info({finished_trade_with: nodeName(alias, id)});
+          } catch (err) {
+            args.logger.error({err});
+          } finally {
+            return cbk();
+          }
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};