ln-service 56.7.0 → 56.8.0

package/test/integration/test_get_channel_balance.js

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

package/test/integration/test_get_channels.js

@@ -1,9 +1,12 @@
+const {ok} = require('node:assert').strict;
+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 {getChannels} = require('./../../');
 const {getWalletInfo} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const anchorFeatureBit = 23;
 const giveTokens = 1e5;
@@ -11,7 +14,7 @@ const remoteCsv = 40;
 const size = 2;
 
 // Getting channels should return the list of channels
-test(`Get channels`, async ({end, equal, ok}) => {
+test(`Get channels`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target] = nodes;
@@ -19,7 +22,7 @@ test(`Get channels`, async ({end, equal, ok}) => {
   const chan = await setupChannel({
     generate,
     lnd,
-    give: giveTokens,
+    give_tokens: giveTokens,
     partner_csv_delay: remoteCsv,
     to: target,
   });
@@ -28,54 +31,54 @@ test(`Get channels`, async ({end, equal, ok}) => {
   const {features} = await getWalletInfo({lnd});
   const [targetChan] = (await getChannels({lnd: target.lnd})).channels;
 
-  equal(targetChan.is_partner_initiated, true, 'Self-init channel');
+  strictEqual(targetChan.is_partner_initiated, true, 'Self-init channel');
 
   if (!!channel.local_given) {
-    equal(channel.local_given, giveTokens, 'Push tokens are reflected');
-    equal(channel.remote_given, Number(), 'Push tokens are reflected');
+    strictEqual(channel.local_given, giveTokens, 'Push tokens are reflected');
+    strictEqual(channel.remote_given, Number(), 'Push tokens are reflected');
   }
 
   if (!!channel.remote_given) {
-    equal(channel.local_given, Number(), 'Push tokens are reflected');
-    equal(channel.remote_given, giveTokens, 'Push tokens are reflected');
+    strictEqual(channel.local_given, Number(), 'Push tokens are reflected');
+    strictEqual(channel.remote_given, giveTokens, 'Push tokens are reflected');
   }
 
   if (channel.remote_csv === remoteCsv) {
-    equal(channel.local_csv, 144, 'Local CSV is returned');
+    strictEqual(channel.local_csv, 144, 'Local CSV is returned');
     ok(channel.local_dust >= 354, 'Local dust limit is returned');
-    equal(channel.local_max_htlcs, 483, 'Local max htlcs are returned');
-    equal(channel.local_max_pending_mtokens, '990000000', 'Local max pending');
-    equal(channel.local_min_htlc_mtokens, '1000', 'Local min HTLC mtokens');
-    equal(channel.remote_csv, remoteCsv, 'Remote CSV is returned');
+    strictEqual(channel.local_max_htlcs, 483, 'Local max htlcs are returned');
+    strictEqual(channel.local_max_pending_mtokens, '990000000', 'Local max');
+    strictEqual(channel.local_min_htlc_mtokens, '1000', 'Local min mtokens');
+    strictEqual(channel.remote_csv, remoteCsv, 'Remote CSV is returned');
     ok(channel.remote_dust >= 354, 'Remote dust limit is returned');
-    equal(channel.remote_max_htlcs, 483, 'Remote max htlcs are returned');
-    equal(channel.remote_max_pending_mtokens, '990000000', 'Remote pending');
-    equal(channel.remote_min_htlc_mtokens, '1', 'Remote min HTLC mtokens');
+    strictEqual(channel.remote_max_htlcs, 483, 'Remote max htlcs returned');
+    strictEqual(channel.remote_max_pending_mtokens, '990000000', 'Remote');
+    strictEqual(channel.remote_min_htlc_mtokens, '1', 'Remote min HTLC');
   }
 
-  equal(channel.capacity, 1000000, 'Channel capacity');
-  equal(channel.commit_transaction_fee, 2810, 'Commit fee');
-  equal(channel.commit_transaction_weight, 1116, 'Commit weight');
-  equal(channel.id, chan.id, 'Channel id returned');
-  equal(channel.is_active, true, 'Channel active');
-  equal(channel.is_closing, false, 'Channel not closing');
-  equal(channel.is_opening, false, 'Channel not opening');
-  equal(channel.is_partner_initiated, false, 'Partner initiated channel');
-  equal(channel.is_private, false, 'Channel not private');
-  equal(channel.local_balance, 896530, 'Local balance');
-  equal(channel.local_reserve, 10000, 'Local reserve');
-  equal(channel.partner_public_key, target.id, 'Pubkey');
-  equal(channel.pending_payments.length, 0, 'No pending payments');
-  equal(channel.received, 0, 'Channel received');
-  equal(channel.remote_balance, 100000, 'Channel remote balance');
-  equal(channel.remote_reserve, 10000, 'Remote reserve amount');
-  equal(channel.sent, 0, 'Channel sent');
-  equal(channel.transaction_id, chan.transaction_id, 'Chan funding tx id');
-  equal(channel.transaction_vout, 0, 'Channel transactin vout');
-  equal(channel.type, 'anchor', 'Channel type is returned');
-  equal(channel.unsettled_balance, 0, 'Channel unsettled balance');
+  strictEqual(channel.capacity, 1000000, 'Channel capacity');
+  strictEqual(channel.commit_transaction_fee, 2810, 'Commit fee');
+  strictEqual(channel.commit_transaction_weight, 1116, 'Commit weight');
+  strictEqual(channel.id, chan.id, 'Channel id returned');
+  strictEqual(channel.is_active, true, 'Channel active');
+  strictEqual(channel.is_closing, false, 'Channel not closing');
+  strictEqual(channel.is_opening, false, 'Channel not opening');
+  strictEqual(channel.is_partner_initiated, false, 'Partner made channel');
+  strictEqual(channel.is_private, false, 'Channel not private');
+  strictEqual(channel.local_balance, 896530, 'Local balance');
+  strictEqual(channel.local_reserve, 10000, 'Local reserve');
+  strictEqual(channel.partner_public_key, target.id, 'Pubkey');
+  strictEqual(channel.pending_payments.length, 0, 'No pending payments');
+  strictEqual(channel.received, 0, 'Channel received');
+  strictEqual(channel.remote_balance, 100000, 'Channel remote balance');
+  strictEqual(channel.remote_reserve, 10000, 'Remote reserve amount');
+  strictEqual(channel.sent, 0, 'Channel sent');
+  strictEqual(channel.transaction_id, chan.transaction_id, 'Chan funding tx');
+  strictEqual(channel.transaction_vout, 0, 'Channel transactin vout');
+  strictEqual(channel.type, 'anchor', 'Channel type is returned');
+  strictEqual(channel.unsettled_balance, 0, 'Channel unsettled balance');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_closed_channels.js

@@ -1,28 +1,18 @@
+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 {closeChannel} = require('./../../');
-const {createChainAddress} = require('./../../');
-const {createCluster} = require('./../macros');
 const {createHodlInvoice} = require('./../../');
-const {delay} = require('./../macros');
-const {payViaPaymentRequest} = require('./../../');
-const {getChainTransactions} = require('./../../');
 const {getClosedChannels} = require('./../../');
-const {getLockedUtxos} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {getSweepTransactions} = require('./../../');
-const {getUtxos} = require('./../../');
 const {getWalletInfo} = require('./../../');
-const {sendToChainAddress} = require('./../../');
 const {settleHodlInvoice} = require('./../../');
-const {setupChannel} = require('./../macros');
 const {subscribeToInvoice} = require('./../../');
 const {subscribeToPayViaRequest} = require('./../../');
 
-const all = promise => Promise.all(promise);
-const confirmationCount = 6;
 const defaultFee = 1e3;
 const interval = 125;
 const maxChanTokens = Math.pow(2, 24) - 1;
@@ -30,22 +20,13 @@ const size = 2;
 const times = 1000;
 
 // Getting closed channels should return closed channels
-test(`Get closed channels`, async ({end, equal}) => {
+test(`Get closed channels`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target] = nodes;
 
   const {generate, lnd} = control;
 
-  try {
-    await getLockedUtxos({lnd});
-  } catch (err) {
-    // Skip test on LND 0.12 due to sweep timing
-    await kill({});
-
-    return end();
-  }
-
   const channelOpen = await setupChannel({
     generate,
     lnd,
@@ -80,39 +61,39 @@ test(`Get closed channels`, async ({end, equal}) => {
 
   const [channel] = channels;
 
-  equal(channels.length, [channelOpen].length, 'Channel close listed');
+  strictEqual(channels.length, [channelOpen].length, 'Channel close listed');
 
   const spend = maxChanTokens - channel.final_local_balance;
 
   // LND 0.11.1 and below do not use anchors
   if (isAnchors) {
-    equal([53345, 28473, 2810].includes(spend), true, 'Final');
+    strictEqual([53345, 28473, 2810].includes(spend), true, 'Final');
   } else {
-    equal(spend, 9050, 'Final');
+    strictEqual(spend, 9050, 'Final');
   }
 
-  equal(channel.capacity, maxChanTokens, 'Channel capacity reflected');
-  equal(!!channel.close_confirm_height, true, 'Channel close height');
-  equal(channel.close_transaction_id, closing.transaction_id, 'Close tx id');
-  equal(channel.final_time_locked_balance, 0, 'Final locked balance');
-  equal(!!channel.id, true, 'Channel id');
-  equal(channel.is_breach_close, false, 'Not breach close');
-  equal(channel.is_cooperative_close, true, 'Is cooperative close');
-  equal(channel.is_funding_cancel, false, 'Not funding cancel');
-  equal(channel.is_local_force_close, false, 'Not local force close');
-  equal(channel.is_partner_closed, false, 'Partner did not close the chan');
-  equal(channel.is_partner_initiated, false, 'Partner did not open channel');
-  equal(channel.is_remote_force_close, false, 'Not remote force close');
-  equal(channel.partner_public_key, target.id, 'Pubkey');
-  equal(channel.transaction_id, channelOpen.transaction_id, 'Channel tx id');
-  equal(channel.transaction_vout, channelOpen.transaction_vout, 'Chan vout');
+  strictEqual(channel.capacity, maxChanTokens, 'Channel capacity reflected');
+  strictEqual(!!channel.close_confirm_height, true, 'Channel close height');
+  strictEqual(channel.close_transaction_id, closing.transaction_id, 'Close');
+  strictEqual(channel.final_time_locked_balance, 0, 'Final locked balance');
+  strictEqual(!!channel.id, true, 'Channel id');
+  strictEqual(channel.is_breach_close, false, 'Not breach close');
+  strictEqual(channel.is_cooperative_close, true, 'Is cooperative close');
+  strictEqual(channel.is_funding_cancel, false, 'Not funding cancel');
+  strictEqual(channel.is_local_force_close, false, 'Not local force close');
+  strictEqual(channel.is_partner_closed, false, 'Partner did not close');
+  strictEqual(channel.is_partner_initiated, false, 'Partner did not open');
+  strictEqual(channel.is_remote_force_close, false, 'Not remote force close');
+  strictEqual(channel.partner_public_key, target.id, 'Pubkey');
+  strictEqual(channel.transaction_id, channelOpen.transaction_id, 'Channel');
+  strictEqual(channel.transaction_vout, channelOpen.transaction_vout, 'Vout');
 
   // Setup a force close to show force close channel output
   const toForceClose = await setupChannel({
     generate,
     lnd,
     capacity: 7e5,
-    give: 3e5,
+    give_tokens: 3e5,
     partner_csv_delay: 20,
     to: target,
   });
@@ -187,47 +168,47 @@ test(`Get closed channels`, async ({end, equal}) => {
 
   const forced = deadChans.find(n => !!n.is_remote_force_close);
 
-  equal(forced.capacity, 7e5, 'Got force close capacity');
-  equal(!!forced.close_balance_spent_by, true, 'Got a spend id');
-  equal(forced.close_balance_vout !== undefined, true, 'Got a spend vout');
-  equal(!!forced.close_confirm_height !== undefined, true, 'Confirm height');
-  equal(forced.close_payments.length, 2, '2 pending payments');
-  equal(!!forced.close_transaction_id, true, 'Got closed tx id');
-  equal(!!forced.final_local_balance, true, 'Got final balance');
-  equal(forced.final_time_locked_balance, 0, 'Got timelock balance');
-  equal(forced.id, toForceClose.id, 'Got closed channel id');
-  equal(forced.is_breach_close, false, 'Not a breach');
-  equal(forced.is_cooperative_close, false, 'Not a coop close');
-  equal(forced.is_funding_cancel, false, 'Not a cancel');
-  equal(forced.is_local_force_close, false, 'Not a local force close');
-  equal(forced.is_partner_closed, true, 'The remote closed');
-  equal(forced.is_partner_initiated, false, 'Local initiated');
-  equal(forced.is_remote_force_close, true, 'Remote force closed');
-  equal(forced.partner_public_key, target.id, 'Got remote public key');
-  equal(forced.transaction_id, toForceClose.transaction_id, 'Got txid');
-  equal(forced.transaction_vout, toForceClose.transaction_vout, 'Got vout');
+  strictEqual(forced.capacity, 7e5, 'Got force close capacity');
+  strictEqual(!!forced.close_balance_spent_by, true, 'Got a spend id');
+  strictEqual(forced.close_balance_vout !== undefined, true, 'Got a vout');
+  strictEqual(!!forced.close_confirm_height !== undefined, true, 'Height');
+  strictEqual(forced.close_payments.length, 2, '2 pending payments');
+  strictEqual(!!forced.close_transaction_id, true, 'Got closed tx id');
+  strictEqual(!!forced.final_local_balance, true, 'Got final balance');
+  strictEqual(forced.final_time_locked_balance, 0, 'Got timelock balance');
+  strictEqual(forced.id, toForceClose.id, 'Got closed channel id');
+  strictEqual(forced.is_breach_close, false, 'Not a breach');
+  strictEqual(forced.is_cooperative_close, false, 'Not a coop close');
+  strictEqual(forced.is_funding_cancel, false, 'Not a cancel');
+  strictEqual(forced.is_local_force_close, false, 'Not a local force close');
+  strictEqual(forced.is_partner_closed, true, 'The remote closed');
+  strictEqual(forced.is_partner_initiated, false, 'Local initiated');
+  strictEqual(forced.is_remote_force_close, true, 'Remote force closed');
+  strictEqual(forced.partner_public_key, target.id, 'Got remote public key');
+  strictEqual(forced.transaction_id, toForceClose.transaction_id, 'Got txid');
+  strictEqual(forced.transaction_vout, toForceClose.transaction_vout, 'Vout');
 
   const cancelHtlc = forced.close_payments.find(n => !n.is_paid);
 
-  equal(cancelHtlc.is_outgoing, false, 'HTLC is incoming');
-  equal(cancelHtlc.is_paid, false, 'HTLC is not settled');
-  equal(cancelHtlc.is_pending, false, 'HTLC cannot be settled');
-  equal(cancelHtlc.is_refunded, false, 'HTLC has not been refunded');
-  equal(cancelHtlc.spent_by, undefined, 'HTLC has no sweep tx');
-  equal(cancelHtlc.tokens, 1e5, 'HTLC has invoice value');
-  equal(!!cancelHtlc.transaction_id, true, 'HTLC has tx id');
-  equal(cancelHtlc.transaction_vout !== undefined, true, 'HTLC has tx vout');
+  strictEqual(cancelHtlc.is_outgoing, false, 'HTLC is incoming');
+  strictEqual(cancelHtlc.is_paid, false, 'HTLC is not settled');
+  strictEqual(cancelHtlc.is_pending, false, 'HTLC cannot be settled');
+  strictEqual(cancelHtlc.is_refunded, false, 'HTLC has not been refunded');
+  strictEqual(cancelHtlc.spent_by, undefined, 'HTLC has no sweep tx');
+  strictEqual(cancelHtlc.tokens, 1e5, 'HTLC has invoice value');
+  strictEqual(!!cancelHtlc.transaction_id, true, 'HTLC has tx id');
+  strictEqual(cancelHtlc.transaction_vout !== undefined, true, 'HTLC vout');
 
   const settleHtlc = forced.close_payments.find(n => !!n.is_paid);
 
-  equal(settleHtlc.is_outgoing, false, 'Settle is incoming');
-  equal(settleHtlc.is_paid, true, 'Settle is paid');
-  equal(settleHtlc.is_pending, false, 'Already settled');
-  equal(settleHtlc.is_refunded, false, 'No refund available');
-  equal(!!settleHtlc.spent_by, true, 'Swept with preimage tx');
-  equal(settleHtlc.tokens, 1e5, 'Settled with invoice value');
-  equal(!!settleHtlc.transaction_id, true, 'Output tx id');
-  equal(settleHtlc.transaction_vout !== undefined, true, 'Output tx vout');
+  strictEqual(settleHtlc.is_outgoing, false, 'Settle is incoming');
+  strictEqual(settleHtlc.is_paid, true, 'Settle is paid');
+  strictEqual(settleHtlc.is_pending, false, 'Already settled');
+  strictEqual(settleHtlc.is_refunded, false, 'No refund available');
+  strictEqual(!!settleHtlc.spent_by, true, 'Swept with preimage tx');
+  strictEqual(settleHtlc.tokens, 1e5, 'Settled with invoice value');
+  strictEqual(!!settleHtlc.transaction_id, true, 'Output tx id');
+  strictEqual(settleHtlc.transaction_vout !== undefined, true, 'Output vout');
 
   const alsoDead = await asyncRetry({interval: 20, times: 7000}, async () => {
     const {channels} = await getClosedChannels({lnd: target.lnd});
@@ -243,49 +224,49 @@ test(`Get closed channels`, async ({end, equal}) => {
 
   const forceClosed = alsoDead.find(n => !!n.is_local_force_close);
 
-  equal(forceClosed.capacity, 7e5, 'Target capacity reflected');
-  equal(!!forceClosed.close_balance_spent_by, true, 'Target spent by');
-  equal(forceClosed.close_balance_vout !== undefined, true, 'Has balance out');
-  equal(!!forceClosed.close_confirm_height, true, 'Has confirm height');
-  equal(!!forceClosed.close_payments.length, true, 'Has close payments');
-  equal(!!forceClosed.close_transaction_id, true, 'Has close id');
-  equal(forceClosed.final_local_balance, 1e5, 'Has local balance');
-  equal(forceClosed.final_time_locked_balance, 3e5, 'Has timelock balance');
-  equal(forceClosed.id, toForceClose.id, 'Has channel id');
-  equal(forceClosed.is_breach_close, false, 'Not breach close');
-  equal(forceClosed.is_cooperative_close, false, 'Not coop close');
-  equal(forceClosed.is_funding_cancel, false, 'Not funding cancel');
-  equal(forceClosed.is_local_force_close, true, 'Locally forced closed');
-  equal(forceClosed.is_partner_closed, false, 'Not remote closed');
-  equal(forceClosed.is_partner_initiated, true, 'Remote created channel');
-  equal(forceClosed.is_remote_force_close, false, 'Remote not force closed');
-  equal(forceClosed.partner_public_key, control.id, 'Got peer key');
-  equal(forceClosed.transaction_id, toForceClose.transaction_id, 'Got tx id');
-  equal(forceClosed.transaction_vout, toForceClose.transaction_vout, 'Vout');
+  strictEqual(forceClosed.capacity, 7e5, 'Target capacity reflected');
+  strictEqual(!!forceClosed.close_balance_spent_by, true, 'Target spent by');
+  strictEqual(forceClosed.close_balance_vout !== undefined, true, 'Balance');
+  strictEqual(!!forceClosed.close_confirm_height, true, 'Has confirm height');
+  strictEqual(!!forceClosed.close_payments.length, true, 'Has close payments');
+  strictEqual(!!forceClosed.close_transaction_id, true, 'Has close id');
+  strictEqual(forceClosed.final_local_balance, 1e5, 'Has local balance');
+  strictEqual(forceClosed.final_time_locked_balance, 3e5, 'Timelock balance');
+  strictEqual(forceClosed.id, toForceClose.id, 'Has channel id');
+  strictEqual(forceClosed.is_breach_close, false, 'Not breach close');
+  strictEqual(forceClosed.is_cooperative_close, false, 'Not coop close');
+  strictEqual(forceClosed.is_funding_cancel, false, 'Not funding cancel');
+  strictEqual(forceClosed.is_local_force_close, true, 'Locally forced closed');
+  strictEqual(forceClosed.is_partner_closed, false, 'Not remote closed');
+  strictEqual(forceClosed.is_partner_initiated, true, 'Remote create channel');
+  strictEqual(forceClosed.is_remote_force_close, false, 'Remote not force');
+  strictEqual(forceClosed.partner_public_key, control.id, 'Got peer key');
+  strictEqual(forceClosed.transaction_id, toForceClose.transaction_id, 'Tx');
+  strictEqual(forceClosed.transaction_vout, toForceClose.transaction_vout);
 
   const forcePay = forceClosed.close_payments.find(n => !!n.is_paid);
 
-  equal(forcePay.is_outgoing, true, 'Payment was outgoing');
-  equal(forcePay.is_paid, true, 'Payment was sent');
-  equal(forcePay.is_pending, false, 'Payment is settled');
-  equal(forcePay.is_refunded, false, 'Payment completed successfully');
-  equal(!!forcePay.spent_by, true, 'Payment was swept with preimage');
-  equal(forcePay.tokens, 1e5, 'Payment tokens amount');
-  equal(!!forcePay.transaction_id, true, 'Got payment transaction id');
-  equal(forcePay.transaction_vout !== undefined, true, 'Got payment vout');
+  strictEqual(forcePay.is_outgoing, true, 'Payment was outgoing');
+  strictEqual(forcePay.is_paid, true, 'Payment was sent');
+  strictEqual(forcePay.is_pending, false, 'Payment is settled');
+  strictEqual(forcePay.is_refunded, false, 'Payment completed successfully');
+  strictEqual(!!forcePay.spent_by, true, 'Payment was swept with preimage');
+  strictEqual(forcePay.tokens, 1e5, 'Payment tokens amount');
+  strictEqual(!!forcePay.transaction_id, true, 'Got payment transaction id');
+  strictEqual(forcePay.transaction_vout !== undefined, true, 'Got vout');
 
   const refundedHtlc = forceClosed.close_payments.find(n => !!n.is_refunded);
 
-  equal(refundedHtlc.is_outgoing, true, 'Payment was outgoing');
-  equal(refundedHtlc.is_paid, false, 'Payment was not paid');
-  equal(refundedHtlc.is_pending, false, 'Payment is resolved back');
-  equal(refundedHtlc.is_refunded, true, 'Payment refunded successfully');
-  equal(!!refundedHtlc.spent_by, true, 'Payment was swept with preimage');
-  equal(refundedHtlc.tokens, 1e5, 'Payment refund tokens amount');
-  equal(!!refundedHtlc.transaction_id, true, 'Got refund transaction id');
-  equal(refundedHtlc.transaction_vout !== undefined, true, 'Got refund vout');
+  strictEqual(refundedHtlc.is_outgoing, true, 'Payment was outgoing');
+  strictEqual(refundedHtlc.is_paid, false, 'Payment was not paid');
+  strictEqual(refundedHtlc.is_pending, false, 'Payment is resolved back');
+  strictEqual(refundedHtlc.is_refunded, true, 'Payment refunded successfully');
+  strictEqual(!!refundedHtlc.spent_by, true, 'Payment was swept');
+  strictEqual(refundedHtlc.tokens, 1e5, 'Payment refund tokens amount');
+  strictEqual(!!refundedHtlc.transaction_id, true, 'Got refund tx id');
+  strictEqual(refundedHtlc.transaction_vout !== undefined, true, 'Got vout');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_failed_payments.js

@@ -1,19 +1,20 @@
+const {deepStrictEqual} = require('node:assert').strict;
+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 {addPeer} = require('./../../');
 const {createChainAddress} = require('./../../');
-const {createCluster} = require('./../macros');
 const {createInvoice} = require('./../../');
 const {deleteForwardingReputations} = require('./../../');
-const {getChainBalance} = require('./../../');
 const {getFailedPayments} = require('./../../');
 const {getPayment} = require('./../../');
 const {getPayments} = require('./../../');
 const {pay} = require('./../../');
 const {sendToChainAddress} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const channelCapacityTokens = 1e6;
 const confirmationCount = 20;
@@ -23,7 +24,7 @@ const times = 1000;
 const tokens = 1e6 / 2;
 
 // Getting failed payments should return failed payments
-test('Get failed payments', async ({end, equal, strictSame}) => {
+test('Get failed payments', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;
@@ -52,7 +53,7 @@ test('Get failed payments', async ({end, equal, strictSame}) => {
       lnd: target.lnd,
       generate: target.generate,
       generator: target,
-      give: Math.round(channelCapacityTokens / 2),
+      give_tokens: Math.round(channelCapacityTokens / 2),
       to: remote,
     });
 
@@ -90,25 +91,25 @@ test('Get failed payments', async ({end, equal, strictSame}) => {
 
       const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
 
-      equal(payment.destination, remote.id, 'Payment to');
-      equal(payment.confirmed_at, undefined, 'No confirmation date');
-      equal(!!payment.created_at, true, 'Got payment created date');
-      equal(payment.fee, undefined, 'No fee when not paid');
-      equal(payment.fee_mtokens, undefined, 'No fee mtokens when not paid');
-      equal(!!payment.id, true, 'Got a payment id');
-      equal(!!payment.index, true, 'Got payment index');
-      equal(payment.is_confirmed, false, 'Failed payment is not confirmed');
-      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-      equal(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
-      equal(payment.request, bigInvoice.request, 'Probe has a request');
-      equal(payment.secret, undefined, 'Failed has no secret');
-      equal(payment.safe_fee, undefined, 'Failed has no fee');
-      equal(payment.safe_tokens, bigInvoice.tokens, 'Failed has safe tokens');
-      equal(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
+      strictEqual(payment.destination, remote.id, 'Payment to');
+      strictEqual(payment.confirmed_at, undefined, 'No confirmation date');
+      strictEqual(!!payment.created_at, true, 'Got payment created date');
+      strictEqual(payment.fee, undefined, 'No fee when not paid');
+      strictEqual(payment.fee_mtokens, undefined, 'No fee mtokens not paid');
+      strictEqual(!!payment.id, true, 'Got a payment id');
+      strictEqual(!!payment.index, true, 'Got payment index');
+      strictEqual(payment.is_confirmed, false, 'Failed payment not confirmed');
+      strictEqual(payment.is_outgoing, true, 'Failed payment is outgoing');
+      strictEqual(payment.mtokens, bigInvoice.mtokens, 'Payment has mtokens');
+      strictEqual(payment.request, bigInvoice.request, 'Probe has a request');
+      strictEqual(payment.secret, undefined, 'Failed has no secret');
+      strictEqual(payment.safe_fee, undefined, 'Failed has no fee');
+      strictEqual(payment.safe_tokens, bigInvoice.tokens, 'Safe tokens');
+      strictEqual(payment.tokens, bigInvoice.tokens, 'Failed has tokens');
 
       const gotFailed = await getPayment({lnd, id: payment.id});
 
-      strictSame(
+      deepStrictEqual(
         gotFailed,
         {
           failed: {
@@ -133,28 +134,28 @@ test('Get failed payments', async ({end, equal, strictSame}) => {
 
       const [payment] = payments;
 
-      equal(payment.destination, remote.id, 'Paid to');
-      equal(!!payment.confirmed_at, true, 'Got confirmation date');
-      equal(!!payment.created_at, true, 'Got payment start date');
-      equal(payment.fee, 1, 'Got fee paid');
-      equal(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
-      strictSame(payment.hops, [target.id], 'Got hops');
-      equal(!!payment.id, true, 'Got a payment id');
-      equal(!!payment.index, true, 'Got payment index');
-      equal(payment.is_confirmed, true, 'Failed payment is not confirmed');
-      equal(payment.is_outgoing, true, 'Failed payment is outgoing');
-      equal(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
-      equal(payment.request, invoice.request, 'Payment has a request');
-      equal(!!payment.secret, true, 'Failed has no secret');
-      equal(payment.safe_fee, 2, 'Failed has no fee');
-      equal(payment.safe_tokens, invoice.tokens, 'Failed has safe tokens');
-      equal(payment.tokens, invoice.tokens, 'Failed has tokens');
+      deepStrictEqual(payment.destination, remote.id, 'Paid to');
+      deepStrictEqual(!!payment.confirmed_at, true, 'Got confirmation date');
+      deepStrictEqual(!!payment.created_at, true, 'Got payment start date');
+      deepStrictEqual(payment.fee, 1, 'Got fee paid');
+      deepStrictEqual(payment.fee_mtokens, '1500', 'Got fee mtokens paid');
+      deepStrictEqual(payment.hops, [target.id], 'Got hops');
+      deepStrictEqual(!!payment.id, true, 'Got a payment id');
+      deepStrictEqual(!!payment.index, true, 'Got payment index');
+      deepStrictEqual(payment.is_confirmed, true, 'Failed not confirmed');
+      deepStrictEqual(payment.is_outgoing, true, 'Failed payment is outgoing');
+      deepStrictEqual(payment.mtokens, invoice.mtokens, 'Payment has mtokens');
+      deepStrictEqual(payment.request, invoice.request, 'Payment has request');
+      deepStrictEqual(!!payment.secret, true, 'Failed has no secret');
+      deepStrictEqual(payment.safe_fee, 2, 'Failed has no fee');
+      deepStrictEqual(payment.safe_tokens, invoice.tokens, 'Safe tokens');
+      deepStrictEqual(payment.tokens, invoice.tokens, 'Failed has tokens');
     }
   } catch (err) {
-    strictSame(err, null, 'Expected no error');
-  } finally {
-    await kill({});
+    strictEqual(err, null, 'Expected no error');
   }
 
-  return end();
+  await kill({});
+
+  return;
 });

package/test/integration/test_get_fee_rates.js

@@ -1,15 +1,17 @@
+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 {getFeeRates} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const defaultBaseFee = 1;
 const defaultFeeRate = 1;
 const size = 2;
 
 // Getting fee rates should return the fee rates of nodes in the channel graph
-test(`Get fee rates`, async ({end, equal}) => {
+test(`Get fee rates`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, to] = nodes;
@@ -18,21 +20,21 @@ test(`Get fee rates`, async ({end, equal}) => {
 
   const {channels} = await getFeeRates({lnd});
 
-  equal(channels.length, [channelOpen].length, 'Channel was opened');
+  strictEqual(channels.length, [channelOpen].length, 'Channel was opened');
 
   const [channel] = channels || [{}];
 
   if (!!channel.id) {
-    equal(channel.id, channelOpen.id, 'Channel id is represented');
+    strictEqual(channel.id, channelOpen.id, 'Channel id is represented');
   }
 
-  equal(channel.base_fee, defaultFeeRate, 'Channel base fee');
-  equal(channel.base_fee_mtokens, (defaultFeeRate * 1000)+'', 'Base fee mtok');
-  equal(channel.fee_rate, defaultBaseFee, 'Channel fee rate');
-  equal(channel.transaction_id, channelOpen.transaction_id, 'Channel tx id');
-  equal(channel.transaction_vout, channelOpen.transaction_vout, 'Tx vout');
+  strictEqual(channel.base_fee, defaultFeeRate, 'Channel base fee');
+  strictEqual(channel.base_fee_mtokens, (defaultFeeRate * 1000)+'', 'Base');
+  strictEqual(channel.fee_rate, defaultBaseFee, 'Channel fee rate');
+  strictEqual(channel.transaction_id, channelOpen.transaction_id, 'Tx id');
+  strictEqual(channel.transaction_vout, channelOpen.transaction_vout, 'Vout');
 
   await kill({});
 
-  return end();
+  return;
 });