paid-services 3.15.3 → 3.16.1

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## Version 3.15.3
+## Version 3.16.1
+
+- `manageSwap`: Add external funding, conf target setting, keysend pushes
+
+## Version 3.15.4
 
 - `manageSwap`: Add method to execute submarine swaps on testnet
 

package/package.json

@@ -8,24 +8,24 @@
   },
   "dependencies": {
     "@alexbosworth/fiat": "1.0.2",
-    "async": "3.2.3",
+    "async": "3.2.4",
     "asyncjs-util": "1.2.9",
     "bech32": "2.0.0",
-    "bolt01": "1.2.4",
-    "bolt07": "1.8.1",
+    "bolt01": "1.2.5",
+    "bolt07": "1.8.2",
     "ecpair": "2.0.1",
-    "goldengate": "11.2.1",
-    "invoices": "2.0.6",
-    "ln-service": "53.14.1",
-    "ln-sync": "3.12.0",
-    "psbt": "2.0.1",
+    "goldengate": "11.2.2",
+    "invoices": "2.0.7",
+    "ln-service": "53.17.2",
+    "ln-sync": "3.12.1",
+    "psbt": "2.6.0",
     "p2tr": "1.3.1",
     "tiny-secp256k1": "2.2.1"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
-    "ln-docker-daemons": "2.2.9",
+    "ln-docker-daemons": "2.3.0",
     "mock-lnd": "1.4.1",
     "secp256k1": "4.0.3"
   },
@@ -47,5 +47,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.15.3"
+  "version": "3.16.1"
 }

package/service_types.json

@@ -6,6 +6,7 @@
   "serviceTypeReceiveChannelSale": "8050008",
   "serviceTypeRequestChannelSale": "8050007",
   "serviceTypeSignCapacityChange": "8050004",
+  "serviceTypeSwapResponse": "8050009",
   "serviceTypeWaitOnConfirmation": "8050003",
   "types": {
     "8050001": "serviceTypeChangeCapacity",
@@ -15,6 +16,7 @@
     "8050005": "serviceTypeRequestTrades",
     "8050006": "serviceTypeReceiveTrades",
     "8050007": "serviceTypeRequestChannelSale",
-    "8050008": "serviceTypeReceiveChannelSale"
+    "8050008": "serviceTypeReceiveChannelSale",
+    "8050009": "serviceTypeSwapResponse"
   }
 }

package/swaps/complete_off_to_on_swap.js

@@ -81,6 +81,7 @@ const v1AddressWords = key => [].concat(1).concat(bech32m.toWords(key));
   {
     emitter: <Event Emitter Object>
     [is_avoiding_broadcast]: <Avoid Sweep Broadcast Bool>
+    [is_external_funding]: <Externally Fund Swap Bool>
     [is_uncooperative]: <Avoid Cooperative Signing Bool>
     lnd: <Autenticated LND API Object>
     max_fee_deposit: <Max Routing Fee Tokens For Deposit Number>
@@ -236,6 +237,12 @@ module.exports = (args, cbk) => {
       payToFund: ['responseDetails', asyncReflect(({responseDetails}, cbk) => {
         const request = responseDetails.request;
 
+        if (!!args.is_external_funding) {
+          args.emitter.emit('update', {pay_to_fund_swap_offchain: request});
+
+          return cbk();
+        }
+
         args.emitter.emit('update', {funding_swap_offchain: request});
 
         return pay({
@@ -906,9 +913,9 @@ module.exports = (args, cbk) => {
 
         return cbk(null, {
           paid_execution_fee: deposit.tokens,
-          paid_execution_routing: deposit.fee,
+          paid_execution_routing: deposit.fee || undefined,
           swap_payment_sent: funding.tokens,
-          swap_payment_routing_fee: funding.fee,
+          swap_payment_routing_fee: funding.fee || undefined,
         });
       }],
     },

package/swaps/complete_on_to_off_swap.js

@@ -68,9 +68,9 @@ const witnessLengthTimeoutSweep = 3;
 /** Complete the on-chain side of the swap by taking the off-chain funds
 
   {
+    [confirmation_target]: <Funding Confirmation Target Number>
     emitter: <Event Emitter Object>
     [is_ignoring_deposit]: <Ignore Held Deposit Funds Bool>
-    [fund_fee_rate]: <Fund Chain Fee Rate Number>
     lnd: <Authenticated LND API Object>
     recovery: <Swap Recovery Hex String>
     [request]: <Request Function>
@@ -486,8 +486,8 @@ module.exports = (args, cbk) => {
 
         return fundPsbt({
           psbt,
-          fee_tokens_per_vbyte: args.fund_fee_rate,
           lnd: args.lnd,
+          target_confirmations: args.confirmation_target,
         },
         cbk);
       }],

package/swaps/manage_swap.js

@@ -1,17 +1,32 @@
 const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const {findKey} = require('ln-sync');
 const {getMasterPublicKeys} = require('ln-service');
+const {getAllInvoices} = require('ln-sync');
+const {getInvoice} = require('ln-service');
 const {getNetwork} = require('ln-sync');
+const {getNodeAlias} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
+const decodeOffToOnRequest = require('./decode_off_to_on_request');
+const {decodeTrade} = require('./../trades');
 const recoverResponseToSwapOut = require('./recover_response_to_swap_out');
 const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
 
+const actionPushRequest = 'push-request';
 const allowedNetwork = 'btctestnet';
 const bip86Path = `m/86'/0'/0'`;
+const flatten = arr => [].concat(...arr);
+const minConfirmations = {btc: 2, btcregtest: 3, btctestnet: 1};
+const niceId = id => id.substring(0, 8);
+const niceName = node => `${node.alias} ${node.id.substring(0, 8)}`.trim();
+const pushesReceivedAfter = () => new Date(Date.now() - 1000 * 60 * 60 * 24);
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const typeKeySendTrade = '805805';
 
 /** Manage a swap
 
@@ -24,37 +39,118 @@ const respondAction = 'respond';
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger, request}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!ask) {
+        if (!args.ask) {
           return cbk([400, 'ExpectedAskFunctionToManageSwap']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToManageSwap']);
         }
 
-        if (!logger) {
+        if (!args.logger) {
           return cbk([400, 'ExpectedWinstonLoggerToManageSwap']);
         }
 
-        if (!request) {
+        if (!args.request) {
           return cbk([400, 'ExpectedRequestFunctionToManageSwap']);
         }
 
         return cbk();
       },
 
+      // Get invoices to find past swap requests
+      getInvoices: ['validate', ({}, cbk) => {
+        return getAllInvoices({
+          created_after: pushesReceivedAfter().toISOString(),
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
       // Look for a p2tr master public key to detect p2tr support
       getMasterPublicKeys: ['validate', ({}, cbk) => {
-        return getMasterPublicKeys({lnd}, cbk);
+        return getMasterPublicKeys({lnd: args.lnd}, cbk);
       }],
 
       // Get the network to make sure this is on testnet
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
+
+      // Received swap pushes
+      swapPushes: ['getInvoices', ({getInvoices}, cbk) => {
+        const pushes = getInvoices.invoices.map(invoice => {
+          // A swap push is a KeySend payment
+          if (!invoice.is_confirmed || !invoice.is_push) {
+            return;
+          }
+
+          const messages = flatten(invoice.payments.map(n => n.messages));
+
+          // Convert messages to swaps
+          const swaps = messages.map(message => {
+            // Swaps have the trade type wrapper
+            if (message.type !== typeKeySendTrade) {
+              return;
+            }
+
+            // The trade type should be a swap
+            try {
+              const {swap} = decodeTrade({trade: message.value});
+
+              if (!swap) {
+                return;
+              }
+
+              const details = decodeOffToOnRequest({request: swap.request});
+
+              // Return relevant swap details for acceptance
+              return {
+                confirmed_at: invoice.confirmed_at,
+                id: details.hash,
+                tokens: details.tokens,
+                node: swap.node,
+                trade: message.value,
+              };
+            } catch (err) {
+              return;
+            }
+          });
+
+          const [swap] = swaps.filter(n => !!n);
+
+          return swap;
+        });
+
+        return cbk(null, pushes.filter(n => !!n));
+      }],
+
+      // Get node aliases for pushes
+      getAliases: ['swapPushes', ({swapPushes}, cbk) => {
+        return asyncMap(swapPushes, ({node}, cbk) => {
+          return getNodeAlias({id: node, lnd: args.lnd}, cbk);
+        },
+        cbk);
+      }],
+
+      // Get existing swaps
+      getExisting: ['swapPushes', ({swapPushes}, cbk) => {
+        return asyncMap(swapPushes, ({id}, cbk) => {
+          return getInvoice({id, lnd: args.lnd}, (err, res) => {
+            // Error indicates that the invoice could not be looked up
+            if (!!err) {
+              return cbk();
+            }
+
+            // Result indicates the invoice is known so the swap is in progress
+            return cbk(null, id);
+          });
+        },
+        cbk);
+      }],
 
       // Determine if taproot is supported or not
       hasTr: ['getMasterPublicKeys', ({getMasterPublicKeys}, cbk) => {
@@ -64,27 +160,53 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       }],
 
       // Select a swap action
-      selectAction: ['getNetwork', 'hasTr', ({getNetwork, hasTr}, cbk) => {
+      selectAction: [
+        'getAliases',
+        'getExisting',
+        'getNetwork',
+        'hasTr',
+        'swapPushes',
+        ({getAliases, getExisting, getNetwork, hasTr, swapPushes}, cbk) =>
+      {
         // Check to make sure the network is supported
         if (!hasTr && getNetwork.network !== allowedNetwork) {
           return cbk([501, 'CurrentlyUnsupportedChainForSwap']);
         }
 
-        return ask({
-          choices: [
-            {
-              name: 'Make a new swap request',
-              value: requestAction,
-            },
-            {
-              name: 'Respond to a swap request',
-              value: respondAction,
-            },
-            {
-              name: 'Recovery for swap response',
-              value: recoverRespondAction,
-            },
-          ],
+        const pushes = swapPushes
+          .filter(push => !getExisting.includes(push.id))
+          .map(push => {
+            const amount = tokensAsBigUnit(push.tokens);
+            const id = niceId(push.id);
+            const node = niceName(getAliases.find(n => n.id === push.node));
+
+            return {
+              name: `Accept request ${id} to swap ${amount} with ${node}`,
+              value: push.trade,
+            };
+          });
+
+        const choices = [
+          {
+            name: 'Make a new swap request',
+            value: requestAction,
+          },
+          {
+            name: 'Send a new swap request via KeySend',
+            value: actionPushRequest,
+          },
+          {
+            name: 'Respond to a swap request',
+            value: respondAction,
+          },
+          {
+            name: 'Recovery for swap response',
+            value: recoverRespondAction,
+          },
+        ];
+
+        return args.ask({
+          choices: choices.concat(pushes),
           message: 'Off-chain to on-chain swap:',
           name: 'action',
           type: 'list',
@@ -92,32 +214,125 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         ({action}) => cbk(null, action));
       }],
 
+      // Ask for the remote to send to
+      askForRemote: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when the request is not KeySend
+        if (selectAction !== actionPushRequest) {
+          return cbk();
+        }
+
+        return args.ask({
+          message: 'Node key or channel peer alias to send request to?',
+          name: 'remote',
+          validate: input => !!input,
+        },
+        ({remote}) => cbk(null, remote));
+      }],
+
+      // Find the remote identity key when specified
+      findKey: ['askForRemote', ({askForRemote}, cbk) => {
+        if (!askForRemote) {
+          return cbk(null, {});
+        }
+
+        return findKey({lnd: args.lnd, query: askForRemote}, cbk);
+      }],
+
+      // Ask if the offchain funding should be external
+      askForExternal: [
+        'askForRemote',
+        'selectAction',
+        ({selectAction}, cbk) =>
+      {
+        switch (selectAction) {
+        case actionPushRequest:
+        case requestAction:
+          return args.ask({
+            message: 'Use internal funds to pay offchain payment request?',
+            name: 'internal',
+            type: 'confirm',
+          },
+          ({internal}) => cbk(null, !internal));
+
+        default:
+          // External funding not supported
+          return cbk();
+        }
+      }],
+
       // Make swap request
-      makeRequest: ['hasTr', 'selectAction', ({hasTr, selectAction}, cbk) => {
-        if (selectAction !== requestAction) {
+      makeRequest: [
+        'askForExternal',
+        'askForRemote',
+        'findKey',
+        'hasTr',
+        'selectAction',
+        ({askForExternal, askForRemote, findKey, hasTr, selectAction}, cbk) =>
+      {
+        switch (selectAction) {
+        case actionPushRequest:
+          if (!findKey.public_key) {
+            return cbk([400, 'UnknownNodeToPushSwapRequestTo']);
+          }
+          break;
+
+        case requestAction:
+          break;
+
+        default:
           return cbk();
         }
 
         return requestSwapOut({
-          ask,
-          lnd,
-          logger,
-          request: !hasTr ? request : undefined,
+          ask: args.ask,
+          is_external_funding: askForExternal,
+          lnd: args.lnd,
+          logger: args.logger,
+          push_to: findKey.public_key,
+          min_confirmations: minConfirmations[getNetwork.network],
+          request: !hasTr ? args.request : undefined,
         },
         cbk);
       }],
 
-      // Respond to swap request
+      // Make a response for a swap request
       makeResponse: ['hasTr', 'selectAction', ({hasTr, selectAction}, cbk) => {
         if (selectAction !== respondAction) {
           return cbk();
         }
 
         return respondToSwapOutRequest({
-          ask,
-          lnd,
-          logger,
-          request: !hasTr ? request : undefined,
+          ask: args.ask,
+          is_external_funding: true,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
+        },
+        cbk);
+      }],
+
+      // Respond to a pushed swap request
+      respondToPush: [
+        'hasTr',
+        'selectAction',
+        ({hasTr, selectAction}, cbk) =>
+      {
+        // Exit early when not responding to a push
+        try {
+          decodeTrade({trade: selectAction});
+        } catch (err) {
+          return cbk();
+        }
+
+        const {swap} = decodeTrade({trade: selectAction});
+
+        return respondToSwapOutRequest({
+          ask: args.ask,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
+          swap: swap.request,
+          to: swap.node,
         },
         cbk);
       }],
@@ -133,10 +348,10 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         }
 
         return recoverResponseToSwapOut({
-          ask,
-          lnd,
-          logger,
-          request: !hasTr ? request : undefined,
+          ask: args.ask,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
         },
         cbk);
       }],
@@ -146,9 +361,26 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         'makeRequest',
         'makeResponse',
         'recoverResponse',
-        ({makeRequest, makeResponse, recoverResponse}, cbk) =>
+        'respondToPush',
+        ({makeRequest, makeResponse, recoverResponse, respondToPush}, cbk) =>
       {
-        return cbk(null, makeRequest || makeResponse || recoverResponse);
+        if (!!makeRequest) {
+          return cbk(null, makeRequest);
+        }
+
+        if (!!makeResponse) {
+          return cbk(null, makeResponse);
+        }
+
+        if (!!recoverResponse) {
+          return cbk(null, recoverResponse);
+        }
+
+        if (!!respondToPush) {
+          return cbk(null, respondToPush);
+        }
+
+        return cbk();
       }],
     },
     returnResult({reject, resolve, of: 'result'}, cbk));

package/swaps/request_swap_out.js

@@ -1,31 +1,55 @@
+const {createHash} = require('crypto');
 const EventEmitter = require('events');
+const {randomBytes} = require('crypto');
 
 const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
+const {connectPeer} = require('ln-sync');
+const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {parsePaymentRequest} = require('ln-service');
+const {payViaPaymentDetails} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const completeOffToOnSwap = require('./complete_off_to_on_swap');
 const decodeOffToOnResponse = require('./decode_off_to_on_response');
+const {encodeTrade} = require('./../trades');
 const makeRequest = require('./start_off_to_on_swap');
+const {pushTypes} = require('./swap_field_types');
+const {servicePeerRequests} = require('./../p2p');
+const serviceTypes = require('./../service_types');
 
+const bufferAsHex = buffer => buffer.toString('hex');
 const defaultFeeRate = 5000;
 const defaultMaxFeeForDeposit = 1337;
 const defaultSwapAmount = 2500000;
+const findRecord = (r, type) => (r.find(n => n.type === type) || {}).value;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const isNumber = n => !isNaN(n) && !isNaN(parseFloat(n));
+const makeSecret = () => randomBytes(32);
 const minAmount = 10000;
 const minRate = 0;
 const mtokensAsTokens = n => Number(BigInt(n) / BigInt(1e3));
+const pushSwapRequestMaxFee = 10;
+const pushSwapRequestTokens = 10;
 const rateDenominator = 1e6;
+const rateForFee = (tokens, fee) => fee * 1e6 / tokens;
+const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const typeKeySendPreimage = '5482373484';
+const typeKeySendTrade = '805805';
+const typeSwapResponse = serviceTypes.serviceTypeSwapResponse;
 
 /** Request a swap out
 
   {
     ask: <Ask Function>
     [is_avoiding_broadcast]: <Avoid Broadcasting Bool>
+    [is_external_funding]: <Externally Fund Swap Bool>
     [is_uncooperative]: <Avoid Cooperative Resolution Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    [min_confirmations]: <Minimum Confirmations to Wait Number>
+    [push_to]: <Push Swap Request to Node with Identity Public Key Hex String>
     [request]: <Request Function>
   }
 
@@ -72,11 +96,36 @@ module.exports = (args, cbk) => {
         ({tokens}) => cbk(null, Number(tokens)));
       }],
 
-      // Get the network name
+      // Attempt to connect to the push peer
+      connect: ['validate', asyncReflect(({}, cbk) => {
+        // Exit early when there is no push
+        if (!args.push_to) {
+          return cbk();
+        }
+
+        return connectPeer({id: args.push_to, lnd: args.lnd}, cbk);
+      })],
+
+      // Get the public key for node identity attachment
+      getIdentity: ['validate', ({}, cbk) => {
+        // Exit early when not pushing a request
+        if (!args.push_to) {
+          return cbk();
+        }
+
+        return getIdentity({lnd: args.lnd}, cbk);
+      }],
+
+      // Get the network name to decode the encoded swap payment request
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
       // Ask for routing fee rate
       askForRate: ['askForTokens', ({}, cbk) => {
+        // Exit earlyw hen there is no internal routing
+        if (!!args.is_external_funding) {
+          return cbk();
+        }
+
         return args.ask({
           default: defaultFeeRate,
           message: 'Max routing fee rate for swap funds in parts per million?',
@@ -96,6 +145,32 @@ module.exports = (args, cbk) => {
         ({rate}) => cbk(null, Number(rate)));
       }],
 
+      // Ask for the max swap fee rate that will be paid automatically
+      askForSwapRate: ['askForRate', ({}, cbk) => {
+        // Exit early when not pushing a swap request
+        if (!args.push_to) {
+          return cbk();
+        }
+
+        return args.ask({
+          default: defaultFeeRate,
+          message: 'Max auto-accept fee rate for funds in parts per million?',
+          name: 'max',
+          validate: input => {
+            if (!isNumber(input)) {
+              return false;
+            }
+
+            if (Number(input) < minRate) {
+              return `A larger rate is required, minimum: ${minRate}`;
+            }
+
+            return true;
+          },
+        },
+        ({max}) => cbk(null, Number(max)));
+      }],
+
       // Make a swap request
       makeRequest: ['askForTokens', ({askForTokens}, cbk) => {
         return makeRequest({
@@ -106,13 +181,118 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Listen on p2p for a response to the swap request
+      listenForResponse: [
+        'getNetwork',
+        'makeRequest',
+        ({getNetwork, makeRequest}, cbk) =>
+      {
+        // Exit early when not pushing a request
+        if (!args.push_to) {
+          return cbk();
+        }
+
+        const service = servicePeerRequests({lnd: args.lnd});
+
+        // The identifier of the swap is the hash over the swap request
+        const id = bufferAsHex(sha256(hexAsBuffer(makeRequest.request)));
+
+        // Listen for an accepted swap request
+        service.request({type: typeSwapResponse}, (req, res) => {
+          // Exit early when the request is from a different peer
+          if (req.from !== args.push_to) {
+            return;
+          }
+
+          // Exit early when the request is for a different swap
+          if (findRecord(req.records, pushTypes.typeSwapId) !== id) {
+            return;
+          }
+
+          // The peer will message the response to the swap in a record
+          const response = findRecord(req.records, pushTypes.typeSwapResponse);
+
+          // Check the swap response is valid
+          try {
+            decodeOffToOnResponse({response, network: getNetwork.bitcoinjs});
+          } catch (err) {
+            return res.failure([400, err.message]);
+          }
+
+          args.logger.info({got_response: true});
+
+          // Tell the peer that the swap response was received
+          res.success({});
+
+          // Don't listen for additional results
+          service.stop({});
+
+          return cbk(null, response);
+        });
+      }],
+
+      // Push the request to the destination
+      pushRequest: [
+        'askForSwapRate',
+        'getIdentity',
+        'makeRequest',
+        ({getIdentity, makeRequest}, cbk) =>
+      {
+        // Exit early when this is not a push request
+        if (!args.push_to) {
+          return cbk();
+        }
+
+        const secret = makeSecret();
+
+        const id = bufferAsHex(sha256(secret));
+
+        // Include local peer details so the node can p2p message the response
+        const {trade} = encodeTrade({
+          swap: {node: getIdentity.public_key, request: makeRequest.request},
+        });
+
+        args.logger.info({
+          sending_swap_request_to: args.push_to,
+          push_request_id: id,
+        });
+
+        // Push the swap request
+        return payViaPaymentDetails({
+          id,
+          destination: args.push_to,
+          lnd: args.lnd,
+          max_fee: pushSwapRequestMaxFee,
+          messages: [
+            {type: typeKeySendPreimage, value: bufferAsHex(secret)},
+            {type: typeKeySendTrade, value: trade},
+          ],
+          tokens: pushSwapRequestTokens,
+        },
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          args.logger.info({sent_swap_request_waiting_for_response: true});
+
+          return cbk();
+        });
+      }],
+
       // Wait for a response
       getResponse: [
         'askForRate',
         'getNetwork',
+        'listenForResponse',
         'makeRequest',
-        ({getNetwork, makeRequest}, cbk) =>
+        ({getNetwork, listenForResponse, makeRequest}, cbk) =>
       {
+        // Exit early when there is a p2p request
+        if (!!listenForResponse) {
+          return cbk(null, listenForResponse);
+        }
+
         args.logger.info({swap_request: makeRequest.request});
 
         return args.ask({
@@ -137,10 +317,11 @@ module.exports = (args, cbk) => {
 
       // Confirm the swap details
       okSwap: [
+        'askForSwapRate',
         'askForTokens',
         'getNetwork',
         'getResponse',
-        ({askForTokens, getNetwork, getResponse}, cbk) =>
+        ({askForSwapRate, askForTokens, getNetwork, getResponse}, cbk) =>
       {
         const response = decodeOffToOnResponse({
           network: getNetwork.bitcoinjs,
@@ -154,6 +335,11 @@ module.exports = (args, cbk) => {
         const fee = tokens - askForTokens;
         const pricing = `Execution cost ${deposit}, plus liquidity fee ${fee}`;
 
+        // Exit early when swap fee is below the pre-specified tolerance
+        if (rateForFee(askForTokens, deposit + fee) <= askForSwapRate) {
+          return cbk(null, true)
+        }
+
         return args.ask({
           default: true,
           message: `Start swap ${timeout}? ${pricing}?`,
@@ -183,10 +369,12 @@ module.exports = (args, cbk) => {
         return completeOffToOnSwap({
           emitter,
           is_avoiding_broadcast: args.is_avoiding_broadcast,
+          is_external_funding: args.is_external_funding,
           is_uncooperative: args.is_uncooperative,
           lnd: args.lnd,
           max_fee_deposit: defaultMaxFeeForDeposit,
           max_fee_funding: askForTokens * askForRate / rateDenominator,
+          min_confirmations: args.min_confirmations,
           recovery: makeRequest.recovery,
           request: args.request,
           response: getResponse,

package/swaps/respond_to_swap_out_request.js

@@ -1,3 +1,4 @@
+const {createHash} = require('crypto');
 const EventEmitter = require('events');
 
 const asyncAuto = require('async/auto');
@@ -5,17 +6,30 @@ const {getChainFeeRate} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const completeOnToOffSwap = require('./complete_on_to_off_swap');
+const {connectPeer} = require('ln-sync');
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
+const {makePeerRequest} = require('./../p2p');
+const serviceTypes = require('./../service_types');
 const startOnToOffSwap = require('./start_on_to_off_swap');
 
+const bufferAsHex = buffer => buffer.toString('hex');
 const {ceil} = Math;
+const defaultConfirmationTarget = 6;
 const {floor} = Math;
 const defaultCltvDelta = 400;
-const defaultFeeRate = 5000;
+const defaultFeeRate = 2500;
 const estimatedVirtualSize = 300;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const isNumber = n => !isNaN(n) && !isNaN(parseFloat(n));
+const maxTarget = 144;
 const minRate = 1;
+const minTarget = 2;
+const peerRequestTimeoutMs = 1000 * 60 * 3;
 const rateDenominator = 1e6;
+const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const typeSwapId = '0';
+const typeSwapReply = '1';
+const typeSwapResponse = serviceTypes.serviceTypeSwapResponse;
 
 /** Respond to a swap out request
 
@@ -24,11 +38,13 @@ const rateDenominator = 1e6;
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
     [request]: <Request Function>
+    [swap]: <Swap Hex String>
+    [to]: <Send Swap Response To Public Key Id Hex String>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger, request}, cbk) => {
+module.exports = ({ask, lnd, logger, request, swap, to}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -45,11 +61,24 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           return cbk([400, 'ExpectedLoggerToRespondToSwapOutRequest']);
         }
 
+        if (!!swap) {
+          try {
+            decodeOffToOnRequest({request: swap});
+          } catch (err) {
+            return cbk([400, err.message]);
+          }
+        }
+
         return cbk();
       },
 
       // Ask for a request
       askForRequest: ['validate', ({}, cbk) => {
+        // Exit early when a swap request is defined
+        if (!!swap) {
+          return cbk(null, swap);
+        }
+
         return ask({
           message: 'Swap request?',
           name: 'req',
@@ -70,8 +99,14 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         ({req}) => cbk(null, req));
       }],
 
-      // Get the chain fee rate
-      getRate: ['validate', ({}, cbk) => getChainFeeRate({lnd}, cbk)],
+      // Connect to the peer when a swap is pushed
+      connect: ['validate', ({}, cbk) => {
+        if (!to) {
+          return cbk();
+        }
+
+        return connectPeer({lnd, id: to}, cbk);
+      }],
 
       // Ask for pricing
       askForRate: ['askForRequest', ({askForRequest}, cbk) => {
@@ -98,6 +133,36 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         ({rate}) => cbk(null, Number(rate)));
       }],
 
+      // Ask for chain fee target
+      askForTarget: ['askForRate', ({}, cbk) => {
+        return ask({
+          default: defaultConfirmationTarget,
+          message: 'Confirm on-chain funding within how many blocks?',
+          name: 'target',
+          validate: input => {
+            if (!isNumber(input)) {
+              return false;
+            }
+
+            if (Number(input) > maxTarget) {
+              return `A smaller number is required, maximum: ${maxTarget}`;
+            }
+
+            if (Number(input) < minTarget) {
+              return `A larger number is required, minimum: ${minTarget}`;
+            }
+
+            return true;
+          },
+        },
+        ({target}) => cbk(null, Number(target)));
+      }],
+
+      // Get the chain fee rate
+      getRate: ['askForTarget', ({askForTarget}, cbk) => {
+        return getChainFeeRate({lnd, confirmation_target: askForTarget}, cbk);
+      }],
+
       // Make a response
       makeResponse: [
         'askForRate',
@@ -119,10 +184,14 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       }],
 
       // Complete the swap
-      completeSwap: ['makeResponse', ({makeResponse}, cbk) => {
+      completeSwap: [
+        'askForTarget',
+        'makeResponse',
+        ({askForTarget, makeResponse}, cbk) =>
+      {
         logger.info({
           recovery: makeResponse.recovery,
-          response: makeResponse.response,
+          response: !to ? makeResponse.response : undefined,
         });
 
         const emitter = new EventEmitter();
@@ -133,10 +202,31 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           emitter,
           lnd,
           request,
+          confirmation_target: askForTarget,
           recovery: makeResponse.recovery,
         },
         cbk);
       }],
+
+      // Send swap response over p2p so the peer can start the payment
+      sendResponse: ['connect', 'makeResponse', ({makeResponse}, cbk) => {
+        // Exit early when a swap response destination is not defined
+        if (!swap || !to) {
+          return cbk();
+        }
+
+        return makePeerRequest({
+          lnd,
+          to,
+          records: [
+            {type: typeSwapId, value: bufferAsHex(sha256(hexAsBuffer(swap)))},
+            {type: typeSwapReply, value: makeResponse.response},
+          ],
+          timeout: peerRequestTimeoutMs,
+          type: typeSwapResponse,
+        },
+        cbk);
+      }],
     },
     returnResult({reject, resolve, of: 'completeSwap'}, cbk));
   });

package/swaps/swap_field_types.json

@@ -23,5 +23,9 @@
     "typeTokens": "13",
     "typeVersion": "0"
   },
+  "pushTypes": {
+    "typeSwapId": "0",
+    "typeSwapResponse": "1"
+  },
   "typePayMetadata": "805001"
 }

package/test/integration/test_request_swap_out.js

@@ -99,8 +99,8 @@ test(`Start offchain swap`, async ({end, equal, strictSame}) => {
         if (args.name === 'response') {
           return await respondToSwapOut({
             ask: (args, cbk) => {
-              if (args.name === 'rate') {
-                return cbk({rate: '100'});
+              if (args.default) {
+                return cbk({[args.name]: args.default});
               }
 
               if (args.name === 'req') {
@@ -140,6 +140,7 @@ test(`Start offchain swap`, async ({end, equal, strictSame}) => {
           return messages.push(message);
         },
       },
+      min_confirmations: 3,
     });
   } catch (err) {
     strictSame(err, null, 'Expected no failure');

package/test/integration/test_swap_with_claim_path.js

@@ -99,8 +99,8 @@ test(`Swap with claim path`, async ({end, equal, strictSame}) => {
         if (args.name === 'response') {
           return await respondToSwapOut({
             ask: (args, cbk) => {
-              if (args.name === 'rate') {
-                return cbk({rate: '100'});
+              if (args.default) {
+                return cbk({[args.name]: args.default});
               }
 
               if (args.name === 'req') {

package/test/integration/test_swap_with_refund_path.js

@@ -100,8 +100,8 @@ test(`Timeout a swap`, async ({end, equal, strictSame}) => {
           try {
             return await respondToSwapOut({
               ask: (args, cbk) => {
-                if (args.name === 'rate') {
-                  return cbk({rate: '100'});
+                if (args.default) {
+                  return cbk({[args.name]: args.default});
                 }
 
                 if (args.name === 'req') {

package/test/trades/test_encode_trade.js

@@ -5,13 +5,8 @@ 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',
+    description: 'Trade details are required',
+    error: 'ExpectedTradeDetailsToEncode',
   },
   {
     args: {

package/trades/decode_swap_trade.js

@@ -0,0 +1,55 @@
+const {decodeTlvStream} = require('bolt01');
+
+const recordAsNode = require('./record_as_node');
+
+const findSwapRecord = records => records.find(n => n.type === '6');
+const {isArray} = Array;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const nodeForSwap = record => record.substring(0, 66);
+const requestForSwap = record => record.substring(66);
+
+/** Decode swap trade records
+
+  6: <Swap Request>
+
+  {
+    records: [{
+      type: <Type Number String>
+      value: <Value Hex Encoded String>
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    node: <Node Public Key Id Hex String>
+    request: <Swap Request Hex String>
+  }
+*/
+module.exports = ({records}) => {
+  if (!isArray(records)) {
+    throw new Error('ExpectedArrayOfRecordsToDecodeSwapTrade');
+  }
+
+  const swapRecord = findSwapRecord(records);
+
+  if (!swapRecord) {
+    throw new Error('ExpectedSwapRecordInSwapTrade');
+  }
+
+  const node = nodeForSwap(swapRecord.value)
+
+  if (!isPublicKey(node)) {
+    throw new Error('ExpectedIdentityPublicKeyInSwapTrade');
+  }
+
+  const request = requestForSwap(swapRecord.value);
+
+  if (!request) {
+    throw new Error('ExpectedSwapRequestInSwapTrade');
+  }
+
+  return {node, request};
+};

package/trades/decode_trade.js

@@ -2,6 +2,7 @@ const {decodeBigSize} = require('bolt01');
 const {decodeTlvStream} = require('bolt01');
 
 const decodeOpenTrade = require('./decode_open_trade');
+const decodeSwapTrade = require('./decode_swap_trade');
 const decodeTradePayment = require('./decode_trade_payment');
 const decodeTradeSecret = require('./decode_trade_secret');
 const networkFromNetworkRecord = require('./network_from_network_record');
@@ -10,8 +11,9 @@ 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');
+const findSwapRecord = records => records.find(n => n.type === '6');
 const isTrade = trade => trade.toLowerCase().startsWith('626f73ff');
-const isValidVersion = version => BigInt(version) <= BigInt(1);
+const isValidVersion = version => BigInt(version) <= BigInt(2);
 const tradeData = trade => trade.slice('626f73ff'.length);
 
 /** Decode a trade record
@@ -22,6 +24,7 @@ const tradeData = trade => trade.slice('626f73ff'.length);
   [3]: <Trade Details Record
   [4]: <Nodes Records>
   [5]: <Trade Identifier>
+  [6]: <Swap Request>
 
   {
     trade: <Trade Record Hex String>
@@ -49,6 +52,10 @@ const tradeData = trade => trade.slice('626f73ff'.length);
       payload: <Preimage Encrypted Payload Hex String>
       request: <BOLT 11 Payment Request String>
     }
+    [swap]: {
+      node: <Node Public Key Id Hex String>
+      request: <Swap Request Hex String>
+    }
   }
 */
 module.exports = ({trade}) => {
@@ -98,5 +105,10 @@ module.exports = ({trade}) => {
     return {payment: decodeTradePayment({network, records})};
   }
 
+  // Exit early when there is a swap encoded
+  if (!!findSwapRecord(records)) {
+    return {swap: decodeSwapTrade({records})};
+  }
+
   return {connect: decodeOpenTrade({network, records})};
 };

package/trades/encode_swap_trade.js

@@ -0,0 +1,38 @@
+const {encodeTlvStream} = require('bolt01');
+
+const networkRecordFromNetwork = require('./network_record_from_network');
+const nodeAsRecord = require('./node_as_record');
+
+const asTrade = hex => `626f73ff${hex}`;
+const typeSwap = '6';
+const typeVersion = '0';
+const versionRecord = '02';
+
+/** Encode records for a swap trade request
+
+  A swap trade request 
+
+  0: version (v2)
+  6: swap request
+
+  {
+    node: <Swap Node Identity Public Key Hex String>
+    request: <Swap Request Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    trade: <Encoded Swap Trade Request Hex String>
+  }
+*/
+module.exports = ({node, request}) => {
+  const records = [
+    {type: typeSwap, value: node + request},
+    {type: typeVersion, value: versionRecord},
+  ];
+
+  return {trade: asTrade(encodeTlvStream({records}).encoded)};
+};

package/trades/encode_trade.js

@@ -1,4 +1,5 @@
 const encodeOpenTrade = require('./encode_open_trade');
+const encodeSwapTrade = require('./encode_swap_trade');
 const encodeTradeSecret = require('./encode_trade_secret');
 
 /** Encode v1 trade records
@@ -12,6 +13,7 @@ const encodeTradeSecret = require('./encode_trade_secret');
   [3]: trade details
   [4]: nodes records
   [5]: trade identifier
+  [6]: swap request
 
   {
     [connect]: {
@@ -28,6 +30,10 @@ const encodeTradeSecret = require('./encode_trade_secret');
       payload: <Preimage Encrypted Payload Hex String>
       request: <BOLT 11 Payment Request String>
     }
+    [swap]: {
+      node: <Node Public Key Id Hex String>
+      request: <Swap Request Hex String>
+    }
   }
 
   @throws
@@ -38,16 +44,11 @@ const encodeTradeSecret = require('./encode_trade_secret');
     trade: <Hex Encoded Trade String>
   }
 */
-module.exports = ({connect, secret}) => {
-  if (!connect && !secret) {
-    throw new Error('ExpectedEitherConnectDetailsOrTradeSecret');
-  }
-
-  if (!!connect && !!secret) {
-    throw new Error('ExpectedOnlyOneConnectDetailsOrTradeSecretNotBoth');
+module.exports = ({connect, secret, swap}) => {
+  if (!connect && !secret && !swap) {
+    throw new Error('ExpectedTradeDetailsToEncode');
   }
 
-  // Exit early when this is an open ended trade
   if (!!connect) {
     return encodeOpenTrade({
       id: connect.id,
@@ -56,10 +57,17 @@ module.exports = ({connect, secret}) => {
     });
   }
 
-  // Encode the trade secret
-  return encodeTradeSecret({
-    auth: secret.auth,
-    payload: secret.payload,
-    request: secret.request,
-  });
+  if (!!secret) {
+    return encodeTradeSecret({
+      auth: secret.auth,
+      payload: secret.payload,
+      request: secret.request,
+    });
+  }
+
+  if (!!swap) {
+    return encodeSwapTrade({node: swap.node, request: swap.request});
+  }
+
+  throw new Error('ExpectedTradeTypeToEncode');
 };