ln-service 56.7.1 → 56.8.1

package/test/integration/test_create_invoice.js

@@ -1,28 +1,32 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
 const {parsePaymentRequest} = require('./../../');
 
+const count = 100;
+
 // createInvoice should result in a created invoice
-test(`Create an invoice`, async ({end, equal}) => {
+test(`Create an invoice`, async () => {
   const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
-  await generate({count: 100});
+  await generate({count});
 
   try {
     const invoice = await createInvoice({lnd});
 
     const parsed = parsePaymentRequest({request: invoice.request});
 
-    equal(invoice.chain_address, undefined, 'Default address is undefined');
-    equal(invoice.created_at, parsed.created_at, 'Invoice has created date');
-    equal(invoice.description, undefined, 'Default description is undefined');
-    equal(invoice.id, parsed.id, 'Invoice has id');
-    equal(invoice.mtokens, '0', 'Default mtokens are 0');
-    equal(!!invoice.request, true, 'Invoice has request');
-    equal(!!invoice.secret, true, 'Invoice returns secret');
-    equal(invoice.tokens, 0, 'Default tokens are 0');
+    strictEqual(invoice.chain_address, undefined, 'Address is undefined');
+    strictEqual(invoice.created_at, parsed.created_at, 'Invoice created date');
+    strictEqual(invoice.description, undefined, 'Description undefined');
+    strictEqual(invoice.id, parsed.id, 'Invoice has id');
+    strictEqual(invoice.mtokens, '0', 'Default mtokens are 0');
+    strictEqual(!!invoice.request, true, 'Invoice has request');
+    strictEqual(!!invoice.secret, true, 'Invoice returns secret');
+    strictEqual(invoice.tokens, 0, 'Default tokens are 0');
 
     try {
       const duplicate = await createInvoice({lnd, secret: invoice.secret});
@@ -31,15 +35,15 @@ test(`Create an invoice`, async ({end, equal}) => {
     } catch (err) {
       const [code, message] = err;
 
-      equal(code, 409, 'Got expected error code');
-      equal(message, 'InvoiceWithGivenHashAlreadyExists', 'Got expected msg');
+      strictEqual(code, 409, 'Got expected error code');
+      strictEqual(message, 'InvoiceWithGivenHashAlreadyExists', 'Got msg');
     }
 
   } catch (err) {
-    equal(err, null, 'Expected no error in create invoice');
+    strictEqual(err, null, 'Expected no error in create invoice');
   }
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_decode_payment_request.js

@@ -1,5 +1,7 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {createInvoice} = require('./../../');
 const {decodePaymentRequest} = require('./../../');
@@ -21,7 +23,7 @@ const tests = [
 ];
 
 tests.forEach(({description, expected}) => {
-  return test(description, async ({end, equal}) => {
+  return test(description, async () => {
     const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
     try {
@@ -34,24 +36,25 @@ tests.forEach(({description, expected}) => {
       });
 
       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');
+      const identity = (await getIdentity({lnd})).public_key;
+
+      strictEqual(decoded.chain_addresses, expected.chain_addresses, 'Addr');
+      strictEqual(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv');
+      strictEqual(!!decoded.created_at, true, 'Created at date');
+      strictEqual(decoded.description, expected.description, 'Decode desc');
+      strictEqual(decoded.description_hash, expected.description_hash, 'Hash');
+      strictEqual(decoded.destination, identity, 'Got public key');
+      strictEqual(!!decoded.expires_at, true, 'Expiration date decoded');
+      strictEqual(decoded.id, expected.id, 'Decoded payment hash');
+      strictEqual(decoded.mtokens, expected.mtokens, 'Decode millitokens');
+      strictEqual(decoded.safe_tokens, expected.safe_tokens, 'Safe amount');
+      strictEqual(decoded.tokens, expected.tokens, 'Decode tokens amount');
     } catch (err) {
-      equal(err, null, 'Expected no error');
+      strictEqual(err, null, 'Expected no error');
     }
 
     await kill({});
 
-    return end();
+    return;
   });
 });

package/test/integration/test_delete_payment.js

@@ -1,57 +1,38 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
+const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 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}) => {
+test('Delete payment', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [control, target] = nodes;
-
-  const {lnd} = control;
+  const [{generate, lnd}, target] = nodes;
 
-  await setupChannel({lnd, generate: control.generate, to: target});
+  await setupChannel({generate, lnd, to: target});
 
   const invoice = await createInvoice({tokens, lnd: target.lnd});
 
-  let paid;
-
-  try {
-    paid = await pay({lnd, request: invoice.request});
-  } catch (err) {
-    fail('Payment should be made to destination');
-
-    await kill({});
-
-    return end();
-  }
+  const paid = await pay({lnd, request: invoice.request});
 
   const priorLength = (await getPayments({lnd})).payments.length;
 
-  // LND 0.13.4 and below do not support deletePayment
-  try {
-    await deletePayment({lnd, id: invoice.id});
-  } catch (err) {
-    strictSame(err, [501, 'DeletePaymentMethodNotSupported']);
-
-    await kill({});
-
-    return end();
-  }
+  await deletePayment({lnd, id: invoice.id});
 
   const wipedLength = (await getPayments({lnd})).payments.length;
 
-  equal(priorLength - wipedLength, [paid].length, 'Payment deleted');
+  strictEqual(priorLength - wipedLength, [paid].length, 'Payment deleted');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_delete_payments.js

@@ -1,24 +1,24 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const asyncRetry = require('async/retry');
+const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 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}) => {
+test('Delete payments', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [control, target] = nodes;
-
-  const {generate, lnd} = control;
+  const [{generate, lnd}, target] = nodes;
 
   await setupChannel({generate, lnd, to: target});
 
@@ -34,9 +34,9 @@ test('Delete payments', async ({afterEach, fail, end, equal}) => {
 
   const wipedLength = (await getPayments({lnd})).payments.length;
 
-  equal(priorLength - wipedLength, [paid].length, 'Payment history deleted');
+  strictEqual(priorLength - wipedLength, [paid].length, 'History deleted');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_delete_pending_channel.js

@@ -1,18 +1,16 @@
-const {once} = require('events');
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
 
 const asyncEach = require('async/each');
 const asyncRetry = require('async/retry');
 const asyncTimeout = require('async/timeout');
 const {extractTransaction} = require('psbt');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 const tinysecp = require('tiny-secp256k1');
 
 const {addPeer} = require('./../../');
 const {broadcastChainTransaction} = require('./../../');
 const {cancelPendingChannel} = require('./../../');
-const {createCluster} = require('./../macros');
-const {delay} = require('./../macros');
 const {deletePendingChannel} = require('./../../');
 const {fundPendingChannels} = require('./../../');
 const {fundPsbt} = require('./../../');
@@ -27,6 +25,7 @@ const {unlockUtxo} = require('./../../');
 
 const capacity = 1e6;
 const count = 100;
+const delay = n => new Promise(resolve => setTimeout(resolve, n));
 const description = 'description';
 const interval = 100;
 const race = promises => Promise.race(promises);
@@ -35,28 +34,15 @@ const timeout = 1000 * 20;
 const times = 2000;
 
 // Forfeiting a pending channel should remove the pending channel
-test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
+test(`Forfeit pending channel`, async () => {
   const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [control, target, remote] = nodes;
-
-  const {generate, lnd} = control;
-
-  try {
-    const {keys} = await getMasterPublicKeys({lnd});
-  } catch (err) {
-    // LND 0.13.3 and below should not be tested
-    strictSame(err, [501, 'GetMasterPublicKeysMethodNotSupported'], 'Got err');
-
-    await kill({});
-
-    return end();
-  }
+  const [{generate, lnd}, target, remote] = nodes;
 
   try {
-    await control.generate({count});
+    await generate({count});
 
     await asyncEach([target, remote], async node => {
       return await addPeer({lnd, public_key: node.id, socket: node.socket});
@@ -174,7 +160,7 @@ test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
     } catch (err) {
       const [code] = err;
 
-      equal(code, 503, 'Pending channel cannot be canceled');
+      deepStrictEqual(code, 503, 'Pending channel cannot be canceled');
     }
 
     try {
@@ -187,15 +173,15 @@ test(`Forfeit pending channel`, async ({end, equal, strictSame}) => {
 
       const [notPending] = (await getPendingChannels({lnd})).pending_channels;
 
-      equal(notPending, undefined, 'Conflicting pending channel deleted');
+      deepStrictEqual(notPending, undefined, 'Conflicting pending deleted');
     } catch (err) {
-      strictSame(err, [501, 'DeletePendingChannelMethodNotSupported']);
+      deepStrictEqual(err, [501, 'DeletePendingChannelMethodNotSupported']);
     }
   } catch (err) {
-    equal(err, null, 'No error is expected');
-  } finally {
-    await kill({});
+    deepStrictEqual(err, null, 'No error is expected');
   }
 
-  return end();
+  await kill({});
+
+  return;
 });

package/test/integration/test_get_access_ids.js

@@ -1,35 +1,27 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {getAccessIds} = require('./../../');
 const {grantAccess} = require('./../../');
-const {spawnLnd} = 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}) => {
+test(`Get access ids`, async () => {
   const {kill, nodes} = await spawnLightningCluster({});
 
   const [{lnd}] = nodes;
 
   await grantAccess({id, lnd, is_ok_to_create_chain_addresses: true});
 
-  try {
-    const {ids} = await getAccessIds({lnd});
-
-    strictSame(ids, [defaultId, id], 'Got expected access ids');
-  } catch (err) {
-    const [, type] = err;
+  const {ids} = await getAccessIds({lnd});
 
-    // Ignore failures on LND 0.11.0 and below
-    if (type !== 'ListRootMacaroonIdsMethodNotSupported') {
-      throw err;
-    }
-  }
+  deepStrictEqual(ids, [defaultId, id], 'Got expected access ids');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_backup.js

@@ -1,42 +1,40 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
+const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 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}) => {
+test(`Get channel backup`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [control, target] = nodes;
+  const [{generate, lnd}, target] = nodes;
 
-  const channel = await setupChannel({
-    generate: control.generate,
-    lnd: control.lnd,
-    to: target,
-  });
+  const channel = await setupChannel({generate, lnd, to: target});
 
   const {backup} = await getBackup({
-    lnd: control.lnd,
+    lnd,
     transaction_id: channel.transaction_id,
     transaction_vout: channel.transaction_vout,
   });
 
-  equal(!!backup, true, 'Channel backup is returned');
+  deepStrictEqual(!!backup, true, 'Channel backup is returned');
 
   const channelBackup = await verifyBackup({
     backup,
-    lnd: control.lnd,
+    lnd,
     transaction_id: channel.transaction_id,
     transaction_vout: channel.transaction_vout,
   });
 
-  equal(channelBackup.is_valid, true, 'Channel backup is a valid backup');
+  deepStrictEqual(channelBackup.is_valid, true, 'Is a valid backup');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_backups.js

@@ -1,14 +1,16 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const asyncRetry = require('async/retry');
+const {setupChannel} = require('ln-docker-daemons');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 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}) => {
+test(`Get channel backup`, async () => {
   await asyncRetry({}, async () => {
     const {kill, nodes} = await spawnLightningCluster({size});
 
@@ -18,19 +20,19 @@ test(`Get channel backup`, async ({end, equal}) => {
 
     const {backup, channels} = await getBackups({lnd});
 
-    equal(!!backup, true, 'Multi-backup blob is returned');
-    equal(channels.length, [channel].length, 'Individualized channel backup');
+    strictEqual(!!backup, true, 'Multi-backup blob is returned');
+    strictEqual(channels.length, [channel].length, 'Individualized backup');
 
     const [chanBackup] = channels;
 
-    equal(!!chanBackup.backup.length, true, 'Channel backup has its own blob');
-    equal(chanBackup.transaction_id, channel.transaction_id, 'Chan tx id');
-    equal(chanBackup.transaction_vout, channel.transaction_vout, 'Chan vout');
+    strictEqual(!!chanBackup.backup.length, true, 'Channel backup has blob');
+    strictEqual(chanBackup.transaction_id, channel.transaction_id, 'Chan id');
+    strictEqual(chanBackup.transaction_vout, channel.transaction_vout, 'Vout');
 
     await kill({});
 
     return;
   });
 
-  return end();
+  return;
 });

package/test/integration/test_get_chain_balance.js

@@ -1,12 +1,12 @@
-const asyncRetry = require('async/retry');
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {getChainBalance} = require('./../../');
 
+const count = 100;
 const emptyChainBalance = 0;
-const interval = 1;
-const times = 150;
 const tokens = 5000000000;
 
 // Getting chain balance should result in a chain balance
@@ -19,18 +19,18 @@ test(`Get the chain balance`, async ({end, equal}) => {
   {
     const result = await getChainBalance({lnd});
 
-    equal(result.chain_balance, emptyChainBalance, 'Valid chain balance');
+    strictEqual(result.chain_balance, emptyChainBalance, 'Got chain balance');
   }
 
   // Generate some funds for LND
-  await generate({count: 100});
+  await generate({count});
 
   // Check that the balance is updated
   const postDeposit = await getChainBalance({lnd});
 
-  equal(postDeposit.chain_balance >= tokens, true, 'Got funds');
+  strictEqual(postDeposit.chain_balance >= tokens, true, 'Got funds');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_chain_fee_estimate.js

@@ -1,6 +1,8 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {createChainAddress} = require('./../../');
 const {getChainBalance} = require('./../../');
@@ -14,7 +16,7 @@ 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}) => {
+test(`Get chain fee estimate`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, {lnd}] = nodes;
@@ -41,14 +43,14 @@ test(`Get chain fee estimate`, async ({end, equal}) => {
 
   // LND 0.15.4 and below uses P2WPKH as change
   if (estimate.fee === 8650) {
-    equal(estimate.fee, 8650, 'Total fee is estimated');
+    strictEqual(estimate.fee, 8650, 'Total fee is estimated');
   } else {
-    equal(estimate.fee, expectedFee, 'Total fee is estimated');
+    strictEqual(estimate.fee, expectedFee, 'Total fee is estimated');
   }
 
-  equal(estimate.tokens_per_vbyte, expectedFeeRate, 'Fee per vbyte is given');
+  strictEqual(estimate.tokens_per_vbyte, expectedFeeRate, 'Got fee per vbyte');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_chain_transactions.js

@@ -1,8 +1,9 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
-const {getChainBalance} = require('./../../');
 const {getChainTransactions} = require('./../../');
 const {getWalletInfo} = require('./../../');
 
@@ -12,7 +13,7 @@ const format = 'np2wpkh';
 const times = 300;
 
 // Getting chain transactions should list out the chain transactions
-test(`Get chain transactions`, async ({end, equal, strictSame}) => {
+test(`Get chain transactions`, async () => {
   const {kill, nodes} = await spawnLightningCluster({});
 
   const [{generate, lnd}] = nodes;
@@ -20,7 +21,7 @@ test(`Get chain transactions`, async ({end, equal, strictSame}) => {
   // Generate some funds for LND
   await generate({count});
 
-  await asyncRetry({interval: 10, times: 3000}, async () => {
+  await asyncRetry({interval: 10, times: 6000}, async () => {
     const wallet = await getWalletInfo({lnd});
 
     if (!wallet.is_synced_to_chain) {
@@ -47,29 +48,29 @@ test(`Get chain transactions`, async ({end, equal, strictSame}) => {
 
   const {transactions} = await getChainTransactions({lnd});
 
-  equal(transactions.length > 1, true, 'Transaction found');
+  strictEqual(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');
-  equal(tx.output_addresses.length, 1, 'Tx output address');
-  equal(tx.tokens, 5000000000, 'Got coinbase reward tokens');
-  equal(!!tx.transaction, true, 'Got transaction hex');
+  strictEqual(!!tx.block_id, true, 'Transaction has block id');
+  strictEqual(!!tx.confirmation_count, true, 'Transaction confirm count');
+  strictEqual(!!tx.confirmation_height, true, 'Transaction confirm height');
+  strictEqual(!!tx.created_at, true, 'Transaction record create time');
+  strictEqual(tx.description, undefined, 'No tx description');
+  strictEqual(tx.fee, undefined, 'No transaction fee');
+  strictEqual(!!tx.id, true, 'Transaction id');
+  strictEqual(tx.is_confirmed, true, 'Transaction is confirmed');
+  strictEqual(tx.is_outgoing, false, 'Transaction is incoming');
+  strictEqual(tx.output_addresses.length, 1, 'Tx output address');
+  strictEqual(tx.tokens, 5000000000, 'Got coinbase reward tokens');
+  strictEqual(!!tx.transaction, true, 'Got transaction hex');
 
   const onlyAfter = await getChainTransactions({
     lnd,
     after: tx.confirmation_height,
   });
 
-  equal(onlyAfter.transactions.length, [].length, 'No transactions after');
+  strictEqual(onlyAfter.transactions.length, [].length, 'No txs after');
 
   const [height] = transactions
     .map(n => n.confirmation_height)
@@ -77,7 +78,7 @@ test(`Get chain transactions`, async ({end, equal, strictSame}) => {
 
   const onlyBefore = await getChainTransactions({lnd, before: height});
 
-  equal(onlyBefore.transactions.length, [].length, 'No tx before');
+  strictEqual(onlyBefore.transactions.length, [].length, 'No tx before');
 
   const between = await getChainTransactions({
     lnd,
@@ -85,9 +86,9 @@ test(`Get chain transactions`, async ({end, equal, strictSame}) => {
     before: tx.confirmation_height + 1,
   });
 
-  strictSame(between.transactions.length, [tx].length, 'One transaction');
+  strictEqual(between.transactions.length, [tx].length, 'One transaction');
 
   await kill({});
 
-  return end();
+  return;
 });