paid-services 3.3.0 → 3.4.0

package/trades/manage_trade.js

@@ -11,6 +11,7 @@ const {returnResult} = require('asyncjs-util');
 const buyPreimage = require('./buy_preimage');
 const decodeTrade = require('./decode_trade');
 const decryptTradeSecret = require('./decrypt_trade_secret');
+const findTrade = require('./find_trade');
 
 const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
 const {isArray} = Array;
@@ -52,13 +53,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           name: 'trade',
           message: 'Enter encoded trade',
           type: 'input',
-          validate: input => {
-            if (!input) {
-              return false;
-            }
-
-            return true;
-          },
+          validate: input => !!input,
         },
         cbk);
       }],
@@ -71,22 +66,43 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         try {
           const details = decodeTrade({trade: askForTrade.trade});
 
-          return cbk(null, {
-            auth: details.auth,
-            payload: details.payload,
-            request: details.request,
-          });
+          return cbk(null, details);
         } catch (err) {
           return cbk([400, err.message]);
         }
       }],
 
-      // Parse the trade payment request
-      requestDetails: ['decodeDetails', ({decodeDetails}, cbk) => {
-        const {request} = decodeDetails;
+      // Get details about an open ended trade
+      findTrade: [
+        'decodeDetails',
+        'getIdentity',
+        ({decodeDetails, getIdentity}, cbk) =>
+      {
+        // Exit early when there is a known trade
+        if (!!decodeDetails.secret) {
+          return cbk(null, {
+            auth: decodeDetails.secret.auth,
+            payload: decodeDetails.secret.payload,
+            request: decodeDetails.secret.request,
+          });
+        }
+
+        // Get the trade details interactively
+        return findTrade({
+          ask,
+          lnd,
+          logger,
+          id: decodeDetails.connect.id,
+          identity: getIdentity.public_key,
+          nodes: decodeDetails.connect.nodes,
+        },
+        cbk);
+      }],
 
+      // Parse the trade payment request
+      requestDetails: ['findTrade', ({findTrade}, cbk) => {
         try {
-          return cbk(null, parsePaymentRequest({request}));
+          return cbk(null, parsePaymentRequest({request: findTrade.request}));
         } catch (err) {
           return cbk([400, err.message]);
         }
@@ -184,11 +200,11 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
       // Select a purchase option for the trade
       selectPurchaseAction: [
-        'decodeDetails',
+        'findTrade',
         'getPurchase',
         'getRequest',
         'requestDetails',
-        ({decodeDetails, getPurchase, getRequest, requestDetails}, cbk) =>
+        ({findTrade, getPurchase, getRequest, requestDetails}, cbk) =>
       {
         // Exit early when the trade was already purchased
         if (!!getPurchase.value && !!getPurchase.value.is_confirmed) {
@@ -201,7 +217,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         }
 
         logger.info({
-          request: decodeDetails.request,
+          request: findTrade.request,
           purchase: requestDetails.description,
           price: requestDetails.tokens,
           to: requestDetails.destination,
@@ -257,9 +273,9 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
       // Pay and get the preimage through paying for it
       payForPreimage: [
-        'decodeDetails',
+        'findTrade',
         'selectPurchaseAction',
-        ({decodeDetails, selectPurchaseAction}, cbk) =>
+        ({findTrade, selectPurchaseAction}, cbk) =>
       {
         // Exit early when this is an offer
         if (!selectPurchaseAction) {
@@ -271,32 +287,25 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk();
         }
 
+        const {request} = findTrade;
+
         return asyncRetry({
           errorFilter: err => !!isArray(err) && err.slice().shift() >= 500,
         },
-        cbk => {
-          return buyPreimage({
-            ask,
-            lnd,
-            logger,
-            request: decodeDetails.request,
-          },
-          cbk);
-        },
-        cbk);
+        cbk => buyPreimage({ask, lnd, logger, request}, cbk), cbk);
       }],
 
       // Use the preimage to decrypt the trade secret
       decryptSecret: [
         'askForPreimage',
-        'decodeDetails',
+        'findTrade',
         'getPurchase',
         'payForPreimage',
         'requestDetails',
         'selectPurchaseAction',
         ({
           askForPreimage,
-          decodeDetails,
+          findTrade,
           getPurchase,
           payForPreimage,
           requestDetails,
@@ -327,11 +336,13 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
         const paid = payForPreimage || askForPreimage || payment;
 
+        const {auth, payload} = findTrade;
+
         return decryptTradeSecret({
+          auth,
           lnd,
-          auth: decodeDetails.auth,
+          payload,
           from: requestDetails.destination,
-          payload: decodeDetails.payload,
           secret: paid.secret,
         },
         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,89 @@
+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>
+  }
+*/
+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, secret);
+          } catch (err) {
+            return cbk([503, 'ExpectedValidTradeRecordFromPeer', {err}]);
+          }
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getTrade'}, cbk));
+  });
+};