paid-services 3.3.0 → 3.6.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/network_from_network_record.js

@@ -17,15 +17,15 @@ const testnetNetworkType = '01';
 */
 module.exports = ({value}) => {
   if (!value) {
-    return defaultNetwork;
+    return {network: defaultNetwork};
   }
 
   if (value === regtestNetworkType) {
-    return regtestNetwork;
+    return {network: regtestNetwork};
   }
 
   if (value === testnetNetworkType) {
-    return testnetNetwork;
+    return {network: testnetNetwork};
   }
 
   throw new Error('UnknownNetworkType');

package/trades/network_record_from_network.js

@@ -0,0 +1,36 @@
+const defaultNetwork = 'btc';
+const regtestNetwork = 'btcregtest';
+const regtestNetworkType = '02';
+const testnetNetwork = 'btctestnet';
+const testnetNetworkType = '01';
+
+/** Derive a network record name from a network name
+
+  {
+    network: <Network Name String>
+  }
+
+  @returns
+  {
+    [value]: <Network Record Value Hex String>
+  }
+*/
+module.exports = ({network}) => {
+  if (!network) {
+    throw new Error('ExpectedNetworkNameToDeriveNetworkRecord');
+  }
+
+  switch (network) {
+  case defaultNetwork:
+    return {};
+
+  case regtestNetwork:
+    return {value: regestNetworkType};
+
+  case testnetNetwork:
+    return {value: testnetNetworkType};
+
+  default:
+    throw new Error('UnknownNetworkNameToDeriveNetworkRecordFor');
+  }
+};

package/trades/network_record_from_request.js

@@ -1,5 +1,6 @@
 const defaultNetwork = 'lnbc';
 const regtestNetwork = 'lnbcrt';
+const regtestNetworkType = '02';
 const testnetNetwork = 'lntb';
 const testnetNetworkType = '01';
 
@@ -24,7 +25,7 @@ module.exports = ({request}) => {
   }
 
   if (request.startsWith(regtestNetwork)) {
-    return {};
+    return {value: regtestNetworkType};
   }
 
   if (request.startsWith(testnetNetwork)) {

package/trades/node_as_record.js

@@ -0,0 +1,98 @@
+const {decodeChanId} = require('bolt07');
+const {encodeSocket} = require('bolt07');
+const {encodeTlvStream} = require('bolt01');
+const {rawChanId} = require('bolt07');
+
+const highOrderKeyType = '1';
+const ipV4SocketsType = '3';
+const ipV6SocketsType = '4';
+const torV3SocketsType = '5';
+const {isArray} = Array;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const join = arr => arr.join('');
+const lowOrderKeyType = '0';
+const nodeIdType = '2';
+
+/** Convert node details to a node record
+
+  A node record looks like:
+
+  [0]: low order key channel id
+  [1]: high order key channel id
+  [2]: node identity public key
+  [3]: node ipv4 sockets (6 byte chunks)
+  [4]: node ipv6 sockets (18 byte chunks)
+  [5]: node torV3 addresses (37 byte chunks)
+
+  {
+    channels: [{
+      id: <Standard Format Channel Id String>
+      partner_public_key: <Node Public Key Hex String>
+    }]
+    id: <Node Public Key Id Hex String>
+    sockets: [<Peer Socket String>]
+  }
+
+  @returns
+  {
+    encoded: <Encoded Node Details Hex String>
+  }
+*/
+module.exports = ({channels, id, sockets}) => {
+  if (!isArray(channels)) {
+    throw new Error('ExpectedArrayOfChannelsToMapNodeToRecord');
+  }
+
+  if (!isPublicKey(id)) {
+    throw new Error('ExpectedNodePublicKeyToMapNodeToRecord');
+  }
+
+  if (!isArray(sockets)) {
+    throw new Error('ExpectedArrayOfSocketsToMapNodeToRecord');
+  }
+
+  // Sort the channels by their height ascending, use the oldest as a landmark
+  const [channel] = channels.slice().sort((a, b) => {
+    const aHeight = decodeChanId({channel: a.id}).block_height;
+    const bHeight = decodeChanId({channel: b.id}).block_height;
+
+    return aHeight - bHeight;
+  });
+
+  // Exit early when there is a channel to reference
+  if (!!channel) {
+    const value = rawChanId({channel: channel.id}).id;
+
+    // Sort the keys by lexicographical order
+    const [key1, key2] = [channel.partner_public_key, id].sort();
+
+    // When the id is the first key in order, it is a low record
+    const type = key1 === id ? lowOrderKeyType : highOrderKeyType;
+
+    return encodeTlvStream({records: [{type, value}]});
+  }
+
+  // When there is no channel to reference, use the node identity key instead
+  const records = [{type: nodeIdType, value: id}];
+
+  const encodedSockets = sockets.map(socket => encodeSocket({socket}));
+
+  const ipV4 = join(encodedSockets.filter(n => !!n.ip4).map(n => n.ip4));
+  const ipV6 = join(encodedSockets.filter(n => !!n.ip6).map(n => n.ip6));
+  const torV3 = join(encodedSockets.filter(n => !!n.tor3).map(n => n.tor3));
+
+  if (!!ipV4) {
+    records.push({type: ipV4SocketsType, value: ipV4});
+  }
+
+  if (!!ipV6) {
+    records.push({type: ipV6SocketsType, value: ipV6});
+  }
+
+  if (!!torV3) {
+    records.push({type: torV3SocketsType, value: ipV6});
+  }
+
+  // Return the node identity key and network sockets
+  return encodeTlvStream({records});
+};

package/trades/record_as_node.js

@@ -0,0 +1,113 @@
+const {chanFormat} = require('bolt07');
+const {decodeSocket} = require('bolt07');
+const {decodeTlvStream} = require('bolt01');
+
+const channelHexLength = 16;
+const chunkIpV4 = data => !!data ? data.value.match(/.{1,12}/g) : [];
+const chunkIpV6 = data => !!data ? data.value.match(/.{1,36}/g) : [];
+const chunkTorV3 = data => !!data ? data.value.match(/.{1,74}/g) : [];
+
+const findHighKeyChannelRecord = records => records.find(n => n.type === '1');
+const findIdRecord = records => records.find(n => n.type === '2');
+const findIpV4Record = records => records.find(n => n.type === '3');
+const findIpV6Record = records => records.find(n => n.type === '4');
+const findLowKeyChannelRecord = records => records.find(n => n.type === '0');
+const findTorV3Record = records => records.find(n => n.type === '5');
+const ipV4HexLength = 12;
+const ipV6HexLength = 36;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const torV3HexLength = 74;
+
+/** Decode a node record
+
+  {
+    encoded: <Encoded Node Record>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [high_channel]: <High Key Channel Id String>
+    [low_channel]: <Low Key Channel Id String>
+    [node]: {
+      id: <Node Public Key Id Hex String>
+      sockets: [<Peer Socket String>]
+    }
+  }
+*/
+module.exports = ({encoded}) => {
+  if (!encoded) {
+    throw new Error('ExpectedEncodedNodeRecordToGetNodePointer');
+  }
+
+  const {records} = decodeTlvStream({encoded});
+
+  const highKeyRecord = findHighKeyChannelRecord(records);
+
+  if (!!highKeyRecord && highKeyRecord.value.length !== channelHexLength) {
+    throw new Error('ExpectedChannelIdInHighKeyRecord');
+  }
+
+  if (!!highKeyRecord) {
+    return {high_channel: chanFormat({id: highKeyRecord.value}).channel};
+  }
+
+  const lowKeyRecord = findLowKeyChannelRecord(records);
+
+  if (!!lowKeyRecord && lowKeyRecord.value.length !== channelHexLength) {
+    throw new Error('ExpectedChannelIdInLowKeyRecord');
+  }
+
+  if (!!lowKeyRecord) {
+    return {low_channel: chanFormat({id: lowKeyRecord.value}).channel};
+  }
+
+  const idRecord = findIdRecord(records);
+
+  if (!idRecord) {
+    throw new Error('ExpectedNodeIdRecordToMapNodeRecordToNodePointer');
+  }
+
+  if (!isPublicKey(idRecord.value)) {
+    throw new Error('ExpectedNodeIdPublicKeyToMapNodeRecordToNodePointer');
+  }
+
+  const ipV4SocketsRecord = findIpV4Record(records);
+
+  if (!!ipV4SocketsRecord && !!(ipV4SocketsRecord % ipV4HexLength)) {
+    throw new Error('ExpectedListOfIpV4SocketsToMapRecordToNode');
+  }
+
+  const ipV4Sockets = chunkIpV4(ipV4SocketsRecord).map(ip4 => {
+    return decodeSocket({ip4}).socket;
+  });
+
+  const ipV6SocketsRecord = findIpV6Record(records);
+
+  if (!!ipV6SocketsRecord && !!(ipV6SocketsRecord % ipV6HexLength)) {
+    throw new Error('ExpectedListOfIpV6SocketsToMapRecordToNode');
+  }
+
+  const ipV6Sockets = chunkIpV6(ipV6SocketsRecord).map(ip6 => {
+    return decodeSocket({ip6}).socket;
+  });
+
+  const torV3SocketsRecord = findTorV3Record(records);
+
+  if (!!torV3SocketsRecord && !!(torV3SocketsRecord % torV3HexLength)) {
+    throw new Error('ExpectedListOfTorV3SocketsToMapRecordToNode');
+  }
+
+  const torV3Sockets = chunkTorV3(torV3SocketsRecord).map(tor3 => {
+    return decodeSocket({tor3}).socket;
+  });
+
+  return {
+    node: {
+      id: idRecord.value,
+      sockets: [].concat(ipV4Sockets).concat(ipV6Sockets).concat(torV3Sockets),
+    },
+  };
+};

package/trades/request_trade_by_id.js

@@ -0,0 +1,95 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const decodeTrade = require('./decode_trade');
+const {makePeerRequest} = require('./../p2p');
+
+const findTradeRecord = records => records.find(n => n.type === '1');
+const requestTradeTimeoutMs = 1000 * 30;
+const {serviceTypeRequestTrades} = require('./../service_types');
+const tradeIdRecordType = '0';
+
+/** Request a specific trade by its id
+
+  {
+    id: <Trade Identifier Hex String>
+    lnd: <Authenticated LND API Object>
+    to: <Make Request To Public Key Hex Encoded String>
+  }
+
+  @returns via cbk or Promise
+  {
+    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) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedTradeIdentifierToRequestTradeById']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToRequestTradeById']);
+        }
+
+        if (!to) {
+          return cbk([400, 'ExpectedRemotePublicKeyToRequestTradeById']);
+        }
+
+        return cbk();
+      },
+
+      // Get trade
+      getTrade: ['validate', ({}, cbk) => {
+        return makePeerRequest({
+          lnd,
+          to,
+          records: [{type: tradeIdRecordType, value: id}],
+          timeout: requestTradeTimeoutMs,
+          type: serviceTypeRequestTrades,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          const tradeRecord = findTradeRecord(res.records);
+
+          if (!tradeRecord) {
+            return cbk([503, 'ExpectedTradeRecordFromPeer']);
+          }
+
+          try {
+            decodeTrade({trade: tradeRecord.value});
+          } catch (err) {
+            return cbk([503, err.message]);
+          }
+
+          const {secret} = decodeTrade({trade: tradeRecord.value});
+
+          if (!secret) {
+            return cbk([503, 'ExpectedTradeSecretInResponseForTradeById']);
+          }
+
+          try {
+            return cbk(null, {
+              auth: secret.auth,
+              payload: secret.payload,
+              request: secret.request,
+              trade: tradeRecord.value,
+            });
+          } catch (err) {
+            return cbk([503, 'ExpectedValidTradeRecordFromPeer', {err}]);
+          }
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getTrade'}, cbk));
+  });
+};