paid-services 3.15.1 → 3.15.4

package/CHANGELOG.md

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

package/package.json

@@ -16,7 +16,7 @@
     "ecpair": "2.0.1",
     "goldengate": "11.2.1",
     "invoices": "2.0.6",
-    "ln-service": "53.11.0",
+    "ln-service": "53.15.0",
     "ln-sync": "3.12.0",
     "psbt": "2.0.1",
     "p2tr": "1.3.1",
@@ -25,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"
   },
@@ -47,5 +47,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 180 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/balanced/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.15.1"
+  "version": "3.15.4"
 }

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));

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,8 @@ const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
 
 const allowedNetwork = 'btctestnet';
+const bip86Path = `m/86'/0'/0'`;
+const minConfirmations = {btc: 2, btcregtest: 3, btctestnet: 1};
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
@@ -46,13 +49,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 +94,53 @@ 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,
+          min_confirmations: minConfirmations[getNetwork.network],
+          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,30 @@ 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>
+    [min_confirmations]: <Minimum Confirmations to Wait Number>
+    [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 +54,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 +74,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 +100,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 +114,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 +155,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 +179,18 @@ 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,
+          min_confirmations: args.min_confirmations,
           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,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
+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);
+        },
+      },
+      min_confirmations: 3,
+    });
+  } 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();
+});