paid-services 3.13.2 → 3.14.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## Version 3.14.2
+
+- `manageTrades`: Fix listing of trades that have fiat-pricing
+
+## Version 3.14.1
+
+- `manageTrades`: Add support for dynamic fiat-priced trades
+
 ## Version 3.13.2
 
 - `acceptTrade`: Fix `logger` to be documented as an arg and optional

package/p2p/encode_peer_response.js

@@ -1,9 +1,8 @@
-const {encodeBigSize} = require('bolt01');
 const {encodeTlvStream} = require('bolt01');
 
-const encodeMessage = message => `626f73ff${message}`;
 const encodeResponseCode = require('./encode_response_code');
 
+const encodeMessage = message => `626f73ff${message}`;
 const headers = null;
 const params = null;
 const version = null;

package/package.json

@@ -7,6 +7,7 @@
     "url": "https://github.com/alexbosworth/paid-services/issues"
   },
   "dependencies": {
+    "@alexbosworth/fiat": "1.0.1",
     "async": "3.2.3",
     "asyncjs-util": "1.2.8",
     "bolt01": "1.2.3",
@@ -42,5 +43,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 180 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/balanced/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.13.2"
+  "version": "3.14.2"
 }

package/test/trades/test_encode_open_trade.js

@@ -3,6 +3,54 @@ const {test} = require('@alexbosworth/tap');
 const method = require('./../../trades/encode_open_trade');
 
 const tests = [
+  {
+    args: {},
+    description: 'A network name is required',
+    error: 'ExpectedNetworkNameToEncodeOpenTrade',
+  },
+  {
+    args: {network: 'btc'},
+    description: 'Nodes array is required',
+    error: 'ExpectedArrayOfNodesToEncodeOpenTrade',
+  },
+  {
+    args: {network: 'btc', nodes: []},
+    description: 'Nodes are required',
+    error: 'ExpectedNodeToReferToInOpenTrade',
+  },
+  {
+    args: {
+      network: 'btctestnet',
+      nodes: [{
+        channels: [{
+          id: '1x2x3',
+          partner_public_key: Buffer.alloc(33, 2).toString('hex'),
+        }],
+        id: Buffer.alloc(33, 3).toString('hex'),
+        sockets: [],
+      }],
+    },
+    description: 'A network record is added',
+    expected: {trade: '626f73ff000101010101040c000a01080000010000020003'},
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      network: 'btctestnet',
+      nodes: [{
+        channels: [{
+          id: '1x2x3',
+          partner_public_key: Buffer.alloc(33, 2).toString('hex'),
+        }],
+        id: Buffer.alloc(33, 3).toString('hex'),
+        sockets: [],
+      }],
+    },
+    description: 'A trade id record is added',
+    expected: {
+      trade: '626f73ff000101010101040c000a0108000001000002000305200000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
   {
     args: {
       network: 'btc',

package/test/trades/test_encode_trade.js

@@ -3,6 +3,29 @@ const {test} = require('@alexbosworth/tap');
 const method = require('./../../trades/encode_trade');
 
 const tests = [
+  {
+    args: {},
+    description: 'Either connect or secret is required',
+    error: 'ExpectedEitherConnectDetailsOrTradeSecret',
+  },
+  {
+    args: {connect: true, secret: true},
+    description: 'Cannot encode both connect and secret',
+    error: 'ExpectedOnlyOneConnectDetailsOrTradeSecretNotBoth',
+  },
+  {
+    args: {
+      secret: {
+        auth: '00',
+        payload: '11',
+        request: 'lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d73gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ecky03ylcqca784w',
+      },
+    },
+    description: 'Trade secret is encoded',
+    expected: {
+      trade: '626f73ff02960001e801910b25fe64410d00004080c1014181c20240004080c1014181c20240004080c1014181c202404081a1fa83632b0b9b29031b7b739b4b232b91039bab83837b93a34b733903a3434b990383937b532b1ba038ec6891345e204145be8a3a99de38e98a39d6a569434e1845c8af7205afcfcc7f425fcd1463e93c32881ead0d6e356d467ec8c02553f9aab15e5738b11f127f0003080006000111010100',
+    },
+  },
   {
     args: {
       connect: {
@@ -17,7 +40,7 @@ const tests = [
         }],
       },
     },
-    description: 'Trade is encoded',
+    description: 'Trade connect is encoded',
     expected: {trade: '626f73ff000101040c000a01080000010000020003'},
   },
 ];

package/trades/accept_trade.js

@@ -1,45 +1,58 @@
+const {acceptsChannelOpen} = require('ln-sync');
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
 const {cancelHodlInvoice} = require('ln-service');
+const {getChainFeeRate} = require('ln-service');
 const {getInvoice} = require('ln-service');
+const {openChannel} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {settleHodlInvoice} = require('ln-service');
 
-const openChannel = require('./open_channel');
-
 const {isArray} = Array;
-const sellAction = 'sell';
+const slowConf = 144;
 
 /** Accept an open ended trade
 
   {
     cancel: [<Alternative Invoice Id Hex String>]
+    [channel]: <Channel Capacity Tokens Number>
+    from: <Trade With Node Identity Public Key Hex String>
     id: <Trade Id Hex String>
     lnd: <Authenticated LND API Object>
-    [logger]: <Winston Logger Object>
     secret: <Invoice to Settle Preimage Hex String>
   }
 
   @returns via cbk or Promise
+  {
+    [opening_channel]: {
+      fee_tokens_per_vbyte: <Chain Fee Rate Number>
+      transaction_id: <Channel Funding Transaction Id Hex String>
+      transaction_vout: <Channel Funding Transaction Output Index Number>
+    }
+  }
 */
-module.exports = (args, cbk) => {
+module.exports = ({cancel, channel, from, id, lnd, secret}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!isArray(args.cancel)) {
+        if (!isArray(cancel)) {
           return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
         }
 
-        if (!args.id) {
+        if (!from) {
+          return cbk([400, 'ExpectedWithPeerPublicKeyToAcceptTrade']);
+        }
+
+        if (!id) {
           return cbk([400, 'ExpectedAnchorTradeIdToAcceptTrade']);
         }
 
-        if (!args.lnd) {
+        if (!lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
         }
 
-        if (!args.secret) {
+        if (!secret) {
           return cbk([400, 'ExpectedSettlementPreimageToAcceptTrade']);
         }
 
@@ -47,49 +60,86 @@ module.exports = (args, cbk) => {
       },
 
       // Fetch the anchor invoice to make sure it's still open
-      getAnchor: ['validate', ({}, cbk) => {
-        return getInvoice({id: args.id, lnd: args.lnd}, cbk);
+      getAnchor: ['validate', ({}, cbk) => getInvoice({id, lnd}, cbk)],
+
+      // Get the chain fee rate for channel opening trades
+      getFeeRate: ['validate', ({}, cbk) => {
+        // Exit early when not trading a channel open
+        if (!channel) {
+          return cbk();
+        }
+
+        return getChainFeeRate({lnd, confirmation_target: slowConf}, cbk);
       }],
 
       // Cancel alternative invoices so that only one resolves as settled
-      cancel: ['getAnchor', ({}, cbk) => {
-        return asyncEach([].concat(args.cancel).concat(args.id), (id, cbk) => {
-          return cancelHodlInvoice({id, lnd: args.lnd}, cbk);
+      cancel: ['getAnchor', ({getAnchor}, cbk) => {
+        if (!!getAnchor.is_canceled) {
+          return cbk([404, 'OpenTradeNotFound']);
+        }
+
+        return asyncEach([].concat(cancel).concat(id), (alternative, cbk) => {
+          return cancelHodlInvoice({lnd, id: alternative}, cbk);
+        },
+        cbk);
+      }],
+
+      // Check opening for channel trades
+      acceptsOpen: ['cancel', ({}, cbk) => {
+        // Exit early when not opening a channel
+        if (!channel) {
+          return cbk();
+        }
+
+        return acceptsChannelOpen({
+          lnd,
+          capacity: channel,
+          partner_public_key: from,
         },
         cbk);
       }],
 
       // Settle the held invoice with the preimage
-      settle: ['cancel', ({}, cbk) => {
-        return settleHodlInvoice({lnd: args.lnd, secret: args.secret}, cbk);
+      settle: ['acceptsOpen', 'cancel', 'getFeeRate', ({}, cbk) => {
+        return settleHodlInvoice({lnd, secret}, cbk);
       }],
 
       // Open the channel
-      openChannel: ['settle', ({}, cbk) => {
-        // Exit early when the channel action is not a sell action
-        if (args.action !== sellAction) {
+      openChannel: ['getFeeRate', 'settle', ({getFeeRate}, cbk) => {
+        // Exit early when this is not a channel trade
+        if (!channel) {
           return cbk();
         }
 
         return openChannel({
-          id: args.partner_public_key,
-          lnd: args.lnd,
-          tokens: args.capacity,
+          lnd,
+          chain_fee_rate: getFeeRate.tokens_per_vbyte,
+          local_tokens: channel,
+          partner_public_key: from,
         },
-        (err, res) => {
-          if (!!err) {
-            return cbk(err);
-          }
+        cbk);
+      }],
 
-          if (!!args.logger) {
-            args.logger.info({channel_opened: res});
-          }
+      // Trade is settled
+      settled: [
+        'getFeeRate',
+        'openChannel',
+        ({getFeeRate, openChannel}, cbk) =>
+      {
+        // Exit early when there is no trade result
+        if (!openChannel) {
+          return cbk(null, {});
+        }
 
-          return cbk();
-        },
-        cbk);
+        return cbk(null, {
+          opening_channel: {
+            fee_tokens_per_vbyte: getFeeRate.tokens_per_vbyte,
+            transaction_id: openChannel.transaction_id,
+            transaction_vout: openChannel.transaction_vout,
+          },
+        });
       }],
     },
-    returnResult({reject, resolve}, cbk));
+    returnResult({reject, resolve, of: 'settled'}, cbk));
   });
 };

package/trades/buy_channel.js

@@ -0,0 +1,251 @@
+const {randomBytes} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {parsePaymentRequest} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const buyPreimage = require('./buy_preimage');
+const connectToSeller = require('./connect_to_seller');
+const decodeBasicTrade = require('./decode_basic_trade');
+const decodeTrade = require('./decode_trade');
+const {makePeerRequest} = require('./../p2p');
+const {servicePeerRequests} = require('./../p2p');
+const {serviceTypeReceiveChannelSale} = require('./../service_types');
+const {serviceTypeRequestChannelSale} = require('./../service_types');
+
+const findBasicRecord = records => records.find(n => n.type === '1');
+const findIdRecord = records => records.find(n => n.type === '0');
+const findTradeRecord = records => records.find(n => n.type === '1');
+const {isArray} = Array;
+const makeRequestId = () => randomBytes(32).toString('hex');
+const requestTradeTimeoutMs = 1000 * 30;
+const requestTradesTimeoutMs = 1000 * 30;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const tradeIdRecordType = '0';
+const tradesRequestIdType = '1';
+
+/** Purchase a channel
+
+  {
+    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, 'ExpectedAskFunctionToBuyChannel']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToBuyChannel']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToBuyChannel']);
+        }
+
+        return cbk();
+      },
+
+      // Get the trade data to decode it
+      askForTrade: ['validate', ({}, cbk) => {
+        return ask({
+          name: 'trade',
+          message: 'Enter encoded trade',
+          type: 'input',
+          validate: trade => {
+            if (!trade) {
+              return false;
+            }
+
+            try {
+              decodeTrade({trade});
+            } catch (err) {
+              return 'Failed to parse trade details, try re-entering it?';
+            }
+
+            // The trade type should be a connect type
+            if (!decodeTrade({trade}).connect) {
+              return 'Incorrect type of trade, enter a channel sale trade?';
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Decode the connect details
+      connectDetails: ['askForTrade', ({askForTrade}, cbk) => {
+        try {
+          const {connect} = decodeTrade({trade: askForTrade.trade});
+
+          if (!connect) {
+            return cbk([400, 'ExpectedConnectDetailsInTradeInput']);
+          }
+
+          return cbk(null, connect);
+        } catch (err) {
+          return cbk([400, err.message]);
+        }
+      }],
+
+      // Connect to the selling node
+      connectToSeller: ['connectDetails', ({connectDetails}, cbk) => {
+        return connectToSeller({
+          lnd,
+          logger,
+          nodes: connectDetails.nodes,
+        },
+        cbk);
+      }],
+
+      // Get channels being sold
+      requestTrade: ['connectToSeller', ({connectToSeller}, cbk) => {
+        const requestId = makeRequestId();
+        const service = servicePeerRequests({lnd});
+
+        service.request({type: serviceTypeReceiveChannelSale}, (req, res) => {
+          const requestIdRecord = findIdRecord(req.records);
+
+          // Exit early when this is a request for something else
+          if (!requestIdRecord || requestIdRecord.value !== requestId) {
+            return;
+          }
+
+          // Make sure there is a basic trade record in the records
+          if (!findBasicRecord(req.records)) {
+            return res.failure([400, 'ExpectedBasicTradeRecord']);
+          }
+
+          // Make sure the basic trade record is valid
+          try {
+            decodeBasicTrade({records: req.records});
+          } catch (err) {
+            return res.failure([400, 'ExpectedValidBasicTradeRecord']);
+          }
+
+          const trade = decodeBasicTrade({records: req.records});
+
+          res.success({});
+
+          // Don't listen for more channel sales
+          service.stop({});
+
+          return cbk(null, trade);
+        });
+
+        logger.info({requesting_trade_details: true});
+
+        // Once connected, ask for the trade details
+        return makePeerRequest({
+          lnd,
+          records: [{type: tradesRequestIdType, value: requestId}],
+          timeout: requestTradesTimeoutMs,
+          to: connectToSeller.id,
+          type: serviceTypeRequestChannelSale,
+        },
+        (err, res) => {
+          if (!!err) {
+            service.stop({});
+
+            return cbk(err);
+          }
+
+          // A trade will be pinged back into the listening service
+          return;
+        });
+      }],
+
+      // Get the specific trade details
+      getTrade: [
+        'connectToSeller',
+        'requestTrade',
+        ({connectToSeller, requestTrade}, cbk) =>
+      {
+        return makePeerRequest({
+          lnd,
+          records: [{type: tradeIdRecordType, value: requestTrade.id}],
+          timeout: requestTradeTimeoutMs,
+          to: connectToSeller.id,
+          type: serviceTypeRequestChannelSale,
+        },
+        (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 {payment} = decodeTrade({trade: tradeRecord.value});
+
+          if (!payment) {
+            return cbk([503, 'ExpectedTradePaymentInResponseForTradeById']);
+          }
+
+          return cbk(null, {request: payment.request});
+        });
+      }],
+
+      // Parse the trade payment request
+      requestDetails: ['getTrade', ({getTrade}, cbk) => {
+        try {
+          return cbk(null, parsePaymentRequest({request: getTrade.request}));
+        } catch (err) {
+          return cbk([503, 'FailedToParseBuyChannelPaymentRequest', {err}]);
+        }
+      }],
+
+      // Pay and get the preimage through paying for it
+      payForPreimage: [
+        'getTrade',
+        'requestDetails',
+        ({getTrade, requestDetails}, cbk) =>
+      {
+        logger.info({
+          request: getTrade.request,
+          purchase: requestDetails.description,
+          price: tokensAsBigUnit(requestDetails.tokens),
+          to: requestDetails.destination,
+        });
+
+        const {request} = getTrade;
+
+        return asyncRetry({
+          errorFilter: err => !!isArray(err) && err.slice().shift() >= 500,
+        },
+        cbk => buyPreimage({ask, lnd, logger, request}, cbk), cbk);
+      }],
+
+      // Signal that the payment was made
+      finished: ['payForPreimage', ({payForPreimage}, cbk) => {
+        logger.info({
+          price: payForPreimage.tokens,
+          payment_proof: payForPreimage.secret,
+          routing_fee: payForPreimage.fee,
+        });
+
+        return cbk();
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/trades/buy_preimage.js

@@ -5,6 +5,7 @@ const {returnResult} = require('asyncjs-util');
 const {subscribeToProbeForRoute} = require('ln-service');
 
 const cltvDeltaBuffer = 5;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Buy the preimage for a trade
 
@@ -134,9 +135,9 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       // Final payment
       paid: ['parseRequest', 'pay', ({parseRequest, pay}, cbk) => {
         return cbk(null, {
-          fee: pay.fee,
+          fee: tokensAsBigUnit(pay.fee),
           secret: pay.secret,
-          tokens: parseRequest.tokens,
+          tokens: tokensAsBigUnit(parseRequest.tokens),
         });
       }],
     },