paid-services 3.3.0 → 3.6.0

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));
+  });
+};

package/trades/service_trade_requests.js

@@ -0,0 +1,255 @@
+const EventEmitter = require('events');
+const {randomBytes} = require('crypto');
+
+const {getInvoice} = require('ln-service');
+const {subscribeToInvoice} = require('ln-service');
+
+const acceptTrade = require('./accept_trade');
+const finalizeTradeSecret = require('./finalize_trade_secret');
+const {makePeerRequest} = require('./../p2p');
+const {servicePeerRequests} = require('./../p2p');
+const {serviceTypeRequestTrades} = require('./../service_types');
+const {serviceTypeReceiveTrades} = require('./../service_types');
+
+const descRecord = description => ({type: '2', value: description});
+const events = ['details', 'end', 'failure', 'settled', 'trade'];
+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 sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const tradeSecretType = '1';
+const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
+
+/** Service requests for an open trade
+
+  The maximum expiration date is three weeks
+
+  {
+    description: <Trade Description String>
+    expires_at: <Trade Expires At ISO 8601 Date String>
+    id: <Trade Id Hex String>
+    lnd: <Authenticated LND API Object>
+    secret: <Secret Payload String>
+    tokens: <Tokens Number>
+  }
+
+  // Return details
+  @event 'details'
+  {
+    to: <Public Key Id Hex String>
+  }
+
+  // Service ended
+  @event 'end'
+
+  // Encountered a failure
+  @event 'failure'
+  [<Failure Code Number>, <Failure Code String>]
+
+  // Received payment
+  @event 'settled'
+  {
+    to: <Public Key Id Hex String>
+  }
+
+  // Return finalized trade
+  @event 'trade'
+  {
+    to: <Public Key Id Hex String>
+  }
+
+  @returns
+  <Service Event Emitter Object>
+*/
+module.exports = args => {
+  if (!args.description) {
+    throw new Error('ExpectedTradeDescriptionToServiceTradeRequests');
+  }
+
+  if (!args.id) {
+    throw new Error('ExpectedTradeIdToServiceTradeRequests');
+  }
+
+  if (args.id.length !== hashHexLength) {
+    throw new Error('ExpectedShorterRequestIdValueToServiceTradeRequests');
+  }
+
+  if (!args.lnd) {
+    throw new Error('ExpectedAuthenticatedLndToServiceTradeRequests');
+  }
+
+  if (!args.secret) {
+    throw new Error('ExpectedSecretToEncryptToServiceTradeRequests');
+  }
+
+  if (!args.tokens) {
+    throw new Error('ExpectedTokensPriceForTradeToServiceTradeRequests');
+  }
+
+  const emitter = new EventEmitter();
+
+  const holds = [];
+  const service = servicePeerRequests({lnd: args.lnd});
+
+  // Stop the service when there are no more listeners
+  emitter.on('removeListener', () => {
+    // Exit early when there are still listeners on an event
+    if (!!sumOf(events.map(n => emitter.listenerCount(n)))) {
+      return;
+    }
+
+    return service.stop({});
+  });
+
+  const sub = subscribeToInvoice({id: args.id, lnd: args.lnd});
+
+  sub.on('invoice_updated', invoice => {
+    if (!invoice.is_canceled) {
+      return;
+    }
+
+    holds.forEach(n => n.sub.removeAllListeners());
+
+    return service.stop({});
+  });
+
+  // Notify when the service ends
+  service.end(() => emitter.emit('end', {}));
+
+  // Basic trade description
+  const basicTradeRecords = [
+    idRecord(args.id),
+    descRecord(utf8AsHex(args.description)),
+  ];
+
+  // Wait for a request for the open trade
+  service.request({type: serviceTypeRequestTrades}, (req, res) => {
+    const {failure, success} = res;
+    const requestTradeId = findIdRecord(req.records);
+
+    // Exit early when the trade requested is unrelated
+    if (!!requestTradeId && requestTradeId.value !== args.id) {
+      return;
+    }
+
+    const requestIdRecord = findRequestIdRecord(req.records);
+
+    // A trade request either is for a specific trade or has a pingback id
+    if (!requestTradeId && !requestIdRecord) {
+      return emitter.emit('failure', [400, 'ExpectedRequestTradeOrRequestId']);
+    }
+
+    // Exit early when the trade is expired
+    if (args.expires_at < new Date().toISOString()) {
+      service.stop({});
+
+      return;
+    }
+
+    // Exit early and ping peer with trade when this is an open ended query
+    if (!requestTradeId) {
+      emitter.emit('details', {to: req.from});
+
+      const reqIdRecord = {type: idBackType, value: requestIdRecord.value};
+
+      const records = [].concat(basicTradeRecords).concat(reqIdRecord);
+
+      return getInvoice({id: args.id, lnd: args.lnd}, (err, res) => {
+        if (!!err || !!res.is_canceled) {
+          return;
+        }
+
+        // Ping the node with trade details
+        return makePeerRequest({
+          records,
+          lnd: args.lnd,
+          timeout: postOpenTradeTimeoutMs,
+          to: req.from,
+          type: serviceTypeReceiveTrades,
+        },
+        err => {
+          if (!!err) {
+            failure([503, 'FailedToDeliverTradeInfo']);
+
+            return emitter.emit(
+              'failure',
+              [503, 'FailedToDeliverTradeInfo', {err}]
+            );
+          }
+
+          return success({});
+        });
+      });
+    }
+
+    // Make a finalized trade secret for the peer
+    emitter.emit('trade', ({to: req.from}));
+
+    // Create a trade secret for the requesting peer and return that
+    return finalizeTradeSecret({
+      description: args.description,
+      expires_at: args.expires_at,
+      is_hold: true,
+      lnd: args.lnd,
+      secret: args.secret,
+      to: req.from,
+      tokens: args.tokens,
+    },
+    (err, res) => {
+      if (!!err) {
+        emitter.emit('failure', err);
+
+        return failure([503, 'FailedToFinalizeTradeSecret']);
+      }
+
+      // Create a record for the encoded trade
+      const record = {type: tradeSecretType, value: res.trade};
+
+      // Add hold invoice to set of held invoices, only one should settle
+      const sub = subscribeToInvoice({id: res.id, lnd: args.lnd});
+
+      // Add sub to list of holds
+      holds.push({sub, id: res.id});
+
+      // Wait for the invoice to be paid
+      sub.on('invoice_updated', updated => {
+        // Exit early when the payment is not held yet
+        if (!updated.is_held) {
+          return;
+        }
+
+        // Do not accept any more bids
+        service.stop({});
+
+        // Stop listening to invoice events
+        holds.forEach(hold => hold.sub.removeAllListeners());
+
+        // Settle the held invoice with the preimage
+        return acceptTrade({
+          cancel: holds.filter(n => n.id !== updated.id).map(n => n.id),
+          id: args.id,
+          lnd: args.lnd,
+          secret: res.secret,
+        },
+        err => {
+          if (!!err) {
+            return emitter.emit('failure', err);
+          }
+
+          emitter.emit('settled', {to: req.from});
+
+          return emitter.emit('end', {});
+        });
+      });
+
+      // Return details about the trade
+      return success({records: [record]});
+    });
+  });
+
+  return emitter;
+};

package/trades/trade_from_invoice.js

@@ -0,0 +1,51 @@
+const decodeAnchoredTrade = require('./decode_anchored_trade');
+
+/** Derive open trade details from an invoice
+
+  {
+    description: <Invoice Description String>
+    id: <Invoice Id Hex String>
+    expires_at: <Invoice Expiration ISO 8601 Date String>
+    [is_canceled]: <Invoice is Canceled Bool>
+    is_confirmed: <Invoice is Confirmed Bool>
+    [is_push]: <Invoice is Push Payment Bool>
+    tokens: <Invoiced Amount Number>
+  }
+
+  @returns
+  {
+    [trade]: {
+      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>
+    }
+  }
+*/
+module.exports = args => {
+  if (!args.description || !!args.is_canceled || !!args.is_confirmed) {
+    return {};
+  }
+
+  if (!!args.is_push || !args.tokens) {
+    return {};
+  }
+
+  const {trade} = decodeAnchoredTrade({encoded: args.description});
+
+  // Exit early when the invoice doesn't match an anchored trade
+  if (!trade) {
+    return {};
+  }
+
+  return {
+    trade: {
+      description: trade.description,
+      expires_at: args.expires_at,
+      id: args.id,
+      secret: trade.secret,
+      tokens: args.tokens,
+    },
+  };
+};

package/capacity/service_types.json

@@ -1,6 +0,0 @@
-{
-  "serviceTypeAcceptCapacityChange": "8050002",
-  "serviceTypeChangeCapacity": "8050001",
-  "serviceTypeSignCapacityChange": "805004",
-  "serviceTypeWaitOnConfirmation": "8050003"
-}