ln-service 52.14.4 → 53.0.0

package/test/integration/test_open_channel.js

@@ -1,43 +1,50 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
+const {addPeer} = require('./../../');
 const {createChainAddress} = require('./../../');
-const {createCluster} = require('./../macros');
+const {getChainBalance} = require('./../../');
 const {openChannel} = require('./../../');
 
 const channelCapacityTokens = 1e6;
+const count = 100;
 const defaultFee = 1e3;
 const defaultVout = 0;
-const format = 'p2wpkh';
 const giftTokens = 1000;
 const interval = 250;
-const times = 100;
+const size = 2;
+const times = 1000;
 const txIdHexLength = 32 * 2;
 
 // Opening a channel should open a channel
 test(`Open channel`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target] = nodes;
 
-  const {address} = await createChainAddress({format, lnd});
+  const {address} = await createChainAddress({lnd});
+
+  await generate({count});
 
   const channelOpen = await asyncRetry({interval, times}, async () => {
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
     return await openChannel({
       lnd,
       chain_fee_tokens_per_vbyte: defaultFee,
       cooperative_close_address: address,
       give_tokens: giftTokens,
       local_tokens: channelCapacityTokens,
-      partner_public_key: cluster.target.public_key,
-      socket: cluster.target.socket,
+      partner_public_key: target.id,
+      socket: target.socket,
     });
   });
 
   equal(channelOpen.transaction_id.length, txIdHexLength, 'Channel tx id');
   equal(channelOpen.transaction_vout, defaultVout, 'Channel tx output index');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_open_channels.js

@@ -1,13 +1,14 @@
 const asyncRetry = require('async/retry');
 const {extractTransaction} = require('psbt');
 const {finalizePsbt} = require('psbt');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 const {transactionAsPsbt} = require('psbt');
 
 const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
 const {fundPendingChannels} = require('./../../');
+const {getChainBalance} = require('./../../');
 const {getChainTransactions} = require('./../../');
 const {getChannels} = require('./../../');
 const {getPeers} = require('./../../');
@@ -16,99 +17,98 @@ const {sendToChainAddresses} = require('./../../');
 
 const capacity = 1e6;
 const count = 10;
-const interval = 200;
+const interval = 1;
 const race = promises => Promise.race(promises);
+const size = 3;
 const timeout = 250 * 10;
-const times = 100;
+const times = 200;
 
 // Opening channels should open up channels
 test(`Open channels`, async ({end, equal}) => {
-  await asyncRetry({interval, times}, async () => {
-    const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-    try {
-      const {lnd} = cluster.control;
+  const [{generate, lnd}, target, remote] = nodes;
 
-      const chainTx = (await getChainTransactions({lnd})).transactions;
+  await asyncRetry({times}, async () => {
+    if (!(await getChainBalance({lnd})).chain_balance) {
+      await generate({});
 
-      const spending = chainTx.map(({transaction}) => transaction);
+      throw new Error('ExpectedChainBalanceToOpenChannel');
+    }
+  });
 
-      await addPeer({
-        lnd,
-        public_key: cluster.remote.public_key,
-        socket: cluster.remote.socket,
-      });
+  try {
+    const chainTx = (await getChainTransactions({lnd})).transactions;
 
-      const channels = [cluster.target, cluster.remote].map(node => ({
-        capacity,
-        partner_public_key: node.public_key,
-      }));
+    const spending = chainTx.map(({transaction}) => transaction);
 
-      let pending;
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-      // Wait for peers to be connected
-      await asyncRetry({interval, times}, async () => {
-        await addPeer({
-          lnd,
-          public_key: cluster.remote.public_key,
-          socket: cluster.remote.socket,
-        });
+    const channels = [target, remote].map(node => ({
+      capacity,
+      partner_public_key: node.id,
+    }));
 
-        if ((await getPeers({lnd})).peers.length !== channels.length) {
-          throw new Error('ExpectedConnectedPeersToOpenChannels');
-        }
+    let pending;
 
-        return;
-      });
+    // Wait for peers to be connected
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-      await asyncRetry({interval, times}, async () => {
-        pending = (await openChannels({channels, lnd})).pending;
-      });
+      if ((await getPeers({lnd})).peers.length !== channels.length) {
+        throw new Error('ExpectedConnectedPeersToOpenChannels');
+      }
 
-      // Normally funding would involve an un-broadcast transaction
-      await sendToChainAddresses({lnd, send_to: pending});
+      return;
+    });
 
-      await asyncRetry({interval, times}, async() => {
-        const {transactions} = await getChainTransactions({lnd});
+    await asyncRetry({interval, times}, async () => {
+      pending = (await openChannels({channels, lnd})).pending;
+    });
 
-        if (transactions.length !== pending.length) {
-          throw new Error('ExpectedMultipleChainTransactions');
-        }
+    // Normally funding would involve an un-broadcast transaction
+    await sendToChainAddresses({lnd, send_to: pending});
 
-        return;
-      });
+    await asyncRetry({interval, times}, async() => {
+      const {transactions} = await getChainTransactions({lnd});
 
-      const fundTx = (await getChainTransactions({lnd})).transactions
-        .map(({transaction}) => transaction)
-        .find(transaction => spending.find(spend => transaction !== spend));
+      if (transactions.length !== pending.length) {
+        throw new Error('ExpectedMultipleChainTransactions');
+      }
 
-      const fundingPsbt = transactionAsPsbt({spending, transaction: fundTx});
+      return;
+    });
 
-      const {psbt} = finalizePsbt({psbt: fundingPsbt.psbt});
+    const fundTx = (await getChainTransactions({lnd})).transactions
+      .map(({transaction}) => transaction)
+      .find(transaction => spending.find(spend => transaction !== spend));
 
-      const reconstitutedTransaction = extractTransaction({psbt});
+    const fundingPsbt = transactionAsPsbt({spending, transaction: fundTx});
 
-      await fundPendingChannels({
-        lnd,
-        channels: pending.map(({id}) => id),
-        funding: psbt,
-      });
+    const {psbt} = finalizePsbt({psbt: fundingPsbt.psbt});
 
-      await asyncRetry({interval, times}, async () => {
-        await cluster.generate({count});
+    const reconstitutedTransaction = extractTransaction({psbt});
 
-        const {channels} = await getChannels({lnd})
+    await fundPendingChannels({
+      lnd,
+      channels: pending.map(({id}) => id),
+      funding: psbt,
+    });
 
-        if (channels.filter(n => !!n.is_active).length !== pending.length) {
-          throw new Error('ExpectedNewChannelsCreatedAndActive');
-        }
+    await asyncRetry({interval, times}, async () => {
+      await generate({count});
 
-        return;
-      });
-    } finally {
-      return await cluster.kill({});
-    }
-  });
+      const {channels} = await getChannels({lnd});
+
+      if (channels.filter(n => !!n.is_active).length !== pending.length) {
+        throw new Error('ExpectedNewChannelsCreatedAndActive');
+      }
+
+      return;
+    });
+  } finally {
+    return await kill({});
+  }
 
   return end();
 });

package/test/integration/test_pay.js

@@ -1,5 +1,7 @@
 const {randomBytes} = require('crypto');
 
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {addPeer} = require('./../../');
@@ -22,42 +24,37 @@ const channelCapacityTokens = 1e6;
 const confirmationCount = 6;
 const defaultFee = 1e3;
 const defaultVout = 0;
+const interval = 10;
 const mtokPadding = '000';
 const reserveRatio = 0.99;
+const size = 3;
+const times = 1000;
 const tokens = 100;
 const txIdHexLength = 32 * 2;
 
 // Paying an invoice should settle the invoice
 test(`Pay`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [{generate, lnd}, target, remote] = nodes;
 
-  const channel = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    to: cluster.target,
-  });
+  const channel = await setupChannel({generate, lnd, to: target});
 
   const remoteChan = await setupChannel({
-    generate: cluster.generate,
-    generator: cluster.target,
-    lnd: cluster.target.lnd,
-    to: cluster.remote,
-  });
-
-  await addPeer({
-    lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
+    generate: target.generate,
+    lnd: target.lnd,
+    to: remote,
   });
 
-  await delay(3000);
+  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
 
-  const invoice = await createInvoice({tokens, lnd: cluster.remote.lnd});
+  const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
   const commitTxFee = channel.commit_transaction_fee;
-  const paid = await pay({lnd, request: invoice.request});
+
+  const paid = await asyncRetry({interval, times}, async () => {
+    return await pay({lnd, request: invoice.request});
+  });
 
   equal(paid.fee, 1, 'Fee paid for hop');
   equal(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
@@ -86,7 +83,7 @@ test(`Pay`, async ({end, equal, strictSame}) => {
       fee_mtokens: '1000',
       forward: 100,
       forward_mtokens: `${invoice.tokens}${mtokPadding}`,
-      public_key: cluster.target.public_key,
+      public_key: target.id,
     },
     {
       channel: remoteChan.id,
@@ -95,35 +92,41 @@ test(`Pay`, async ({end, equal, strictSame}) => {
       fee_mtokens: '0',
       forward: 100,
       forward_mtokens: '100000',
-      public_key: cluster.remote.public_key,
+      public_key: remote.id,
     },
   ];
 
   strictSame(paid.hops, expectedHops, 'Hops are returned');
 
-  const invoice2 = await createInvoice({lnd: cluster.remote.lnd, tokens: 100});
+  const invoice2 = await createInvoice({lnd: remote.lnd, tokens: 100});
 
   const {destination} = await decodePaymentRequest({
-    lnd: cluster.remote.lnd,
+    lnd: remote.lnd,
     request: invoice2.request,
   });
 
-  await cluster.generate({count: confirmationCount, node: cluster.control});
+  await generate({count: confirmationCount});
 
-  await delay(3000);
+  const route = await asyncRetry({interval, times}, async () => {
+    const {route} = await getRouteToDestination({
+      destination,
+      lnd,
+      payment: invoice2.payment,
+      tokens: invoice2.tokens,
+      total_mtokens: !!invoice2.payment ? invoice2.mtokens : undefined,
+    });
 
-  const {route} = await getRouteToDestination({
-    destination,
-    lnd,
-    payment: invoice2.payment,
-    tokens: invoice2.tokens,
-    total_mtokens: !!invoice2.payment ? invoice2.mtokens : undefined,
+    if (!route) {
+      throw new Error('ExpectedRouteToDestination');
+    }
+
+    return route;
   });
 
   // Test paying to a route, but to an id that isn't known
   try {
     await pay({
-      lnd: cluster.control.lnd,
+      lnd,
       path: {routes: [route], id: randomBytes(32).toString('hex')},
     });
   } catch (err) {
@@ -135,15 +138,15 @@ test(`Pay`, async ({end, equal, strictSame}) => {
 
   // Test paying regularly to a destination
   const directPay = await pay({
-    lnd: cluster.control.lnd,
+    lnd,
     path: {routes: [route], id: invoice2.id},
   });
 
-  const zeroInvoice = await createInvoice({lnd: cluster.target.lnd});
+  const zeroInvoice = await createInvoice({lnd: target.lnd});
 
   await pay({lnd, request: zeroInvoice.request, mtokens: '1000'});
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_pay_private_invoice.js

@@ -1,102 +1,108 @@
 const {randomBytes} = require('crypto');
 
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {addPeer} = require('./../../');
-const {createCluster} = require('./../macros');
+const {cancelHodlInvoice} = require('./../../');
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
-const {delay} = require('./../macros');
 const {getChannel} = require('./../../');
 const {getChannels} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getRouteToDestination} = require('./../../');
 const {openChannel} = require('./../../');
+const {parsePaymentRequest} = require('./../../');
 const {pay} = require('./../../');
+const {removePeer} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {waitForChannel} = require('./../macros');
 const {waitForPendingChannel} = require('./../macros');
 
 const channelCapacityTokens = 1e6;
 const confirmationCount = 6;
+const count = 100;
 const defaultFee = 1e3;
 const defaultVout = 0;
+const interval = 10;
 const mtokPadding = '000';
 const reserveRatio = 0.99;
+const size = 3;
+const times = 1000;
 const tokens = 100;
 const txIdHexLength = 32 * 2;
 
 // Paying a private invoice should settle the invoice
 test(`Pay private invoice`, async ({end, equal, strictSame}) => {
-  const cluster = await createCluster({});
-
-  const {lnd} = cluster.control;
-  const remoteLnd = cluster.remote.lnd;
-
-  await addPeer({
-    lnd,
-    public_key: cluster.target.public_key,
-    socket: cluster.target.socket,
-  });
-
-  const channel = await setupChannel({
-    lnd,
-    generate: cluster.generate,
-    to: cluster.target,
-  });
-
-  await addPeer({
-    lnd: cluster.target.lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
-  });
-
-  const remoteChannel = await setupChannel({
-    capacity: channelCapacityTokens,
-    generate: cluster.generate,
-    generator: cluster.target,
-    hidden: true,
-    lnd: cluster.target.lnd,
-    to: cluster.remote,
-  });
-
-
-  await addPeer({
-    lnd,
-    public_key: cluster.remote.public_key,
-    socket: cluster.remote.socket,
-  });
-
-  await cluster.generate({count: confirmationCount, node: cluster.target});
-
-  const invoice = await createInvoice({
-    tokens,
-    is_including_private_channels: true,
-    lnd: cluster.remote.lnd,
-  });
-
-  const {id} = invoice;
-  const {request} = invoice;
-
-  const decodedRequest = await decodePaymentRequest({lnd, request});
-
-  const {route} = await getRouteToDestination({
-    lnd,
-    destination: decodedRequest.destination,
-    payment: invoice.payment,
-    routes: decodedRequest.routes,
-    tokens: invoice.tokens,
-    total_mtokens: !!invoice.payment ? invoice.mtokens : undefined,
-  });
-
-  const payment = await pay({lnd, path: {id, routes: [route]}});
-
-  const paidInvoice = await getInvoice({id, lnd: cluster.remote.lnd});
-
-  equal(paidInvoice.secret, invoice.secret, 'Paying invoice got secret');
-  equal(paidInvoice.is_confirmed, true, 'Private invoice is paid');
-
-  await cluster.kill({});
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  try {
+    const [{generate, lnd}, target, remote] = nodes;
+
+    await generate({count: 400});
+
+    const channel = await setupChannel({generate, lnd, to: target});
+
+    const remoteChannel = await setupChannel({
+      capacity: channelCapacityTokens,
+      generate: target.generate,
+      hidden: true,
+      lnd: target.lnd,
+      to: remote,
+    });
+
+    const invoice = await asyncRetry({interval, times}, async () => {
+      const invoice = await createInvoice({
+        tokens,
+        is_including_private_channels: true,
+        lnd: remote.lnd,
+      });
+
+      const {routes} = parsePaymentRequest({request: invoice.request});
+
+      // Wait for private routes to get picked up
+      if (!routes) {
+        await cancelHodlInvoice({id: invoice.id, lnd: remote.lnd});
+
+        throw new Error('ExpectedRouteForInvoice');
+      }
+
+      return invoice;
+    });
+
+    const {id} = invoice;
+    const {request} = invoice;
+
+    const decodedRequest = await decodePaymentRequest({lnd, request});
+
+    const route = await asyncRetry({interval: 10, times: 1000}, async () => {
+      const {route} = await getRouteToDestination({
+        lnd,
+        destination: decodedRequest.destination,
+        payment: invoice.payment,
+        routes: decodedRequest.routes,
+        tokens: invoice.tokens,
+        total_mtokens: !!invoice.payment ? invoice.mtokens : undefined,
+      });
+
+      if (!route) {
+        throw new Error('ExpectedRouteToDestination');
+      }
+
+      return route;
+    });
+
+    const payment = await pay({lnd, path: {id, routes: [route]}});
+
+    const paidInvoice = await getInvoice({id, lnd: remote.lnd});
+
+    equal(paidInvoice.secret, invoice.secret, 'Paying invoice got secret');
+    equal(paidInvoice.is_confirmed, true, 'Private invoice is paid');
+  } catch (err) {
+    equal(err, null, 'Expected no error paying invoice');
+  }
+
+  await kill({});
 
   return end();
 });

package/test/integration/test_payment_errors.js

@@ -2,9 +2,9 @@ const asyncRetry = require('async/retry');
 const {decodeChanId} = require('bolt07');
 const {hopsFromChannels} = require('bolt07');
 const {routeFromHops} = require('bolt07');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {delay} = require('./../macros');
 const {getChannel} = require('./../../');
@@ -16,28 +16,30 @@ const {setupChannel} = require('./../macros');
 
 const interval = retryCount => 50 * Math.pow(2, retryCount);
 const mtok = '000';
+const size = 2;
 const times = 15;
 const tokens = 1e3;
 
 // Encountering errors in payment should return valid error codes
 test('Payment errors', async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
+
+  const {lnd} = control;
 
   // Create a channel from the control to the target node
   const controlToTargetChannel = await setupChannel({
     lnd,
-    generate: cluster.generate,
-    to: cluster.target,
+    generate: control.generate,
+    to: target,
   });
 
   // Create a channel from the target back to the control
   const targetToControlChannel = await setupChannel({
-    generate: cluster.generate,
-    generator: cluster.target,
-    lnd: cluster.target.lnd,
-    to: cluster.control,
+    generate: target.generate,
+    lnd: target.lnd,
+    to: control,
   });
 
   const height = (await getHeight({lnd})).current_block_height;
@@ -49,7 +51,7 @@ test('Payment errors', async ({end, equal}) => {
 
   const [inChanId, outChanId] = channels.map(({id}) => id).sort();
 
-  const destination = (await getIdentity({lnd})).public_key;
+  const destination = control.id;
 
   try {
     let route;
@@ -93,7 +95,7 @@ test('Payment errors', async ({end, equal}) => {
     }
   }
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });