ln-service 59.5.0 → 59.7.0

package/test/integration/test_get_network_info.js

@@ -1,33 +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 {getNetworkInfo} = require('./../../');
-
-const size = 2;
-const tokens = 1e6;
-
-// Getting the network info should return basic network statistics
-test(`Get network info`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  await setupChannel({generate, lnd, to: target});
-
-  const result = await getNetworkInfo({lnd});
-
-  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;
-});

package/test/integration/test_get_node.js

@@ -1,117 +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 {getIdentity} = require('./../../');
-const {getNode} = require('./../../');
-const {updateRoutingFees} = require('./../../');
-
-const baseFee = 1337;
-const channelCapacityTokens = 1e6;
-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);
-const size = 3;
-const times = 1000;
-
-// Getting a node should return the public graph node info
-test(`Get node`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, id, lnd}, target, remote] = nodes;
-
-  try {
-    const controlToTarget = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      return await setupChannel({generate, lnd, to: target});
-    });
-
-    const targetToRemote = await asyncRetry({interval, times}, async () => {
-      await target.generate({});
-
-      return await setupChannel({
-        generate: target.generate,
-        lnd: target.lnd,
-        to: remote,
-      });
-    });
-
-    await updateRoutingFees({
-      lnd,
-      base_fee_tokens: baseFee,
-      cltv_delta: cltvDelta,
-      fee_rate: feeRate,
-      transaction_id: controlToTarget.transaction_id,
-      transaction_vout: controlToTarget.transaction_vout,
-    });
-
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      await addPeer({
-        lnd,
-        public_key: remote.id,
-        retry_count: 1,
-        retry_delay: 1,
-        socket: remote.socket,
-        timeout: 1000,
-      });
-    });
-
-    const node = await getNode({lnd, public_key: id});
-
-    {
-      const {channels} = await getNode({
-        lnd,
-        is_omitting_channels: true,
-        public_key: id,
-      });
-
-      strictEqual(channels.length, [].length, 'Channels are omitted');
-    }
-
-    if (!!node.channels.length) {
-      const [{policies}] = node.channels;
-
-      const policy = policies.find(n => n.public_key === id);
-
-      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;
-
-    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');
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  return;
-});

package/test/integration/test_get_payments.js

@@ -1,69 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncTimesSeries = require('async/timesSeries');
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createInvoice} = require('./../../');
-const {getPayments} = require('./../../');
-const {pay} = require('./../../');
-
-const start = new Date().toISOString();
-const size = 2;
-const tokens = 100;
-
-// Getting payments should return the list of payments
-test('Get payments', async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  await setupChannel({generate, lnd, to: target});
-
-  const invoice = await createInvoice({tokens, lnd: target.lnd});
-
-  const paid = await pay({lnd, request: invoice.request});
-
-  const [payment] = (await getPayments({lnd})).payments;
-
-  strictEqual(payment.destination, target.id, 'Destination');
-  strictEqual(payment.confirmed_at > start, true, 'Got confirmed date');
-  strictEqual(payment.created_at.length, 24, 'Created at time');
-  strictEqual(payment.fee, 0, 'Fee paid');
-  strictEqual(payment.hops.length, [].length, 'Hops');
-  strictEqual(payment.id, invoice.id, 'Id');
-  strictEqual(payment.is_confirmed, true, 'Confirmed');
-  strictEqual(payment.is_outgoing, true, 'Outgoing');
-  strictEqual(payment.mtokens, (BigInt(tokens) * BigInt(1e3)).toString(), 'M');
-  strictEqual(payment.secret, invoice.secret, 'Payment secret');
-  strictEqual(payment.tokens, tokens, 'Paid tokens');
-
-  if (!!payment.request) {
-    strictEqual(payment.request, invoice.request, 'Returns original request');
-  }
-
-  await asyncTimesSeries(4, async () => {
-    const {request} = await createInvoice({tokens, lnd: target.lnd});
-
-    const paid = await pay({lnd, request});
-  });
-
-  const page1 = await getPayments({lnd, limit: 2});
-
-  const [firstOfPage1] = page1.payments;
-
-  const page2 = await getPayments({lnd, token: page1.next});
-
-  const [firstOfPage2] = page2.payments;
-
-  strictEqual(firstOfPage2.index, 3, 'Got payment index');
-
-  const page3 = await getPayments({lnd, token: page2.next});
-
-  strictEqual(!!page3.next, false, 'There is no page 4');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_peers.js

@@ -1,58 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {getPeers} = require('./../../');
-
-const interval = 10
-const size = 2;
-const times = 2000;
-
-// Getting peers should return the list of peers
-test('Get peers', async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  try {
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      await addPeer({
-        lnd,
-        public_key: target.id,
-        retry_count: 1,
-        retry_delay: 1,
-        socket: target.socket,
-        timeout: 100,
-      });
-
-      const [peer] = (await getPeers({lnd})).peers;
-
-      if (!peer || !peer.is_sync_peer) {
-        throw new Error('ExpectedSyncPeer');
-      }
-
-      strictEqual(peer.bytes_received !== undefined, true, 'Bytes received');
-      strictEqual(peer.bytes_sent !== undefined, true, 'Bytes sent');
-      strictEqual(peer.is_inbound, false, 'Is inbound peer');
-      strictEqual(peer.is_sync_peer, true, 'Is sync peer');
-      strictEqual(peer.ping_time, 0, 'Ping time');
-      strictEqual(peer.public_key, target.id, 'Public key');
-      strictEqual(!!peer.socket, true, 'Socket');
-      strictEqual(peer.tokens_received, 0, 'Tokens received');
-      strictEqual(peer.tokens_sent, 0, 'Tokens sent');
-
-      return;
-    });
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_pending_coop.js

@@ -1,122 +0,0 @@
-const {equal} = require('node:assert').strict;
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {componentsOfTransaction} = require('@alexbosworth/blockchain');
-const {idForTransactionComponents} = require('@alexbosworth/blockchain');
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {closeChannel} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-const defaultFee = 1e3;
-const give = 1e4;
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
-const interval = 10;
-const size = 2;
-const times = 2000;
-
-// Getting pending channels should show pending channels
-test(`Get pending channels`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  try {
-    const {features} = await getWalletInfo({lnd});
-
-    // Target starts a channel with control
-    const coopChan = await setupChannel({
-      generate,
-      lnd,
-      give_tokens: give,
-      to: target,
-    });
-
-    // Target closes the channel
-    const niceClose = await closeChannel({
-      lnd: target.lnd,
-      tokens_per_vbyte: 100,
-      transaction_id: coopChan.transaction_id,
-      transaction_vout: coopChan.transaction_vout,
-    });
-
-    // Control views their pending channels
-    const {channel} = await asyncRetry({interval, times}, async () => {
-      const res = await getPendingChannels({lnd});
-
-      const id = coopChan.transaction_id;
-
-      const channel = res.pending_channels.find(n => n.transaction_id === id);
-
-      if (!channel) {
-        throw new Error('FailedToFindPendingChannelWithTransactionId');
-      }
-
-      return {channel};
-    });
-
-    const transaction = channel.close_transaction;
-
-    // LND 0.17.4 and below do not support close_transaction
-    if (!!transaction) {
-      const components = componentsOfTransaction({transaction});
-
-      const closing = idForTransactionComponents({
-        inputs: components.inputs.map(input => ({
-          hash: hexAsBuffer(input.id).reverse(),
-          script: hexAsBuffer(input.script),
-          sequence: input.sequence,
-          vout: input.vout,
-        })),
-        locktime: components.locktime,
-        outputs: components.outputs.map(output => ({
-          script: hexAsBuffer(output.script),
-          tokens: output.tokens,
-        })),
-        version: components.version,
-      });
-
-      equal(closing.id, channel.close_transaction_id, 'Got closing tx');
-    }
-
-    if (channel.is_partner_initiated !== undefined) {
-      strictEqual(channel.is_partner_initiated, false, 'Channel initiated');
-    }
-
-    strictEqual(channel.local_balance, 986530, 'Original balance');
-    strictEqual(channel.pending_balance, 986530, 'Waiting on balance');
-
-    strictEqual(channel.capacity, 1000000, 'Got channel capacity');
-    strictEqual(channel.is_active, false, 'Ended');
-    strictEqual(channel.is_closing, true, 'Closing');
-    strictEqual(channel.is_opening, false, 'Not Opening');
-    strictEqual(channel.local_reserve, 10000, 'Local reserve');
-    strictEqual(channel.partner_public_key, target.id, 'Target public key');
-    strictEqual(channel.pending_payments, undefined, 'No pending payments');
-    strictEqual(channel.received, 0, 'Never received');
-    strictEqual(channel.recovered_tokens, undefined, 'Nothing to recover');
-    strictEqual(channel.remote_reserve, 10000, 'Remote reserve');
-    strictEqual(channel.sent, 0, 'Never sent anything');
-    strictEqual(channel.timelock_expiration, undefined, 'No timelock in coop');
-    strictEqual(channel.transaction_fee, null, 'No transaction fee data');
-    strictEqual(channel.transaction_id, coopChan.transaction_id, 'funding tx');
-    strictEqual(channel.transaction_vout, coopChan.transaction_vout, 'Vout');
-    strictEqual(channel.transaction_weight, null, 'No funding tx weight data');
-
-    if (!!channel.remote_balance) {
-      strictEqual(channel.remote_balance, give, 'Opposing channel balance');
-    }
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  return;
-});

package/test/integration/test_get_pending_force.js

@@ -1,172 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {closeChannel} = require('./../../');
-const {getChannels} = require('./../../');
-const {getHeight} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-const {openChannel} = require('./../../');
-
-const anchorFeatureBit = 23;
-const channelCapacityTokens = 1e6;
-const confirmationCount = 20;
-const count = 100;
-const defaultFee = 1e3;
-const defaultVout = 0;
-const giftTokens = 1e4;
-const interval = 10;
-const size = 2;
-const spendableRatio = 0.99;
-const times = 2000;
-
-// Getting pending channels should show pending channels
-test(`Get pending channels`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  const {features} = await getWalletInfo({lnd});
-
-  const isAnchors = !!features.find(n => n.bit === anchorFeatureBit);
-  const startHeight = (await getHeight({lnd})).current_block_height;
-
-  await generate({count});
-
-  const channelOpen = await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    return await openChannel({
-      lnd,
-      chain_fee_tokens_per_vbyte: defaultFee,
-      give_tokens: giftTokens,
-      local_tokens: channelCapacityTokens,
-      partner_csv_delay: 10,
-      partner_public_key: target.id,
-      socket: target.socket,
-    });
-  });
-
-  await getPendingChannels({lnd, id: channelOpen.transaction_id});
-
-  const [pendingOpen] = (await getPendingChannels({lnd})).pending_channels;
-
-  strictEqual(pendingOpen.local_balance, 986530, 'Local balance minus gift');
-  strictEqual(pendingOpen.transaction_fee, 2810, 'Transaction fee tokens');
-  strictEqual(pendingOpen.transaction_weight, 1116, 'Channel tx weight');
-
-  strictEqual(pendingOpen.capacity, 1000000, 'Got channel opening capacity');
-  strictEqual(pendingOpen.is_active, false, 'Not active yet');
-  strictEqual(pendingOpen.is_closing, false, 'Not closing yet');
-  strictEqual(pendingOpen.is_opening, true, 'Channel is opening');
-  strictEqual(pendingOpen.local_reserve, 10000, 'Local reserve amount');
-  strictEqual(pendingOpen.partner_public_key, target.id, 'Key');
-  strictEqual(pendingOpen.pending_balance, undefined, 'No pending balance');
-  strictEqual(pendingOpen.pending_payments, undefined, 'No pending payments');
-  strictEqual(pendingOpen.received, 0, 'Nothing received');
-  strictEqual(pendingOpen.recovered_tokens, undefined, 'Nothing recovered');
-  strictEqual(pendingOpen.remote_balance, giftTokens, 'Tokens gifted');
-  strictEqual(pendingOpen.remote_reserve, 10000, 'Remote reserve amount');
-  strictEqual(pendingOpen.sent, 0, 'Nothing sent');
-  strictEqual(pendingOpen.timelock_expiration, undefined, 'Not timelocked');
-  strictEqual(pendingOpen.transaction_id, channelOpen.transaction_id, 'Tx id');
-  strictEqual(pendingOpen.transaction_vout, channelOpen.transaction_vout, 'V');
-
-  await generate({count: confirmationCount});
-
-  await getChannels({lnd, id: channelOpen.transaction_id});
-
-  const channelClose = await closeChannel({
-    lnd,
-    is_force_close: true,
-    transaction_id: channelOpen.transaction_id,
-    transaction_vout: channelOpen.transaction_vout,
-  });
-
-  await getPendingChannels({lnd, id: channelOpen.transaction_id});
-
-  const [waitClose] = (await getPendingChannels({lnd})).pending_channels;
-
-  strictEqual(waitClose.local_balance, 986530, 'Original balance');
-  strictEqual(waitClose.pending_balance, 986530, 'Waiting on balance');
-
-  strictEqual(waitClose.capacity, 1000000, 'Got channel closing capacity');
-  strictEqual(waitClose.is_active, false, 'Not active yet');
-  strictEqual(waitClose.is_closing, true, 'Channel is closing');
-  strictEqual(waitClose.is_opening, false, 'Not opening channel');
-  strictEqual(waitClose.local_reserve, 10000, 'Local reserve of closing');
-  strictEqual(waitClose.partner_public_key, target.id, 'Pkey');
-  strictEqual(waitClose.pending_payments, undefined, 'No pending payments');
-  strictEqual(waitClose.received, 0, 'Nothing received');
-  strictEqual(waitClose.recovered_tokens, undefined, 'Funds not recovered');
-  strictEqual(waitClose.remote_reserve, 10000, 'Remote reserve');
-  strictEqual(waitClose.sent, 0, 'No sent tokens');
-  strictEqual(waitClose.timelock_expiration, undefined, 'No timelock data');
-  strictEqual(waitClose.transaction_fee, null, 'No tx fee data');
-  strictEqual(waitClose.transaction_id, channelOpen.transaction_id, 'Txid');
-  strictEqual(waitClose.transaction_vout, channelOpen.transaction_vout, 'Vt');
-  strictEqual(waitClose.transaction_weight, null, 'No funding tx weight data');
-
-  if (!!waitClose.remote_balance) {
-    strictEqual(waitClose.remote_balance, giftTokens, 'Remote tokens');
-  }
-
-  strictEqual(waitClose.sent, 0, 'Channel never sent funds');
-  strictEqual(waitClose.timelock_expiration, undefined, 'Not timelocked yet');
-  strictEqual(waitClose.transaction_id, channelOpen.transaction_id, 'txid');
-  strictEqual(waitClose.transaction_vout, channelOpen.transaction_vout, 'out');
-
-  // Wait for generation to be over
-  await asyncRetry({interval, times}, async () => {
-    // Generate to confirm the tx
-    await generate({});
-
-    const [forceClose] = (await getPendingChannels({lnd})).pending_channels;
-
-    if (!forceClose.close_transaction_id) {
-      throw new Error('ExpectedCloseTransactionId');
-    }
-
-    if (!forceClose.timelock_expiration) {
-      throw new Error('ExpectedTimelockExpiration');
-    }
-
-    return;
-  });
-
-  const [forceClose] = (await getPendingChannels({lnd})).pending_channels;
-
-  strictEqual(forceClose.local_balance, 986530, 'Original balance');
-  strictEqual(forceClose.pending_balance, 986860, 'Waiting on balance');
-
-  strictEqual(forceClose.capacity, 1000000, 'Got channel close capacity');
-  strictEqual(forceClose.close_transaction_id, channelClose.transaction_id);
-  strictEqual(forceClose.is_active, false, 'Not active anymore');
-  strictEqual(forceClose.is_closing, true, 'Channel is force closing');
-  strictEqual(forceClose.is_timelocked, true, 'Force close funds timelocked');
-  strictEqual(forceClose.is_opening, false, 'Channel is not opening');
-  strictEqual(forceClose.partner_public_key, target.id, 'pk');
-  strictEqual(forceClose.received, 0, 'No receive amount');
-  strictEqual(forceClose.recovered_tokens, undefined, 'No recovered amount');
-
-  // LND 0.14.5 and below do not support remote balance info
-  if (!!forceClose.remote_balance) {
-    strictEqual(forceClose.remote_balance, giftTokens, 'Got gift remote');
-  } else {
-    strictEqual(forceClose.remote_balance, 0, 'No remote balance');
-  }
-
-  strictEqual(forceClose.sent, 0, 'No sent amount');
-  strictEqual(!!forceClose.timelock_blocks, true, 'Timelock blocks set');
-  strictEqual(forceClose.timelock_expiration, startHeight + 265, 'Funds lock');
-  strictEqual(forceClose.transaction_id, channelOpen.transaction_id, 'Txid');
-  strictEqual(forceClose.transaction_vout, channelOpen.transaction_vout, 'V');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_pending_payments.js

@@ -1,86 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {createInvoice} = require('./../../');
-const {deleteForwardingReputations} = require('./../../');
-const {getHeight} = require('./../../');
-const {getInvoice} = require('./../../');
-const {getPayment} = require('./../../');
-const {getPendingPayments} = require('./../../');
-const {payViaPaymentRequest} = require('./../../');
-const {subscribeToForwardRequests} = require('./../../');
-const {subscribeToPayViaRequest} = require('./../../');
-const waitForRoute = require('./../macros/wait_for_route');
-
-const size = 3;
-const tokens = 100;
-
-// Getting pending payments should list out payments in flight
-test(`Get pending payments`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  const channel = await setupChannel({generate, lnd, to: target});
-
-  await remote.generate({count: 100});
-
-  const remoteChan = await setupChannel({
-    lnd: target.lnd,
-    generate: target.generate,
-    to: remote,
-  });
-
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  const {routes} = await waitForRoute({lnd, tokens, destination: remote.id});
-
-  let height;
-  const [route] = routes;
-
-  {
-    const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-    const sub = subscribeToForwardRequests({lnd: target.lnd});
-
-    sub.once('forward_request', async forward => {
-      const {pending} = await getPayment({lnd, id: invoice.id});
-
-      const {next, payments} = await getPendingPayments({lnd});
-
-      deepStrictEqual(next, undefined, 'No more pages');
-      deepStrictEqual(payments.length, 1, 'A single pending payment');
-
-      const [payment] = payments;
-
-      deepStrictEqual(payment.destination, remote.id, 'Paying to remote');
-      deepStrictEqual(payment.index, 1, 'First payment');
-      deepStrictEqual(payment.request, invoice.request, 'Paying request');
-      deepStrictEqual(payment.confirmed_at, undefined, 'Not a payment');
-      deepStrictEqual(!!payment.created_at, true, 'Has created date');
-      deepStrictEqual(payment.fee, undefined, 'No fee yet');
-      deepStrictEqual(payment.fee_mtokens, undefined, 'No fee mtokens');
-      deepStrictEqual(payment.hops.length, 1, 'Going through hops');
-      deepStrictEqual(payment.id, invoice.id, 'Paying to the same hash');
-      deepStrictEqual(payment.is_confirmed, false, 'Payment is pending');
-      deepStrictEqual(payment.is_outgoing, true, 'Outgoing payment type');
-      deepStrictEqual(payment.mtokens, invoice.mtokens, 'Paying invoiced');
-      deepStrictEqual(payment.safe_fee, undefined, 'No fee paid yet');
-      deepStrictEqual(payment.safe_tokens, invoice.tokens, 'Paying tokens');
-      deepStrictEqual(payment.secret, undefined, 'Preimage not yet known');
-      deepStrictEqual(payment.tokens, invoice.tokens, 'Paying invoiced');
-
-      return forward.accept();
-    });
-
-    await payViaPaymentRequest({lnd, request: invoice.request});
-  }
-
-  await kill({});
-
-  return;
-});