ln-service 56.7.0 → 56.8.0

package/test/integration/test_get_forwards.js

@@ -1,14 +1,17 @@
+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 {createInvoice} = require('./../../');
-const {delay} = require('./../macros');
 const {getForwards} = require('./../../');
 const {pay} = require('./../../');
-const {setupChannel} = require('./../macros');
 
+const delay = n => new Promise(resolve => setTimeout(resolve, n));
 const interval = 100;
 const limit = 1;
 const size = 3;
@@ -16,7 +19,7 @@ const times = 1000;
 const tokens = 100;
 
 // Getting forwarded payments should return all forwarded payments
-test('Get forwards', async ({end, equal, strictSame}) => {
+test('Get forwards', async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target, remote] = nodes;
@@ -46,37 +49,37 @@ test('Get forwards', async ({end, equal, strictSame}) => {
 
   const page1 = await getForwards({limit, lnd: target.lnd});
 
-  equal(!!page1.next, true, 'Page 1 leads to page 2');
+  strictEqual(!!page1.next, true, 'Page 1 leads to page 2');
 
   {
     const [forward] = page1.forwards;
 
-    equal(!!forward.created_at, true, 'Forward created at');
-    equal(forward.fee, 1, 'Forward fee charged');
-    equal(forward.fee_mtokens, '1000', 'Forward fee charged');
-    equal(!!forward.incoming_channel, true, 'Forward incoming channel');
-    equal(forward.tokens, 100, 'Forwarded tokens count');
-    equal(!!forward.outgoing_channel, true, 'Forward outgoing channel');
+    strictEqual(!!forward.created_at, true, 'Forward created at');
+    strictEqual(forward.fee, 1, 'Forward fee charged');
+    strictEqual(forward.fee_mtokens, '1000', 'Forward fee charged');
+    strictEqual(!!forward.incoming_channel, true, 'Forward incoming channel');
+    strictEqual(forward.tokens, 100, 'Forwarded tokens count');
+    strictEqual(!!forward.outgoing_channel, true, 'Forward outgoing channel');
   }
 
   const page2 = await getForwards({lnd: target.lnd, token: page1.next});
 
-  equal(!!page2.next, true, 'Page 2 leads to page 3');
+  strictEqual(!!page2.next, true, 'Page 2 leads to page 3');
 
   {
     const [forward] = page2.forwards;
 
-    equal(forward.tokens, 101, 'Second forward tokens count');
+    strictEqual(forward.tokens, 101, 'Second forward tokens count');
   }
 
   const page3 = await getForwards({lnd: target.lnd, token: page2.next});
 
-  equal(!!page3.next, true, 'Page 3 leads to page 4');
+  strictEqual(!!page3.next, true, 'Page 3 leads to page 4');
 
   {
     const [forward] = page3.forwards;
 
-    equal(forward.tokens, 102, 'Third forward tokens count');
+    strictEqual(forward.tokens, 102, 'Third forward tokens count');
 
     // Check "before" based paging
     const prev0 = await getForwards({
@@ -87,17 +90,17 @@ test('Get forwards', async ({end, equal, strictSame}) => {
 
     const [firstForward] = prev0.forwards;
 
-    equal(firstForward.tokens, 100, 'Previous row #1');
+    strictEqual(firstForward.tokens, 100, 'Previous row #1');
 
     const prev1 = await getForwards({lnd: target.lnd, token: prev0.next});
 
     const [secondForward] = prev1.forwards;
 
-    equal(secondForward.tokens, 101, 'Previous row #2');
+    strictEqual(secondForward.tokens, 101, 'Previous row #2');
 
     const prev2 = await getForwards({lnd: target.lnd, token: prev1.next});
 
-    equal(prev2.next, undefined, 'Ended paging of previous rows');
+    strictEqual(prev2.next, undefined, 'Ended paging of previous rows');
 
     // Check "after" based paging
     const after0 = await getForwards({
@@ -107,23 +110,23 @@ test('Get forwards', async ({end, equal, strictSame}) => {
       lnd: target.lnd,
     });
 
-    strictSame(after0.forwards, prev0.forwards, 'After is inclusive of start');
+    deepStrictEqual(after0.forwards, prev0.forwards, 'After is inclusive');
 
     const after1 = await getForwards({lnd: target.lnd, token: after0.next});
 
-    strictSame(after1.forwards, prev1.forwards, 'Iterating before, after');
+    deepStrictEqual(after1.forwards, prev1.forwards, 'Iterating before');
 
     const after2 = await getForwards({lnd: target.lnd, token: after1.next});
 
-    equal(after2.next, undefined, 'Before is non-inclusive');
+    strictEqual(after2.next, undefined, 'Before is non-inclusive');
   }
 
   const page4 = await getForwards({lnd: target.lnd, token: page3.next});
 
-  equal(page4.forwards.length, [].length, 'Page 4 has no results');
-  equal(page4.next, undefined, 'Page 4 leads to nowhere');
+  strictEqual(page4.forwards.length, [].length, 'Page 4 has no results');
+  strictEqual(page4.next, undefined, 'Page 4 leads to nowhere');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_invoice.js

@@ -1,10 +1,12 @@
+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 {getInvoice} = require('./../../');
 const {pay} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const description = 'description';
 const secret = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';
@@ -12,49 +14,54 @@ const size = 2;
 const tokens = 42;
 
 // getInvoice results in invoice details
-test(`Get an invoice`, async ({end, equal}) => {
+test(`Get an invoice`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target] = nodes;
 
-  const channel = await setupChannel({generate, lnd, give: 1e5, to: target});
+  const channel = await setupChannel({
+    generate,
+    lnd,
+    give_tokens: 1e5,
+    to: target,
+  });
 
   const created = await createInvoice({description, lnd, secret, tokens});
 
   const invoice = await getInvoice({lnd, id: created.id});
 
-  equal(invoice.description, description, 'Invoice description');
-  equal(invoice.is_private, false, 'Invoice is public');
-  equal(invoice.received, 0, 'Invoice received tokens');
-  equal(invoice.received_mtokens, '0', 'Invoice received mtokens');
-  equal(invoice.secret, secret, 'Invoice secret');
-  equal(invoice.tokens, tokens, 'Invoice tokens');
+  strictEqual(invoice.description, description, 'Invoice description');
+  strictEqual(invoice.is_private, false, 'Invoice is public');
+  strictEqual(invoice.received, 0, 'Invoice received tokens');
+  strictEqual(invoice.received_mtokens, '0', 'Invoice received mtokens');
+  strictEqual(invoice.secret, secret, 'Invoice secret');
+  strictEqual(invoice.tokens, tokens, 'Invoice tokens');
 
   await pay({lnd: target.lnd, request: created.request});
 
   const paid = await getInvoice({lnd, id: created.id});
 
   if (!!paid.payments.length) {
-    equal(paid.payments.length, [created.request].length, 'Paid only once');
+    strictEqual(paid.payments.length, [created.request].length, 'Paid once');
 
     const [payment] = paid.payments;
 
-    equal(payment.canceled_at, undefined, 'Payment was not canceled');
-    equal(!!payment.confirmed_at, true, 'Payment settle date returned');
-    equal(!!payment.created_at, true, 'Payment first held date returned');
-    equal(!!payment.created_height, true, 'Payment height');
-    equal(payment.in_channel, channel.id, 'Payment channel id returned');
-    equal(payment.is_canceled, false, 'Payment not canceled');
-    equal(payment.is_confirmed, true, 'Payment was settled');
-    equal(payment.is_held, false, 'Payment is no longer held');
-    equal(payment.mtokens, (BigInt(tokens) * BigInt(1e3)).toString(), 'Mtoks');
-    equal(payment.pending_index, undefined, 'Pending index not defined');
-    equal(payment.tokens, tokens, 'Payment tokens returned');
+    strictEqual(payment.canceled_at, undefined, 'Payment was not canceled');
+    strictEqual(!!payment.confirmed_at, true, 'Payment settle date returned');
+    strictEqual(!!payment.created_at, true, 'Payment first held date');
+    strictEqual(!!payment.created_height, true, 'Payment height');
+    strictEqual(payment.in_channel, channel.id, 'Payment channel id returned');
+    strictEqual(payment.is_canceled, false, 'Payment not canceled');
+    strictEqual(payment.is_confirmed, true, 'Payment was settled');
+    strictEqual(payment.is_held, false, 'Payment is no longer held');
+    strictEqual(payment.mtokens, (BigInt(tokens) * BigInt(1e3)).toString());
+    strictEqual(payment.pending_index, undefined, 'Pending index not defined');
+    strictEqual(payment.tokens, tokens, 'Payment tokens returned');
   }
 
-  equal(paid.is_confirmed, true, 'Invoice has been paid');
+  strictEqual(paid.is_confirmed, true, 'Invoice has been paid');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_invoices.js

@@ -1,6 +1,9 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const asyncEach = require('async/each');
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {cancelHodlInvoice} = require('./../../');
 const {createInvoice} = require('./../../');
@@ -9,7 +12,7 @@ const {getInvoices} = require('./../../');
 const limit = 1;
 
 // createInvoice should result in a created invoice
-test(`Create an invoice`, async ({end, equal, strictSame}) => {
+test(`Create an invoice`, async () => {
   const {kill, nodes} = await spawnLightningCluster({});
 
   try {
@@ -25,15 +28,15 @@ test(`Create an invoice`, async ({end, equal, strictSame}) => {
 
     const firstPage = await getInvoices({limit, lnd});
 
-    equal(!!firstPage.next, true, 'First page has a next token');
+    strictEqual(!!firstPage.next, true, 'First page has a next token');
 
     const secondPage = await getInvoices({lnd, token: firstPage.next});
 
-    equal(!!secondPage.next, true, 'Second page has a next token');
+    strictEqual(!!secondPage.next, true, 'Second page has a next token');
 
     const thirdPage = await getInvoices({lnd, token: secondPage.next});
 
-    equal(!!thirdPage.next, false, 'Third page has no next token');
+    strictEqual(!!thirdPage.next, false, 'Third page has no next token');
 
     const receivedInvoices = []
       .concat(firstPage.invoices)
@@ -43,28 +46,28 @@ test(`Create an invoice`, async ({end, equal, strictSame}) => {
     receivedInvoices.forEach((invoice, i) => {
       const expected = invoices[i];
 
-      equal(invoice.chain_address, expected.chain_address, 'Chain address');
-      equal(invoice.confirmed_at, expected.confirmed_at, 'Confirmed at');
-      equal(invoice.id, expected.id, 'Invoice id');
-      equal(invoice.request, expected.request, 'Payment request');
-      equal(invoice.secret, expected.secret, 'Payment secret');
-      equal(invoice.tokens, expected.tokens, 'Tokens');
+      strictEqual(invoice.chain_address, expected.chain_address, 'Address');
+      strictEqual(invoice.confirmed_at, expected.confirmed_at, 'Confirmed at');
+      strictEqual(invoice.id, expected.id, 'Invoice id');
+      strictEqual(invoice.request, expected.request, 'Payment request');
+      strictEqual(invoice.secret, expected.secret, 'Payment secret');
+      strictEqual(invoice.tokens, expected.tokens, 'Tokens');
     });
 
     const reversed = invoices.slice().reverse();
 
-    await asyncEach(reversed.filter((n, i) => !!i), async (invoice) => {
+    await asyncEach(reversed.filter((n, i) => !!i), async invoice => {
       return await cancelHodlInvoice({lnd, id: invoice.id});
     });
 
     const unconfirmed = await getInvoices({limit, lnd, is_unconfirmed: true});
 
-    strictSame(unconfirmed, thirdPage, 'Pending invoices are ignored');
+    deepStrictEqual(unconfirmed, thirdPage, 'Pending invoices are ignored');
   } catch (err) {
-    equal(err, null, 'No error is expected');
+    strictEqual(err, null, 'No error is expected');
   }
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_methods.js

@@ -1,33 +1,30 @@
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
 const {spawnLightningCluster} = require('ln-docker-daemons');
-const {test} = require('@alexbosworth/tap');
 
 const {getMethods} = require('./../../');
 
+const {isArray} = Array;
+
 // Getting LND methods should result in LND methods returned
-test(`Get LND methods`, async ({end, equal, type}) => {
+test(`Get LND methods`, async () => {
   const {kill, nodes} = await spawnLightningCluster({});
 
   const [{lnd}] = nodes;
 
-  try {
-    const {methods} = await getMethods({lnd});
-
-    const [method] = methods;
+  const {methods} = await getMethods({lnd});
 
-    type(method.endpoint, 'string', 'Has endpoint path');
-    type(method.permissions, Array, 'Has array of permissions');
+  const [method] = methods;
 
-    const [permission] = method.permissions;
+  strictEqual(typeof method.endpoint, 'string', 'Has endpoint path');
+  strictEqual(isArray(method.permissions), true, 'Has array of permissions');
 
-    type(permission, 'string', 'Has permission');
-  } catch (err) {
-    const [code, message] = err;
+  const [permission] = method.permissions;
 
-    equal(code, 501, 'Method not supported yet');
-    equal(message, 'ListPermissionsMethodNotSupported', 'Not supported msg');
-  }
+  strictEqual(typeof permission, 'string', 'Has permission');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_network_centrality.js

@@ -1,18 +1,20 @@
+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 {getNetworkCentrality} = require('./../../');
 const {getWalletInfo} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const interval = 100;
 const size = 3;
 const times = 800;
 
 // Getting the network centrality should return the centrality scores
-test(`Get network centrality`, async ({end, equal, strictSame}) => {
+test(`Get network centrality`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target, remote] = nodes;
@@ -49,20 +51,20 @@ test(`Get network centrality`, async ({end, equal, strictSame}) => {
         throw new Error('WrongBetweennessScore');
       }
 
-      equal(controlScore.betweenness, 0, 'No centrality on control');
-      equal(controlScore.betweenness_normalized, 0, 'No control centrality');
-      equal(remoteScore.betweenness, 0, 'No centrality on remote');
-      equal(remoteScore.betweenness_normalized, 0, 'No centrality on remote');
-      equal(targetScore.betweenness, 1e6, 'Centrality around target');
-      equal(targetScore.betweenness_normalized, 1e6, 'Centrality at target');
+      strictEqual(controlScore.betweenness, 0, 'No centrality on control');
+      strictEqual(controlScore.betweenness_normalized, 0, 'No centrality');
+      strictEqual(remoteScore.betweenness, 0, 'No centrality on remote');
+      strictEqual(remoteScore.betweenness_normalized, 0, 'No centrality');
+      strictEqual(targetScore.betweenness, 1e6, 'Centrality around target');
+      strictEqual(targetScore.betweenness_normalized, 1e6, 'Centrality');
 
       return;
     });
   } catch (err) {
-    equal(err, null, 'Expected no error');
-  } finally {
-    await kill({});
+    strictEqual(err, null, 'Expected no error');
   }
 
-  return end();
+  await kill({});
+
+  return;
 });

package/test/integration/test_get_network_graph.js

@@ -1,10 +1,12 @@
+const {deepStrictEqual} = 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 {getNetworkGraph} = require('./../../');
 const {getNode} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const {ceil} = Math;
 const interval = 250;
@@ -12,7 +14,7 @@ const size = 3;
 const times = 50;
 
 // Getting the network graph should return the public nodes and connections
-test(`Get network graph`, async ({end, equal, strictSame}) => {
+test(`Get network graph`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target] = nodes;
@@ -40,35 +42,46 @@ test(`Get network graph`, async ({end, equal, strictSame}) => {
   if (!!nodeDetails && !!nodeDetails.channels.length) {
     const [chan] = nodeDetails.channels;
 
-    strictSame(chan, channel, 'Graph channel matches node details channel');
+    deepStrictEqual(chan, channel, 'Graph channel matches node details');
   }
 
-  equal(node.alias, control.id.slice(0, 20), 'Node alias is own');
-  equal(node.color, '#3399ff', 'Node color is default');
-  equal(node.public_key, control.id, 'Node pubkey is own');
-  equal(node.sockets.length, 1, 'Socket');
-  equal(new Date() - new Date(node.updated_at) < 1e5, true, 'Recent update');
+  deepStrictEqual(node.alias, control.id.slice(0, 20), 'Node alias is own');
+  deepStrictEqual(node.color, '#3399ff', 'Node color is default');
+  deepStrictEqual(node.public_key, control.id, 'Node pubkey is own');
+  deepStrictEqual(node.sockets.length, 1, 'Socket');
+  deepStrictEqual(new Date() - new Date(node.updated_at) < 1e5, true, 'At');
 
   channel.policies.forEach(policy => {
-    equal(policy.base_fee_mtokens, '1000', 'Default channel base fee');
-    equal([40, 80].includes(policy.cltv_delta), true, 'Default CLTV delta');
-    equal(policy.fee_rate, 1, 'Default channel fee rate');
-    equal(policy.is_disabled, false, 'Channels are active');
-    equal(policy.max_htlc_mtokens, `${ceil(channel.capacity * 0.99)}000`);
-    equal(!!policy.min_htlc_mtokens, true, 'Default min htlc value');
-    equal(!!policy.public_key, true, 'Policy has public key');
-    equal(new Date() - new Date(policy.updated_at) < 1e5, true, 'Updated at');
+    deepStrictEqual(policy.base_fee_mtokens, '1000', 'Default channel base');
+    deepStrictEqual([40, 80].includes(policy.cltv_delta), true, 'Cltv delta');
+    deepStrictEqual(policy.fee_rate, 1, 'Default channel fee rate');
+    deepStrictEqual(policy.is_disabled, false, 'Channels are active');
+    deepStrictEqual(
+      policy.max_htlc_mtokens,
+      `${ceil(channel.capacity * 0.99)}000`
+    );
+    deepStrictEqual(!!policy.min_htlc_mtokens, true, 'Default min htlc value');
+    deepStrictEqual(!!policy.public_key, true, 'Policy has public key');
+    deepStrictEqual(new Date()-new Date(policy.updated_at) < 1e5, true, 'At');
 
     return;
   });
 
-  equal(channel.capacity, expectedChannel.capacity, 'Channel capacity');
-  equal(channel.id, expectedChannel.id, 'Channel id');
-  equal(channel.transaction_id, expectedChannel.transaction_id, 'Chan tx id');
-  equal(channel.transaction_vout, expectedChannel.transaction_vout, 'Tx Vout');
-  equal(new Date() - new Date(channel.updated_at) < 1e5, true, 'Updated at');
+  deepStrictEqual(channel.capacity, expectedChannel.capacity, 'Capacity');
+  deepStrictEqual(channel.id, expectedChannel.id, 'Channel id');
+  deepStrictEqual(channel.transaction_id, expectedChannel.transaction_id, 'T');
+  deepStrictEqual(
+    channel.transaction_vout,
+    expectedChannel.transaction_vout,
+    'Tx Vout'
+  );
+  deepStrictEqual(
+    new Date() - new Date(channel.updated_at) < 1e5,
+    true,
+    'Updated at'
+  );
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_network_info.js

@@ -1,14 +1,16 @@
+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 {getNetworkInfo} = require('./../../');
-const {setupChannel} = require('./../macros');
 
 const size = 2;
 const tokens = 1e6;
 
 // Getting the network info should return basic network statistics
-test(`Get network info`, async ({end, equal}) => {
+test(`Get network info`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, lnd}, target] = nodes;
@@ -17,15 +19,15 @@ test(`Get network info`, async ({end, equal}) => {
 
   const result = await getNetworkInfo({lnd});
 
-  equal(result.average_channel_size, tokens, 'Average channel size');
-  equal(result.channel_count, 1, 'Channel count');
-  equal(result.max_channel_size, tokens, 'Maximum channel size');
-  equal(result.median_channel_size, tokens, 'Median channel size');
-  equal(result.min_channel_size, tokens, 'Minimum channel size');
-  equal(result.not_recently_updated_policy_count, 0, 'Not updated count');
-  equal(result.total_capacity, tokens, 'Total capacity');
+  strictEqual(result.average_channel_size, tokens, 'Average channel size');
+  strictEqual(result.channel_count, 1, 'Channel count');
+  strictEqual(result.max_channel_size, tokens, 'Maximum channel size');
+  strictEqual(result.median_channel_size, tokens, 'Median channel size');
+  strictEqual(result.min_channel_size, tokens, 'Minimum channel size');
+  strictEqual(result.not_recently_updated_policy_count, 0, 'No updated count');
+  strictEqual(result.total_capacity, tokens, 'Total capacity');
 
   await kill({});
 
-  return end();
+  return;
 });

package/test/integration/test_get_node.js

@@ -1,12 +1,13 @@
+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 {delay} = require('./../macros');
 const {getIdentity} = require('./../../');
 const {getNode} = require('./../../');
-const {setupChannel} = require('./../macros');
 const {updateRoutingFees} = require('./../../');
 
 const baseFee = 1337;
@@ -15,6 +16,7 @@ const cltvDelta = 42;
 const confirmationCount = 20;
 const defaultFee = 1e3;
 const defaultAliasLength = '00000000000000000000'.length;
+const delay = n => new Promise(resolve => setTimeout(resolve, n));
 const feeRate = 21;
 const interval = 10;
 const mtokPerTok = BigInt(1e3);
@@ -22,7 +24,7 @@ const size = 3;
 const times = 1000;
 
 // Getting a node should return the public graph node info
-test(`Get node`, async ({end, equal, strictSame}) => {
+test(`Get node`, async () => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [{generate, id, lnd}, target, remote] = nodes;
@@ -65,7 +67,7 @@ test(`Get node`, async ({end, equal, strictSame}) => {
         public_key: id,
       });
 
-      equal(channels.length, [].length, 'Channels are omitted')
+      strictEqual(channels.length, [].length, 'Channels are omitted');
     }
 
     if (!!node.channels.length) {
@@ -73,27 +75,31 @@ test(`Get node`, async ({end, equal, strictSame}) => {
 
       const policy = policies.find(n => n.public_key === id);
 
-      equal(BigInt(policy.base_fee_mtokens), BigInt(baseFee)*mtokPerTok, 'bf');
-      equal(policy.cltv_delta, cltvDelta, 'Got expected cltv delta');
-      equal(policy.fee_rate, feeRate, 'Got expected fee rate');
-      equal(policy.is_disabled, false, 'Channel is not disabled');
-      equal(policy.max_htlc_mtokens, '990000000', 'Max HTLC mtokens returned');
-      equal(policy.min_htlc_mtokens, '1000', 'Min HTLC mtokens returned');
+      strictEqual(
+        BigInt(policy.base_fee_mtokens),
+        BigInt(baseFee) * mtokPerTok,
+        'bf'
+      );
+      strictEqual(policy.cltv_delta, cltvDelta, 'Got expected cltv delta');
+      strictEqual(policy.fee_rate, feeRate, 'Got expected fee rate');
+      strictEqual(policy.is_disabled, false, 'Channel is not disabled');
+      strictEqual(policy.max_htlc_mtokens, '990000000', 'Max HTLC returned');
+      strictEqual(policy.min_htlc_mtokens, '1000', 'Min HTLC returned');
     }
 
     const [socket] = node.sockets;
 
-    equal(node.alias, id.slice(0, defaultAliasLength), 'Alias');
-    equal(node.color, '#3399ff', 'Color');
-    equal(node.sockets.length, 1, 'Socket');
-    equal(!!socket.socket, true, 'Ip, port');
-    equal(socket.type, 'tcp', 'Socket type');
-    equal(node.updated_at.length, 24, 'Update date');
+    strictEqual(node.alias, id.slice(0, defaultAliasLength), 'Alias');
+    strictEqual(node.color, '#3399ff', 'Color');
+    strictEqual(node.sockets.length, 1, 'Socket');
+    strictEqual(!!socket.socket, true, 'Ip, port');
+    strictEqual(socket.type, 'tcp', 'Socket type');
+    strictEqual(node.updated_at.length, 24, 'Update date');
   } catch (err) {
-    strictSame(err, null, 'Expected no error');
-  } finally {
-    await kill({});
+    strictEqual(err, null, 'Expected no error');
   }
 
-  return end();
+  await kill({});
+
+  return;
 });