ln-service 59.5.0 → 59.7.0

package/test/integration/test_get_failed_payments.js

@@ -1,164 +0,0 @@
-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 {addPeer} = require('./../../');
-const {createChainAddress} = require('./../../');
-const {createInvoice} = require('./../../');
-const {deleteForwardingReputations} = require('./../../');
-const {getFailedPayments} = require('./../../');
-const {getPayment} = require('./../../');
-const {getPayments} = require('./../../');
-const {pay} = require('./../../');
-const {sendToChainAddress} = require('./../../');
-
-const channelCapacityTokens = 1e6;
-const confirmationCount = 20;
-const count = 100;
-const size = 3;
-const times = 1000;
-const tokens = 1e6 / 2;
-
-// Getting failed payments should return failed payments
-test('Get failed payments', async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  try {
-    const {address} = await createChainAddress({lnd: remote.lnd});
-
-    await generate({count});
-
-    // Send coins to remote so that it can accept the channel
-    await sendToChainAddress({lnd, address, tokens: channelCapacityTokens});
-
-    // Generate to confirm the tx
-    await generate({count: confirmationCount});
-    await remote.generate({count: confirmationCount});
-
-    await setupChannel({
-      generate,
-      lnd,
-      capacity: channelCapacityTokens + channelCapacityTokens,
-      to: target,
-    });
-
-    await setupChannel({
-      capacity: channelCapacityTokens,
-      lnd: target.lnd,
-      generate: target.generate,
-      generator: target,
-      give_tokens: Math.round(channelCapacityTokens / 2),
-      to: remote,
-    });
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-    const bigInvoice = await createInvoice({
-      tokens: (channelCapacityTokens / 2) + (channelCapacityTokens / 4),
-      lnd: remote.lnd,
-    });
-
-    try {
-      await pay({lnd, request: bigInvoice.request});
-    } catch (err) {
-    }
-
-    // Create a new channel to increase total edge liquidity
-    await setupChannel({
-      capacity: channelCapacityTokens,
-      lnd: target.lnd,
-      generate: target.generate,
-      generator: target,
-      to: remote,
-    });
-
-    await deleteForwardingReputations({lnd});
-
-    await asyncRetry({times}, async () => {
-      await pay({lnd, request: invoice.request});
-    });
-
-    {
-      const {payments} = await getFailedPayments({lnd});
-
-      const [payment] = payments.filter(n => n.mtokens === bigInvoice.mtokens);
-
-      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});
-
-      deepStrictEqual(
-        gotFailed,
-        {
-          failed: {
-            id: payment.id,
-            is_canceled: false,
-            is_insufficient_balance: false,
-            is_invalid_payment: false,
-            is_pathfinding_timeout: false,
-            is_route_not_found: true,
-          },
-          is_confirmed: false,
-          is_failed: true,
-          is_pending: false,
-          payment: undefined,
-          pending: undefined,
-        },
-        'Got failed state'
-      );
-    }
-
-    {
-      const {payments} = await getPayments({lnd});
-
-      const [payment] = payments;
-
-      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');
-    }
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  return;
-});

package/test/integration/test_get_fee_rates.js

@@ -1,40 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getFeeRates} = require('./../../');
-
-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 () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, to] = nodes;
-
-  const channelOpen = await setupChannel({generate, lnd, to});
-
-  const {channels} = await getFeeRates({lnd});
-
-  strictEqual(channels.length, [channelOpen].length, 'Channel was opened');
-
-  const [channel] = channels || [{}];
-
-  if (!!channel.id) {
-    strictEqual(channel.id, channelOpen.id, 'Channel id is represented');
-  }
-
-  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;
-});

package/test/integration/test_get_forwards.js

@@ -1,144 +0,0 @@
-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 {addPeer} = require('./../../');
-const {createInvoice} = require('./../../');
-const {getForwards} = require('./../../');
-const {pay} = require('./../../');
-
-const delay = n => new Promise(resolve => setTimeout(resolve, n));
-const interval = 100;
-const limit = 1;
-const size = 3;
-const times = 1000;
-const tokens = 100;
-
-// Getting forwarded payments should return all forwarded payments
-test('Get forwards', async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  await asyncRetry({interval, times}, async () => {
-    await generate({});
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    await setupChannel({generate, lnd, to: target});
-  });
-
-  await asyncRetry({interval, times}, async () => {
-    await generate({});
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    await setupChannel({
-      lnd: target.lnd,
-      generate: target.generate,
-      to: remote,
-    });
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  await delay(2000);
-
-  for (let i = 0, l = remote.lnd; i < 3; i++) {
-    await asyncRetry({interval, times}, async () => {
-      await delay(1000);
-
-      await pay({
-        lnd,
-        request: (await createInvoice({lnd: l, tokens: tokens + i})).request,
-      });
-    });
-  }
-
-  const page1 = await getForwards({limit, lnd: target.lnd});
-
-  strictEqual(!!page1.next, true, 'Page 1 leads to page 2');
-
-  {
-    const [forward] = page1.forwards;
-
-    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});
-
-  strictEqual(!!page2.next, true, 'Page 2 leads to page 3');
-
-  {
-    const [forward] = page2.forwards;
-
-    strictEqual(forward.tokens, 101, 'Second forward tokens count');
-  }
-
-  const page3 = await getForwards({lnd: target.lnd, token: page2.next});
-
-  strictEqual(!!page3.next, true, 'Page 3 leads to page 4');
-
-  {
-    const [forward] = page3.forwards;
-
-    strictEqual(forward.tokens, 102, 'Third forward tokens count');
-
-    // Check "before" based paging
-    const prev0 = await getForwards({
-      limit,
-      before: forward.created_at,
-      lnd: target.lnd,
-    });
-
-    const [firstForward] = prev0.forwards;
-
-    strictEqual(firstForward.tokens, 100, 'Previous row #1');
-
-    const prev1 = await getForwards({lnd: target.lnd, token: prev0.next});
-
-    const [secondForward] = prev1.forwards;
-
-    strictEqual(secondForward.tokens, 101, 'Previous row #2');
-
-    const prev2 = await getForwards({lnd: target.lnd, token: prev1.next});
-
-    strictEqual(prev2.next, undefined, 'Ended paging of previous rows');
-
-    // Check "after" based paging
-    const after0 = await getForwards({
-      limit,
-      before: forward.created_at,
-      after: firstForward.created_at,
-      lnd: target.lnd,
-    });
-
-    deepStrictEqual(after0.forwards, prev0.forwards, 'After is inclusive');
-
-    const after1 = await getForwards({lnd: target.lnd, token: after0.next});
-
-    deepStrictEqual(after1.forwards, prev1.forwards, 'Iterating before');
-
-    const after2 = await getForwards({lnd: target.lnd, token: after1.next});
-
-    strictEqual(after2.next, undefined, 'Before is non-inclusive');
-  }
-
-  const page4 = await getForwards({lnd: target.lnd, token: page3.next});
-
-  strictEqual(page4.forwards.length, [].length, 'Page 4 has no results');
-  strictEqual(page4.next, undefined, 'Page 4 leads to nowhere');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_invoice.js

@@ -1,67 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createInvoice} = require('./../../');
-const {getInvoice} = require('./../../');
-const {pay} = require('./../../');
-
-const description = 'description';
-const secret = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';
-const size = 2;
-const tokens = 42;
-
-// getInvoice results in invoice details
-test(`Get an invoice`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  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});
-
-  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) {
-    strictEqual(paid.payments.length, [created.request].length, 'Paid once');
-
-    const [payment] = paid.payments;
-
-    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');
-  }
-
-  strictEqual(paid.is_confirmed, true, 'Invoice has been paid');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_invoices.js

@@ -1,88 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncEach = require('async/each');
-const asyncRetry = require('async/retry');
-const {getWalletInfo} = require('./../../');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {cancelHodlInvoice} = require('./../../');
-const {createInvoice} = require('./../../');
-const {getInvoices} = require('./../../');
-
-const interval = 1000;
-const limit = 1;
-const times = 1000;
-
-// Get invoices should result in a list of created invoices
-test(`Get invoices`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  try {
-    const [{generate, lnd}] = nodes;
-
-    // Make sure that target is synced to the chain otherwise invoice can halt
-    await asyncRetry({interval, times}, async () => {
-      const wallet = await getWalletInfo({lnd});
-
-      await generate({});
-
-      if (!wallet.is_synced_to_chain) {
-        throw new Error('WaitingForSyncToChain');
-      }
-    });
-
-    const invoices = [
-      await createInvoice({lnd, description: '3'}),
-      await createInvoice({lnd, description: '2'}),
-      await createInvoice({lnd, description: '1'}),
-    ];
-
-    invoices.reverse();
-
-    const firstPage = await getInvoices({limit, lnd});
-
-    strictEqual(!!firstPage.next, true, 'First page has a next token');
-
-    const secondPage = await getInvoices({lnd, token: firstPage.next});
-
-    strictEqual(!!secondPage.next, true, 'Second page has a next token');
-
-    const thirdPage = await getInvoices({lnd, token: secondPage.next});
-
-    strictEqual(!!thirdPage.next, false, 'Third page has no next token');
-
-    const receivedInvoices = []
-      .concat(firstPage.invoices)
-      .concat(secondPage.invoices)
-      .concat(thirdPage.invoices);
-
-    receivedInvoices.forEach((invoice, i) => {
-      const expected = invoices[i];
-
-      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 => {
-      return await cancelHodlInvoice({lnd, id: invoice.id});
-    });
-
-    const unconfirmed = await getInvoices({limit, lnd, is_unconfirmed: true});
-
-    deepStrictEqual(unconfirmed, thirdPage, 'Pending invoices are ignored');
-  } catch (err) {
-    strictEqual(err, null, 'No error is expected');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_methods.js

@@ -1,30 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getMethods} = require('./../../');
-
-const {isArray} = Array;
-
-// Getting LND methods should result in LND methods returned
-test(`Get LND methods`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{lnd}] = nodes;
-
-  const {methods} = await getMethods({lnd});
-
-  const [method] = methods;
-
-  strictEqual(typeof method.endpoint, 'string', 'Has endpoint path');
-  strictEqual(isArray(method.permissions), true, 'Has array of permissions');
-
-  const [permission] = method.permissions;
-
-  strictEqual(typeof permission, 'string', 'Has permission');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_network_centrality.js

@@ -1,72 +0,0 @@
-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 {addPeer} = require('./../../');
-const {getNetworkCentrality} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-const interval = 100;
-const size = 3;
-const times = 800;
-
-// Getting the network centrality should return the centrality scores
-test(`Get network centrality`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target, remote] = nodes;
-
-  const {lnd} = control;
-
-  try {
-    await control.generate({count: 100});
-
-    await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-      await setupChannel({lnd, generate: control.generate, to: target});
-
-      await setupChannel({
-        generate: target.generate,
-        lnd: target.lnd,
-        to: remote,
-      });
-    });
-
-    await asyncRetry({interval, times}, async () => {
-      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-      const {nodes} = await getNetworkCentrality({lnd});
-
-      const controlScore = nodes.find(n => n.public_key === control.id);
-      const remoteScore = nodes.find(n => n.public_key === remote.id);
-      const targetScore = nodes.find(n => n.public_key === target.id);
-
-      if (!targetScore.betweenness || !targetScore.betweenness_normalized) {
-        throw new Error('UnexpectedValueForTargetScoreBetweenness');
-      }
-
-      if (targetScore.betweenness !== 1e6) {
-        throw new Error('WrongBetweennessScore');
-      }
-
-      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) {
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_network_graph.js

@@ -1,87 +0,0 @@
-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 {getNetworkGraph} = require('./../../');
-const {getNode} = require('./../../');
-
-const {ceil} = Math;
-const interval = 250;
-const size = 3;
-const times = 50;
-
-// Getting the network graph should return the public nodes and connections
-test(`Get network graph`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, target] = nodes;
-
-  const {generate, lnd} = control;
-
-  const expectedChannel = await setupChannel({generate, lnd, to: target});
-
-  // Wait until the node shows up in the graph
-  const graph = await asyncRetry({interval, times}, async () => {
-    const networkGraph = await getNetworkGraph({lnd});
-
-    if (!networkGraph.nodes.find(n => n.public_key === control.id)) {
-      throw new Error('ExpectedToFindNodeInGraph');
-    }
-
-    return networkGraph;
-  });
-
-  const node = graph.nodes.find(n => n.public_key === control.id);
-  const [channel] = graph.channels;
-
-  const nodeDetails = await getNode({lnd, public_key: node.public_key});
-
-  if (!!nodeDetails && !!nodeDetails.channels.length) {
-    const [chan] = nodeDetails.channels;
-
-    deepStrictEqual(chan, channel, 'Graph channel matches node details');
-  }
-
-  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 => {
-    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;
-  });
-
-  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;
-});