paid-services 3.3.0 → 3.4.0

package/trades/create_trade.js

@@ -1,10 +1,13 @@
 const asyncAuto = require('async/auto');
-const {createInvoice} = require('ln-service');
-const {getIdentity} = 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 encodeTrade = require('./encode_trade');
-const encryptTradeSecret = require('./encrypt_trade_secret');
+const encodeOpenTrade = require('./encode_open_trade');
+const finalizeTradeSecret = require('./finalize_trade_secret');
+const serviceTradeRequests = require('./service_trade_requests');
 
 const asNumber = n => parseFloat(n, 10);
 const {floor} = Math;
@@ -12,6 +15,8 @@ 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');
 
 /** Create a new trade
@@ -19,6 +24,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
   {
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
   }
 
   @returns via cbk or Promise
@@ -26,7 +32,7 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({ask, lnd}, cbk) => {
+module.exports = ({ask, lnd, logger}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -39,28 +45,32 @@ module.exports = ({ask, lnd}, cbk) => {
           return cbk([400, 'ExpectedAuthenticatedLndToCreateTrade']);
         }
 
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToCreateTrade']);
+        }
+
         return cbk();
       },
 
       // Get the node identity key
-      getNodeId: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+      getIdentity: ['validate', ({}, cbk) => getWalletInfo({lnd}, cbk)],
 
       // Ask for the public key of the node to trade with
-      askForNodeId: ['getNodeId', ({getNodeId}, cbk) => {
+      askForNodeId: ['getIdentity', ({getIdentity}, cbk) => {
         return ask({
           name: 'id',
-          message: 'Public key of node you are trading with?',
+          message: 'Public key of node you are trading with? (Optional)',
           type: 'input',
           validate: input => {
             if (!input) {
-              return false;
+              return true;
             }
 
             if (!isPublicKey(input)) {
               return 'Expected public key of node to trade with';
             }
 
-            if (input === getNodeId.public_key) {
+            if (input === getIdentity.public_key) {
               return 'Expected public key of other node';
             }
 
@@ -70,6 +80,26 @@ module.exports = ({ask, lnd}, cbk) => {
         cbk);
       }],
 
+      // Get the public channels to use for an open trade
+      getChannels: ['askForNodeId', ({askForNodeId}, cbk) => {
+        // Exit early when there is a specific node
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        return getChannels({lnd, is_public: true}, cbk);
+      }],
+
+      // Get the network name to use for an open trade
+      getNetwork: ['askForNodeId', ({askForNodeId}, cbk) => {
+        // Exit early when there is a specific node
+        if (!!askForNodeId.id) {
+          return cbk();
+        }
+
+        return getNetwork({lnd}, cbk);
+      }],
+
       // Ask for how to describe the payload
       askForDescription: ['askForNodeId', ({}, cbk) => {
         return ask({
@@ -134,55 +164,105 @@ module.exports = ({ask, lnd}, cbk) => {
         cbk);
       }],
 
-      // Encrypt the secret data
-      encryptPayload: [
+      // Wait for a peer to connect and ask for the trade details
+      serviceTradeRequests: [
+        'askForDescription',
         'askForNodeId',
+        'askForPrice',
         'askForSecret',
-        ({askForNodeId, askForSecret}, cbk) =>
+        'getChannels',
+        'getIdentity',
+        'getNetwork',
+        ({
+          askForDescription,
+          askForNodeId,
+          askForPrice,
+          askForSecret,
+          getChannels,
+          getIdentity,
+          getNetwork,
+        },
+        cbk) =>
       {
-        return encryptTradeSecret({
+        // Exit early if this is a closed trade
+        if (!!askForNodeId.id) {
+          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({
           lnd,
-          secret: utf8AsHex(askForSecret.secret),
-          to: askForNodeId.id,
-        },
-        cbk);
+          description: askForDescription.description,
+          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});
       }],
 
-      // Create the invoice to purchase the unlocking secret
-      createPurchaseInvoice: [
+      // Finalize the trade with an encrypted secret and an invoice
+      finalize: [
         'askForDescription',
+        'askForNodeId',
         'askForPrice',
-        'encryptPayload',
-        ({askForDescription, askForPrice, encryptPayload}, cbk) =>
+        'askForSecret',
+        ({askForDescription, askForNodeId, askForPrice, askForSecret}, cbk) =>
       {
-        return createInvoice({
+        // Exit early when there is no node to finalize the trade to
+        if (!askForNodeId.id) {
+          return cbk();
+        }
+
+        return finalizeTradeSecret({
           lnd,
           description: askForDescription.description,
-          secret: encryptPayload.payment_secret,
+          secret: askForSecret.secret,
+          to: askForNodeId.id,
           tokens: asNumber(askForPrice.tokens),
         },
         cbk);
       }],
-
-      // Encode all the trade data into wire format
-      encodeTradeToWireFormat: [
-        'createPurchaseInvoice',
-        'encryptPayload',
-        ({createPurchaseInvoice, encryptPayload}, cbk) =>
-      {
-        try {
-          const {trade} = encodeTrade({
-            auth: encryptPayload.trade_auth_tag,
-            payload: encryptPayload.trade_cipher,
-            request: createPurchaseInvoice.request,
-          });
-
-          return cbk(null, {trade});
-        } catch (err) {
-          return cbk([500, err.message]);
-        }
-      }],
     },
-    returnResult({reject, resolve, of: 'encodeTradeToWireFormat'}, cbk));
+    returnResult({reject, resolve, of: 'finalize'}, cbk));
   });
 };

package/trades/decode_basic_trade.js

@@ -0,0 +1,45 @@
+const findDescriptionRecord = records => records.find(n => n.type === '2');
+const findIdRecord = records => records.find(n => n.type === '1');
+const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString('utf8');
+const {isArray} = Array;
+
+/** Decode a basic trade
+
+  1: <Trade Id>
+  2: <Trade Description>
+
+  {
+    records: [{
+      type: <Basic Trade Record Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+
+  @returns
+  {
+    description: <Trade Description String>
+    id: <Trade Id Hex String>
+  }
+*/
+module.exports = ({records}) => {
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeBasicTrade');
+  }
+
+  const descriptionRecord = findDescriptionRecord(records);
+
+  if (!descriptionRecord) {
+    throw new Error('ExpectedDescriptionRecordToDecodeBasicTrade');
+  }
+
+  const idRecord = findIdRecord(records);
+
+  if (!idRecord) {
+    throw new Error('ExpectedIdRecordToDecodeBasicTradeDetails');
+  }
+
+  return {
+    description: hexAsUtf8(descriptionRecord.value),
+    id: idRecord.value,
+  };
+};

package/trades/decode_open_trade.js

@@ -0,0 +1,69 @@
+const {decodeTlvStream} = require('bolt01');
+
+const recordAsNode = require('./record_as_node');
+
+const findIdRecord = records => records.find(n => n.type === '5');
+const findNodesRecord = records => records.find(n => n.type === '4');
+const {isArray} = Array;
+
+/** Decode open trade records
+
+  An open ended trade is a pointer to a node or nodes that can create trade
+  invoices.
+
+  4: <Nodes Records>
+  [5]: <Trade Identifier>
+
+  {
+    network: <Network Name String>
+    records: [{
+      type: <Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [id]: <Trade Identifier Hex String>
+    network: <Network Name String>
+    nodes: [{
+      [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 = ({network, records}) => {
+  if (!network) {
+    throw new Error('ExpectedNetworkNameToDecodeOpenTrade');
+  }
+
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeOpenTrade');
+  }
+
+  const idRecord = findIdRecord(records);
+  const nodesRecord = findNodesRecord(records);
+
+  if (!nodesRecord) {
+    throw new Error('ExpectedNodesRecordToDecodeOpenTradeDetails');
+  }
+
+  const nodeRecords = decodeTlvStream({encoded: nodesRecord.value}).records;
+
+  if (!nodeRecords.length) {
+    throw new Error('ExpectedNodeRecordsForOpenTrade');
+  }
+
+  return {
+    network,
+    id: !!idRecord ? idRecord.value : undefined,
+    nodes: nodeRecords.map(({value}) => recordAsNode({encoded: value})),
+  };
+};

package/trades/decode_trade.js

@@ -1,32 +1,49 @@
+const {decodeBigSize} = require('bolt01');
 const {decodeTlvStream} = require('bolt01');
 
+const decodeOpenTrade = require('./decode_open_trade');
+const decodeTradeSecret = require('./decode_trade_secret');
 const networkFromNetworkRecord = require('./network_from_network_record');
-const {requestRecordsAsRequest} = require('./../records');
 
-const findAuth = records => records.find(n => n.type === '1');
-const findCipher = records => records.find(n => n.type === '0');
-const findDetails = records => records.find(n => n.type === '3');
-const findEncrypt = records => records.find(n => n.type === '0');
 const findNetwork = records => records.find(n => n.type === '1');
-const findRequest = records => records.find(n => n.type === '2');
-const findVersion = records => records.find(n => n.type === '0');
+const findVer = records => records.find(n => n.type === '0') || {value: '00'};
+const findRequestRecord = records => records.find(n => n.type === '2');
 const isTrade = trade => trade.toLowerCase().startsWith('626f73ff');
+const isValidVersion = version => BigInt(version) <= BigInt(1);
 const tradeData = trade => trade.slice('626f73ff'.length);
 
-/** Encode a trade
+/** Decode a trade record
+
+  [0]: <Version Record>
+  [1]: <Network Name Record>
+  [2]: <Payment Request Record>
+  [3]: <Trade Details Record
+  [4]: <Nodes Records>
+  [5]: <Trade Identifier>
 
   {
-    trade: <Hex Encoded Trade String>
+    trade: <Trade Record Hex String>
   }
 
-  @throws
-  <Error>
-
   @returns
   {
-    auth: <Encrypted Payload Auth Hex String>
-    payload: <Preimage Encrypted Payload Hex String>
-    request: <BOLT 11 Payment Request String>
+    [connect]: {
+      [id]: <Reference Trade Id Hex String>
+      network: <Network Name String>
+      nodes: [{
+        [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>]
+        }
+      }]
+    }
+    [secret]: {
+      auth: <Encrypted Payload Auth Hex String>
+      payload: <Preimage Encrypted Payload Hex String>
+      request: <BOLT 11 Payment Request String>
+    }
   }
 */
 module.exports = ({trade}) => {
@@ -45,64 +62,29 @@ module.exports = ({trade}) => {
   }
 
   // Decode the overall packet
-  const tradeRecords = decodeTlvStream({encoded: tradeData(trade)}).records;
+  const {records} = decodeTlvStream({encoded: tradeData(trade)});
 
   // Get the trade version
-  const version = findVersion(tradeRecords);
-
-  if (!!version) {
-    throw new Error('UnexpectedVersionOfTradeData');
-  }
-
-  // Get the network record
-  const networkRecord = findNetwork(tradeRecords) || {};
-
-  // Get the payment request record
-  const requestRecord = findRequest(tradeRecords);
-
-  if (!requestRecord) {
-    throw new Error('ExpectedRequestRecordInTradeData');
-  }
-
-  const {request} = requestRecordsAsRequest({
-    network: networkFromNetworkRecord({value: networkRecord.value}),
-    encoded: requestRecord.value,
-  });
+  const versionRecord = findVer(records);
 
-  // Get the trade details
-  const detailsRecord = findDetails(tradeRecords);
+  // Decode the version number
+  const version = decodeBigSize({encoded: versionRecord.value}).decoded;
 
-  if (!detailsRecord) {
-    throw new Error('ExpctedDetailsRecordToDecodeTrade');
+  // Too-high versions cannot be parsed
+  if (!isValidVersion(version)) {
+    throw new Error('ExpectedKnownVersionToDecodeTrade');
   }
 
-  // Trade details
-  const details = decodeTlvStream({encoded: detailsRecord.value}).records;
-
-  // Encode the encrypted data
-  const encryptedRecord = findEncrypt(details);
-
-  if (!encryptedRecord) {
-    throw new Error('ExpectedEncryptedRecordToDecodeTrade');
-  }
-
-  const encrypted = decodeTlvStream({encoded: encryptedRecord.value}).records;
-
-  const encryptedDataRecord = findCipher(encrypted);
-
-  if (!encryptedDataRecord) {
-    throw new Error('ExpectedEncryptedDataRecordToDecodeTrade');
-  }
+  // Get the network record
+  const networkRecord = findNetwork(records) || {};
 
-  const authDataRecord = findAuth(encrypted);
+  // Decode the network record
+  const {network} = networkFromNetworkRecord({value: networkRecord.value});
 
-  if (!authDataRecord) {
-    throw new Error('ExpectedAuthDataRecordToDecodeTrade');
+  // A trade is either a trade secret to someone or an open trade offer
+  if (!!findRequestRecord(records)) {
+    return {secret: decodeTradeSecret({network, records})};
+  } else {
+    return {connect: decodeOpenTrade({network, records})};
   }
-
-  return {
-    request,
-    auth: authDataRecord.value,
-    payload: encryptedDataRecord.value,
-  };
 };

package/trades/decode_trade_secret.js

@@ -0,0 +1,89 @@
+const {decodeTlvStream} = require('bolt01');
+
+const {requestRecordsAsRequest} = require('./../records');
+
+const findAuth = records => records.find(n => n.type === '1');
+const findCipher = records => records.find(n => n.type === '0');
+const findDetails = records => records.find(n => n.type === '3');
+const findEncrypt = records => records.find(n => n.type === '0');
+const findRequest = records => records.find(n => n.type === '2');
+const {isArray} = Array;
+
+/** Decode a trade secret
+
+  2: <Payment Request Record>
+  3: <Trade Details Record
+
+  {
+    network: <Network Name String>
+    records: [{
+      type: <Type Number String>
+      value: <Hex Encoded Value String>
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    auth: <Encrypted Payload Auth Hex String>
+    payload: <Preimage Encrypted Payload Hex String>
+    request: <BOLT 11 Payment Request String>
+  }
+*/
+module.exports = ({network, records}) => {
+  if (!network) {
+    throw new Error('ExpectedNetworkNameToDecodeTradeSecret');
+  }
+
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeTradeSecret');
+  }
+
+  // Get the payment request record
+  const requestRecord = findRequest(records);
+
+  if (!requestRecord) {
+    throw new Error('ExpectedRequestRecordInTradeData');
+  }
+
+  const encoded = requestRecord.value;
+
+  // Get the trade details
+  const detailsRecord = findDetails(records);
+
+  if (!detailsRecord) {
+    throw new Error('ExpctedDetailsRecordToDecodeTrade');
+  }
+
+  // Trade details
+  const details = decodeTlvStream({encoded: detailsRecord.value}).records;
+
+  // Encode the encrypted data
+  const encryptedRecord = findEncrypt(details);
+
+  if (!encryptedRecord) {
+    throw new Error('ExpectedEncryptedRecordToDecodeTrade');
+  }
+
+  const encrypted = decodeTlvStream({encoded: encryptedRecord.value}).records;
+
+  const encryptedDataRecord = findCipher(encrypted);
+
+  if (!encryptedDataRecord) {
+    throw new Error('ExpectedEncryptedDataRecordToDecodeTrade');
+  }
+
+  const authDataRecord = findAuth(encrypted);
+
+  if (!authDataRecord) {
+    throw new Error('ExpectedAuthDataRecordToDecodeTrade');
+  }
+
+  return {
+    request: requestRecordsAsRequest({encoded, network}).request,
+    auth: authDataRecord.value,
+    payload: encryptedDataRecord.value,
+  };
+};

package/trades/encode_open_trade.js

@@ -0,0 +1,89 @@
+const {encodeTlvStream} = require('bolt01');
+
+const networkRecordFromNetwork = require('./network_record_from_network');
+const nodeAsRecord = require('./node_as_record');
+
+const asTrade = hex => `626f73ff${hex}`;
+const idType = '5';
+const {isArray} = Array;
+const networkRecordType = '1';
+const nodeType = '4';
+const versionRecord = '01';
+const versionType = '0';
+
+/** Encode records for an open ended trade
+
+  An open ended trade is a pointer to a node or nodes that can create trade
+  invoices. At the minimum it has a pointer to a node.
+
+  0: version (v1)
+  [1]: network name
+  4: nodes records
+  [5]: trade identifier
+
+  {
+    [id]: <Trade Identifier Hex String>
+    network: <Network Name String>
+    nodes: [{
+      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>]
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    trade: <Encoded Open Ended Trade Hex String>
+  }
+*/
+module.exports = ({id, network, nodes}) => {
+  if (!network) {
+    throw new Error('ExpectedNetworkNameToEncodeOpenTrade');
+  }
+
+  if (!isArray(nodes)) {
+    throw new Error('ExpectedArrayOfNodesToEncodeOpenTrade');
+  }
+
+  if (!nodes.length) {
+    throw new Error('ExpectedNodeToReferToInOpenTrade');
+  }
+
+  // Add trade version record
+  const records = [{type: versionType, value: versionRecord}];
+
+  // Add a network name record if required
+  if (!!networkRecordFromNetwork({network}).value) {
+    records.push({
+      type: networkRecordType,
+      value: networkRecordFromNetwork({network}).value,
+    });
+  }
+
+  // A trade id refers to a specific trade
+  if (!!id) {
+    records.push({type: idType, value: id});
+  }
+
+  // Map the nodes to node records
+  const nodeRecords = nodes.map(({channels, id, sockets}, type) => {
+    return {
+      type: type.toString(),
+      value: nodeAsRecord({channels, id, sockets}).encoded,
+    };
+  });
+
+  // Add the node records to the open trade
+  records.push({
+    type: nodeType,
+    value: encodeTlvStream({records: nodeRecords}).encoded,
+  });
+
+  return {trade: asTrade(encodeTlvStream({records}).encoded)};
+};