paid-services 3.12.2 → 3.13.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## Version 3.13.0
+
+- `manageTrades`: Add support for experimental channel trades
+
 ## Version 3.12.2
 
 - `serviceOpenTrade`: Fix regtest network support

package/package.json

@@ -42,5 +42,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.12.2"
+  "version": "3.13.0"
 }

package/service_types.json

@@ -3,6 +3,8 @@
   "serviceTypeChangeCapacity": "8050001",
   "serviceTypeReceiveTrades": "8050006",
   "serviceTypeRequestTrades": "8050005",
+  "serviceTypeReceiveChannelSale": "8050008",
+  "serviceTypeRequestChannelSale": "8050007",
   "serviceTypeSignCapacityChange": "8050004",
   "serviceTypeWaitOnConfirmation": "8050003",
   "types": {
@@ -11,6 +13,8 @@
     "8050003": "serviceTypeWaitOnConfirmation",
     "8050004": "serviceTypeSignCapacityChange",
     "8050005": "serviceTypeRequestTrades",
-    "8050006": "serviceTypeReceiveTrades"
+    "8050006": "serviceTypeReceiveTrades",
+    "8050007": "serviceTypeRequestChannelSale",
+    "8050008": "serviceTypeReceiveChannelSale"
   }
 }

package/trades/accept_trade.js

@@ -5,7 +5,10 @@ const {getInvoice} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {settleHodlInvoice} = require('ln-service');
 
+const openChannel = require('./open_channel');
+
 const {isArray} = Array;
+const sellAction = 'sell';
 
 /** Accept an open ended trade
 
@@ -18,24 +21,28 @@ const {isArray} = Array;
 
   @returns via cbk or Promise
 */
-module.exports = ({cancel, id, lnd, secret}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!isArray(cancel)) {
+        if (!isArray(args.cancel)) {
           return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
         }
 
-        if (!id) {
+        if (!args.id) {
           return cbk([400, 'ExpectedAnchorTradeIdToAcceptTrade']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
         }
 
-        if (!secret) {
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToAcceptTrade']);
+        }
+
+        if (!args.secret) {
           return cbk([400, 'ExpectedSettlementPreimageToAcceptTrade']);
         }
 
@@ -43,18 +50,46 @@ module.exports = ({cancel, id, lnd, secret}, cbk) => {
       },
 
       // Fetch the anchor invoice to make sure it's still open
-      getAnchor: ['validate', ({}, cbk) => getInvoice({id, lnd}, cbk)],
+      getAnchor: ['validate', ({}, cbk) => {
+        return getInvoice({id: args.id, lnd: args.lnd}, cbk);
+      }],
 
       // Cancel alternative invoices so that only one resolves as settled
       cancel: ['getAnchor', ({}, cbk) => {
-        return asyncEach([].concat(cancel).concat(id), (id, cbk) => {
-          return cancelHodlInvoice({id, lnd}, cbk);
+        return asyncEach([].concat(args.cancel).concat(args.id), (id, cbk) => {
+          return cancelHodlInvoice({id, lnd: args.lnd}, cbk);
         },
         cbk);
       }],
 
       // Settle the held invoice with the preimage
-      settle: ['cancel', ({}, cbk) => settleHodlInvoice({lnd, secret}, cbk)],
+      settle: ['cancel', ({}, cbk) => {
+        return settleHodlInvoice({lnd: args.lnd, secret: args.secret}, cbk);
+      }],
+
+      // Open the channel
+      openChannel: ['settle', ({}, cbk) => {
+        // Exit early when the channel action is not a sell action
+        if (args.action !== sellAction) {
+          return cbk();
+        }
+
+        return openChannel({
+          id: args.partner_public_key,
+          lnd: args.lnd,
+          tokens: args.capacity,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          args.logger.info({channel_opened: res});
+
+          return cbk();
+        },
+        cbk);
+      }],
     },
     returnResult({reject, resolve}, cbk));
   });

package/trades/create_channel_sale.js

@@ -0,0 +1,233 @@
+const {randomBytes} = require('crypto');
+
+const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
+const {getChainFeeRate} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {getWalletInfo} = require('ln-service');
+const {signMessage} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const createAnchoredTrade = require('./create_anchored_trade');
+const serviceOpenTrade = require('./service_open_trade');
+
+const asNumber = n => parseFloat(n, 10);
+const daysAsMs = days => Number(days) * 1000 * 60 * 60 * 24;
+const defaultExpirationDays = 1;
+const futureDate = ms => new Date(Date.now() + ms).toISOString();
+const isNumber = n => !isNaN(n);
+const query = 'How much would you like to sell?';
+const saleCost = (amount, rate) => (amount * rate / 1000000).toFixed(0);
+const saleSecret = randomBytes(48).toString('hex');
+const tradeDescription = (alias, tokens) => `channelsale:${alias}-${tokens}`;
+
+/** Create a new channel sale
+
+  {
+    action: <Channel Sale Action String>
+    ask: <Ask Function>
+    balance: <Total Available Chain Confirmed Balance Tokens Number>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({action, ask, balance, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!action) {
+          return cbk([400, 'ExpectedActionTypeToCreateChannelSale']);
+        }
+
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToCreateChannelSale']);
+        }
+
+        if (balance === undefined) {
+          return cbk([400, 'ExpectedOnChainBalanceToCreateChannelSale']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToCreateChannelSale']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedLoggerToCreateChannelSale']);
+        }
+
+        return cbk();
+      },
+
+      // Get the public channels to use for an open trade
+      getChannels: ['validate', ({}, cbk) => {
+        return getChannels({lnd, is_public: true}, cbk);
+      }],
+
+      // Get self identity, including alias
+      getIdentity: ['validate', ({}, cbk) => getWalletInfo({lnd}, cbk)],
+
+      // Get the network name to use for an open trade
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+
+      // Ask for sale amount
+      askForAmount: ['validate', ({}, cbk) => {
+        return ask({
+          message: `${query} (Available balance: ${balance})`,
+          name: 'amount',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // The token amount should be numeric
+            if (!isNumber(input)) {
+              return 'Expected numeric amount for sale';
+            }
+
+            if (input > balance) {
+              return 'Sale amount cannot be more than available balance';
+            }
+
+            return true;
+          },
+        },
+        (err, result) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorAskingForSaleAmount', {err}]);
+          }
+
+          return cbk(null, result);
+        });
+      }],
+
+      // Ask for the rate
+      askForRate: ['askForAmount', ({}, cbk) => {
+        return ask({
+          default: '1',
+          message: 'Price of channel (in ppm)?',
+          name: 'rate',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // Price of sale should be numeric
+            if (!isNumber(input)) {
+              return 'Expected numeric fee rate for sale';
+            }
+
+            return true;
+          },
+        },
+        (err, result) => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorAskingForRate', err]);
+          }
+
+          return cbk(null, result);
+        });
+      }],
+
+      // Ask for the expiration of the channel sale
+      askForExpiration: ['askForRate', ({}, cbk) => {
+        return ask({
+          default: defaultExpirationDays,
+          name: 'days',
+          message: 'Days to offer this for?',
+          validate: input => {
+            if (!isNumber(input) || !Number(input)) {
+              return false;
+            }
+
+            return true;
+          },
+        },
+        cbk);
+      }],
+
+      // Calculate sale cost
+      saleCost: [
+        'askForAmount',
+        'askForRate',
+        ({askForRate, askForAmount}, cbk) =>
+      {
+        return cbk(null, saleCost(askForAmount.amount, askForRate.rate));
+      }],
+
+      // Description of sale
+      description: [
+        'askForAmount',
+        'getIdentity',
+        ({askForAmount, getIdentity}, cbk) =>
+      {
+        const alias = getIdentity.alias || getIdentity.public_key;
+
+        return cbk(null, tradeDescription(alias, askForAmount.amount));
+      }],
+
+      // Create an anchor invoice for the channel sale
+      createAnchor: [
+        'askForExpiration',
+        'askForRate',
+        'description',
+        'saleCost',
+        ({askForExpiration, description, saleCost}, cbk) =>
+      {
+        return createAnchoredTrade({
+          description,
+          lnd,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          secret: saleSecret,
+          tokens: asNumber(saleCost),
+        },
+        cbk);
+      }],
+
+      // Wait for a peer to connect and ask for the channel sale details
+      serviceSaleRequests: [
+        'askForAmount',
+        'askForExpiration',
+        'createAnchor',
+        'description',
+        'getChannels',
+        'getNetwork',
+        'getIdentity',
+        ({
+          askForAmount,
+          askForExpiration,
+          createAnchor,
+          description,
+          getChannels,
+          getNetwork,
+          getIdentity,
+          saleCost,
+        },
+        cbk) =>
+      {
+        return serviceOpenTrade({
+          action,
+          description,
+          lnd,
+          logger,
+          capacity: askForAmount.amount,
+          channels: getChannels.channels,
+          expires_at: futureDate(daysAsMs(askForExpiration.days)),
+          id: createAnchor.id,
+          network: getNetwork.network,
+          public_key: getIdentity.public_key,
+          secret: saleSecret,
+          tokens: asNumber(saleCost),
+          uris: (getIdentity.uris || []),
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/trades/finalize_trade_secret.js

@@ -3,23 +3,30 @@ const {createHash} = require('crypto');
 const asyncAuto = require('async/auto');
 const {createHodlInvoice} = require('ln-service');
 const {createInvoice} = require('ln-service');
+const {getChainFeeRate} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const encodeTradeSecret = require('./encode_trade_secret');
 const encryptTradeSecret = require('./encrypt_trade_secret');
 
 const bufferAsHex = buffer => buffer.toString('hex');
+const {ceil} = Math;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const openSizeVbytes = 250;
+const sellAction = 'sell';
 const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const slowConf = 144;
 const utf8AsHex = utf8 => Buffer.from(utf8, 'utf8').toString('hex');
 
 /** Create a trade secret for a node
 
   {
+    action: <Trade Action String>
     description: <Trade Description String>
     expires_at: <Trade Expires At ISO 8601 Date String>
     is_hold: <Create Hold Invoice Bool>
     lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
     secret: <Clear Secret String>
     to: <To Public Key Hex Encoded String>
     tokens: <Price Tokens Number>
@@ -64,6 +71,34 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
+      // Calculate dynamic sale price for channel sales
+      salePrice: ['validate', ({}, cbk) => {
+        // Exit early when this is not a channel sale
+        if (args.action !== sellAction) {
+          return cbk(null, {});
+        }
+
+        // Get a chain fee rate to dynamically price vs the chain cost
+        return getChainFeeRate({
+          confirmation_target: slowConf,
+          lnd: args.lnd,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          const chainSurcharge = ceil(res.tokens_per_vbyte * openSizeVbytes);
+
+          const price = chainSurcharge + args.tokens;
+
+          args.logger.info({total_channel_sale_cost: price});
+
+          return cbk(null, {price});
+        },
+        cbk);
+      }],
+
       // Encrypt the secret data
       encrypt: ['validate', ({}, cbk) => {
         return encryptTradeSecret({
@@ -75,7 +110,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Create the invoice to purchase the unlocking secret
-      createInvoice: ['encrypt', ({encrypt}, cbk) => {
+      createInvoice: ['encrypt', 'salePrice', ({encrypt, salePrice}, cbk) => {
         // Exit early when this is a hold invoice
         if (!!args.is_hold) {
           return createHodlInvoice({
@@ -84,7 +119,7 @@ module.exports = (args, cbk) => {
             id: bufferAsHex(sha256(hexAsBuffer(encrypt.payment_secret))),
             lnd: args.lnd,
             secret: encrypt.payment_secret,
-            tokens: args.tokens,
+            tokens: salePrice.price || args.tokens,
           },
           cbk);
         }

package/trades/find_trade.js

@@ -15,9 +15,12 @@ const decodeBasicTrade = require('./decode_basic_trade');
 const {makePeerRequest} = require('./../p2p');
 const requestTradeById = require('./request_trade_by_id');
 const {servicePeerRequests} = require('./../p2p');
+const {serviceTypeReceiveChannelSale} = require('./../service_types');
+const {serviceTypeRequestChannelSale} = require('./../service_types');
 const {serviceTypeReceiveTrades} = require('./../service_types');
 const {serviceTypeRequestTrades} = require('./../service_types');
 
+const buyChannelAction = 'buy';
 const findBasicRecord = records => records.find(n => n.type === '1');
 const findIdRecord = records => records.find(n => n.type === '0');
 const {isArray} = Array;
@@ -55,11 +58,15 @@ const waitForTradesMs = 1000 * 5;
     trade: <Encoded Trade String>
   }
 */
-module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
+module.exports = ({action, ask, id, identity, lnd, logger, nodes}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!action) {
+          return cbk([400, 'ExpectedActionTypeToFindTrade']);
+        }
+
         if (!ask) {
           return cbk([400, 'ExpectedAskMethodToFindTrade']);
         }
@@ -160,6 +167,26 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
       // Get the list of connected peers
       getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
 
+      // Determine the receive type to listen for
+      receiveType: ['validate', ({}, cbk) => {
+        // Exit early when the action is to buy a channel
+        if (action === buyChannelAction) {
+          return cbk(null, serviceTypeReceiveChannelSale);
+        }
+
+        return cbk(null, serviceTypeReceiveTrades);
+      }],
+
+      // Determine the request type to send
+      requestType: ['validate', ({}, cbk) => {
+        // Exit early when the action is to buy a channel
+        if (action === buyChannelAction) {
+          return cbk(null, serviceTypeRequestChannelSale);
+        }
+
+        return cbk(null, serviceTypeRequestTrades);
+      }],
+
       // Try and connect to a node in order to do p2p messaging
       connect: ['getNodes', 'getPeers', ({getNodes, getPeers}, cbk) => {
         const connected = getPeers.peers.map(n => n.public_key);
@@ -213,11 +240,17 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk();
         }
 
-        return requestTradeById({id, lnd, to}, cbk);
+        return requestTradeById({action, id, lnd, to}, cbk);
       })],
 
       // Request an inventory of trades
-      requestTrades: ['requestTrade', 'to', ({requestTrade, to}, cbk) => {
+      requestTrades: [
+        'receiveType',
+        'requestTrade',
+        'requestType',
+        'to',
+        ({receiveType, requestTrade, requestType, to}, cbk) =>
+      {
         // Exit early when there was a successful request for a specific id
         if (!!requestTrade.value) {
           return cbk();
@@ -234,8 +267,7 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return !!err ? cbk(err) : cbk(null, {trades});
         };
 
-        // Listen for trades
-        service.request({type: serviceTypeReceiveTrades}, (req, res) => {
+        service.request({type: receiveType}, (req, res) => {
           const requestIdRecord = findIdRecord(req.records);
 
           // Exit early when this is a request for something else
@@ -268,7 +300,7 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           to,
           records: [{type: tradesRequestIdType, value: requestId}],
           timeout: requestTradesTimeoutMs,
-          type: serviceTypeRequestTrades,
+          type: requestType,
         },
         (err, res) => {
           if (!!err) {
@@ -323,7 +355,7 @@ module.exports = ({ask, id, identity, lnd, logger, nodes}, cbk) => {
           return cbk();
         }
 
-        return requestTradeById({lnd, to, id: selectTrade.id}, cbk);
+        return requestTradeById({action, lnd, to, id: selectTrade.id}, cbk);
       }],
 
       // Final trade details

package/trades/manage_trade.js

@@ -21,6 +21,7 @@ const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 /** Manage an individual trade
 
   {
+    action: <Action Type String>
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
@@ -28,11 +29,15 @@ const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger}, cbk) => {
+module.exports = ({action, ask, lnd, logger}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!action) {
+          return cbk([400, 'ExpectedActionTypeToManageTrade']);
+        }
+
         if (!ask) {
           return cbk([400, 'ExpectedAskFunctionToManageTrade']);
         }
@@ -90,6 +95,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
         // Get the trade details interactively
         return findTrade({
+          action,
           ask,
           lnd,
           logger,

package/trades/manage_trades.js

@@ -2,12 +2,14 @@ const asyncAuto = require('async/auto');
 const asyncUntil = require('async/until');
 const {cancelHodlInvoice} = require('ln-service');
 const {diffieHellmanComputeSecret} = require('ln-service');
+const {getChainBalance} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getInvoices} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getNodeAlias} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
+const createChannelSale = require('./create_channel_sale');
 const createTrade = require('./create_trade');
 const encodeTrade = require('./encode_trade');
 const manageTrade = require('./manage_trade');
@@ -15,11 +17,13 @@ const serviceAnchoredTrades = require('./service_anchored_trades');
 const serviceOpenTrade = require('./service_open_trade');
 const tradeFromInvoice = require('./trade_from_invoice');
 
+const buyAction = 'buy';
 const cancelAction = 'cancel-';
 const createAction = 'create';
 const decodeAction = 'decode';
 const defaultInvoicesLimit = 100;
 const listAction = 'list';
+const sellAction = 'sell';
 const serveAction = 'serve';
 const serveTradeAction = 'serve-trade-';
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
@@ -29,6 +33,7 @@ const viewAction = 'view';
 
   {
     ask: <Ask Function>
+    experimental: <Experiment Mode Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     separator: <Create Separator Function>
@@ -36,7 +41,7 @@ const viewAction = 'view';
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger, separator}, cbk) => {
+module.exports = ({ask, experimental, lnd, logger, separator}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -66,12 +71,25 @@ module.exports = ({ask, lnd, logger, separator}, cbk) => {
       select: ['validate', ({}, cbk) => {
         return ask({
           choices: [
+            separator(),
             {name: 'Create Trade', value: createAction},
             {name: 'Decode Trade', value: decodeAction},
             separator(),
+            {
+              name: 'Buy Channel (experimental)',
+              value: buyAction,
+              disabled: !experimental,
+            },
+            {
+              name: 'Sell Channel (experimental)',
+              value: sellAction,
+              disabled: !experimental,
+            },
+            separator(),
             {name: 'Open Trades', value: listAction},
             {name: 'Serve Trades', value: serveAction},
           ],
+          loop: false,
           message: 'Trade?',
           name: 'action',
           type: 'list',
@@ -113,11 +131,11 @@ module.exports = ({ask, lnd, logger, separator}, cbk) => {
       // View an existing trade
       view: ['checkSigner', 'select', ({checkSigner, select}, cbk) => {
         // Exit early when not decoding a trade
-        if (select.action !== decodeAction) {
+        if (select.action !== decodeAction && select.action !== buyAction) {
           return cbk();
         }
 
-        return manageTrade({ask, lnd, logger}, cbk)
+        return manageTrade({ask, lnd, logger, action: select.action}, cbk)
       }],
 
       // Get open trades
@@ -289,6 +307,29 @@ module.exports = ({ask, lnd, logger, separator}, cbk) => {
           return cbk(err);
         });
       }],
+
+      // Sell a channel
+      sellChannel: ['select', ({select}, cbk) => {
+        // Exit early when not selling a channel
+        if (select.action !== sellAction) {
+          return cbk();
+        }
+
+        return getChainBalance({lnd}, (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          return createChannelSale({
+            ask,
+            lnd,
+            logger,
+            action: select.action,
+            balance: res.chain_balance,
+          },
+          cbk);
+        });
+      }],
     },
     returnResult({reject, resolve}, cbk));
   });

package/trades/network_record_from_request.js

@@ -1,7 +1,9 @@
-const defaultNetwork = 'lnbc';
-const regtestNetwork = 'lnbcrt';
+const {parsePaymentRequest} = require('ln-service');
+
+const defaultNetwork = 'bitcoin';
+const regtestNetwork = 'regtest';
 const regtestNetworkType = '02';
-const testnetNetwork = 'lntb';
+const testnetNetwork = 'testnet';
 const testnetNetworkType = '01';
 
 /** Derive a network record name from a payment request
@@ -20,17 +22,24 @@ module.exports = ({request}) => {
     throw new Error('ExpectedPaymentRequestToDeriveNetworkRecord');
   }
 
-  if (request.startsWith(defaultNetwork)) {
-    return {};
-  }
+  try {
+    const {network} = parsePaymentRequest({request});
 
-  if (request.startsWith(regtestNetwork)) {
-    return {value: regtestNetworkType};
-  }
+    if (network === defaultNetwork) {
+      return {};
+    }
 
-  if (request.startsWith(testnetNetwork)) {
-    return {value: testnetNetworkType};
-  }
+    if (network === regtestNetwork) {
+      return {value: regtestNetworkType};
+    }
 
-  throw new Error('UnknownNetworkToDeriveNetworkRecordFor');
+    if (network === testnetNetwork) {
+      return {value: testnetNetworkType};
+    }
+
+    throw new Error('UnknownNetworkToDeriveNetworkRecordFor');
+
+  } catch (err) {
+    throw new Error('FailedToParsePaymentRequestToDeriveNetworkRecord');
+  }
 };

package/trades/open_channel.js

@@ -0,0 +1,60 @@
+const asyncAuto = require('async/auto');
+const {getPeers} = require('ln-service');
+const {getChainFeeRate} = require('ln-service');
+const {openChannel} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const slowConf = 144;
+
+/** Opens channel on invoice payment
+  {
+    id: <Partner Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+    tokens: <Capacity of Channel To Open Tokens Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    transaction_id: <Funding Transaction Id String>
+    transaction_vout: <Funding Transaction Output Index Number>
+  }
+*/
+module.exports = ({id, lnd, tokens}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedPartnerPublicKeyToOpenNewChannel']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndObjectToOpenNewChannel']);
+        }
+
+        if (!tokens) {
+          return cbk([400, 'ExpectedCapacityToOpenNewChannel']);
+        }
+
+        return cbk();
+      },
+
+      // Get low fee rate
+      getSlowFee: ['validate', ({}, cbk) => {
+        return getChainFeeRate({lnd, confirmation_target: slowConf}, cbk);
+      }],
+
+      // Select a peer and open a channel
+      openChannel: ['getSlowFee', ({getSlowFee}, cbk) => {
+        return openChannel({
+          lnd,
+          chain_fee_rate: getSlowFee.tokens_per_vbyte,
+          local_tokens: tokens,
+          partner_public_key: id,
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'openChannel'}, cbk));
+  });
+};

package/trades/request_trade_by_id.js

@@ -4,14 +4,17 @@ const {returnResult} = require('asyncjs-util');
 const decodeTrade = require('./decode_trade');
 const {makePeerRequest} = require('./../p2p');
 
+const buyChannelAction = 'buy';
 const findTradeRecord = records => records.find(n => n.type === '1');
 const requestTradeTimeoutMs = 1000 * 30;
+const {serviceTypeRequestChannelSale} = require('./../service_types');
 const {serviceTypeRequestTrades} = require('./../service_types');
 const tradeIdRecordType = '0';
 
 /** Request a specific trade by its id
 
   {
+    action: <Purchase Action String>
     id: <Trade Identifier Hex String>
     lnd: <Authenticated LND API Object>
     to: <Make Request To Public Key Hex Encoded String>
@@ -25,11 +28,15 @@ const tradeIdRecordType = '0';
     trade: <Encoded Trade Record String>
   }
 */
-module.exports = ({id, lnd, to}, cbk) => {
+module.exports = ({action, id, lnd, to}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
+        if (!action) {
+          return cbk([400, 'ExpectedActionTypeToRequestTradeById']);
+        }
+
         if (!id) {
           return cbk([400, 'ExpectedTradeIdentifierToRequestTradeById']);
         }
@@ -45,14 +52,23 @@ module.exports = ({id, lnd, to}, cbk) => {
         return cbk();
       },
 
+      // Derive request type
+      requestType: ['validate', ({}, cbk) => {
+        if (action === buyChannelAction) {
+          return cbk(null, serviceTypeRequestChannelSale);
+        }
+
+        return cbk(null, serviceTypeRequestTrades);
+      }],
+
       // Get trade
-      getTrade: ['validate', ({}, cbk) => {
+      getTrade: ['requestType', ({requestType}, cbk) => {
         return makePeerRequest({
           lnd,
           to,
           records: [{type: tradeIdRecordType, value: id}],
           timeout: requestTradeTimeoutMs,
-          type: serviceTypeRequestTrades,
+          type: requestType,
         },
         (err, res) => {
           if (!!err) {

package/trades/service_open_trade.js

@@ -14,6 +14,8 @@ const uriAsSocket = n => n.substring(67);
 /** Service an individual trade
 
   {
+    [action]: <Trade Action String>
+    [capacity]: <Channel Open Capacity Tokens Number>
     channels: [{
       id: <Standard Format Channel Id String>
       partner_public_key: <Node Public Key Hex String>
@@ -102,10 +104,13 @@ module.exports = (args, cbk) => {
         args.logger.info({trade_expiry: new Date(args.expires_at)});
 
         const sub = serviceTradeRequests({
+          action: args.action,
+          capacity: args.capacity,
           description: args.description,
           expires_at: args.expires_at,
           id: args.id,
           lnd: args.lnd,
+          logger: args.logger,
           secret: args.secret,
           tokens: asNumber(args.tokens),
         });

package/trades/service_trade_requests.js

@@ -1,6 +1,7 @@
 const EventEmitter = require('events');
 const {randomBytes} = require('crypto');
 
+const {acceptsChannelOpen} = require('ln-sync');
 const {getInvoice} = require('ln-service');
 const {subscribeToInvoice} = require('ln-service');
 
@@ -8,6 +9,8 @@ const acceptTrade = require('./accept_trade');
 const finalizeTradeSecret = require('./finalize_trade_secret');
 const {makePeerRequest} = require('./../p2p');
 const {servicePeerRequests} = require('./../p2p');
+const {serviceTypeReceiveChannelSale} = require('./../service_types');
+const {serviceTypeRequestChannelSale} = require('./../service_types');
 const {serviceTypeRequestTrades} = require('./../service_types');
 const {serviceTypeReceiveTrades} = require('./../service_types');
 
@@ -20,6 +23,7 @@ const idBackType = '0';
 const idRecord = id => ({type: '1', value: id});
 const msRemainingToTime = time => time - Date.now();
 const postOpenTradeTimeoutMs = 1000 * 30;
+const sellAction = 'sell';
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const tradeSecretType = '1';
 const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
@@ -29,10 +33,12 @@ const utf8AsHex = utf8 => Buffer.from(utf8).toString('hex');
   The maximum expiration date is three weeks
 
   {
+    action: <Trade Action String>
     description: <Trade Description String>
     expires_at: <Trade Expires At ISO 8601 Date String>
     id: <Trade Id Hex String>
     lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
     secret: <Secret Payload String>
     tokens: <Tokens Number>
   }
@@ -126,8 +132,12 @@ module.exports = args => {
     descRecord(utf8AsHex(args.description)),
   ];
 
+  const requestType = !!args.action ?
+    serviceTypeRequestChannelSale :
+    serviceTypeRequestTrades;
+
   // Wait for a request for the open trade
-  service.request({type: serviceTypeRequestTrades}, (req, res) => {
+  service.request({type: requestType}, (req, res) => {
     const {failure, success} = res;
     const requestTradeId = findIdRecord(req.records);
 
@@ -163,13 +173,17 @@ module.exports = args => {
           return;
         }
 
+        const receiveType = args.action === sellAction ?
+          serviceTypeReceiveChannelSale :
+          serviceTypeReceiveTrades;
+
         // Ping the node with trade details
         return makePeerRequest({
           records,
           lnd: args.lnd,
           timeout: postOpenTradeTimeoutMs,
           to: req.from,
-          type: serviceTypeReceiveTrades,
+          type: receiveType,
         },
         err => {
           if (!!err) {
@@ -191,10 +205,12 @@ module.exports = args => {
 
     // Create a trade secret for the requesting peer and return that
     return finalizeTradeSecret({
+      action: args.action,
       description: args.description,
       expires_at: args.expires_at,
       is_hold: true,
       lnd: args.lnd,
+      logger: args.logger,
       secret: args.secret,
       to: req.from,
       tokens: args.tokens,
@@ -230,9 +246,13 @@ module.exports = args => {
 
         // Settle the held invoice with the preimage
         return acceptTrade({
+          action: args.action,
+          capacity: args.capacity,
           cancel: holds.filter(n => n.id !== updated.id).map(n => n.id),
           id: args.id,
           lnd: args.lnd,
+          logger: args.logger,
+          partner_public_key: req.from,
           secret: res.secret,
         },
         err => {
@@ -246,6 +266,23 @@ module.exports = args => {
         });
       });
 
+      // Exit early on channel sale, confirming acceptance
+      if (args.action === sellAction) {
+        return acceptsChannelOpen({
+          capacity: args.capacity,
+          lnd: args.lnd,
+          partner_public_key: req.from,
+        },
+        err => {
+          if (!!err) {
+            return failure([503, 'FailedToAcceptChannelOpen', {err}]);
+          }
+
+          // Return details about the trade
+          return success({records: [record]});
+        });
+      }
+
       // Return details about the trade
       return success({records: [record]});
     });