paid-services 3.3.0 → 3.6.0

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_anchored_trade.js

@@ -0,0 +1,35 @@
+const {encodeTlvStream} = require('bolt01');
+
+const anchorPrefix = 'anchor-trade-secret:';
+const descriptionRecord = value => !!value ? ({value, type: '1'}) : undefined;
+const secretRecord = value => ({value, type: '0'});
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
+
+/** Encode a trade into an anchor blob
+
+  This will look like anchored-trade-secret:<base64-encoded-data>
+
+  The data encodes a TLV:
+  0: <Trade Secret>
+  [1]: <Trade Description>
+
+  {
+    [description]: <Open Trade Description String>
+    secret: <Open Trade Secret String>
+  }
+
+  @returns
+  {
+    encoded: <Encoded Anchor Trade Data Blob String>
+  }
+*/
+module.exports = ({description, secret}) => {
+  const records = [secretRecord(secret), descriptionRecord(description)]
+    .filter(n => !!n)
+    .map(({type, value}) => ({type, value: utf8AsHex(value)}));
+
+  const {encoded} = encodeTlvStream({records});
+
+  return {encoded: withPrefix(anchorPrefix, encoded)};
+};

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

package/trades/encode_trade.js

@@ -1,50 +1,65 @@
-const {encodeTlvStream} = require('bolt01');
+const encodeOpenTrade = require('./encode_open_trade');
+const encodeTradeSecret = require('./encode_trade_secret');
 
-const networkRecordFromRequest = require('./network_record_from_request');
-const {requestAsRequestRecords} = require('./../records');
+/** Encode v1 trade records
 
-const asTrade = hex => `626f73ff${hex}`;
+  A v1 trade is either a qualified trade with a request, or an open ended trade
+  with connection details.
 
-/** Encode a trade
+  0: version (v1)
+  [1]: network
+  [2]: payment request
+  [3]: trade details
+  [4]: nodes records
+  [5]: trade identifier
 
   {
-    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: [{
+        channels: [<Standard Format Channel Id String>]
+        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>
+    }
   }
 
+  @throws
+  <Error>
+
   @returns
   {
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({auth, payload, request}, cbk) => {
-  // Encode the trade record
-  const tradeRecords = [{
-    type: '2',
-    value: requestAsRequestRecords({request}).encoded,
-  }];
-
-  // Add a network name record if required
-  if (!!networkRecordFromRequest({request}).value) {
-    tradeRecords.push({
-      type: '1',
-      value: networkRecordFromRequest({request}).value,
-    });
+module.exports = ({connect, secret}) => {
+  if (!connect && !secret) {
+    throw new Error('ExpectedEitherConnectDetailsOrTradeSecret');
   }
 
-  // Encode the encrypted data
-  const encryptionRecords = encodeTlvStream({
-    records: [{type: '0', value: payload}, {type: '1', value: auth}],
-  });
-
-  // Encode the details of the trade
-  const detailsRecords = encodeTlvStream({
-    records: [{type: '0', value: encryptionRecords.encoded}],
-  });
+  if (!!connect && !!secret) {
+    throw new Error('ExpectedEitherConnectDetailsOrTradeSecretNotBoth');
+  }
 
-  // Add the trade details to the trade
-  tradeRecords.push({type: '3', value: detailsRecords.encoded});
+  // Exit early when this is an open ended trade
+  if (!!connect) {
+    return encodeOpenTrade({
+      id: connect.id,
+      network: connect.network,
+      nodes: connect.nodes,
+    });
+  }
 
-  return {trade: asTrade(encodeTlvStream({records: tradeRecords}).encoded)};
+  // Encode the trade secret
+  return encodeTradeSecret({
+    auth: secret.auth,
+    payload: secret.payload,
+    request: secret.request,
+  });
 };

package/trades/encode_trade_secret.js

@@ -0,0 +1,50 @@
+const {encodeTlvStream} = require('bolt01');
+
+const networkRecordFromRequest = require('./network_record_from_request');
+const {requestAsRequestRecords} = require('./../records');
+
+const asTrade = hex => `626f73ff${hex}`;
+
+/** Encode a trade
+
+  {
+    auth: <Encrypted Payload Auth Hex String>
+    payload: <Preimage Encrypted Payload Hex String>
+    request: <BOLT 11 Payment Request String>
+  }
+
+  @returns
+  {
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = ({auth, payload, request}, cbk) => {
+  // Encode the trade record
+  const tradeRecords = [{
+    type: '2',
+    value: requestAsRequestRecords({request}).encoded,
+  }];
+
+  // Add a network name record if required
+  if (!!networkRecordFromRequest({request}).value) {
+    tradeRecords.push({
+      type: '1',
+      value: networkRecordFromRequest({request}).value,
+    });
+  }
+
+  // Encode the encrypted data
+  const encryptionRecords = encodeTlvStream({
+    records: [{type: '0', value: payload}, {type: '1', value: auth}],
+  });
+
+  // Encode the details of the trade
+  const detailsRecords = encodeTlvStream({
+    records: [{type: '0', value: encryptionRecords.encoded}],
+  });
+
+  // Add the trade details to the trade
+  tradeRecords.push({type: '3', value: detailsRecords.encoded});
+
+  return {trade: asTrade(encodeTlvStream({records: tradeRecords}).encoded)};
+};