ln-service 59.5.0 → 59.7.0

package/test/integration/test_get_chain_balance.js

@@ -1,36 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getChainBalance} = require('./../../');
-
-const count = 100;
-const emptyChainBalance = 0;
-const tokens = 5000000000;
-
-// Getting chain balance should result in a chain balance
-test(`Get the chain balance`, async ({end, equal}) => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{generate, lnd}] = nodes;
-
-  // The initial chain balance should be zero
-  {
-    const result = await getChainBalance({lnd});
-
-    strictEqual(result.chain_balance, emptyChainBalance, 'Got chain balance');
-  }
-
-  // Generate some funds for LND
-  await generate({count});
-
-  // Check that the balance is updated
-  const postDeposit = await getChainBalance({lnd});
-
-  strictEqual(postDeposit.chain_balance >= tokens, true, 'Got funds');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_chain_fee_estimate.js

@@ -1,63 +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 {createChainAddress} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getChainFeeEstimate} = require('./../../');
-
-const expectedFee = 4625;
-const expectedFeeRate = 25;
-const format = 'np2wpkh';
-const size = 2;
-const times = 200;
-const tokens = 1e6;
-
-// Getting a chain fee estimate should return an estimate of the chain fee
-test(`Get chain fee estimate`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [control, {lnd}] = nodes;
-
-  const address1 = (await createChainAddress({lnd})).address;
-  const address2 = (await createChainAddress({format, lnd})).address;
-
-  // Generate coins for the node
-  await asyncRetry({times}, async () => {
-    if (!(await getChainBalance({lnd: control.lnd})).chain_balance) {
-      await control.generate({});
-
-      throw new Error('ExpectedChainBalance');
-    }
-  });
-
-  const estimate = await getChainFeeEstimate({
-    lnd: control.lnd,
-    send_to: [
-      {address: address1, tokens: tokens / [address1, address2].length},
-      {address: address2, tokens: tokens / [address1, address2].length},
-    ],
-  });
-
-  // LND 0.15.4 and below uses P2WPKH as change
-  if (estimate.fee === 8650) {
-    strictEqual(estimate.fee, 8650, 'Total fee is estimated');
-  } else if (estimate.fee === 9250) { // LND 0.18.5 and below fee rate
-    strictEqual(estimate.fee, 9250, 'Total fee is estimated');
-  } else {
-    strictEqual(estimate.fee, expectedFee, 'Total fee is estimated');
-  }
-
-  // LND 0.18.5 and below fee rate is higher
-  if (estimate.tokens_per_vbyte === 50) {
-    strictEqual(estimate.tokens_per_vbyte, 50, 'Got fee/vbyte');
-  } else {
-    strictEqual(estimate.tokens_per_vbyte, expectedFeeRate, 'Got fee/vbyte');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_chain_transactions.js

@@ -1,83 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getChainTransactions} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-const count = 100;
-const defaultFee = 1e3;
-const format = 'np2wpkh';
-const times = 300;
-
-// Getting chain transactions should list out the chain transactions
-test(`Get chain transactions`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{generate, lnd}] = nodes;
-
-  // Generate some funds for LND
-  await generate({count});
-
-  await asyncRetry({interval: 10, times: 6000}, async () => {
-    const wallet = await getWalletInfo({lnd});
-
-    if (!wallet.is_synced_to_chain) {
-      throw new Error('ExpectedWalletSyncedToChain');
-    }
-
-    await generate({});
-
-    if (wallet.current_block_height < count + 1) {
-      throw new Error('ExpectedFullySyncedToChain');
-    }
-  });
-
-  // Wait for generation to be over
-  const transactions = await asyncRetry({times}, async () => {
-    const {transactions} = await getChainTransactions({lnd});
-
-    const [tx] = transactions;
-
-    if (!tx.is_confirmed) {
-      throw new Error('ExpectedTransactionConfirmed');
-    }
-
-    return transactions;
-  });
-
-  equal(transactions.length > 1, true, 'Transaction found');
-
-  const [tx] = transactions;
-
-  equal(!!tx.block_id, true, 'Transaction has block id');
-  equal(!!tx.confirmation_count, true, 'Transaction confirm count');
-  equal(!!tx.confirmation_height, true, 'Transaction confirm height');
-  equal(!!tx.created_at, true, 'Transaction record create time');
-  equal(tx.description, undefined, 'No tx description');
-  equal(tx.fee, undefined, 'No transaction fee');
-  equal(!!tx.id, true, 'Transaction id');
-  equal(tx.is_confirmed, true, 'Transaction is confirmed');
-  equal(tx.is_outgoing, false, 'Transaction is incoming');
-  equal(tx.output_addresses.length, 1, 'Tx output address');
-  equal(tx.tokens, 5000000000, 'Got coinbase reward tokens');
-  equal(!!tx.transaction, true, 'Got transaction hex');
-
-  const onlyBefore = await getChainTransactions({lnd, before: 2});
-
-  equal(onlyBefore.transactions.length < 100, true, 'Got before txs');
-
-  const between = await getChainTransactions({
-    lnd,
-    after: tx.confirmation_height - 1,
-    before: tx.confirmation_height + 1,
-  });
-
-  equal(between.transactions.length, [tx].length, 'One transaction');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_channel.js

@@ -1,64 +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 {getChannel} = require('./../../');
-const {getChannels} = require('./../../');
-
-const {ceil} = Math;
-const size = 2;
-
-// Getting a channel should return channel details from the channel graph
-test(`Get channel`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  await setupChannel({generate, lnd, to: target});
-
-  const [channel] = (await getChannels({lnd})).channels;
-
-  const details = await getChannel({lnd, id: channel.id});
-
-  strictEqual(details.capacity, channel.capacity, 'Capacity');
-  strictEqual(details.policies.length, size, 'Policies for both nodes');
-
-  details.policies.forEach(policy => {
-    strictEqual(policy.base_fee_mtokens, '1000', 'Base fee mtokens');
-    strictEqual([40, 80].includes(policy.cltv_delta), true, 'CLTV policy');
-    strictEqual(policy.fee_rate, 1, 'Fee rate');
-    strictEqual(policy.is_disabled, false, 'Disabled flag');
-    strictEqual(policy.max_htlc_mtokens, `${ceil(details.capacity*0.99)}000`);
-    strictEqual(!!policy.min_htlc_mtokens, true, 'Min HTLC value');
-    strictEqual(policy.public_key.length, 66, 'Policy public key');
-    strictEqual(Date.now()-new Date(policy.updated_at) < 1e5, true, 'Updated');
-
-    return;
-  });
-
-  strictEqual(details.transaction_id, channel.transaction_id, 'Funding tx id');
-  strictEqual(details.transaction_vout, channel.transaction_vout, 'Tx vout');
-
-  strictEqual(Date.now()-new Date(details.updated_at) < 1e5, true, 'Updated');
-
-  try {
-    const details = await getChannel({
-      lnd,
-      transaction_id: channel.transaction_id,
-      transaction_vout: channel.transaction_vout,
-    });
-  } catch (err) {
-    const [code] = err;
-
-    // On LND 0.18.0 and below a transaction id and vout is not supported
-    if (code !== 404) {
-      throw err;
-    }
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_channel_balance.js

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

package/test/integration/test_get_channels.js

@@ -1,84 +0,0 @@
-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 {getChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-const anchorFeatureBit = 23;
-const giveTokens = 1e5;
-const remoteCsv = 40;
-const size = 2;
-
-// Getting channels should return the list of channels
-test(`Get channels`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  const chan = await setupChannel({
-    generate,
-    lnd,
-    give_tokens: giveTokens,
-    partner_csv_delay: remoteCsv,
-    to: target,
-  });
-
-  const [channel] = (await getChannels({lnd})).channels;
-  const {features} = await getWalletInfo({lnd});
-  const [targetChan] = (await getChannels({lnd: target.lnd})).channels;
-
-  strictEqual(targetChan.is_partner_initiated, true, 'Self-init channel');
-
-  if (!!channel.local_given) {
-    strictEqual(channel.local_given, giveTokens, 'Push tokens are reflected');
-    strictEqual(channel.remote_given, Number(), 'Push tokens are reflected');
-  }
-
-  if (!!channel.remote_given) {
-    strictEqual(channel.local_given, Number(), 'Push tokens are reflected');
-    strictEqual(channel.remote_given, giveTokens, 'Push tokens are reflected');
-  }
-
-  if (channel.remote_csv === remoteCsv) {
-    strictEqual(channel.local_csv, 144, 'Local CSV is returned');
-    ok(channel.local_dust >= 354, 'Local dust limit 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');
-    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');
-  }
-
-  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;
-});

package/test/integration/test_get_closed_channels.js

@@ -1,275 +0,0 @@
-const {exit} = require('node:process');
-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 {closeChannel} = require('./../../');
-const {createHodlInvoice} = require('./../../');
-const {getClosedChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-const {settleHodlInvoice} = require('./../../');
-const {subscribeToInvoice} = require('./../../');
-const {subscribeToPayViaRequest} = require('./../../');
-
-const defaultFee = 1e3;
-const interval = 125;
-const maxChanTokens = Math.pow(2, 24) - 1;
-const size = 2;
-const times = 1000;
-
-// Getting closed channels should return closed channels
-test(`Get closed channels`, async t => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  t.after(() => exit());
-
-  const [control, target] = nodes;
-
-  const {generate, lnd} = control;
-
-  const channelOpen = await setupChannel({
-    generate,
-    lnd,
-    capacity: maxChanTokens,
-    partner_csv_delay: 20,
-    to: target,
-  });
-
-  const closing = await closeChannel({
-    lnd,
-    tokens_per_vbyte: defaultFee,
-    transaction_id: channelOpen.transaction_id,
-    transaction_vout: channelOpen.transaction_vout,
-  });
-
-  const {features} = await getWalletInfo({lnd});
-
-  const isAnchors = !!features.find(n => n.bit === 23);
-
-  // Wait for channel to close
-  await asyncRetry({interval, times}, async () => {
-    await generate({});
-
-    const {channels} = await getClosedChannels({lnd});
-
-    if (!channels.length) {
-      throw new Error('ExpectedClosedChannel');
-    }
-  });
-
-  const {channels} = await getClosedChannels({lnd});
-
-  const [channel] = channels;
-
-  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) {
-    strictEqual([53345, 28473, 2810].includes(spend), true, 'Final');
-  } else {
-    strictEqual(spend, 9050, 'Final');
-  }
-
-  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_tokens: 3e5,
-    partner_csv_delay: 20,
-    to: target,
-  });
-
-  const cancelInvoice = await createHodlInvoice({
-    lnd,
-    cltv_delta: 20,
-    tokens: 1e5,
-  });
-
-  const settleInvoice = await createHodlInvoice({
-    lnd,
-    cltv_delta: 144,
-    tokens: 1e5,
-  });
-
-  const subCancelInvoice = subscribeToInvoice({lnd, id: cancelInvoice.id});
-  const subSettleInvoice = subscribeToInvoice({lnd, id: settleInvoice.id});
-
-  const cancelInvoiceUpdates = [];
-  const settleInvoiceUpdates = [];
-
-  subCancelInvoice.on('invoice_updated', n => cancelInvoiceUpdates.push(n));
-  subSettleInvoice.on('invoice_updated', n => settleInvoiceUpdates.push(n));
-
-  // Kick off a payment to the cancel invoice
-  const payToCancel = subscribeToPayViaRequest({
-    lnd: target.lnd,
-    request: cancelInvoice.request,
-  });
-
-  // Kick off a payment to the settle invoice
-  const payToSettle = subscribeToPayViaRequest({
-    lnd: target.lnd,
-    request: settleInvoice.request,
-  });
-
-  await asyncRetry({interval, times}, async () => {
-    if (!cancelInvoiceUpdates.filter(n => !!n.is_held).length) {
-      throw new Error('WaitingForLockToCancelInvoice');
-    }
-
-    if (!settleInvoiceUpdates.filter(n => !!n.is_held).length) {
-      throw new Error('WaitingForLockToSettleInvoice');
-    }
-
-    // Push the held HTLCs to chain
-    await closeChannel({
-      lnd: target.lnd,
-      is_force_close: true,
-      transaction_id: toForceClose.transaction_id,
-      transaction_vout: toForceClose.transaction_vout,
-    });
-  });
-
-  // Use the preimage to sweep the settle invoice on chain
-  await settleHodlInvoice({lnd, secret: settleInvoice.secret});
-
-  // LND 0.12.0 requires a delay before sweeps start
-  const deadChans = await asyncRetry({interval: 1000, times: 99}, async () => {
-    const {channels} = await getClosedChannels({lnd});
-
-    if (channels.length === [toForceClose, channelOpen].length) {
-      return channels;
-    }
-
-    await target.generate({});
-    await generate({});
-
-    throw new Error('WaitingForForceClose');
-  });
-
-  const forced = deadChans.find(n => !!n.is_remote_force_close);
-
-  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);
-
-  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);
-
-  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});
-
-    if (channels.length === [toForceClose, channelOpen].length) {
-      return channels;
-    }
-
-    await target.generate({});
-
-    throw new Error('WaitingForTargetForceClose');
-  });
-
-  const forceClosed = alsoDead.find(n => !!n.is_local_force_close);
-
-  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);
-
-  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);
-
-  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;
-});

package/test/integration/test_get_configuration.js

@@ -1,35 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const {equal} = require('node:assert').strict;
-const {ok} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getConfiguration} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-// Getting the configuration info should return info about the config
-test(`Get configuration info`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{lnd}] = nodes;
-
-  try {
-    const {log, options} = await getConfiguration({lnd});
-
-    ok(!!log.length, 'Got the log lines');
-
-    const color = options.find(n => n.type === 'color').value.toLowerCase();
-
-    equal(color, (await getWalletInfo({lnd})).color, 'Got color from config');
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    deepEqual(err, [501, 'GetDebugConfigurationInfoNotSupported'], '404');
-  }
-
-  return;
-});