paid-services 3.15.1 → 3.15.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 3.15.1
+## Version 3.15.2
 
 - `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.14.1",
     "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.2"
 }

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();
       },
 

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 = 6;
+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();
+});