paid-services 3.15.0 → 3.15.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 3.15.0
+## Version 3.15.3
 
 - `manageSwap`: Add method to execute submarine swaps on testnet
 

package/package.json

@@ -10,12 +10,13 @@
     "@alexbosworth/fiat": "1.0.2",
     "async": "3.2.3",
     "asyncjs-util": "1.2.9",
+    "bech32": "2.0.0",
     "bolt01": "1.2.4",
     "bolt07": "1.8.1",
     "ecpair": "2.0.1",
     "goldengate": "11.2.1",
     "invoices": "2.0.6",
-    "ln-service": "53.11.0",
+    "ln-service": "53.14.1",
     "ln-sync": "3.12.0",
     "psbt": "2.0.1",
     "p2tr": "1.3.1",
@@ -24,7 +25,7 @@
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
-    "ln-docker-daemons": "2.2.7",
+    "ln-docker-daemons": "2.2.9",
     "mock-lnd": "1.4.1",
     "secp256k1": "4.0.3"
   },
@@ -46,5 +47,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 180 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/balanced/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.15.0"
+  "version": "3.15.3"
 }

package/swaps/complete_off_to_on_swap.js

@@ -5,6 +5,7 @@ const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
 const asyncRace = require('async/race');
 const asyncReflect = require('async/reflect');
+const {bech32m} = require('bech32');
 const {broadcastChainTransaction} = require('ln-service');
 const {confirmationFee} = require('goldengate');
 const {controlBlock} = require('p2tr');
@@ -19,12 +20,14 @@ const {getNetwork} = require('ln-sync');
 const {getPayment} = require('ln-service');
 const {getPublicKey} = require('ln-service');
 const {hashForTree} = require('p2tr');
+const {networks} = require('bitcoinjs-lib');
 const {parsePaymentRequest} = require('ln-service');
 const {pay} = require('ln-service');
 const {payViaPaymentDetails} = require('ln-service');
 const {pointAdd} = require('tiny-secp256k1');
 const {privateAdd} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
+const {script} = require('bitcoinjs-lib');
 const {signTransaction} = require('ln-service');
 const {subscribeToBlocks} = require('ln-service');
 const {subscribeToPastPayment} = require('ln-service');
@@ -42,12 +45,14 @@ const {typePayMetadata} = require('./swap_field_types');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const {ceil} = Math;
+const decompileOutputScript = hex => script.decompile(Buffer.from(hex, 'hex'));
 const defaultConfsCount = 1;
 const defaultDepositSettleTimeoutMs = 1000 * 60 * 10;
 const defaultMaxFeeMultiplier = 1000;
 const defaultMaxPreimagePushFee = 10;
 const defaultMinSweepBlocks = 20;
 const defaultWaitForChainFundingMs = 1000 * 60 * 60 * 3;
+const encodeAddress = (prefix, data) => bech32m.encode(prefix, data);
 const family = 805;
 const {floor} = Math;
 const {from} = Buffer;
@@ -69,6 +74,7 @@ const sweepInputIndex = 0;
 const times = n => Array(n).fill(null).map((_, i) => i);
 const tokensForPushPreimage = 1;
 const uniqBy = (a,b) => a.filter((e,i) => a.findIndex(n => n[b] == e[b]) == i);
+const v1AddressWords = key => [].concat(1).concat(bech32m.toWords(key));
 
 /** Complete the off to on swap
 
@@ -393,9 +399,13 @@ module.exports = (args, cbk) => {
         'swap',
         ({deadline, getNetwork, requestDetails, startHeight, swap}, cbk) =>
       {
+        const [, key] = decompileOutputScript(swap.output_script);
         const outputScript = swap.output_script;
+        const prefix = networks[getNetwork.bitcoinjs].bech32;
 
-        args.emitter.emit('update', {waiting_for_chain_funding: outputScript});
+        const address = encodeAddress(prefix, v1AddressWords(key));
+
+        args.emitter.emit('update', {waiting_for_chain_funding: address});
 
         if (!!args.request) {
           return findDeposit({

package/swaps/complete_on_to_off_swap.js

@@ -418,8 +418,7 @@ module.exports = (args, cbk) => {
             });
 
             return cbk(null, tx.toHex());
-          },
-          cbk);
+          });
         },
         cbk);
       }],
@@ -681,7 +680,7 @@ module.exports = (args, cbk) => {
             transaction,
             lnd: args.lnd,
           },
-          err => {});
+          () => {});
         });
 
         subTimeout.on('error', err => done(err));
@@ -718,7 +717,7 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
-        args.emitter.emit('update', {receiving_funds: findSecret.secret});
+        args.emitter.emit('update', {receiving_funds: getSettlement.tokens});
 
         return settleHodlInvoice({
           lnd: args.lnd,

package/swaps/manage_swap.js

@@ -1,5 +1,6 @@
 const asyncAuto = require('async/auto');
-const {getNetwork} = require('ln-sync')
+const {getMasterPublicKeys} = require('ln-service');
+const {getNetwork} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
 const recoverResponseToSwapOut = require('./recover_response_to_swap_out');
@@ -7,6 +8,7 @@ const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
 
 const allowedNetwork = 'btctestnet';
+const bip86Path = `m/86'/0'/0'`;
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
@@ -46,13 +48,25 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         return cbk();
       },
 
+      // Look for a p2tr master public key to detect p2tr support
+      getMasterPublicKeys: ['validate', ({}, cbk) => {
+        return getMasterPublicKeys({lnd}, cbk);
+      }],
+
       // Get the network to make sure this is on testnet
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
 
+      // Determine if taproot is supported or not
+      hasTr: ['getMasterPublicKeys', ({getMasterPublicKeys}, cbk) => {
+        const {keys} = getMasterPublicKeys;
+
+        return cbk(null, !!keys.find(n => n.derivation_path === bip86Path));
+      }],
+
       // Select a swap action
-      selectAction: ['getNetwork', ({getNetwork}, cbk) => {
+      selectAction: ['getNetwork', 'hasTr', ({getNetwork, hasTr}, cbk) => {
         // Check to make sure the network is supported
-        if (getNetwork.network !== allowedNetwork) {
+        if (!hasTr && getNetwork.network !== allowedNetwork) {
           return cbk([501, 'CurrentlyUnsupportedChainForSwap']);
         }
 
@@ -79,30 +93,52 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       }],
 
       // Make swap request
-      makeRequest: ['selectAction', ({selectAction}, cbk) => {
+      makeRequest: ['hasTr', 'selectAction', ({hasTr, selectAction}, cbk) => {
         if (selectAction !== requestAction) {
           return cbk();
         }
 
-        return requestSwapOut({ask, lnd, logger, request}, cbk);
+        return requestSwapOut({
+          ask,
+          lnd,
+          logger,
+          request: !hasTr ? request : undefined,
+        },
+        cbk);
       }],
 
       // Respond to swap request
-      makeResponse: ['selectAction', ({selectAction}, cbk) => {
+      makeResponse: ['hasTr', 'selectAction', ({hasTr, selectAction}, cbk) => {
         if (selectAction !== respondAction) {
           return cbk();
         }
 
-        return respondToSwapOutRequest({ask, lnd, logger, request}, cbk);
+        return respondToSwapOutRequest({
+          ask,
+          lnd,
+          logger,
+          request: !hasTr ? request : undefined,
+        },
+        cbk);
       }],
 
       // Recover responding to swap request
-      recoverResponse: ['selectAction', ({selectAction}, cbk) => {
+      recoverResponse: [
+        'hasTr',
+        'selectAction',
+        ({hasTr, selectAction}, cbk) =>
+      {
         if (selectAction !== recoverRespondAction) {
           return cbk();
         }
 
-        return recoverResponseToSwapOut({ask, lnd, logger, request}, cbk);
+        return recoverResponseToSwapOut({
+          ask,
+          lnd,
+          logger,
+          request: !hasTr ? request : undefined,
+        },
+        cbk);
       }],
 
       // Final result

package/swaps/recover_response_to_swap_out.js

@@ -11,7 +11,7 @@ const completeOnToOffSwap = require('./complete_on_to_off_swap');
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
-    request: <Request Function>
+    [request]: <Request Function>
   }
 
   @returns via cbk or Promise
@@ -33,10 +33,6 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           return cbk([400, 'ExpectedWinstonLoggerToRecoverResponseToSwapOut']);
         }
 
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToRecoverResponseToSwap']);
-        }
-
         return cbk();
       },
 

package/swaps/request_swap_out.js

@@ -22,27 +22,29 @@ const rateDenominator = 1e6;
 
   {
     ask: <Ask Function>
+    [is_avoiding_broadcast]: <Avoid Broadcasting Bool>
+    [is_uncooperative]: <Avoid Cooperative Resolution Bool>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
-    request: <Request Function>
+    [request]: <Request Function>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger, request}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!ask) {
+        if (!args.ask) {
           return cbk([400, 'ExpectedAskFunctionToRequestSwapOut']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToRequestSwapOut']);
         }
 
-        if (!logger) {
+        if (!args.logger) {
           return cbk([400, 'ExpectedWinstonLoggerToRequestSwapOut']);
         }
 
@@ -51,7 +53,7 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
 
       // Ask for amount
       askForTokens: ['validate', ({}, cbk) => {
-        return ask({
+        return args.ask({
           default: defaultSwapAmount,
           message: 'Amount to swap?',
           name: 'tokens',
@@ -71,11 +73,11 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       }],
 
       // Get the network name
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
       // Ask for routing fee rate
       askForRate: ['askForTokens', ({}, cbk) => {
-        return ask({
+        return args.ask({
           default: defaultFeeRate,
           message: 'Max routing fee rate for swap funds in parts per million?',
           name: 'rate',
@@ -97,8 +99,8 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
       // Make a swap request
       makeRequest: ['askForTokens', ({askForTokens}, cbk) => {
         return makeRequest({
-          lnd,
-          is_external_solo_key: true,
+          is_external_solo_key: !!args.request,
+          lnd: args.lnd,
           tokens: askForTokens,
         },
         cbk);
@@ -111,9 +113,9 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         'makeRequest',
         ({getNetwork, makeRequest}, cbk) =>
       {
-        logger.info({swap_request: makeRequest.request});
+        args.logger.info({swap_request: makeRequest.request});
 
-        return ask({
+        return args.ask({
           message: 'Response to swap request?',
           name: 'response',
           validate: response => {
@@ -152,7 +154,7 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         const fee = tokens - askForTokens;
         const pricing = `Execution cost ${deposit}, plus liquidity fee ${fee}`;
 
-        return ask({
+        return args.ask({
           default: true,
           message: `Start swap ${timeout}? ${pricing}?`,
           name: 'ok',
@@ -176,15 +178,17 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
 
         const emitter = new EventEmitter();
 
-        emitter.on('update', update => logger.info(update));
+        emitter.on('update', update => args.logger.info(update));
 
         return completeOffToOnSwap({
           emitter,
-          lnd,
-          request,
+          is_avoiding_broadcast: args.is_avoiding_broadcast,
+          is_uncooperative: args.is_uncooperative,
+          lnd: args.lnd,
           max_fee_deposit: defaultMaxFeeForDeposit,
           max_fee_funding: askForTokens * askForRate / rateDenominator,
           recovery: makeRequest.recovery,
+          request: args.request,
           response: getResponse,
         },
         cbk);

package/swaps/respond_to_swap_out_request.js

@@ -23,7 +23,7 @@ const rateDenominator = 1e6;
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
-    request: <Request Function>
+    [request]: <Request Function>
   }
 
   @returns via cbk or Promise
@@ -45,10 +45,6 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           return cbk([400, 'ExpectedLoggerToRespondToSwapOutRequest']);
         }
 
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToRespondToSwapOutReq']);
-        }
-
         return cbk();
       },
 
@@ -115,7 +111,7 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           lnd,
           delta: defaultCltvDelta,
           deposit: ceil(getRate.tokens_per_vbyte * estimatedVirtualSize),
-          is_external_solo_key: true,
+          is_external_solo_key: !!request,
           price: floor(tokens * askForRate / rateDenominator),
           request: askForRequest,
         },

package/test/integration/test_request_swap_out.js

@@ -0,0 +1,151 @@
+const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {createInvoice} = require('ln-service');
+const {getChannelBalance} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getMasterPublicKeys} = require('ln-service');
+const {openChannel} = require('ln-service');
+const {pay} = require('ln-service');
+const {sendToChainAddress} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const requestSwapOut = require('./../../swaps/request_swap_out');
+const respondToSwapOut = require('./../../swaps/respond_to_swap_out_request');
+
+const capacity = 1e6;
+const count = 50;
+const interval = 100;
+const maturity = 100;
+const size = 2;
+const taprootDerivationPath = `m/86'/0'/0'`;
+const times = 3000;
+const tokens = 1e5;
+
+// Start an offchain swap
+test(`Start offchain swap`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, id, lnd}, target] = nodes;
+
+  const {keys} = await getMasterPublicKeys({lnd});
+
+  // Exit early when taproot is not supported
+  if (!keys.find(n => n.derivation_path === taprootDerivationPath)) {
+    await kill({});
+
+    return end();
+  }
+
+  try {
+    await generate({count: maturity});
+
+    // Setup a channel between the nodes
+    {
+      // Make a channel
+      await asyncRetry({interval, times}, async () => {
+        await openChannel({
+          lnd,
+          local_tokens: capacity,
+          partner_public_key: target.id,
+          partner_socket: target.socket,
+        });
+      });
+
+      await asyncRetry({interval, times}, async () => {
+        const {channels} = await getChannels({lnd, is_actve: true});
+
+        if (!!channels.length) {
+          return channels;
+        }
+
+        await generate({});
+
+        await sendToChainAddress({
+          lnd,
+          address: (await createChainAddress({lnd: target.lnd})).address,
+          tokens: capacity,
+        });
+
+        const balance = await getChannelBalance({lnd});
+
+        if (!balance.channel_balance) {
+          throw new Error('WaitingForChannelBalance');
+        }
+
+        throw new Error('WaitingForChannelOpen');
+      });
+
+      await target.generate({count: maturity});
+    }
+
+    // Collect request messages
+    const messages = [];
+
+    // Make a swap out request
+    await requestSwapOut({
+      lnd,
+      ask: async (args, cbk) => {
+        if (args.name === 'tokens') {
+          return cbk({tokens: '10000'});
+        }
+
+        if (args.name === 'rate') {
+          return cbk({rate: '10'});
+        }
+
+        const swapRequest = messages.find(n => !!n.swap_request);
+
+        if (args.name === 'response') {
+          return await respondToSwapOut({
+            ask: (args, cbk) => {
+              if (args.name === 'rate') {
+                return cbk({rate: '100'});
+              }
+
+              if (args.name === 'req') {
+                return cbk({req: swapRequest.swap_request});
+              }
+
+              throw new Error('UnrecognizedQueryForResponse');
+            },
+            lnd: target.lnd,
+            logger: {
+              info: async message => {
+                if (!!message.response) {
+                  return cbk({response: message.response});
+                }
+
+                // Transaction is funded, generate funding into a block
+                if (!!message.funding_transaction_id) {
+                  return await target.generate({count});
+                }
+              },
+            },
+          });
+        }
+
+        if (args.name === 'ok') {
+          return cbk({ok: true});
+        }
+
+        throw new Error('UnrecognizedQueryForRequest');
+      },
+      logger: {
+        info: async message => {
+          if (message.broadcasting_tx_to_resolve_swap) {
+            await generate({count});
+          }
+
+          return messages.push(message);
+        },
+      },
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  }
+
+  await kill({});
+
+  return end();
+});

package/test/integration/test_swap_with_claim_path.js

@@ -0,0 +1,152 @@
+const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {createInvoice} = require('ln-service');
+const {getChannelBalance} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getMasterPublicKeys} = require('ln-service');
+const {openChannel} = require('ln-service');
+const {pay} = require('ln-service');
+const {sendToChainAddress} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const requestSwapOut = require('./../../swaps/request_swap_out');
+const respondToSwapOut = require('./../../swaps/respond_to_swap_out_request');
+
+const capacity = 1e6;
+const count = 50;
+const interval = 100;
+const maturity = 100;
+const size = 2;
+const taprootDerivationPath = `m/86'/0'/0'`;
+const times = 3000;
+const tokens = 1e5;
+
+// Start an offchain swap but use the claim path to sweep
+test(`Swap with claim path`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, id, lnd}, target] = nodes;
+
+  const {keys} = await getMasterPublicKeys({lnd});
+
+  // Exit early when taproot is not supported
+  if (!keys.find(n => n.derivation_path === taprootDerivationPath)) {
+    await kill({});
+
+    return end();
+  }
+
+  try {
+    await generate({count: maturity});
+
+    // Setup a channel between the nodes
+    {
+      // Make a channel
+      await asyncRetry({interval, times}, async () => {
+        await openChannel({
+          lnd,
+          local_tokens: capacity,
+          partner_public_key: target.id,
+          partner_socket: target.socket,
+        });
+      });
+
+      await asyncRetry({interval, times}, async () => {
+        const {channels} = await getChannels({lnd, is_actve: true});
+
+        if (!!channels.length) {
+          return channels;
+        }
+
+        await generate({});
+
+        await sendToChainAddress({
+          lnd,
+          address: (await createChainAddress({lnd: target.lnd})).address,
+          tokens: capacity,
+        });
+
+        const balance = await getChannelBalance({lnd});
+
+        if (!balance.channel_balance) {
+          throw new Error('WaitingForChannelBalance');
+        }
+
+        throw new Error('WaitingForChannelOpen');
+      });
+
+      await target.generate({count: maturity});
+    }
+
+    // Collect request messages
+    const messages = [];
+
+    // Make a swap out request
+    await requestSwapOut({
+      lnd,
+      ask: async (args, cbk) => {
+        if (args.name === 'tokens') {
+          return cbk({tokens: '10000'});
+        }
+
+        if (args.name === 'rate') {
+          return cbk({rate: '10'});
+        }
+
+        const swapRequest = messages.find(n => !!n.swap_request);
+
+        if (args.name === 'response') {
+          return await respondToSwapOut({
+            ask: (args, cbk) => {
+              if (args.name === 'rate') {
+                return cbk({rate: '100'});
+              }
+
+              if (args.name === 'req') {
+                return cbk({req: swapRequest.swap_request});
+              }
+
+              throw new Error('UnrecognizedQueryForResponse');
+            },
+            lnd: target.lnd,
+            logger: {
+              info: async message => {
+                if (!!message.response) {
+                  return cbk({response: message.response});
+                }
+
+                // Transaction is funded, generate funding into a block
+                if (!!message.funding_transaction_id) {
+                  return await target.generate({count});
+                }
+              },
+            },
+          });
+        }
+
+        if (args.name === 'ok') {
+          return cbk({ok: true});
+        }
+
+        throw new Error('UnrecognizedQueryForRequest');
+      },
+      is_uncooperative: true,
+      logger: {
+        info: async message => {
+          if (message.broadcasting_tx_to_resolve_swap) {
+            await generate({count});
+          }
+
+          return messages.push(message);
+        },
+      },
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  }
+
+  await kill({});
+
+  return end();
+});

package/test/integration/test_swap_with_refund_path.js

@@ -0,0 +1,164 @@
+const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {createInvoice} = require('ln-service');
+const {getChannelBalance} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getMasterPublicKeys} = require('ln-service');
+const {openChannel} = require('ln-service');
+const {pay} = require('ln-service');
+const {sendToChainAddress} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const requestSwapOut = require('./../../swaps/request_swap_out');
+const respondToSwapOut = require('./../../swaps/respond_to_swap_out_request');
+
+const capacity = 1e6;
+const count = 50;
+const interval = 100;
+const maturity = 100;
+const size = 2;
+const taprootDerivationPath = `m/86'/0'/0'`;
+const times = 3000;
+const tokens = 1e5;
+
+// Start an offchain swap but do not cooperate and eventually force a refund
+test(`Timeout a swap`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, id, lnd}, target] = nodes;
+
+  const {keys} = await getMasterPublicKeys({lnd});
+
+  // Exit early when taproot is not supported
+  if (!keys.find(n => n.derivation_path === taprootDerivationPath)) {
+    await kill({});
+
+    return end();
+  }
+
+  try {
+    await generate({count: maturity});
+
+    // Setup a channel between the nodes
+    {
+      // Make a channel
+      await asyncRetry({interval, times}, async () => {
+        await openChannel({
+          lnd,
+          local_tokens: capacity,
+          partner_public_key: target.id,
+          partner_socket: target.socket,
+        });
+      });
+
+      await asyncRetry({interval, times}, async () => {
+        const {channels} = await getChannels({lnd, is_actve: true});
+
+        if (!!channels.length) {
+          return channels;
+        }
+
+        await generate({});
+
+        await sendToChainAddress({
+          lnd,
+          address: (await createChainAddress({lnd: target.lnd})).address,
+          tokens: capacity,
+        });
+
+        const balance = await getChannelBalance({lnd});
+
+        if (!balance.channel_balance) {
+          throw new Error('WaitingForChannelBalance');
+        }
+
+        throw new Error('WaitingForChannelOpen');
+      });
+
+      await target.generate({count: maturity});
+    }
+
+    // Collect request messages
+    const messages = [];
+
+    // Make a swap out request
+    await requestSwapOut({
+      lnd,
+      ask: async (args, cbk) => {
+        if (args.name === 'tokens') {
+          return cbk({tokens: '10000'});
+        }
+
+        if (args.name === 'rate') {
+          return cbk({rate: '10'});
+        }
+
+        const swapRequest = messages.find(n => !!n.swap_request);
+
+        if (args.name === 'response') {
+          try {
+            return await respondToSwapOut({
+              ask: (args, cbk) => {
+                if (args.name === 'rate') {
+                  return cbk({rate: '100'});
+                }
+
+                if (args.name === 'req') {
+                  return cbk({req: swapRequest.swap_request});
+                }
+
+                throw new Error('UnrecognizedQueryForResponse');
+              },
+              lnd: target.lnd,
+              logger: {
+                info: async message => {
+                  // Push chain forward to timeout
+                  if (!!message.blocks_until_timeout) {
+                    return await target.generate({});
+                  }
+
+                  if (!!message.response) {
+                    return cbk({response: message.response});
+                  }
+
+                  // Transaction is funded, generate funding into a block
+                  if (!!message.funding_transaction_id) {
+                    return await target.generate({count});
+                  }
+                },
+              },
+            });
+          } catch (err) {
+            strictSame(err, [503, 'SwapFailedViaTimeout']);
+
+            return;
+          }
+        }
+
+        if (args.name === 'ok') {
+          return cbk({ok: true});
+        }
+
+        throw new Error('UnrecognizedQueryForRequest');
+      },
+      is_avoiding_broadcast: true,
+      is_uncooperative: true,
+      logger: {
+        info: async message => {
+          if (message.broadcasting_tx_to_resolve_swap) {
+            await generate({count});
+          }
+
+          return messages.push(message);
+        },
+      },
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  }
+
+  await kill({});
+
+  return end();
+});