paid-services 3.18.0 → 3.19.2

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## Version 3.19.2
+
+- `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

package/package.json

@@ -16,9 +16,9 @@
     "ecpair": "2.0.1",
     "goldengate": "11.2.3",
     "invoices": "2.1.0",
-    "ln-service": "53.17.4",
-    "ln-sync": "3.13.0",
-    "psbt": "2.7.0",
+    "ln-service": "53.17.5",
+    "ln-sync": "3.13.1",
+    "psbt": "2.7.1",
     "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.18.0"
+  "version": "3.19.2"
 }

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