ln-service 52.14.4 → 53.0.0

package/test/integration/test_decode_payment_request.js

@@ -1,10 +1,9 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
 const {getIdentity} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const tests = [
   {
@@ -23,33 +22,35 @@ const tests = [
 
 tests.forEach(({description, expected}) => {
   return test(description, async ({end, equal}) => {
-    const {kill, lnd} = await spawnLnd({});
-
-    const {request} = await createInvoice({
-      lnd,
-      cltv_delta: expected.cltv_delta,
-      description: expected.description,
-      secret: expected.secret,
-      tokens: expected.tokens,
-    });
-
-    const decoded = await decodePaymentRequest({lnd, request});
-
-    equal(decoded.chain_addresses, expected.chain_addresses, 'Chain address');
-    equal(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv delta');
-    equal(!!decoded.created_at, true, 'Created at date');
-    equal(decoded.description, expected.description, 'Decode description');
-    equal(decoded.description_hash, expected.description_hash, 'Desc hash');
-    equal(decoded.destination, (await getIdentity({lnd})).public_key, 'Pk');
-    equal(!!decoded.expires_at, true, 'Expiration date decoded');
-    equal(decoded.id, expected.id, 'Decoded payment hash');
-    equal(decoded.mtokens, expected.mtokens, 'Decode millitokens');
-    equal(decoded.safe_tokens, expected.safe_tokens, 'Decode safe amount');
-    equal(decoded.tokens, expected.tokens, 'Decode tokens amount');
-
-    kill();
-
-    await waitForTermination({lnd});
+    const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
+
+    try {
+      const {request} = await createInvoice({
+        lnd,
+        cltv_delta: expected.cltv_delta,
+        description: expected.description,
+        secret: expected.secret,
+        tokens: expected.tokens,
+      });
+
+      const decoded = await decodePaymentRequest({lnd, request});
+
+      equal(decoded.chain_addresses, expected.chain_addresses, 'Chain addr');
+      equal(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv delta');
+      equal(!!decoded.created_at, true, 'Created at date');
+      equal(decoded.description, expected.description, 'Decode description');
+      equal(decoded.description_hash, expected.description_hash, 'Desc hash');
+      equal(decoded.destination, (await getIdentity({lnd})).public_key, 'Pk');
+      equal(!!decoded.expires_at, true, 'Expiration date decoded');
+      equal(decoded.id, expected.id, 'Decoded payment hash');
+      equal(decoded.mtokens, expected.mtokens, 'Decode millitokens');
+      equal(decoded.safe_tokens, expected.safe_tokens, 'Decode safe amount');
+      equal(decoded.tokens, expected.tokens, 'Decode tokens amount');
+    } catch (err) {
+      equal(err, null, 'Expected no error');
+    }
+
+    await kill({});
 
     return end();
   });

package/test/integration/test_delete_payment.js

@@ -1,23 +1,26 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {deletePayment} = require('./../../');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
 const tokens = 100;
 
 // Deleting a payment should delete the payment record
 test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  const {lnd} = control;
 
-  const invoice = await createInvoice({tokens, lnd: cluster.target.lnd});
+  await setupChannel({lnd, generate: control.generate, to: target});
+
+  const invoice = await createInvoice({tokens, lnd: target.lnd});
 
   let paid;
 
@@ -26,7 +29,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
   } catch (err) {
     fail('Payment should be made to destination');
 
-    await cluster.kill({});
+    await kill({});
 
     return end();
   }
@@ -39,7 +42,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
   } catch (err) {
     strictSame(err, [501, 'DeletePaymentMethodNotSupported']);
 
-    await cluster.kill({});
+    await kill({});
 
     return end();
   }
@@ -48,7 +51,7 @@ test('Delete payment', async ({afterEach, fail, end, equal, strictSame}) => {
 
   equal(priorLength - wipedLength, [paid].length, 'Payment deleted');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_delete_payments.js

@@ -1,35 +1,32 @@
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {deletePayments} = require('./../../');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
+const times = 1000;
 const tokens = 100;
 
 // Deleting payments should delete all payments
 test('Delete payments', async ({afterEach, fail, end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.control;
+  const [control, target] = nodes;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  const {generate, lnd} = control;
 
-  const invoice = await createInvoice({tokens, lnd: cluster.target.lnd});
+  await setupChannel({generate, lnd, to: target});
 
-  let paid;
+  const invoice = await createInvoice({tokens, lnd: target.lnd});
 
-  try {
-    paid = await pay({lnd, request: invoice.request});
-  } catch (err) {
-    fail('Payment should be made to destination');
-
-    await cluster.kill({});
-
-    return end();
-  }
+  const paid = await asyncRetry({times}, async () => {
+    return await pay({lnd, request: invoice.request});
+  });
 
   const priorLength = (await getPayments({lnd})).payments.length;
 
@@ -39,7 +36,7 @@ test('Delete payments', async ({afterEach, fail, end, equal}) => {
 
   equal(priorLength - wipedLength, [paid].length, 'Payment history deleted');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_access_ids.js

@@ -1,19 +1,18 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {authenticatedLndGrpc} = require('./../../');
 const {getAccessIds} = require('./../../');
 const {grantAccess} = require('./../../');
 const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const defaultId = '0';
 const id = '1';
 
 // Getting access ids should return root macaroon ids
 test(`Get access ids`, async ({end, equal, rejects, strictSame}) => {
-  const spawned = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const {lnd, kill} = spawned;
+  const [{lnd}] = nodes;
 
   await grantAccess({id, lnd, is_ok_to_create_chain_addresses: true});
 
@@ -30,9 +29,7 @@ test(`Get access ids`, async ({end, equal, rejects, strictSame}) => {
     }
   }
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_backup.js

@@ -1,22 +1,26 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {getBackup} = require('./../../');
 const {setupChannel} = require('./../macros');
 const {verifyBackup} = require('./../../');
 
+const size = 2;
+
 // Getting a channel backup should return a channel backup
 test(`Get channel backup`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = nodes;
 
   const channel = await setupChannel({
-    generate: cluster.generate,
-    lnd: cluster.control.lnd,
-    to: cluster.target,
+    generate: control.generate,
+    lnd: control.lnd,
+    to: target,
   });
 
   const {backup} = await getBackup({
-    lnd: cluster.control.lnd,
+    lnd: control.lnd,
     transaction_id: channel.transaction_id,
     transaction_vout: channel.transaction_vout,
   });
@@ -25,14 +29,14 @@ test(`Get channel backup`, async ({end, equal}) => {
 
   const channelBackup = await verifyBackup({
     backup,
-    lnd: cluster.control.lnd,
+    lnd: control.lnd,
     transaction_id: channel.transaction_id,
     transaction_vout: channel.transaction_vout,
   });
 
   equal(channelBackup.is_valid, true, 'Channel backup is a valid backup');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_backups.js

@@ -1,22 +1,20 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {getBackups} = require('./../../');
 const {setupChannel} = require('./../macros');
 
+const size = 2;
+
 // Getting a set of channel backups should return channel backups
 test(`Get channel backup`, async ({end, equal}) => {
   await asyncRetry({}, async () => {
-    const cluster = await createCluster({is_remote_skipped: true});
+    const {kill, nodes} = await spawnLightningCluster({size});
 
-    const {lnd} = cluster.control;
+    const [{generate, lnd}, target] = nodes;
 
-    const channel = await setupChannel({
-      lnd,
-      generate: cluster.generate,
-      to: cluster.target,
-    });
+    const channel = await setupChannel({generate, lnd, to: target});
 
     const {backup, channels} = await getBackups({lnd});
 
@@ -26,10 +24,10 @@ test(`Get channel backup`, async ({end, equal}) => {
     const [chanBackup] = channels;
 
     equal(!!chanBackup.backup.length, true, 'Channel backup has its own blob');
-    equal(chanBackup.transaction_id, channel.transaction_id, 'Chan tx id given');
+    equal(chanBackup.transaction_id, channel.transaction_id, 'Chan tx id');
     equal(chanBackup.transaction_vout, channel.transaction_vout, 'Chan vout');
 
-    await cluster.kill({});
+    await kill({});
 
     return;
   });

package/test/integration/test_get_chain_balance.js

@@ -1,37 +1,19 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {chainSendTransaction} = require('./../macros');
-const {createChainAddress} = require('./../../');
-const {generateBlocks} = require('./../macros');
 const {getChainBalance} = require('./../../');
-const {mineTransaction} = require('./../macros');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
-const {waitForUtxo} = require('./../macros');
 
-const count = 100;
-const defaultFee = 1e3;
-const defaultVout = 0;
 const emptyChainBalance = 0;
-const format = 'np2wpkh';
-const interval = retryCount => 50 * Math.pow(2, retryCount);
-const times = 15;
-const tokens = 1e8;
+const interval = 1;
+const times = 150;
+const tokens = 5000000000;
 
 // Getting chain balance should result in a chain balance
 test(`Get the chain balance`, async ({end, equal}) => {
-  const node = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const cert = node.chain_rpc_cert_file;
-  const host = node.listen_ip;
-  const {kill} = node;
-  const pass = node.chain_rpc_pass;
-  const port = node.chain_rpc_port;
-  const {lnd} = node;
-  const user = node.chain_rpc_user;
-
-  const {address} = await createChainAddress({format, lnd});
+  const [{generate, lnd}] = nodes;
 
   // The initial chain balance should be zero
   {
@@ -41,40 +23,14 @@ test(`Get the chain balance`, async ({end, equal}) => {
   }
 
   // Generate some funds for LND
-  const {blocks} = await node.generate({count});
-
-  const [block] = blocks;
-
-  const [coinbaseTransaction] = block.transaction_ids;
-
-  const {transaction} = chainSendTransaction({
-    tokens,
-    destination: address,
-    fee: defaultFee,
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransaction,
-    spend_vout: defaultVout,
-  });
-
-  // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    await mineTransaction({cert, host, pass, port, transaction, user});
-
-    if (!(await getChainBalance({lnd})).chain_balance) {
-      throw new Error('ExpectedChainBalanceReflected');
-    }
-
-    return;
-  });
+  await generate({count: 100});
 
   // Check that the balance is updated
   const postDeposit = await getChainBalance({lnd});
 
-  equal(postDeposit.chain_balance, tokens - defaultFee, 'Deposited funds');
-
-  kill();
+  equal(postDeposit.chain_balance >= tokens, true, 'Got funds');
 
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_chain_fee_estimate.js

@@ -1,27 +1,38 @@
-const {address} = require('bitcoinjs-lib');
+const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {createChainAddress} = require('./../../');
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
+const {getChainBalance} = require('./../../');
 const {getChainFeeEstimate} = require('./../../');
 
-const expectedFee = 9750;
+const expectedFee = 8650;
 const expectedFeeRate = 50;
-const format = 'p2wpkh';
+const format = 'np2wpkh';
+const size = 2;
+const times = 200;
 const tokens = 1e6;
 
 // Getting a chain fee estimate should return an estimate of the chain fee
 test(`Get chain fee estimate`, async ({end, equal}) => {
-  const cluster = await createCluster({is_remote_skipped: true});
+  const {kill, nodes} = await spawnLightningCluster({size});
 
-  const {lnd} = cluster.target;
+  const [control, {lnd}] = nodes;
 
-  const address1 = (await createChainAddress({format, lnd})).address;
+  const address1 = (await createChainAddress({lnd})).address;
   const address2 = (await createChainAddress({format, lnd})).address;
 
+  // Generate coins for the node
+  await asyncRetry({times}, async () => {
+    if (!(await getChainBalance({lnd: control.lnd})).chain_balance) {
+      await control.generate({});
+
+      throw new Error('ExpectedChainBalance');
+    }
+  });
+
   const estimate = await getChainFeeEstimate({
-    lnd: cluster.control.lnd,
+    lnd: control.lnd,
     send_to: [
       {address: address1, tokens: tokens / [address1, address2].length},
       {address: address2, tokens: tokens / [address1, address2].length},
@@ -31,7 +42,7 @@ test(`Get chain fee estimate`, async ({end, equal}) => {
   equal(estimate.fee, expectedFee, 'Total fee is estimated');
   equal(estimate.tokens_per_vbyte, expectedFeeRate, 'Fee per vbyte is given');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_chain_transactions.js

@@ -1,62 +1,35 @@
 const asyncRetry = require('async/retry');
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {chainSendTransaction} = require('./../macros');
-const {createChainAddress} = require('./../../');
-const {delay} = require('./../macros');
-const {generateBlocks} = require('./../macros');
 const {getChainBalance} = require('./../../');
 const {getChainTransactions} = require('./../../');
-const {getWalletVersion} = require('./../../');
-const {mineTransaction} = require('./../macros');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
-const {waitForUtxo} = require('./../macros');
+const {getWalletInfo} = require('./../../');
 
 const count = 100;
 const defaultFee = 1e3;
-const defaultVout = 0;
-const emptyChainBalance = 0;
 const format = 'np2wpkh';
-const interval = retryCount => 10 * Math.pow(2, retryCount);
-const times = 20;
-const tokens = 1e8;
+const times = 300;
 
 // Getting chain transactions should list out the chain transactions
-test(`Get chain transactions`, async ({end, equal, fail, strictSame}) => {
-  const node = await spawnLnd({});
+test(`Get chain transactions`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({});
 
-  const cert = node.chain_rpc_cert_file;
-  const host = node.listen_ip;
-  const {kill} = node;
-  const pass = node.chain_rpc_pass;
-  const port = node.chain_rpc_port;
-  const {lnd} = node;
-  const user = node.chain_rpc_user;
-
-  const {address} = await createChainAddress({format, lnd});
+  const [{generate, lnd}] = nodes;
 
   // Generate some funds for LND
-  const {blocks} = await node.generate({count});
-
-  const [block] = blocks;
+  await generate({count});
 
-  const [coinbaseTransaction] = block.transaction_ids;
+  await asyncRetry({interval: 10, times: 1000}, async () => {
+    const wallet = await getWalletInfo({lnd});
 
-  const {transaction} = chainSendTransaction({
-    tokens,
-    destination: address,
-    fee: defaultFee,
-    private_key: node.mining_key,
-    spend_transaction_id: coinbaseTransaction,
-    spend_vout: defaultVout,
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('ExpectedWalletSyncedToChain');
+    }
   });
 
   // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    // Generate to confirm the tx
-    await mineTransaction({cert, host, pass, port, transaction, user});
-
+  await asyncRetry({times}, async () => {
     const {transactions} = await getChainTransactions({lnd});
 
     const [tx] = transactions;
@@ -70,16 +43,22 @@ test(`Get chain transactions`, async ({end, equal, fail, strictSame}) => {
 
   const {transactions} = await getChainTransactions({lnd});
 
-  equal(transactions.length, [transaction].length, 'Transaction found');
+  equal(transactions.length > 1, true, 'Transaction found');
 
   const [tx] = transactions;
 
+  equal(!!tx.block_id, true, 'Transaction has block id');
+  equal(!!tx.confirmation_count, true, 'Transaction confirm count');
+  equal(!!tx.confirmation_height, true, 'Transaction confirm height');
+  equal(!!tx.created_at, true, 'Transaction record create time');
+  equal(tx.description, undefined, 'No tx description');
+  equal(tx.fee, undefined, 'No transaction fee');
+  equal(!!tx.id, true, 'Transaction id');
   equal(tx.is_confirmed, true, 'Transaction is confirmed');
   equal(tx.is_outgoing, false, 'Transaction is incoming');
-  strictSame(tx.output_addresses, [address], 'Address is returned');
-  equal(tx.tokens, tokens - defaultFee, 'Chain tokens are returned');
-
-  const wallet = await getWalletVersion({lnd});
+  equal(tx.output_addresses.length, 1, 'Tx output address');
+  equal(tx.tokens, 5000000000, 'Got coinbase reward tokens');
+  equal(!!tx.transaction, true, 'Got transaction hex');
 
   const onlyAfter = await getChainTransactions({
     lnd,
@@ -88,10 +67,11 @@ test(`Get chain transactions`, async ({end, equal, fail, strictSame}) => {
 
   equal(onlyAfter.transactions.length, [].length, 'No transactions after');
 
-  const onlyBefore = await getChainTransactions({
-    lnd,
-    before: tx.confirmation_height,
-  });
+  const [height] = transactions
+    .map(n => n.confirmation_height)
+    .sort((a, b) => a - b);
+
+  const onlyBefore = await getChainTransactions({lnd, before: height});
 
   equal(onlyBefore.transactions.length, [].length, 'No tx before');
 
@@ -103,9 +83,7 @@ test(`Get chain transactions`, async ({end, equal, fail, strictSame}) => {
 
   strictSame(between.transactions.length, [tx].length, 'One transaction');
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_channel.js

@@ -1,27 +1,27 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {createCluster} = require('./../macros');
 const {getChannel} = require('./../../');
 const {getChannels} = require('./../../');
 const {setupChannel} = require('./../macros');
 
-const confirmationCount = 20;
 const {ceil} = Math;
+const size = 2;
 
 // Getting a channel should return channel details from the channel graph
 test(`Get 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;
 
-  await setupChannel({lnd, generate: cluster.generate, to: cluster.target});
+  await setupChannel({generate, lnd, to: target});
 
   const [channel] = (await getChannels({lnd})).channels;
 
   const details = await getChannel({lnd, id: channel.id});
 
   equal(details.capacity, channel.capacity, 'Capacity');
-  equal(details.policies.length, [cluster.control, cluster.target].length);
+  equal(details.policies.length, size, 'Policies for both nodes');
 
   details.policies.forEach(policy => {
     equal(policy.base_fee_mtokens, '1000', 'Base fee mtokens');
@@ -41,7 +41,7 @@ test(`Get channel`, async ({end, equal}) => {
 
   equal(Date.now() - new Date(details.updated_at) < 1e5, true, 'Updated at');
 
-  await cluster.kill({});
+  await kill({});
 
   return end();
 });

package/test/integration/test_get_channel_balance.js

@@ -1,22 +1,21 @@
+const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
 const {getChannelBalance} = require('./../../');
-const {spawnLnd} = require('./../macros');
-const {waitForTermination} = require('./../macros');
 
 const emptyBalance = 0;
 
 // Getting channel balance should result in a channel balance
 test(`Get the channel balance`, async ({end, equal}) => {
-  const {kill, lnd} = await spawnLnd({});
+  const {kill, nodes} = await spawnLightningCluster({});
+
+  const [{lnd}] = nodes;
 
   const result = await getChannelBalance({lnd});
 
   equal(result.channel_balance, emptyBalance, 'Valid channel balance');
 
-  kill();
-
-  await waitForTermination({lnd});
+  await kill({});
 
   return end();
 });