ln-service 59.5.0 → 59.7.0

package/test/integration/test_create_invoice.js

@@ -1,49 +0,0 @@
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createInvoice} = require('./../../');
-const {parsePaymentRequest} = require('./../../');
-
-const count = 100;
-
-// createInvoice should result in a created invoice
-test(`Create an invoice`, async () => {
-  const [{generate, kill, lnd}] = (await spawnLightningCluster({})).nodes;
-
-  await generate({count});
-
-  try {
-    const invoice = await createInvoice({lnd});
-
-    const parsed = parsePaymentRequest({request: invoice.request});
-
-    strictEqual(invoice.chain_address, undefined, 'Address is undefined');
-    strictEqual(invoice.created_at, parsed.created_at, 'Invoice created date');
-    strictEqual(invoice.description, undefined, 'Description undefined');
-    strictEqual(invoice.id, parsed.id, 'Invoice has id');
-    strictEqual(invoice.mtokens, '0', 'Default mtokens are 0');
-    strictEqual(!!invoice.request, true, 'Invoice has request');
-    strictEqual(!!invoice.secret, true, 'Invoice returns secret');
-    strictEqual(invoice.tokens, 0, 'Default tokens are 0');
-
-    try {
-      const duplicate = await createInvoice({lnd, secret: invoice.secret});
-
-      equal(duplicate, null, 'Expected no duplicate invoice');
-    } catch (err) {
-      const [code, message] = err;
-
-      strictEqual(code, 409, 'Got expected error code');
-      strictEqual(message, 'InvoiceWithGivenHashAlreadyExists', 'Got msg');
-    }
-
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error in create invoice');
-  }
-
-  await kill({});
-
-  return;
-});

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,162 +0,0 @@
-const asyncRetry = require('async/retry');
-const {equal} = require('node:assert').strict;
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const {paymentPathFromChannels} = require('bolt04');
-const {setupChannel} = require('ln-docker-daemons');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {createInvoice} = require('./../../');
-const {createSignedRequest} = require('./../../');
-const {createUnsignedRequest} = require('./../../');
-const {decodePaymentRequest} = require('./../../');
-const {getChannel} = require('./../../');
-const {getHeight} = require('./../../');
-const {getInvoice} = 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 hopCount = 5;
-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 encrypted routes invoice`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, lnd}, target, remote] = nodes;
-
-  await generate({count});
-
-  try {
-    const channel1 = await setupChannel({
-      generate,
-      lnd,
-      give_tokens: give,
-      to: target,
-    });
-
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-    const channel2 = 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});
-    });
-
-    // Try padded variations on encrypted routes
-    const remoteInvoice = await createInvoice({tokens, lnd: remote.lnd});
-    const targetInvoice = await createInvoice({tokens, lnd: target.lnd});
-
-    const remotePaymentDetails = parsePaymentRequest({
-      request: remoteInvoice.request,
-    });
-
-    const targetPaymentDetails = parsePaymentRequest({
-      request: targetInvoice.request,
-    });
-
-    const remoteHeight = await getHeight({lnd: remote.lnd});
-    const targetHeight = await getHeight({lnd: target.lnd});
-
-    // Paying to a direct peer but with dummy hops to hide that
-    const targetPath = paymentPathFromChannels({
-      channels: [],
-      cltv_delta: targetPaymentDetails.cltv_delta + 3,
-      destination: targetPaymentDetails.destination,
-      current_block_height: targetHeight.current_block_height,
-      hop_count: hopCount,
-      id: targetPaymentDetails.payment,
-      max_mtokens: targetPaymentDetails.mtokens,
-    });
-
-    // Paying to an indirect peer with a receiver fee added
-    const remotePath = paymentPathFromChannels({
-      channels: [await getChannel({lnd: remote.lnd, id: channel2.id})],
-      cltv_delta: remotePaymentDetails.cltv_delta + 3,
-      destination: remotePaymentDetails.destination,
-      current_block_height: remoteHeight.current_block_height,
-      hop_count: hopCount,
-      id: remotePaymentDetails.payment,
-      max_mtokens: remotePaymentDetails.mtokens,
-      receiver_base_fee_mtokens: '1000',
-      receiver_fee_rate: 10000,
-    });
-
-    equal(remotePath.hops.length, hopCount, 'Got expected hops for target');
-    equal(targetPath.hops.length, hopCount, 'Got expected hops for remote');
-
-    // Try paying a remote path
-    {
-      // Make a blinded version of the invoice
-      const {hrp, tags} = createUnsignedRequest({
-        description: remotePaymentDetails.description,
-        expires_at: remotePaymentDetails.expires_at,
-        features: [{bit: 8}, {bit: 15}, {bit: 24}, {bit: 262}],
-        id: remotePaymentDetails.id,
-        mtokens: remotePaymentDetails.mtokens,
-        network: 'regtest',
-        paths: [remotePath],
-      });
-
-      const request = createSignedRequest({hrp, tags}).request;
-
-      await pay({lnd, request});
-
-      const received = await getInvoice({
-        id: remotePaymentDetails.id,
-        lnd: remote.lnd,
-      });
-
-      equal(received.received_mtokens, '102001', 'Got receiver fee');
-    }
-
-    // Try paying a peer path to target
-    {
-      // Make a blinded version of the invoice
-      const {hrp, tags} = createUnsignedRequest({
-        description: targetPaymentDetails.description,
-        expires_at: targetPaymentDetails.expires_at,
-        features: [{bit: 8}, {bit: 15}, {bit: 24}, {bit: 262}],
-        id: targetPaymentDetails.id,
-        mtokens: targetPaymentDetails.mtokens,
-        network: 'regtest',
-        paths: [targetPath],
-      });
-
-      await pay({lnd, request: createSignedRequest({hrp, tags}).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;
-});