ln-service 59.4.1 → 59.6.0

package/test/integration/test_decode_payment_request.js

@@ -1,75 +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 {createInvoice} = require('./../../');
-const {decodePaymentRequest} = require('./../../');
-const {getIdentity} = require('./../../');
-const {getWalletInfo} = require('./../../');
-
-const interval = 50;
-const times = 4000;
-
-const tests = [
-  {
-    description: "Test invoice",
-    expected: {
-      cltv_delta: 99,
-      description: 'Read: Global Cryptocurrency Regulation',
-      id: '7426ba0604c3f8682c7016b44673f85c5bd9da2fa6c1080810cf53ae320c9863',
-      mtokens: '150000',
-      secret: '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f',
-      safe_tokens: 150,
-      tokens: 150,
-    },
-  },
-];
-
-tests.forEach(({description, expected}) => {
-  return test(description, async () => {
-    const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
-
-    await asyncRetry({interval, times}, async () => {
-      const wallet = await getWalletInfo({lnd});
-
-      await generate({});
-
-      if (!wallet.is_synced_to_chain) {
-        throw new Error('NotSyncedToChain');
-      }
-    });
-
-    try {
-      const {request} = await createInvoice({
-        lnd,
-        cltv_delta: expected.cltv_delta,
-        description: expected.description,
-        secret: expected.secret,
-        tokens: expected.tokens,
-      });
-
-      const decoded = await decodePaymentRequest({lnd, request});
-      const identity = (await getIdentity({lnd})).public_key;
-
-      strictEqual(decoded.chain_addresses, expected.chain_addresses, 'Addr');
-      strictEqual(decoded.cltv_delta, expected.cltv_delta, 'Decode cltv');
-      strictEqual(!!decoded.created_at, true, 'Created at date');
-      strictEqual(decoded.description, expected.description, 'Decode desc');
-      strictEqual(decoded.description_hash, expected.description_hash, 'Hash');
-      strictEqual(decoded.destination, identity, 'Got public key');
-      strictEqual(!!decoded.expires_at, true, 'Expiration date decoded');
-      strictEqual(decoded.id, expected.id, 'Decoded payment hash');
-      strictEqual(decoded.mtokens, expected.mtokens, 'Decode millitokens');
-      strictEqual(decoded.safe_tokens, expected.safe_tokens, 'Safe amount');
-      strictEqual(decoded.tokens, expected.tokens, 'Decode tokens amount');
-    } catch (err) {
-      strictEqual(err, null, 'Expected no error');
-    }
-
-    await kill({});
-
-    return;
-  });
-});

package/test/integration/test_delete_payment.js

@@ -1,38 +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 {deletePayment} = require('./../../');
-const {getPayments} = require('./../../');
-const {pay} = require('./../../');
-
-const size = 2;
-const tokens = 100;
-
-// Deleting a payment should delete the payment record
-test('Delete payment', 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 priorLength = (await getPayments({lnd})).payments.length;
-
-  await deletePayment({lnd, id: invoice.id});
-
-  const wipedLength = (await getPayments({lnd})).payments.length;
-
-  strictEqual(priorLength - wipedLength, [paid].length, 'Payment deleted');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_delete_payments.js

@@ -1,42 +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 {createInvoice} = require('./../../');
-const {deletePayments} = require('./../../');
-const {getPayments} = require('./../../');
-const {pay} = require('./../../');
-
-const size = 2;
-const times = 1000;
-const tokens = 100;
-
-// Deleting payments should delete all payments
-test('Delete 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 asyncRetry({times}, async () => {
-    return await pay({lnd, request: invoice.request});
-  });
-
-  const priorLength = (await getPayments({lnd})).payments.length;
-
-  await deletePayments({lnd});
-
-  const wipedLength = (await getPayments({lnd})).payments.length;
-
-  strictEqual(priorLength - wipedLength, [paid].length, 'History deleted');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_delete_pending_channel.js

@@ -1,202 +0,0 @@
-const {deepEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncEach = require('async/each');
-const asyncRetry = require('async/retry');
-const asyncTimeout = require('async/timeout');
-const {extractTransaction} = require('psbt');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-const tinysecp = require('tiny-secp256k1');
-
-const {addPeer} = require('./../../');
-const {broadcastChainTransaction} = require('./../../');
-const {cancelPendingChannel} = require('./../../');
-const {deletePendingChannel} = require('./../../');
-const {fundPendingChannels} = require('./../../');
-const {fundPsbt} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getChannels} = require('./../../');
-const {getLockedUtxos} = require('./../../');
-const {getMasterPublicKeys} = require('./../../');
-const {getPendingChannels} = require('./../../');
-const {getWalletInfo} = require('./../../');
-const {openChannels} = require('./../../');
-const {signPsbt} = require('./../../');
-const {unlockUtxo} = require('./../../');
-
-const capacity = 1e6;
-const count = 100;
-const delay = n => new Promise(resolve => setTimeout(resolve, n));
-const description = 'description';
-const interval = 100;
-const race = promises => Promise.race(promises);
-const size = 3;
-const timeout = 1000 * 20;
-const times = 2000;
-
-// Forfeiting a pending channel should remove the pending channel
-test(`Forfeit pending channel`, async t => {
-  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
-
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  await asyncRetry({interval, times}, async () => {
-    const wallet = await getWalletInfo({lnd});
-
-    await generate({});
-
-    if (!wallet.is_synced_to_chain) {
-      throw new Error('NotSyncedToChain');
-    }
-  });
-
-  await generate({count});
-
-  await asyncEach([target, remote], async node => {
-    return await addPeer({lnd, public_key: node.id, socket: node.socket});
-  });
-
-  const channels = [{
-    capacity,
-    description,
-    is_private: true,
-    partner_public_key: target.id,
-  }];
-
-  // Propose a channel to target
-  const proposeToTarget = await asyncRetry({interval: 1000, times}, cbk => {
-    return asyncTimeout(openChannels, 1000 * 3)({
-      channels,
-      lnd,
-      is_avoiding_broadcast: true,
-    },
-    async (err, res) => {
-      await generate({});
-
-      await asyncEach([target, remote], async node => {
-        return await addPeer({lnd, public_key: node.id, socket: node.socket});
-      });
-
-      return cbk(err, res)
-    });
-  });
-
-  // Setup funding for the target
-  const fundTarget = await fundPsbt({lnd, outputs: proposeToTarget.pending});
-
-  // Sign the funding to the target
-  const signTarget = await signPsbt({lnd, psbt: fundTarget.psbt});
-
-  // Fund the target channel that will get stuck
-  await fundPendingChannels({
-    lnd,
-    channels: proposeToTarget.pending.map(n => n.id),
-    funding: signTarget.psbt,
-  });
-
-  await asyncEach((await getLockedUtxos({lnd})).utxos, async utxo => {
-    return await unlockUtxo({
-      lnd,
-      id: utxo.lock_id,
-      transaction_id: utxo.transaction_id,
-      transaction_vout: utxo.transaction_vout,
-    });
-  });
-
-  // Propose a channel to remote
-  const proposeToRemote = await asyncRetry({interval: 1000, times}, cbk => {
-    return asyncTimeout(openChannels, 1000 * 3)({
-      lnd,
-      channels: [{
-        capacity,
-        description,
-        is_private: true,
-        partner_public_key: remote.id,
-      }],
-      is_avoiding_broadcast: true,
-    },
-    cbk);
-  });
-
-  // Setup funding for the remote, using the same inputs
-  const fundRemote = await fundPsbt({
-    lnd,
-    inputs: fundTarget.inputs,
-    outputs: proposeToRemote.pending
-  });
-
-  // Sign the funding to the target
-  const signRemote = await signPsbt({lnd, psbt: fundRemote.psbt});
-
-  // Fund the remote channel
-  await fundPendingChannels({
-    lnd,
-    channels: proposeToRemote.pending.map(n => n.id),
-    funding: signRemote.psbt,
-  });
-
-  await delay(2000);
-
-  const {transaction} = extractTransaction({ecp, psbt: signRemote.psbt});
-
-  await broadcastChainTransaction({lnd, transaction});
-
-  await generate({});
-
-  const channel = await asyncRetry({interval: 1000, times}, async () => {
-    const [channel] = (await getChannels({lnd})).channels;
-
-    // Exit early when the channel is created
-    if (!!channel) {
-      return channel;
-    }
-
-    await broadcastChainTransaction({lnd, transaction});
-
-    await generate({});
-
-    throw new Error('ExpectedNewChannelCreated');
-  });
-
-  const [pending] = (await getPendingChannels({lnd})).pending_channels;
-
-  // Description is not supported in LND 0.16.4 or before
-  if (!!pending.description) {
-    deepEqual(pending.description, description, 'Got expected description');
-    deepEqual(pending.is_private, true, 'Got pending private status');
-  }
-
-  const stuckTx = extractTransaction({ecp, psbt: signTarget.psbt});
-
-  const [stuckPending] = proposeToTarget.pending;
-
-  // Try to cancel the pending channel, it will fail
-  try {
-    await cancelPendingChannel({lnd, id: stuckPending.id});
-  } catch (err) {
-    const [code] = err;
-
-    deepEqual(code, 503, 'Pending channel cannot be canceled');
-  }
-
-  try {
-    await deletePendingChannel({
-      lnd,
-      confirmed_transaction: transaction,
-      pending_transaction: stuckTx.transaction,
-      pending_transaction_vout: pending.transaction_vout,
-    });
-
-    const [notPending] = (await getPendingChannels({lnd})).pending_channels;
-
-    deepEqual(notPending, undefined, 'Conflicting pending deleted');
-  } catch (err) {
-    deepEqual(err, [501, 'DeletePendingChannelMethodNotSupported']);
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_encrypted_routes.js

@@ -1,66 +0,0 @@
-const asyncRetry = require('async/retry');
-const {strictEqual} = 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 {decodePaymentRequest} = require('./../../');
-const {getWalletInfo} = require('./../../');
-const {parsePaymentRequest} = require('./../../');
-const {pay} = require('./../../');
-
-const count = 100;
-const expiry = () => new Date(Date.now() + (4 * 60 * 60 * 1000)).toISOString();
-const give = 500000;
-const interval = 100;
-const size = 3;
-const times = 10000;
-const tokens = 100;
-
-// Paying to an encrypted routes invoice should result in a payment
-test(`Create an invoice`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  await generate({count});
-
-  try {
-    await setupChannel({generate, lnd, give_tokens: give, to: target});
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    await setupChannel({
-      generate: target.generate,
-      give_tokens: give,
-      lnd: target.lnd,
-      to: remote,
-    });
-
-    await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const invoice = await createInvoice({
-        lnd,
-        tokens,
-        expires_at: expiry(),
-        is_encrypting_routes: true,
-      });
-
-      await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-      await pay({lnd: remote.lnd, request: invoice.request});
-    });
-
-    await kill({});
-  } catch (err) {
-    await kill({});
-
-    strictEqual(err, null, 'Expected no error in create invoice');
-  }
-
-  return;
-});

package/test/integration/test_get_access_ids.js

@@ -1,27 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getAccessIds} = require('./../../');
-const {grantAccess} = require('./../../');
-
-const defaultId = '0';
-const id = '1';
-
-// Getting access ids should return root macaroon ids
-test(`Get access ids`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{lnd}] = nodes;
-
-  await grantAccess({id, lnd, is_ok_to_create_chain_addresses: true});
-
-  const {ids} = await getAccessIds({lnd});
-
-  deepStrictEqual(ids, [defaultId, id], 'Got expected access ids');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_backup.js

@@ -1,40 +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 {getBackup} = require('./../../');
-const {verifyBackup} = require('./../../');
-
-const size = 2;
-
-// Getting a channel backup should return a channel backup
-test(`Get channel backup`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target] = nodes;
-
-  const channel = await setupChannel({generate, lnd, to: target});
-
-  const {backup} = await getBackup({
-    lnd,
-    transaction_id: channel.transaction_id,
-    transaction_vout: channel.transaction_vout,
-  });
-
-  deepStrictEqual(!!backup, true, 'Channel backup is returned');
-
-  const channelBackup = await verifyBackup({
-    backup,
-    lnd,
-    transaction_id: channel.transaction_id,
-    transaction_vout: channel.transaction_vout,
-  });
-
-  deepStrictEqual(channelBackup.is_valid, true, 'Is a valid backup');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_backups.js

@@ -1,38 +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 {getBackups} = require('./../../');
-
-const size = 2;
-
-// Getting a set of channel backups should return channel backups
-test(`Get channel backup`, async () => {
-  await asyncRetry({}, async () => {
-    const {kill, nodes} = await spawnLightningCluster({size});
-
-    const [{generate, lnd}, target] = nodes;
-
-    const channel = await setupChannel({generate, lnd, to: target});
-
-    const {backup, channels} = await getBackups({lnd});
-
-    strictEqual(!!backup, true, 'Multi-backup blob is returned');
-    strictEqual(channels.length, [channel].length, 'Individualized backup');
-
-    const [chanBackup] = channels;
-
-    strictEqual(!!chanBackup.backup.length, true, 'Channel backup has blob');
-    strictEqual(chanBackup.transaction_id, channel.transaction_id, 'Chan id');
-    strictEqual(chanBackup.transaction_vout, channel.transaction_vout, 'Vout');
-
-    await kill({});
-
-    return;
-  });
-
-  return;
-});

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;
-});