paid-services 3.17.1 → 3.19.0

package/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Versions
 
-## Version 3.17.1
+## Version 3.19.0
+
+- `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.1"
+  "version": "3.19.0"
 }

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',