paid-services 3.13.2 → 3.14.2

package/trades/decode_anchored_trade.js

@@ -1,9 +1,13 @@
+const {decodeBigSize} = require('bolt01');
 const {decodeTlvStream} = require('bolt01');
 
 const anchorPrefix = 'anchor-trade-secret:';
 const base64AsHex = base64 => Buffer.from(base64, 'base64').toString('hex');
+const decodeNumber = encoded => Number(decodeBigSize({encoded}).decoded);
+const findChannel = records => records.find(n => n.type === '3');
 const findDescription = records => records.find(n => n.type === '1');
 const findSecret = records => records.find(n => n.type === '0');
+const findPrice = records => records.find(n => n.type === '2');
 const hexAsUtf = n => !n ? '' : Buffer.from(n.value, 'hex').toString('utf8');
 
 /** Decode an anchored trade data blob
@@ -11,8 +15,10 @@ const hexAsUtf = n => !n ? '' : Buffer.from(n.value, 'hex').toString('utf8');
   Data blobs look like anchored-trade-secret:<base64-encoded-data>
 
   Inside the base64 is encoded TLV data:
-  0: <Trade Secret>
+  [0]: <Trade Secret>
   [1]: <Trade Description>
+  [2]: <Price Expression>
+  [3]: <Channel Sale Tokens>
 
   {
     encoded: <Encoded Trade Data String>
@@ -21,8 +27,10 @@ const hexAsUtf = n => !n ? '' : Buffer.from(n.value, 'hex').toString('utf8');
   @returns
   {
     [trade]: {
-      description: <Description of Trade String>
-      secret: <Trade Secret String>
+      [channel]: <Channel Sale Capacity Tokens Number>
+      [description]: <Description of Trade String>
+      [price]: <Trade Price String>
+      [secret]: <Trade Secret String>
     }
   }
 */
@@ -41,16 +49,36 @@ module.exports = ({encoded}) => {
 
   const {records} = decodeTlvStream({encoded: base64AsHex(data)});
 
+  const channel = findChannel(records);
+  const description = findDescription(records);
+  const price = findPrice(records);
   const secret = findSecret(records);
 
-  if (!secret.value) {
-    return {};
+  if (!!channel) {
+    // Make sure the channel value is reasonable
+    try {
+      decodeNumber(channel.value);
+    } catch {
+      return {};
+    }
+
+    return {
+      trade: {
+        channel: decodeNumber(channel.value),
+        price: !!price ? hexAsUtf(price) : undefined,
+      },
+    };
+  }
+
+  if (!!description && !!secret) {
+    return {
+      trade: {
+        description: hexAsUtf(description),
+        price: !!price ? hexAsUtf(price) : undefined,
+        secret: hexAsUtf(secret),
+      },
+    };
   }
 
-  return {
-    trade: {
-      description: hexAsUtf(findDescription(records)),
-      secret: hexAsUtf(secret),
-    },
-  };
+  return {};
 };

package/trades/decode_open_trade.js

@@ -55,6 +55,12 @@ module.exports = ({network, records}) => {
     throw new Error('ExpectedNodesRecordToDecodeOpenTradeDetails');
   }
 
+  try {
+    decodeTlvStream({encoded: nodesRecord.value});
+  } catch (err) {
+    throw new Error('ExpectedValidNodesTlvStreamToDecodeOpenTradeDetails');
+  }
+
   const nodeRecords = decodeTlvStream({encoded: nodesRecord.value}).records;
 
   if (!nodeRecords.length) {

package/trades/decode_trade.js

@@ -2,9 +2,11 @@ const {decodeBigSize} = require('bolt01');
 const {decodeTlvStream} = require('bolt01');
 
 const decodeOpenTrade = require('./decode_open_trade');
+const decodeTradePayment = require('./decode_trade_payment');
 const decodeTradeSecret = require('./decode_trade_secret');
 const networkFromNetworkRecord = require('./network_from_network_record');
 
+const findDetailsRecord = records => records.find(n => n.type === '3');
 const findNetwork = records => records.find(n => n.type === '1');
 const findVer = records => records.find(n => n.type === '0') || {value: '00'};
 const findRequestRecord = records => records.find(n => n.type === '2');
@@ -39,6 +41,9 @@ const tradeData = trade => trade.slice('626f73ff'.length);
         }
       }]
     }
+    [payment]: {
+      request: <BOLT 11 Payment Request String>
+    }
     [secret]: {
       auth: <Encrypted Payload Auth Hex String>
       payload: <Preimage Encrypted Payload Hex String>
@@ -81,10 +86,17 @@ module.exports = ({trade}) => {
   // Decode the network record
   const {network} = networkFromNetworkRecord({value: networkRecord.value});
 
-  // A trade is either a trade secret to someone or an open trade offer
-  if (!!findRequestRecord(records)) {
+  const requestRecord = findRequestRecord(records);
+
+  // Exit early when this is a secret to trade
+  if (!!requestRecord && !!findDetailsRecord(records)) {
     return {secret: decodeTradeSecret({network, records})};
-  } else {
-    return {connect: decodeOpenTrade({network, records})};
   }
+
+  // Exit early when this is just a payment request
+  if (!!requestRecord) {
+    return {payment: decodeTradePayment({network, records})};
+  }
+
+  return {connect: decodeOpenTrade({network, records})};
 };

package/trades/decode_trade_payment.js

@@ -0,0 +1,45 @@
+const {requestRecordsAsRequest} = require('./../records');
+
+const findRequest = records => records.find(n => n.type === '2');
+const {isArray} = Array;
+
+/** Decode a trade payment request
+
+  2: <Payment Request Record>
+
+  {
+    network: <Network Name String>
+    records: [{
+      type: <Type Number String>
+      value: <Hex Encoded Value String>
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    request: <BOLT 11 Payment Request String>
+  }
+*/
+module.exports = ({network, records}) => {
+  if (!network) {
+    throw new Error('ExpectedNetworkNameToDecodeTradePayment');
+  }
+
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeTradePayment');
+  }
+
+  // Get the payment request record
+  const requestRecord = findRequest(records);
+
+  if (!requestRecord) {
+    throw new Error('ExpectedRequestRecordInTradeDataForTradePayment');
+  }
+
+  const encoded = requestRecord.value;
+
+  return {request: requestRecordsAsRequest({encoded, network}).request};
+};

package/trades/encode_anchored_trade.js

@@ -1,8 +1,11 @@
+const {encodeBigSize} = require('bolt01');
 const {encodeTlvStream} = require('bolt01');
 
 const anchorPrefix = 'anchor-trade-secret:';
 const descriptionRecord = value => !!value ? ({value, type: '1'}) : undefined;
-const secretRecord = value => ({value, type: '0'});
+const priceRecord = value => !!value ? ({value, type: '2'}) : undefined;
+const secretRecord = value => !!value ? ({value, type: '0'}) : undefined;
+const typeForChannelSale = '3';
 const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
 const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
 
@@ -11,12 +14,16 @@ const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
   This will look like anchored-trade-secret:<base64-encoded-data>
 
   The data encodes a TLV:
-  0: <Trade Secret>
+  [0]: <Trade Secret>
   [1]: <Trade Description>
+  [2]: <Price Expression>
+  [3]: <Channel Sale Tokens>
 
   {
+    [channel]: <Channel Sale Tokens Number>
     [description]: <Open Trade Description String>
-    secret: <Open Trade Secret String>
+    [price]: <Trade Price String>
+    [secret]: <Open Trade Secret String>
   }
 
   @returns
@@ -24,11 +31,24 @@ const withPrefix = (pre, v) => pre + Buffer.from(v, 'hex').toString('base64');
     encoded: <Encoded Anchor Trade Data Blob String>
   }
 */
-module.exports = ({description, secret}) => {
-  const records = [secretRecord(secret), descriptionRecord(description)]
+module.exports = ({channel, description, price, secret}) => {
+  const elements = [
+    secretRecord(secret),
+    descriptionRecord(description),
+    priceRecord(price),
+  ];
+
+  const records = elements
     .filter(n => !!n)
     .map(({type, value}) => ({type, value: utf8AsHex(value)}));
 
+  if (!!channel) {
+    records.push({
+      type: typeForChannelSale,
+      value: encodeBigSize({number: channel.toString()}).encoded,
+    });
+  }
+
   const {encoded} = encodeTlvStream({records});
 
   return {encoded: withPrefix(anchorPrefix, encoded)};

package/trades/encode_trade.js

@@ -44,7 +44,7 @@ module.exports = ({connect, secret}) => {
   }
 
   if (!!connect && !!secret) {
-    throw new Error('ExpectedEitherConnectDetailsOrTradeSecretNotBoth');
+    throw new Error('ExpectedOnlyOneConnectDetailsOrTradeSecretNotBoth');
   }
 
   // Exit early when this is an open ended trade

package/trades/encode_trade_payment.js

@@ -0,0 +1,38 @@
+const {encodeTlvStream} = require('bolt01');
+
+const networkRecordFromRequest = require('./network_record_from_request');
+const {requestAsRequestRecords} = require('./../records');
+
+const asTrade = hex => `626f73ff${hex}`;
+
+/** Encode a trade for a regular payment
+
+  [1]: <Network Name>
+  2: <Payment Request Record>
+
+  {
+    request: <BOLT 11 Payment Request String>
+  }
+
+  @returns
+  {
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = ({request}, cbk) => {
+  // Encode the request into a 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,
+    });
+  }
+
+  return {trade: asTrade(encodeTlvStream({records: tradeRecords}).encoded)};
+};

package/trades/encode_trade_secret.js

@@ -38,7 +38,7 @@ module.exports = ({auth, payload, request}, cbk) => {
     records: [{type: '0', value: payload}, {type: '1', value: auth}],
   });
 
-  // Encode the details of the trade
+  // Encode the encrypted elements of the trade
   const detailsRecords = encodeTlvStream({
     records: [{type: '0', value: encryptionRecords.encoded}],
   });

package/trades/finalize_trade.js

@@ -0,0 +1,244 @@
+const {createHash} = require('crypto');
+const {randomBytes} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const {createHodlInvoice} = require('ln-service');
+const {createInvoice} = require('ln-service');
+const {getInvoice} = require('ln-service');
+const {getChainFeeRate} = require('ln-service');
+const {parsePaymentRequest} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const convertFiat = require('./convert_fiat');
+const decodeAnchoredTrade = require('./decode_anchored_trade');
+const encodeTradePayment = require('./encode_trade_payment');
+const encodeTradeSecret = require('./encode_trade_secret');
+const encryptTradeSecret = require('./encrypt_trade_secret');
+
+const asNumber = n => parseFloat(n, 10);
+const bufferAsHex = buffer => buffer.toString('hex');
+const {ceil} = Math;
+const defaultShortInvoiceExpiryMs = 1000 * 60 * 30;
+const estimatedChannelOpenSizeVbytes = 250;
+const futureDate = ms => new Date(Date.now() + ms).toISOString();
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const makePaymentSecret = () => randomBytes(32).toString('hex');
+const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const slowConf = 144;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
+
+/** Create a trade secret for a node
+
+  {
+    [channel]: <Sell Channel With Capacity Tokens Number>
+    [description]: <Trade Description String>
+    expires_at: <Trade Expires At ISO 8601 Date String>
+    [id]: <Trade Anchor Id Hex String>
+    is_hold: <Create Hold Invoice Bool>
+    lnd: <Authenticated LND API Object>
+    [price]: <Trade Price String>
+    [request]: <Request Function>
+    [secret]: <Secret Payload String>
+    to: <To Public Key Hex Encoded String>
+    [tokens]: <Price Tokens Number or Fiat>
+  }
+
+  @returns via cbk or Promise
+  {
+    id: <Payment Hash Hex String>
+    [secret]: <Hex Encoded Payment Secret String>
+    trade: <Hex Encoded Trade String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.channel && !args.description) {
+          return cbk([400, 'ExpectedDescriptionToFinalizeTrade']);
+        }
+
+        if (!!args.channel && !args.is_hold) {
+          return cbk([400, 'ExpectedChannelAsHoldInvoiceToFinalizeTrade']);
+        }
+
+        if (!args.expires_at) {
+          return cbk([400, 'ExpectedExpiresAtDateToFinalizeTrade']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToFinalizeTrade']);
+        }
+
+        if (!args.price && !args.tokens) {
+          return cbk([400, 'ExpectedTokensPriceToFinalizeTrade']);
+        }
+
+        if (!!args.price && !args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToFinalizeTrade']);
+        }
+
+        if (!args.channel && !args.secret) {
+          return cbk([400, 'ExpectedChannelOrSecretValueToFinalizeTrade']);
+        }
+
+        if (!args.to) {
+          return cbk([400, 'ExpectedToPublicKeyToFinalizeTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Description for the final invoice
+      description: ['validate', ({}, cbk) => {
+        if (!args.channel) {
+          return cbk(null, args.description);
+        }
+
+        // Make a description for a channel creation
+        const capacity = tokensAsBigUnit(args.channel);
+        const node = args.to;
+
+        const description = `Attempt ${capacity} channel creation to ${node}`;
+
+        return cbk(null, description);
+      }],
+
+      // Encrypt the secret data
+      encrypt: ['validate', ({}, cbk) => {
+        // Exit early when there is no trade of a secret
+        if (!args.secret) {
+          return cbk(null, {payment_secret: makePaymentSecret()});
+        }
+
+        return encryptTradeSecret({
+          lnd: args.lnd,
+          secret: utf8AsHex(args.secret),
+          to: args.to,
+        },
+        cbk);
+      }],
+
+      // Expiration for the final invoice
+      expiry: ['validate', ({}, cbk) => {
+        // Exit early when there is no price expression
+        if (!args.price) {
+          return cbk(null, args.expires_at);
+        }
+
+        // Price expressions get nearer term expiration dates
+        const shortDate = futureDate(defaultShortInvoiceExpiryMs);
+
+        // Check to make sure the short date doesn't go past the expiry
+        if (shortDate > args.expires_at) {
+          return cbk([410, 'TradeIsExpired']);
+        }
+
+        return cbk(null, shortDate);
+      }],
+
+      // Get the current chain fee rate to add a charge for channel sales
+      getFeeRate: ['validate', ({}, cbk) => {
+        // Exit early when this is not a channel sale
+        if (!args.channel) {
+          return cbk();
+        }
+
+        return getChainFeeRate({
+          confirmation_target: slowConf,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Get the sale price in tokens
+      getTokens: ['validate', ({}, cbk) => {
+        // Exit early when there is no price expression
+        if (!args.price) {
+          return cbk(null, {cost: args.tokens});
+        }
+
+        // Convert the price expression into a tokens cost
+        return convertFiat({price: args.price, request: args.request}, cbk);
+      }], 
+
+      // Calculate the final sale price
+      tokens: ['getFeeRate', 'getTokens', ({getFeeRate, getTokens}, cbk) => {
+        // Exit early when there is no need to add chain fee for channel sales
+        if (!args.channel) {
+          return cbk(null, getTokens.cost);
+        }
+
+        // Create a surcharge for the vbytes cost of a channel open
+        const vbytes = estimatedChannelOpenSizeVbytes;
+
+        const chainFeeCharge = ceil(getFeeRate.tokens_per_vbyte * vbytes);
+
+        return cbk(null, getTokens.cost + chainFeeCharge);
+      }],
+
+      // Create the final purchasing invoice
+      createInvoice: [
+        'description',
+        'encrypt',
+        'expiry',
+        'tokens',
+        ({description, encrypt, expiry, tokens}, cbk) =>
+      {
+        // Exit early when this is a hold invoice
+        if (!!args.is_hold) {
+          return createHodlInvoice({
+            description,
+            tokens,
+            expires_at: expiry,
+            id: bufferAsHex(sha256(hexAsBuffer(encrypt.payment_secret))),
+            lnd: args.lnd,
+            secret: encrypt.payment_secret,
+          },
+          cbk);
+        }
+
+        return createInvoice({
+          description,
+          tokens,
+          expires_at: args.expires_at,
+          lnd: args.lnd,
+          secret: encrypt.payment_secret,
+        },
+        cbk);
+      }],
+
+      // Encode all the trade data into wire format
+      encode: ['createInvoice', 'encrypt', ({createInvoice, encrypt}, cbk) => {
+        // Exit early when this is a channel trade, there is no secret
+        if (!!args.channel) {
+          return cbk(null, {
+            id: createInvoice.id,
+            secret: encrypt.payment_secret,
+            trade: encodeTradePayment({request: createInvoice.request}).trade,
+          });
+        }
+
+        try {
+          // Encode the trade secret records
+          const {trade} = encodeTradeSecret({
+            auth: encrypt.trade_auth_tag,
+            payload: encrypt.trade_cipher,
+            request: createInvoice.request,
+          });
+
+          return cbk(null, {
+            trade,
+            id: createInvoice.id,
+            secret: encrypt.payment_secret,
+          });
+        } catch (err) {
+          return cbk([500, err.message]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'encode'}, cbk));
+  });
+};