paid-services 3.17.2 → 3.19.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## Version 3.19.1
+
+- `manageSwap`: Add support for inbound peer constraint
+- `manageSwap`: Add support for external sweep address
+
+## Version 3.18.0
+
+- `manageGroupJoin`: Add conflict tx for safe funded pending channel deletion
+
 ## Version 3.17.2
 
 - `manageGroupJoin`: Add method to coordinate or join a channels group

package/groups/ask_to_confirm_group_join.js

@@ -1,4 +1,5 @@
 const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
 const {connectPeer} = require('ln-sync');
 const {getChainBalance} = require('ln-service');
 const {getNodeAlias} = require('ln-sync');
@@ -8,9 +9,11 @@ const {getGroupDetails} = require('./p2p');
 
 const coordinatorFromJoinCode = n => n.slice(0, 66);
 const groupIdFromJoinCode = n => n.slice(66);
+const interval = 500;
 const isCode = n => !!n && n.length === 98;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const niceName = n => `${n.alias} ${n.id}`.trim();
+const times = 2 * 60;
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Ask to confirm joining a group
@@ -73,7 +76,10 @@ module.exports = ({ask, lnd}, cbk) => {
 
       // Connect to the coordinator
       connect: ['group', ({group}, cbk) => {
-        return connectPeer({lnd, id: group.coordinator}, cbk);
+        return asyncRetry({interval, times}, cbk => {
+          return connectPeer({lnd, id: group.coordinator}, cbk);
+        },
+        cbk);
       }],
 
       // Get the coordinator node alias

package/groups/assemble_channel_group.js

@@ -78,6 +78,9 @@ module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
     return emitter.emit('error', err);
   };
 
+  // An error was encountered
+  coordinator.events.once('error', errored);
+
   // Group members have registered themselves
   coordinator.events.once('joined', async ({ids}) => {
     emitter.emit('filled', {ids});

package/groups/attach_to_channel_group.js

@@ -70,7 +70,9 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return logger.info({peering_with: formatNodes(nodes)});
         });
 
-        join.once('publishing', ({signed}) => logger.info({signed}));
+        join.once('publishing', ({refund, signed}) => {
+          return logger.info({refund, signed});
+        });
 
         return;
       }],

package/groups/funding/confirm_incoming_channel.js

@@ -13,6 +13,8 @@ const half = n => n / 2;
     lnd: <Authenticated LND API Object>
     to: <Look for Outgoing Channel To Identity Public Key Hex String>
   }
+
+  @returns via cbk or Promise
 */
 module.exports = ({capacity, from, id, lnd, to}, cbk) => {
   return new Promise((resolve, reject) => {

package/groups/funding/sign_and_fund_group_channel.js

@@ -1,18 +1,28 @@
+const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
 const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {createPsbt} = require('psbt');
 const {decodePsbt} = require('psbt');
 const {extendPsbt} = require('psbt');
 const {fundPendingChannels} = require('ln-service');
+const {getChainFeeRate} = require('ln-service');
+const {getMaxFundAmount} = require('ln-sync');
 const {getPendingChannels} = require('ln-service');
 const {partiallySignPsbt} = require('ln-service');
+const {payments} = require('bitcoinjs-lib');
 const {returnResult} = require('asyncjs-util');
+const {signPsbt} = require('ln-service');
 const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 const {unextractTransaction} = require('psbt');
 
+const bufferAsHex = buffer => buffer.toString('hex');
 const {concat} = Buffer;
 const dummySignature = Buffer.alloc(1);
+const format = 'p2wpkh';
 const {from} = Buffer;
+const {fromBech32} = address;
 const {fromHex} = Transaction;
 const hashAll = Transaction.SIGHASH_ALL;
 const hashDefault = Transaction.SIGHASH_DEFAULT;
@@ -21,6 +31,9 @@ const inputAsOutpoint = n => `${n.transaction_id}:${n.transaction_vout}`;
 const interval = 10;
 const {isArray} = Array;
 const notEmpty = arr => arr.filter(n => !!n);
+const {p2wpkh} = payments;
+const {random} = Math;
+const slowConf = 144;
 const spendAsOutpoint = n => `${n.hash.reverse().toString('hex')}:${n.index}`;
 const times = 500;
 
@@ -49,6 +62,7 @@ const times = 500;
 
   @returns via cbk or Promise
   {
+    conflict: <Conflict Transaction Hex String>
     psbt: <Partially Signed PSBT Hex String>
   }
 */
@@ -79,11 +93,94 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
         return cbk();
       },
 
+      // Create a conflicting address to refund funds to
+      createConflictAddress: ['validate', ({}, cbk) => {
+        return createChainAddress({format, lnd}, cbk);
+      }],
+
+      // Get the conflicting tx fee rate
+      getRate: ['validate', ({}, cbk) => {
+        return getChainFeeRate({lnd, confirmation_target: slowConf}, cbk);
+      }],
+
+      // Find the conflicting amount to send to the refund address
+      getConflictAmount: [
+        'createConflictAddress',
+        'getRate',
+        ({createConflictAddress, getRate}, cbk) =>
+      {
+        const [input] = utxos;
+
+        return getMaxFundAmount({
+          lnd,
+          addresses: [createConflictAddress.address],
+          fee_tokens_per_vbyte: getRate.tokens_per_vbyte,
+          inputs: [{
+            tokens: input.witness_utxo.tokens,
+            transaction_id: input.transaction_id,
+            transaction_vout: input.transaction_vout,
+          }],
+        },
+        cbk);
+      }],
+
+      // Create a conflicting PSBT to sign
+      conflict: [
+        'createConflictAddress',
+        'ecp',
+        'getConflictAmount',
+        ({createConflictAddress, ecp, getConflictAmount}, cbk) =>
+      {
+        const hash = fromBech32(createConflictAddress.address).data;
+        const [input] = utxos;
+
+        const {psbt} = createPsbt({
+          outputs: [{
+            script: bufferAsHex(p2wpkh({hash}).output),
+            tokens: getConflictAmount.max_tokens,
+          }],
+          utxos: [{
+            id: input.transaction_id,
+            vout: input.transaction_vout,
+          }],
+        });
+
+        const base = decodePsbt({ecp, psbt});
+
+        const tx = fromHex(base.unsigned_transaction);
+
+        const inputs = base.inputs.map((input, vin) => {
+          const outpoint = spendAsOutpoint(tx.ins[vin]);
+
+          // Look for relevant signing instructions
+          const utxo = utxos.find(n => inputAsOutpoint(n) === outpoint) || {};
+
+          return {
+            bip32_derivations: utxo.bip32_derivations,
+            non_witness_utxo: utxo.non_witness_utxo,
+            sighash_type: !!utxo.non_witness_utxo ? hashAll : hashDefault,
+            witness_utxo: utxo.witness_utxo,
+          };
+        });
+
+        // Extend the base PSBT with relevant signing information
+        return cbk(null, extendPsbt({ecp, inputs, psbt}).psbt);
+      }],
+
+      // Decode the PSBT to get the unsigned funding transaction
+      funding: ['ecp', 'validate', ({ecp}, cbk) => {
+        try {
+          return cbk(null, decodePsbt({ecp, psbt}));
+        } catch (err) {
+          return cbk([400, 'ExpectedValidPsbtToSignAndFundChannel', {err}]);
+        }
+      }],
+
       // Extend the PSBT with the derivation paths
-      psbtToSign: ['ecp', 'validate', ({ecp}, cbk) => {
-        const tx = fromHex(decodePsbt({ecp, psbt}).unsigned_transaction);
+      psbtToSign: ['ecp', 'funding', ({ecp, funding}, cbk) => {
+        const tx = fromHex(funding.unsigned_transaction);
 
-        const inputs = decodePsbt({ecp, psbt}).inputs.map((input, vin) => {
+        const inputs = funding.inputs.map((input, vin) => {
           const outpoint = spendAsOutpoint(tx.ins[vin]);
 
           // Look for relevant signing instructions
@@ -101,6 +198,11 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
         return cbk(null, {psbt: extendPsbt({ecp, inputs, psbt}).psbt});
       }],
 
+      // Sign and finalize the conflicting PSBT
+      signConflict: ['conflict', ({conflict}, cbk) => {
+        return signPsbt({lnd, psbt: conflict}, cbk);
+      }],
+
       // Partially sign the PSBT that funds the channel open
       signPsbt: ['psbtToSign', ({psbtToSign}, cbk) => {
         return partiallySignPsbt({lnd, psbt: psbtToSign.psbt}, cbk);
@@ -151,7 +253,7 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
       }],
 
       // Fund the pending channel with the finalized PSBT
-      fundChannel: ['finalizePsbt', ({finalizePsbt}, cbk) => {
+      fundChannel: ['conflict', 'finalizePsbt', ({finalizePsbt}, cbk) => {
         return fundPendingChannels({
           lnd,
           channels: [id],
@@ -182,7 +284,35 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
         },
         cbk);
       }],
+
+      // Final group funding transaction resolution
+      result: [
+        'ecp',
+        'signConflict',
+        'signPsbt',
+        ({ecp, signConflict, signPsbt}, cbk) =>
+      {
+        const signed = decodePsbt({ecp, psbt: signPsbt.psbt});
+
+        const extended = extendPsbt({
+          ecp,
+          psbt,
+          inputs: signed.inputs.map(input => {
+            return {
+              non_witness_utxo: input.non_witness_utxo,
+              partial_sig: input.partial_sig,
+              taproot_key_spend_sig: input.taproot_key_spend_sig,
+              witness_utxo: input.witness_utxo,
+            };
+          }),
+        });
+
+        return cbk(null, {
+          conflict: signConflict.transaction,
+          psbt: extended.psbt,
+        });
+      }],
     },
-    returnResult({reject, resolve, of: 'signPsbt'}, cbk));
+    returnResult({reject, resolve, of: 'result'}, cbk));
   });
 };

package/groups/join_channel_group.js

@@ -1,8 +1,11 @@
 const EventEmitter = require('events');
 
 const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
+const {cancelPendingChannel} = require('ln-service');
 const {decodePsbt} = require('psbt');
+const {deletePendingChannel} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
@@ -16,6 +19,7 @@ const {registerPendingOpen} = require('./p2p');
 const {registerSignedOpen} = require('./p2p');
 
 const {fromHex} = Transaction;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const interval = 1000;
 const times = 60 * 10;
 
@@ -138,10 +142,22 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
     }],
 
     // Decode the unsigned PSBT
-    transaction: ['ecp', 'register', ({ecp, register}, cbk) => {
+    transaction: [
+      'ecp',
+      'propose',
+      'register',
+      ({ecp, propose, register}, cbk) =>
+    {
+      const funding = hexAsBuffer(propose.funding);
       const psbt = decodePsbt({ecp, psbt: register.psbt});
 
-      return cbk(null, {id: fromHex(psbt.unsigned_transaction).getId()});
+      const tx = fromHex(psbt.unsigned_transaction);
+
+      return cbk(null, {
+        id: tx.getId(),
+        raw: psbt.unsigned_transaction,
+        vout: tx.outs.findIndex(n => n.script.equals(funding)),
+      });
     }],
 
     // Confirm the incoming channel
@@ -150,7 +166,7 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
       'partners',
       'register',
       'transaction',
-      ({ecp, partners, register, transaction}, cbk) =>
+      asyncReflect(({ecp, partners, register, transaction}, cbk) =>
     {
       // Make sure that there is an inbound channel
       return asyncRetry({interval, times}, cbk => {
@@ -164,12 +180,45 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
         cbk);
       },
       cbk);
+    })],
+
+    // Clean up funding pending channels when the channel group fails
+    clean: [
+      'incoming',
+      'propose',
+      'register',
+      'transaction',
+      ({incoming, propose, register, transaction}, cbk) =>
+    {
+      // Exit early when incoming channel is seen
+      if (!incoming.error) {
+        return cbk();
+      }
+
+      // When there was no incoming channel detected, fail and clean up
+      return deletePendingChannel({
+        lnd,
+        confirmed_transaction: register.conflict,
+        pending_transaction: transaction.raw,
+        pending_transaction_vout: transaction.vout,
+      },
+      err => {
+        if (!!err) {
+          return cbk([503, 'UnexpectedErrorCleaningUpGroupChannel', {err}]);
+        }
+
+        // Pass back the original error
+        return cbk(incoming.error);
+      });
     }],
 
     // Publish partial signatures to coordinator
-    reveal: ['incoming', 'register', ({register}, cbk) => {
+    reveal: ['clean', 'incoming', 'register', ({register}, cbk) => {
       // Let listeners know that the signature will be sent to coordinator
-      emitter.emit('publishing', {signed: register.psbt});
+      emitter.emit('publishing', {
+        refund: register.conflict,
+        signed: register.psbt,
+      });
 
       return registerSignedOpen({
         coordinator,

package/groups/p2p/register_pending_open.js

@@ -1,5 +1,7 @@
 const asyncAuto = require('async/auto');
+const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
+const {cancelPendingChannel} = require('ln-service');
 const {connectPeer} = require('ln-sync');
 const {decodePsbt} = require('psbt');
 const {returnResult} = require('asyncjs-util');
@@ -46,7 +48,8 @@ const typeGroupChannelId = '1';
 
   @returns via cbk or Promise
   {
-    psbt: <Unsigned PSBT Hex String>
+    conflict: <Conflict Transaction Hex String>
+    psbt: <Partially Signed PSBT Hex String>
   }
 */
 module.exports = (args, cbk) => {
@@ -94,7 +97,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Send connection confirmation request
-      request: ['connect', ({}, cbk) => {
+      request: ['connect', asyncReflect(({}, cbk) => {
         const {records} = encodePendingProposal({
           change: args.change,
           funding: args.funding,
@@ -145,17 +148,34 @@ module.exports = (args, cbk) => {
           });
         },
         cbk);
+      })],
+
+      // Clean up the pending channel if registration fails
+      clean: ['request', ({request}, cbk) => {
+        // Exit early when there was no error registering the pending channel
+        if (!request.error) {
+          return cbk();
+        }
+
+        return cancelPendingChannel({id: args.pending, lnd: args.lnd}, err => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorCleaningPendingChannel', {err}]);
+          }
+
+          // Return the original registration error
+          return cbk(request.error);
+        });
       }],
 
       // Check the unsigned funding transaction represents the partial open
-      check: ['ecp', 'request', ({ecp, request}, cbk) => {
+      check: ['clean', 'ecp', 'request', ({ecp, request}, cbk) => {
         try {
-          decodePsbt({ecp, psbt: request});
+          decodePsbt({ecp, psbt: request.value});
         } catch (err) {
           return cbk([503, 'ExpectedValidUnsignedResponsePsbt', {err}]);
         }
 
-        const psbt = decodePsbt({ecp, psbt: request});
+        const psbt = decodePsbt({ecp, psbt: request.value});
 
         const tx = fromHex(psbt.unsigned_transaction);
 
@@ -207,7 +227,7 @@ module.exports = (args, cbk) => {
         return signAndFundGroupChannel({
           id: args.pending,
           lnd: args.lnd,
-          psbt: request,
+          psbt: request.value,
           utxos: args.utxos,
         },
         cbk);

package/package.json

@@ -15,10 +15,10 @@
     "bolt07": "1.8.2",
     "ecpair": "2.0.1",
     "goldengate": "11.2.3",
-    "invoices": "2.0.7",
+    "invoices": "2.1.0",
     "ln-service": "53.17.4",
     "ln-sync": "3.13.0",
-    "psbt": "2.6.0",
+    "psbt": "2.7.0",
     "p2tr": "1.3.1",
     "tiny-secp256k1": "2.2.1"
   },
@@ -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.17.2"
+  "version": "3.19.1"
 }

package/swaps/complete_off_to_on_swap.js

@@ -90,6 +90,7 @@ const v1AddressWords = key => [].concat(1).concat(bech32m.toWords(key));
     recovery: <Swap Request Recovery Hex String>
     [request]: <Request Function>
     response: <Swap Response Hex String>
+    [sweep_address]: <Sweep Chain Address String>
   }
 
   @returns via cbk or Promise
@@ -134,6 +135,11 @@ module.exports = (args, cbk) => {
 
       // Create a sweep address
       createAddress: ['validate', ({}, cbk) => {
+        // Exit early when there is no need to create a sweep address
+        if (!!args.sweep_address) {
+          return cbk(null, {address: args.sweep_address});
+        }
+
         return createChainAddress({lnd: args.lnd}, cbk);
       }],
 
@@ -204,6 +210,7 @@ module.exports = (args, cbk) => {
             coop_public_key: decoded.coop_public_key,
             deposit_mtokens: decoded.deposit_mtokens,
             deposit_payment: decoded.deposit_payment,
+            incoming_peer: decoded.incoming_peer,
             push: decoded.push,
             refund_public_key: decoded.refund_public_key,
             request: decoded.request,
@@ -238,7 +245,10 @@ module.exports = (args, cbk) => {
         const request = responseDetails.request;
 
         if (!!args.is_external_funding) {
-          args.emitter.emit('update', {pay_to_fund_swap_offchain: request});
+          args.emitter.emit('update', {
+            external_funding_pay_to_fund_swap_offchain: request,
+            must_be_in_through: responseDetails.incoming_peer || undefined,
+          });
 
           return cbk();
         }
@@ -247,6 +257,7 @@ module.exports = (args, cbk) => {
 
         return pay({
           request,
+          incoming_peer: responseDetails.incoming_peer || undefined,
           lnd: args.lnd,
           max_fee: args.max_fee_funding,
         },
@@ -381,6 +392,7 @@ module.exports = (args, cbk) => {
               cltv_delta: to.cltv_delta,
               destination: to.destination,
               features: to.features,
+              incoming_peer: requestDetails.incoming_peer || undefined,
               lnd: args.lnd,
               max_fee: args.max_fee_deposit,
               messages: [{
@@ -412,7 +424,10 @@ module.exports = (args, cbk) => {
 
         const address = encodeAddress(prefix, v1AddressWords(key));
 
-        args.emitter.emit('update', {waiting_for_chain_funding: address});
+        args.emitter.emit('update', {
+          waiting_for_chain_funding: address,
+          required_confirmations: args.min_confirmations || defaultConfsCount,
+        });
 
         if (!!args.request) {
           return findDeposit({

package/swaps/complete_on_to_off_swap.js

@@ -14,6 +14,7 @@ const {diffieHellmanComputeSecret} = require('ln-service');
 const {fundPsbt} = require('ln-service');
 const {getChainFeeRate} = require('ln-service');
 const {getChainTransactions} = require('ln-service');
+const {getChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getInvoice} = require('ln-service');
@@ -159,6 +160,7 @@ module.exports = (args, cbk) => {
             claim_solo_public_key: details.claim_solo_public_key,
             hash: details.hash,
             key_index: details.key_index,
+            incoming_peer: details.incoming_peer || undefined,
             refund_coop_private_key: details.refund_coop_private_key,
             refund_coop_private_key_hash: details.refund_coop_private_key_hash,
             solo_private_key: details.refund_solo_private_key,
@@ -170,6 +172,19 @@ module.exports = (args, cbk) => {
         }
       }],
 
+      // Lookup channel ids with the incoming peer when applicable
+      getChannels: ['recoveryDetails', ({recoveryDetails}, cbk) => {
+        if (!recoveryDetails.incoming_peer) {
+          return cbk();
+        }
+
+        return getChannels({
+          lnd: args.lnd,
+          partner_public_key: recoveryDetails.incoming_peer,
+        },
+        cbk);
+      }],
+
       // Get the refund key
       getRefundKey: [
         'ecp',
@@ -213,6 +228,7 @@ module.exports = (args, cbk) => {
             return;
           }
 
+          const channels = invoice.payments.map(n => n.in_channel);
           const hash = recoveryDetails.claim_coop_public_key_hash;
           const timeout = min(...invoice.payments.map(n => n.timeout));
 
@@ -231,7 +247,11 @@ module.exports = (args, cbk) => {
 
           args.emitter.emit('update', {execution_payment_held: id});
 
-          return cbk(null, {delta, claim_coop_public_key: message.value});
+          return cbk(null, {
+            channels,
+            delta,
+            claim_coop_public_key: message.value,
+          });
         });
       }],
 
@@ -257,13 +277,14 @@ module.exports = (args, cbk) => {
 
           args.emitter.emit('update', {offchain_funding_held: id});
 
+          const channels = invoice.payments.map(n => n.in_channel);
           const timeout = min(...invoice.payments.map(n => n.timeout));
 
           const delta = timeout - recoveryDetails.timeout;
 
           sub.removeAllListeners();
 
-          return cbk(null, {delta});
+          return cbk(null, {channels, delta});
         });
 
         return;
@@ -423,12 +444,52 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Check incoming peer constraints
+      checkIncomingPeer: [
+        'getChannels',
+        'waitForDepositHold',
+        'waitForFundHold',
+        ({getChannels, waitForDepositHold, waitForFundHold}, cbk) =>
+      {
+        // Exit early when there are no incoming peer constraints
+        if (!args.incoming_peer) {
+          return cbk();
+        }
+
+        const channels = getChannels.channels.map(n => n.id);
+
+        // The deposit must come in under a channel with the incoming peer
+        const invalidDeposit = waitForDepositHold.channels.find(id => {
+          return !channels.includes(id);
+        });
+
+        if (!!invalidDeposit) {
+          return cbk([503, 'UnexpectedInboundChannelForHeldDeposit']);
+        }
+
+        // The funding must come in under a channel with the incoming peer
+        const invalidFunding = waitForFundHold.channels.find(id => {
+          return !channels.includes(id);
+        });
+
+        if (!!invalidFunding) {
+          return cbk([503, 'UnexpectedInboundChannelForHeldFunding']);
+        }
+
+        return cbk();
+      }],
+
       // Check that there are sufficient remaining blocks
       checkTimeRemaining: [
         'recoveryDetails',
         'waitForDepositHold',
         'waitForFundHold',
-        ({recoveryDetails, waitForDepositHold, waitForFundHold}, cbk) =>
+        ({
+          recoveryDetails,
+          waitForDepositHold,
+          waitForFundHold,
+        },
+        cbk) =>
       {
         if (waitForDepositHold.delta < defaultMinDelta) {
           return cbk([503, 'InsufficientDepositDeltaBlocksToFundSwap']);
@@ -458,6 +519,7 @@ module.exports = (args, cbk) => {
 
       // Lock chain funds to fund the swap with
       lockFunding: [
+        'checkIncomingPeer',
         'checkTimeRemaining',
         'getTransactions',
         'swap',

package/swaps/decode_off_to_on_response.js

@@ -3,6 +3,7 @@ const {decodeTlvStream} = require('bolt01');
 
 const {requestRecordsAsRequest} = require('./../records');
 const {publicTypes} = require('./swap_field_types');
+const {swapVersion} = require('./swap_field_types');
 
 const decodeNumber = encoded => decodeBigSize({encoded}).decoded;
 const findRecord = (records, type) => records.find(n => n.type === type);
@@ -13,6 +14,7 @@ const paymentNonceLength = 64;
 const startIndex = 0;
 const typeCoopPrivateKeyHash = publicTypes.typeRefundCoopPrivateKeyHash;
 const {typeDeposit} = publicTypes;
+const {typeInboundPeer} = publicTypes;
 const {typePush} = publicTypes;
 const {typeRefundCoopPublicKey} = publicTypes;
 const {typeRefundSoloPublicKey} = publicTypes;
@@ -33,6 +35,7 @@ const {typeVersion} = publicTypes;
     coop_public_key: <Refund Cooperative Key Hex String>
     deposit_mtokens: <Deposit Amount Millitokens Number String>
     deposit_payment: <Deposit Payment Nonce Hex String>
+    [incoming_peer]: <Constrained to Inbound Peer Public Key Id Hex String>
     push: <Push Payment Nonce Hex String>
     refund_public_key: <Refund Unilateral Public Key Hex String>
     request: <BOLT 11 Encoded Funding Request String>
@@ -56,10 +59,22 @@ module.exports = ({network, response}) => {
 
   const {records} = decodeTlvStream({encoded: response});
 
-  if (!!findRecord(records, typeVersion)) {
+  if (!findRecord(records, typeVersion)) {
     throw new Error('UnexpectedVersionOfOffToOnResponse');
   }
 
+  const versionRecord = findRecord(records, typeVersion);
+
+  try {
+    decodeNumber(versionRecord.value);
+  } catch (err) {
+    throw new Error('ExpectedValidVersionRecordForOffToOnResponse');
+  }
+
+  if (Number(decodeNumber(versionRecord.value)) !== swapVersion) {
+    throw new Error('UnsupportedSwapVersionNumberForOffchainToOnchainSwap');
+  }
+
   const coopPrivateKeyHashRecord = findRecord(records, typeCoopPrivateKeyHash);
 
   if (!coopPrivateKeyHashRecord) {
@@ -106,6 +121,12 @@ module.exports = ({network, response}) => {
     throw new Error('ExpectedSmallerDepositAmountInOffToOnResponse');
   }
 
+  const inboundRecord = findRecord(records, typeInboundPeer);
+
+  if (!!inboundRecord && !isPublicKey(inboundRecord.value)) {
+    throw new Error('ExpectectedPublicKeyForInboundPeerConstraint');
+  }
+
   const pushRecord = findRecord(records, typePush);
 
   if (!pushRecord) {
@@ -150,6 +171,7 @@ module.exports = ({network, response}) => {
     coop_public_key: coopPublicKeyRecord.value,
     deposit_mtokens: decodeBigSize({encoded: depositAmount}).decoded,
     deposit_payment: depositRecord.value.slice(startIndex, paymentNonceLength),
+    incoming_peer: !!inboundRecord ? inboundRecord.value : undefined,
     push: pushRecord.value,
     refund_public_key: soloPublicKeyRecord.value,
     request: funding.request,

package/swaps/decode_on_to_off_recovery.js

@@ -5,6 +5,7 @@ const {decodeTlvStream} = require('bolt01');
 
 const decodeSwapSecrets = require('./decode_swap_secrets');
 const {publicTypes} = require('./swap_field_types');
+const {swapVersion} = require('./swap_field_types');
 
 const decodeNumber = encoded => decodeBigSize({encoded}).decoded;
 const findRecord = (records, type) => records.find(n => n.type === type);
@@ -16,6 +17,7 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
 const {typeClaimCoopPublicKeyHash} = publicTypes;
 const {typeClaimSoloPublicKey} = publicTypes;
 const {typeHash} = publicTypes;
+const {typeInboundPeer} = publicTypes;
 const {typePrivateRefundDetails} = publicTypes;
 const {typeRefundCoopPrivateKeyHash} = publicTypes;
 const {typeTimeout} = publicTypes;
@@ -60,8 +62,17 @@ module.exports = ({decrypt, recovery}) => {
 
   const {records} = decodeTlvStream({encoded: recovery});
 
-  if (!!findRecord(records, typeVersion)) {
-    throw new Error('UnexpectedVersionOfOffToOnRecovery');
+  // Make sure the recovery records are for the known swap version
+  const versionRecord = findRecord(records, typeVersion);
+
+  try {
+    decodeNumber(versionRecord.value);
+  } catch (err) {
+    throw new Error('ExpectedValidVersionRecordForOffToOnRecovery');
+  }
+
+  if (Number(decodeNumber(versionRecord.value)) !== swapVersion) {
+    throw new Error('UnsupportedSwapVersionNumberForOffToOnRecovery');
   }
 
   const claimCoopPubKeyHash = findRecord(records, typeClaimCoopPublicKeyHash);
@@ -74,6 +85,12 @@ module.exports = ({decrypt, recovery}) => {
     throw new Error('ExpectedValidClaimCoopPublicKeyHash');
   }
 
+  const inboundRecord = findRecord(records, typeInboundPeer);
+
+  if (!!inboundRecord && !isPublicKey(inboundRecord.value)) {
+    throw new Error('ExpectectedPublicKeyForInboundPeerConstraintInRecovery');
+  }
+
   const claimSoloPublicKeyRecord = findRecord(records, typeClaimSoloPublicKey);
 
   if (!claimSoloPublicKeyRecord) {

package/swaps/encode_off_to_on_response.js

@@ -5,6 +5,7 @@ const {parsePaymentRequest} = require('ln-service');
 const encodeSwapSecrets = require('./encode_swap_secrets');
 const {requestAsRequestRecords} = require('./../records');
 const {publicTypes} = require('./swap_field_types');
+const {swapVersion} = require('./swap_field_types');
 
 const encode = records => encodeTlvStream({records}).encoded;
 const encodeNumber = n => encodeBigSize({number: n.toString()}).encoded;
@@ -13,6 +14,7 @@ const {typeClaimCoopPublicKeyHash} = publicTypes;
 const {typeClaimSoloPublicKey} = publicTypes;
 const {typeDeposit} = publicTypes;
 const {typeHash} = publicTypes;
+const {typeInboundPeer} = publicTypes;
 const {typePush} = publicTypes;
 const {typePrivateRefundDetails} = publicTypes;
 const {typeRefundCoopPrivateKeyHash} = publicTypes;
@@ -21,6 +23,7 @@ const {typeRefundSoloPublicKey} = publicTypes;
 const {typeRequest} = publicTypes;
 const {typeTimeout} = publicTypes;
 const {typeTokens} = publicTypes;
+const {typeVersion} = publicTypes;
 
 /** Serialize off to on swap records
 
@@ -32,6 +35,7 @@ const {typeTokens} = publicTypes;
     deposit: <Deposit BOLT 11 Request String>
     encrypt: <Encrypt Secrets Base Encryption Key Hex String>
     hash: <Swap Hash Hex String>
+    [incoming_peer]: <Constrained to Inbound Peer Public Key Id Hex String>
     [key_index]: <Refund Unilateral Key Id Number>
     push: <BOLT 11 Encoded Push Request String>
     refund_public_key: <Refund Unilateral Public Key Hex String>
@@ -61,6 +65,10 @@ module.exports = args => {
       type: typeDeposit,
       value: deposit.payment + depositAmount,
     },
+    {
+      type: typeInboundPeer,
+      value: args.incoming_peer,
+    },
     {
       type: typeRefundCoopPrivateKeyHash,
       value: privateCoopKeyHash,
@@ -85,6 +93,10 @@ module.exports = args => {
       type: typeTimeout,
       value: timeout,
     },
+    {
+      type: typeVersion,
+      value: encodeNumber(swapVersion),
+    },
   ];
 
   const {encoded} = encodeSwapSecrets({
@@ -108,6 +120,10 @@ module.exports = args => {
       type: typeHash,
       value: swapHash,
     },
+    {
+      type: typeInboundPeer,
+      value: args.incoming_peer,
+    },
     {
       type: typePrivateRefundDetails,
       value: encoded,
@@ -124,10 +140,14 @@ module.exports = args => {
       type: typeTokens,
       value: encodeNumber(args.tokens),
     },
+    {
+      type: typeVersion,
+      value: encodeNumber(swapVersion),
+    },
   ];
 
   return {
-    recovery: encode(recoveryRecords),
-    response: encode(responseRecords),
+    recovery: encode(recoveryRecords.filter(n => !!n.value)),
+    response: encode(responseRecords.filter(n => !!n.value)),
   };
 };

package/swaps/manage_swap.js

@@ -1,3 +1,4 @@
+const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
 const {findKey} = require('ln-sync');
@@ -6,6 +7,7 @@ const {getAllInvoices} = require('ln-sync');
 const {getInvoice} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getNodeAlias} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
 const {returnResult} = require('asyncjs-util');
 
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
@@ -25,6 +27,7 @@ const pushesReceivedAfter = () => new Date(Date.now() - 1000 * 60 * 60 * 24);
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
+const {toOutputScript} = address;
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const typeKeySendTrade = '805805';
 
@@ -260,14 +263,57 @@ module.exports = (args, cbk) => {
         }
       }],
 
+      // Ask if the sweep address should be custom
+      askForSweepAddress: [
+        'askForExternal',
+        'getNetwork',
+        'selectAction',
+        ({getNetwork, selectAction}, cbk) =>
+      {
+        switch (selectAction) {
+        case actionPushRequest:
+        case requestAction:
+          return args.ask({
+            message: 'Send on-chain funds to an external address? (Optional)',
+            name: 'sweep',
+            type: 'input',
+            validate: input => {
+              if (!input) {
+                return true;
+              }
+
+              try {
+                return !!toOutputScript(input, networks[getNetwork.bitcoinjs]);
+              } catch (err) {
+                return 'Unsupported on-chain address format';
+              }
+            }
+          },
+          ({sweep}) => cbk(null, sweep));
+
+        default:
+          // Custom sweep address not supported
+          return cbk();
+        }
+      }],
+
       // Make swap request
       makeRequest: [
         'askForExternal',
         'askForRemote',
+        'askForSweepAddress',
         'findKey',
         'hasTr',
         'selectAction',
-        ({askForExternal, askForRemote, findKey, hasTr, selectAction}, cbk) =>
+        ({
+          askForExternal,
+          askForRemote,
+          askForSweepAddress,
+          findKey,
+          hasTr,
+          selectAction,
+        },
+        cbk) =>
       {
         switch (selectAction) {
         case actionPushRequest:
@@ -291,6 +337,7 @@ module.exports = (args, cbk) => {
           push_to: findKey.public_key,
           min_confirmations: minConfirmations[getNetwork.network],
           request: !hasTr ? args.request : undefined,
+          sweep_address: askForSweepAddress || undefined,
         },
         cbk);
       }],

package/swaps/request_swap_out.js

@@ -51,6 +51,7 @@ const typeSwapResponse = serviceTypes.serviceTypeSwapResponse;
     [min_confirmations]: <Minimum Confirmations to Wait Number>
     [push_to]: <Push Swap Request to Node with Identity Public Key Hex String>
     [request]: <Request Function>
+    [sweep_address]: <Sweep Chain Address String>
   }
 
   @returns via cbk or Promise
@@ -329,6 +330,7 @@ module.exports = (args, cbk) => {
         });
 
         const deposit = mtokensAsTokens(response.deposit_mtokens);
+        const inbound = response.incoming_peer;
         const timeout = `that times out at ${response.timeout}`;
         const {tokens} = parsePaymentRequest({request: response.request});
 
@@ -340,9 +342,11 @@ module.exports = (args, cbk) => {
           return cbk(null, true)
         }
 
+        const inPeer = !!args.is_external_funding ? ` in via ${inbound}` : '';
+
         return args.ask({
           default: true,
-          message: `Start swap ${timeout}? ${pricing}?`,
+          message: `Start swap ${timeout}? ${pricing}${inPeer}?`,
           name: 'ok',
           type: 'confirm',
         },
@@ -378,6 +382,7 @@ module.exports = (args, cbk) => {
           recovery: makeRequest.recovery,
           request: args.request,
           response: getResponse,
+          sweep_address: args.sweep_address,
         },
         cbk);
       }],

package/swaps/respond_to_swap_out_request.js

@@ -2,6 +2,7 @@ const {createHash} = require('crypto');
 const EventEmitter = require('events');
 
 const asyncAuto = require('async/auto');
+const {findKey} = require('ln-sync');
 const {getChainFeeRate} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
@@ -158,6 +159,24 @@ module.exports = ({ask, lnd, logger, request, swap, to}, cbk) => {
         ({target}) => cbk(null, Number(target)));
       }],
 
+      // Ask for an incoming peer to constrain the swap to
+      askForIncoming: ['askForTarget', ({}, cbk) => {
+        return ask({
+          message: 'Require off-chain through a specific peer? (Optional)',
+          name: 'incoming',
+        },
+        ({incoming}) => cbk(null, incoming));
+      }],
+
+      // Find the incoming identity key when specified
+      findIncoming: ['askForIncoming', ({askForIncoming}, cbk) => {
+        if (!askForIncoming) {
+          return cbk(null, {});
+        }
+
+        return findKey({lnd, query: askForIncoming}, cbk);
+      }],
+
       // Get the chain fee rate
       getRate: ['askForTarget', ({askForTarget}, cbk) => {
         return getChainFeeRate({lnd, confirmation_target: askForTarget}, cbk);
@@ -167,15 +186,21 @@ module.exports = ({ask, lnd, logger, request, swap, to}, cbk) => {
       makeResponse: [
         'askForRate',
         'askForRequest',
+        'findIncoming',
         'getRate',
-        ({askForRate, askForRequest, getRate}, cbk) =>
+        ({askForRate, askForRequest, findIncoming, getRate}, cbk) =>
       {
         const {tokens} = decodeOffToOnRequest({request: askForRequest});
 
+        if (!!findIncoming.public_key) {
+          logger.info({incoming_peer_constraint: findIncoming.public_key});
+        }
+
         return startOnToOffSwap({
           lnd,
           delta: defaultCltvDelta,
           deposit: ceil(getRate.tokens_per_vbyte * estimatedVirtualSize),
+          incoming_peer: findIncoming.public_key || undefined,
           is_external_solo_key: !!request,
           price: floor(tokens * askForRate / rateDenominator),
           request: askForRequest,

package/swaps/start_on_to_off_swap.js

@@ -29,6 +29,7 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
   {
     delta: <Swap CLTV Delta Number>
     deposit: <Unilateral Deposit Tokens Number>
+    [incoming_peer]: <Constrained to Inbound Peer Public Key Id Hex String>
     [is_external_solo_key]: <Use External Unilateral Refund Key Bool>
     lnd: <Authenticated LND API Object>
     price: <Swap Price Tokens Number>
@@ -227,6 +228,7 @@ module.exports = (args, cbk) => {
           deposit: createExecInvoice.request,
           encrypt: getEncrypt.secret,
           hash: requestDetails.hash,
+          incoming_peer: args.incoming_peer || undefined,
           key_index: getRefundKey.index,
           push: createPushInvoice.request,
           refund_public_key: getRefundKey.public_key,

package/swaps/swap_field_types.json

@@ -8,6 +8,7 @@
     "typeSoloPrivateKey": "6"
   },
   "publicTypes": {
+    "typeVersion": "0",
     "typeClaimCoopPublicKeyHash": "1",
     "typeClaimSoloPublicKey": "2",
     "typeDeposit": "3",
@@ -21,11 +22,12 @@
     "typeRequest": "11",
     "typeTimeout": "12",
     "typeTokens": "13",
-    "typeVersion": "0"
+    "typeInboundPeer": "14"
   },
   "pushTypes": {
     "typeSwapId": "0",
     "typeSwapResponse": "1"
   },
+  "swapVersion": 1,
   "typePayMetadata": "805001"
 }

package/test/integration/test_request_swap_out.js

@@ -103,6 +103,10 @@ test(`Start offchain swap`, async ({end, equal, strictSame}) => {
                 return cbk({[args.name]: args.default});
               }
 
+              if (args.name === 'incoming') {
+                return cbk({incoming: false});
+              }
+
               if (args.name === 'req') {
                 return cbk({req: swapRequest.swap_request});
               }

package/test/integration/test_swap_with_claim_path.js

@@ -103,6 +103,10 @@ test(`Swap with claim path`, async ({end, equal, strictSame}) => {
                 return cbk({[args.name]: args.default});
               }
 
+              if (args.name === 'incoming') {
+                return cbk({incoming: false});
+              }
+
               if (args.name === 'req') {
                 return cbk({req: swapRequest.swap_request});
               }

package/test/integration/test_swap_with_refund_path.js

@@ -104,6 +104,10 @@ test(`Timeout a swap`, async ({end, equal, strictSame}) => {
                   return cbk({[args.name]: args.default});
                 }
 
+                if (args.name === 'incoming') {
+                  return cbk({incoming: false});
+                }
+
                 if (args.name === 'req') {
                   return cbk({req: swapRequest.swap_request});
                 }

package/trades/connect_to_seller.js

@@ -2,12 +2,15 @@ const {addPeer} = require('ln-service');
 const asyncAuto = require('async/auto');
 const asyncDetect = require('async/detect');
 const asyncDetectSeries = require('async/detectSeries');
+const asyncEach = require('async/each');
 const asyncMap = require('async/map');
 const asyncRetry = require('async/retry');
 const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNode} = require('ln-service');
 const {getPeers} = require('ln-service');
+const {removePeer} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const interval = 1000;
@@ -55,12 +58,14 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
         return cbk();
       },
 
+      // Get the channels to see if this is a channel peer
+      getChannels: ['validate', ({}, cbk) => {
+        return getChannels({lnd, is_active: true}, cbk);
+      }],
+
       // Derive the self public key
       getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
 
-      // Get the list of connected peers
-      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
-
       // Find node connect info to connect to
       getNodes: ['getIdentity', ({getIdentity}, cbk) => {
         return asyncMap(nodes, (connect, cbk) => {
@@ -135,8 +140,56 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
         cbk);
       }],
 
+      // Remove the peer if there is no channel peer to avoid stale peers
+      removePeer: [
+        'getChannels',
+        'getNodes',
+        ({getChannels, getNodes}, cbk) =>
+      {
+        const ids = getChannels.channels.map(n => n.partner_public_key);
+
+        return asyncEach(getNodes, (node, cbk) => {
+          // Exit early when there is no node id
+          if (!node || !node.id || ids.includes(node.id)) {
+            return cbk();
+          }
+
+          return removePeer({lnd, public_key: node.id}, (err, res) => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            return asyncRetry({interval, times}, cbk => {
+              return getPeers({lnd}, (err, res) => {
+                if (!!err) {
+                  return cbk(err);
+                }
+
+                const peers = res.peers.map(n => n.public_key);
+
+                if (!!peers.includes(node.id)) {
+                  return cbk([503, 'FailedToDisconnectSellerPeer']);
+                }
+
+                return cbk();
+              });
+            },
+            cbk);
+          });
+        },
+        cbk);
+      }],
+
+      // Get the list of connected peers
+      getPeers: ['removePeer', ({}, cbk) => getPeers({lnd}, cbk)],
+
       // Try and connect to a node in order to do p2p messaging
-      connect: ['getNodes', 'getPeers', ({getNodes, getPeers}, cbk) => {
+      connect: [
+        'getNodes',
+        'getPeers',
+        'removePeer',
+        ({getNodes, getPeers}, cbk) =>
+      {
         const connected = getPeers.peers.map(n => n.public_key);
 
         // Look for a node that is already a connected peer