paid-services 3.0.0 → 3.2.0

package/trades/decrypt_trade_secret.js

@@ -0,0 +1,100 @@
+const {createDecipheriv} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const {diffieHellmanComputeSecret} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const algorithm = 'aes-256-gcm';
+const bufferAsHex = buffer => buffer.toString('hex');
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const iv = Buffer.alloc(16, 0);
+
+/** Decrypt a trade with a secret preimage
+
+  {
+    auth: <Auth Tag Hex String>
+    from: <Trading With Node Id Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+    payload: <Encrypted Data Hex String>
+    secret: <Preimage Hex String>
+  }
+
+  @returns via cbk or Promise
+  {
+    plain: <Plain Decrypted Secret Hex String>
+  }
+*/
+module.exports = ({auth, from, lnd, payload, secret}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!auth) {
+          return cbk([400, 'ExpectedAuthToDecryptTradeSecret']);
+        }
+
+        if (!from) {
+          return cbk([400, 'ExpectedFromTradingNodeIdToDecryptTradeSecret']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToDecryptTradeSecret']);
+        }
+
+        if (!payload) {
+          return cbk([400, 'ExpectedTradePayloadToDecryptTradeSecret']);
+        }
+
+        if (!secret) {
+          return cbk([400, 'ExpectedTradeUnlockKeyToDecryptTradeSecret']);
+        }
+
+        return cbk();
+      },
+
+      // Get identity public key
+      getId: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Compute a shared secret with the trading partner
+      computeSharedSecret: ['validate', ({}, cbk) => {
+        return diffieHellmanComputeSecret({
+          lnd,
+          partner_public_key: from,
+        },
+        cbk);
+      }],
+
+      // Combine the shared secret with a payment preimage for the final secret
+      key: ['computeSharedSecret', ({computeSharedSecret}, cbk) => {
+        const paidSecret = hexAsBuffer(secret);
+        const key = hexAsBuffer(computeSharedSecret.secret);
+
+        // Combine the shared secret with the payment preimage
+        for (let i = 0; i < key.length; ++i) {
+          key[i] = key[i] ^ paidSecret[i];
+        }
+
+        return cbk(null, key);
+      }],
+
+      // Decrypt the payload
+      decryptPayload: ['key', ({key}, cbk) => {
+        const decipher = createDecipheriv(algorithm, key, iv);
+        const encrypted = hexAsBuffer(payload);
+
+        decipher.setAuthTag(hexAsBuffer(auth));
+
+        // Try decrypting using the unlock key
+        try {
+          const elements = [decipher.update(encrypted), decipher.final()];
+
+          return cbk(null, {plain: bufferAsHex(Buffer.concat(elements))});
+        } catch (err) {
+          return cbk([503, 'FailedToDecryptEncryptedTradePayload', {err}]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'decryptPayload'}, cbk));
+  });
+};

package/trades/encode_trade.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)};
+};

package/trades/encrypt_trade_secret.js

@@ -0,0 +1,98 @@
+const {createCipheriv} = require('crypto');
+const {createHash} = require('crypto');
+const {randomBytes} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const {diffieHellmanComputeSecret} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const algorithm = 'aes-256-gcm';
+const bufferAsHex = buffer => buffer.toString('hex');
+const digest = 'sha512';
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const iv = Buffer.alloc(16, 0);
+const makePreimage = () => randomBytes(32).toString('hex');
+const sha256 = n => createHash('sha256').update(n).digest();
+
+/** Encode a secret for a trade
+
+  {
+    lnd: <Authenticated LND API Object>
+    secret: <Secret Hex String>
+    to: <Trading With Node Id Public Key Hex String>
+  }
+
+  @returns via cbk or Promise
+  {
+    payment_secret: <Payment Hash Preimage Hex String>
+    trade_auth_tag: <Trade Data Data Auth Tag Hex String>
+    trade_cipher: <Trade Data Encrypted Hex String>
+  }
+*/
+module.exports = ({lnd, secret, to}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToEncryptTradeSecret']);
+        }
+
+        if (!secret) {
+          return cbk([400, 'ExpectedSecretToTradeToEncryptTradeSecret']);
+        }
+
+        if (!to) {
+          return cbk([400, 'ExpectedToPublicKeyToEncryptTradeSecret']);
+        }
+
+        return cbk();
+      },
+
+      // Generate a secret to use for the payment preimage
+      paymentSecret: ['validate', ({}, cbk) => cbk(null, makePreimage())],
+
+      // Compute a shared secret with the destination
+      computeSharedSecret: ['validate', ({}, cbk) => {
+        return diffieHellmanComputeSecret({lnd, partner_public_key: to}, cbk);
+      }],
+
+      // Combine the shared secret with a payment preimage for the final secret
+      key: [
+        'computeSharedSecret',
+        'paymentSecret',
+        ({computeSharedSecret, paymentSecret}, cbk) =>
+      {
+        const paidSecret = hexAsBuffer(paymentSecret);
+        const key = hexAsBuffer(computeSharedSecret.secret);
+
+        // Combine the shared secret with the payment preimage
+        for (let i = 0; i < paidSecret.length; ++i) {
+          key[i] = key[i] ^ paidSecret[i];
+        }
+
+        return cbk(null, key);
+      }],
+
+      // Encrypt the trade details with the secret
+      encrypt: ['key', 'paymentSecret', ({key, paymentSecret}, cbk) => {
+        try {
+          createCipheriv(algorithm, key, iv);
+        } catch (err) {
+          return cbk([500, 'FailedToCreateCipherEncryptingSecret', {err}]);
+        }
+
+        const cipher = createCipheriv(algorithm, key, iv);
+
+        const updated = [cipher.update(hexAsBuffer(secret)), cipher.final()];
+
+        return cbk(null, {
+          payment_secret: paymentSecret,
+          trade_auth_tag: bufferAsHex(cipher.getAuthTag()),
+          trade_cipher: bufferAsHex(Buffer.concat(updated)),
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'encrypt'}, cbk));
+  });
+};

package/trades/index.js

@@ -0,0 +1,3 @@
+const manageTrades = require('./manage_trades');
+
+module.exports = {manageTrades};

package/trades/manage_trade.js

@@ -0,0 +1,358 @@
+const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
+const asyncRetry = require('async/retry');
+const {cancelHodlInvoice} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {getInvoice} = require('ln-service');
+const {getPayment} = require('ln-service');
+const {parsePaymentRequest} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const buyPreimage = require('./buy_preimage');
+const decodeTrade = require('./decode_trade');
+const decryptTradeSecret = require('./decrypt_trade_secret');
+
+const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
+const {isArray} = Array;
+const isHexPreimage = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+
+/** Manage an individual trade
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({ask, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToManageTrade']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToManageTrade']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToManageTrade']);
+        }
+
+        return cbk();
+      },
+
+      // Get the trade data to decode it
+      askForTrade: ['validate', ({}, cbk) => {
+        return ask({
+          name: 'trade',
+          message: 'Enter encoded trade',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Derive the self public key
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Decode the trade data
+      decodeDetails: ['askForTrade', ({askForTrade}, cbk) => {
+        try {
+          const details = decodeTrade({trade: askForTrade.trade});
+
+          return cbk(null, {
+            auth: details.auth,
+            payload: details.payload,
+            request: details.request,
+          });
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Parse the trade payment request
+      requestDetails: ['decodeDetails', ({decodeDetails}, cbk) => {
+        const {request} = decodeDetails;
+
+        try {
+          return cbk(null, parsePaymentRequest({request}));
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Get the invoice for the trade in case its our own trade
+      getRequest: ['requestDetails', asyncReflect(({requestDetails}, cbk) => {
+        return getInvoice({lnd, id: requestDetails.id}, cbk);
+      })],
+
+      // Get payment paid for the trade
+      getPurchase: ['requestDetails', asyncReflect(({requestDetails}, cbk) => {
+        return getPayment({lnd, id: requestDetails.id}, cbk);
+      })],
+
+      // Show resolved offer details
+      resolvedOffer: [
+        'getIdentity',
+        'getRequest',
+        'requestDetails',
+        ({getIdentity, getRequest, requestDetails}, cbk) =>
+      {
+        // Exit early when this is not an own offer
+        if (requestDetails.destination !== getIdentity.public_key) {
+          return cbk();
+        }
+
+        // A missing invoice may signal that it is removed
+        const invoice = getRequest.value || {is_canceled: true};
+
+        // Exit early when request is still live
+        if (!invoice.is_canceled && !invoice.is_confirmed) {
+          return cbk();
+        }
+
+        logger.info({
+          id: requestDetails.id,
+          offering: requestDetails.description,
+          price: requestDetails.tokens,
+          is_canceled: invoice.is_canceled || undefined,
+          is_purchased: invoice.is_confirmed || undefined,
+        });
+
+        return cbk();
+      }],
+
+      // Select an offer action for the trade
+      selectOfferAction: [
+        'getRequest',
+        'getPurchase',
+        'requestDetails',
+        ({getRequest, requestDetails}, cbk) =>
+      {
+        // Exit early when this is not our own offer
+        if (!getRequest.value) {
+          return cbk();
+        }
+
+        // Exit early when the payment was made
+        if (getRequest.value.is_confirmed) {
+          return cbk();
+        }
+
+        logger.info({
+          id: requestDetails.id,
+          offering: requestDetails.description,
+          price: requestDetails.tokens,
+        });
+
+        return ask({
+          choices: [
+            {name: 'Exit', value: 'exit'},
+            {name: 'Cancel offer', value: 'cancel'},
+          ],
+          message: ' ',
+          name: 'action',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Cancel past offer
+      cancelOffer: [
+        'requestDetails',
+        'selectOfferAction',
+        ({requestDetails, selectOfferAction}, cbk) =>
+      {
+        // Exit early when there is no action to take
+        if (!selectOfferAction || selectOfferAction.action !== 'cancel') {
+          return cbk();
+        }
+
+        return cancelHodlInvoice({lnd, id: requestDetails.id}, cbk);
+      }],
+
+      // Select a purchase option for the trade
+      selectPurchaseAction: [
+        'decodeDetails',
+        'getPurchase',
+        'getRequest',
+        'requestDetails',
+        ({decodeDetails, getPurchase, getRequest, requestDetails}, cbk) =>
+      {
+        // Exit early when the trade was already purchased
+        if (!!getPurchase.value && !!getPurchase.value.is_confirmed) {
+          return cbk();
+        }
+
+        // Exit early when this is a known outgoing trade
+        if (!!getRequest.value) {
+          return cbk();
+        }
+
+        logger.info({
+          request: decodeDetails.request,
+          purchase: requestDetails.description,
+          price: requestDetails.tokens,
+          to: requestDetails.destination,
+        });
+
+        // Select an action to take on the decoded trade
+        return ask({
+          choices: [
+            {name: 'Purchase', value: 'buy'},
+            {name: 'Already purchased?', value: 'reveal'},
+          ],
+          message: ' ',
+          name: 'action',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Ask for preimage in case it is separately known
+      askForPreimage: [
+        'requestDetails',
+        'selectPurchaseAction',
+        ({requestDetails, selectPurchaseAction}, cbk) =>
+      {
+        // Exit early when this is not a purchase
+        if (!selectPurchaseAction) {
+          return cbk();
+        }
+
+        // Exit early when preimage entry is not selected
+        if (selectPurchaseAction.action !== 'reveal') {
+          return cbk();
+        }
+
+        return ask({
+          message: `Enter the preimage for payment ${requestDetails.id}`,
+          name: 'secret',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            if (!isHexPreimage(input)) {
+              return 'Enter the secret preimage in hex encoded format';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Pay and get the preimage through paying for it
+      payForPreimage: [
+        'decodeDetails',
+        'selectPurchaseAction',
+        ({decodeDetails, selectPurchaseAction}, cbk) =>
+      {
+        // Exit early when this is an offer
+        if (!selectPurchaseAction) {
+          return cbk();
+        }
+
+        // Exit early when buy is not selected
+        if (selectPurchaseAction.action !== 'buy') {
+          return cbk();
+        }
+
+        return asyncRetry({
+          errorFilter: err => !!isArray(err) && err.slice().shift() >= 500,
+        },
+        cbk => {
+          return buyPreimage({
+            ask,
+            lnd,
+            logger,
+            request: decodeDetails.request,
+          },
+          cbk);
+        },
+        cbk);
+      }],
+
+      // Use the preimage to decrypt the trade secret
+      decryptSecret: [
+        'askForPreimage',
+        'decodeDetails',
+        'getPurchase',
+        'payForPreimage',
+        'requestDetails',
+        'selectPurchaseAction',
+        ({
+          askForPreimage,
+          decodeDetails,
+          getPurchase,
+          payForPreimage,
+          requestDetails,
+          selectPurchaseAction,
+        },
+        cbk) =>
+      {
+        // Exit early when this is not a purchase
+        if (!payForPreimage && !askForPreimage && !getPurchase.value) {
+          return cbk();
+        }
+
+        // Exit early when there is no successful purchase
+        if (!!getPurchase.value && !getPurchase.value.payment) {
+          return cbk();
+        }
+
+        // Notify when a preimage was paid for
+        if (!!payForPreimage) {
+          logger.info({
+            paid: payForPreimage.tokens,
+            fee: payForPreimage.fee,
+            secret: payForPreimage.secret,
+          });
+        }
+
+        const {payment} = getPurchase.value || {};
+
+        const paid = payForPreimage || askForPreimage || payment;
+
+        return decryptTradeSecret({
+          lnd,
+          auth: decodeDetails.auth,
+          from: requestDetails.destination,
+          payload: decodeDetails.payload,
+          secret: paid.secret,
+        },
+        cbk);
+      }],
+
+      // Log the trade details
+      trade: [
+        'decryptSecret',
+        'selectPurchaseAction',
+        ({decryptSecret, selectPurchaseAction}, cbk) =>
+      {
+        // Exit early when not purchasing
+        if (!decryptSecret) {
+          return cbk();
+        }
+
+        logger.info({trade_complete: hexAsUtf8(decryptSecret.plain)});
+
+        return cbk();
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/trades/manage_trades.js

@@ -0,0 +1,88 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const createTrade = require('./create_trade');
+const manageTrade = require('./manage_trade');
+
+const createAction = 'create';
+const decodeAction = 'decode';
+
+/** Create, view, and accept trades
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({ask, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToManageTrades']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToManageTrades']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedLoggerToManageTrades']);
+        }
+
+        return cbk();
+      },
+
+      // Select a trade option
+      select: ['validate', ({}, cbk) => {
+        return ask({
+          choices: [
+            {name: 'Create Trade', value: createAction},
+            {name: 'Decode Trade', value: decodeAction},
+          ],
+          message: 'Trade?',
+          name: 'action',
+          type: 'list',
+        },
+        cbk);
+      }],
+
+      // Create a new trade
+      create: ['select', ({select}, cbk) => {
+        // Exit early when not creating a new trade
+        if (select.action !== createAction) {
+          return cbk();
+        }
+
+        return createTrade({ask, lnd, logger}, cbk);
+      }],
+
+      // Trade was created
+      created: ['create', ({create}, cbk) => {
+        // Exit early when not creating a new trade
+        if (!create) {
+          return cbk();
+        }
+
+        logger.info({encoded_trade_created: create.trade});
+
+        return cbk();
+      }],
+
+      // View an existing trade
+      view: ['select', ({select}, cbk) => {
+        // Exit early when not decoding a trade
+        if (select.action !== decodeAction) {
+          return cbk();
+        }
+
+        return manageTrade({ask, lnd, logger}, cbk)
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};