ln-service 59.5.0 → 59.7.0

package/test/integration/test_get_route_to_destination.js

@@ -1,153 +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 {cancelHodlInvoice} = require('./../../');
-const {createInvoice} = require('./../../');
-const {decodePaymentRequest} = require('./../../');
-const {getInvoice} = require('./../../');
-const {getRouteToDestination} = require('./../../');
-const {parsePaymentRequest} = require('./../../');
-const {payViaRoutes} = require('./../../');
-
-const all = promise => Promise.all(promise);
-const interval = 10;
-const {isArray} = Array;
-const message = {type: '85805', value: '01'};
-const size = 3;
-const times = 3000;
-const tokens = 1000;
-
-// Getting a route to a destination should return a route to the destination
-test(`Get a route to a destination`, async () => {
-  await asyncRetry({}, async () => {
-    const {kill, nodes} = await spawnLightningCluster({size});
-
-    const [control, target, remote] = nodes;
-
-    await control.generate({count: 200});
-
-    await setupChannel({
-      generate: control.generate,
-      lnd: control.lnd,
-      to: target,
-    });
-
-    await setupChannel({
-      generate: target.generate,
-      give_tokens: 1e5,
-      is_private: true,
-      lnd: target.lnd,
-      to: remote,
-    });
-
-    const invoice = await asyncRetry({interval, times}, async () => {
-      const invoice = await createInvoice({
-        tokens,
-        is_including_private_channels: true,
-        lnd: remote.lnd,
-      });
-
-      const {routes} = parsePaymentRequest({request: invoice.request});
-
-      // Wait for private routes to get picked up
-      if (!routes) {
-        await cancelHodlInvoice({id: invoice.id, lnd: remote.lnd});
-
-        throw new Error('ExpectedRouteForInvoice');
-      }
-
-      return invoice;
-    });
-
-    const parsed = parsePaymentRequest({request: invoice.request});
-
-    await asyncRetry({interval, times}, async () => {
-      const {route} = await getRouteToDestination({
-        destination: parsed.destination,
-        features: parsed.features,
-        lnd: control.lnd,
-        payment: parsed.payment,
-        routes: parsed.routes,
-        mtokens: parsed.mtokens,
-        total_mtokens: parsed.mtokens,
-      });
-
-      const paid = await payViaRoutes({
-        id: parsed.id,
-        lnd: control.lnd,
-        routes: [route],
-      });
-
-      strictEqual(invoice.secret, paid.secret, 'Paid multi-hop private route');
-    });
-
-    const inv = await createInvoice({tokens, lnd: target.lnd});
-
-    const invDetails = await decodePaymentRequest({
-      lnd: control.lnd,
-      request: inv.request,
-    });
-
-    const controlToTarget = await getRouteToDestination({
-      destination: target.id,
-      features: invDetails.features,
-      lnd: control.lnd,
-      messages: [message],
-      payment: invDetails.payment,
-      tokens: invDetails.tokens / [control, remote].length,
-      total_mtokens: invDetails.mtokens,
-    });
-
-    const remoteToTarget = await getRouteToDestination({
-      destination: target.id,
-      features: invDetails.features,
-      lnd: remote.lnd,
-      messages: [message],
-      payment: invDetails.payment,
-      tokens: invDetails.tokens / [control, remote].length,
-      total_mtokens: invDetails.mtokens,
-    });
-
-    try {
-      const [controlPay, remotePay] = await all([
-        payViaRoutes({
-          id: invDetails.id,
-          lnd: control.lnd,
-          routes: [controlToTarget.route],
-        }),
-        payViaRoutes({
-          id: invDetails.id,
-          lnd: remote.lnd,
-          routes: [remoteToTarget.route],
-        }),
-      ]);
-
-      strictEqual(controlPay.secret, inv.secret, 'Control paid for secret');
-      strictEqual(remotePay.secret, inv.secret, 'Remote paid for secret');
-
-      const {payments} = await getInvoice({
-        id: invDetails.id,
-        lnd: target.lnd,
-      });
-
-      const [payment1, payment2] = payments;
-
-      const [message1] = payment1.messages;
-      const [message2] = payment2.messages;
-
-      deepStrictEqual(message1, message, 'Target received message');
-      deepStrictEqual(message2, message, 'Target received both messages');
-    } catch (err) {
-      strictEqual(err, null, 'Unexpected error paying invoice');
-    }
-
-    await kill({});
-  });
-
-  return;
-});

package/test/integration/test_get_settlement_status.js

@@ -1,78 +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 {createInvoice} = require('./../../');
-const {getSettlementStatus} = require('./../../');
-const {pay} = require('./../../');
-
-const fakeChannelId = '1x1x1';
-const interval = 100;
-const size = 2;
-const times = 2000;
-const tokens = 100;
-
-// Get the settlement status of an HTLC
-test(`Get settlement status`, async () => {
-  // LND 0.15.5 and below do not support settlement status lookups
-  {
-    const {kill, nodes} = await spawnLightningCluster({});
-
-    const [{lnd}] = nodes;
-
-    try {
-      await getSettlementStatus({
-        lnd,
-        channel: fakeChannelId,
-        payment: Number(),
-      });
-
-      await kill({});
-    } catch (err) {
-      const [code, message] = err;
-
-      if (code !== 404) {
-        equal(code, 501, 'Method unsupported');
-        equal(message, 'LookupHtlcResolutionMethodUnsupported', 'Unsupported');
-
-        await kill({});
-
-        return;
-      }
-    }
-  }
-
-  const {kill, nodes} = await spawnLightningCluster({
-    size,
-    lnd_configuration: ['--store-final-htlc-resolutions'],
-  });
-
-  const [{generate, lnd}, target] = nodes;
-
-  try {
-    const channel = await setupChannel({generate, lnd, to: target});
-
-    const {request} = await createInvoice({tokens, lnd: target.lnd});
-
-    const payment = await pay({lnd, request});
-
-    const settlement = await asyncRetry({interval, times}, async () => {
-      return await getSettlementStatus({
-        lnd: target.lnd,
-        channel: channel.id,
-        payment: Number(),
-      });
-    });
-
-    deepStrictEqual(settlement, {is_onchain: false, is_settled: true}, 'Stat');
-  } catch (err) {
-    deepStrictEqual(err, null, 'Expected no error');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_utxos.js

@@ -1,49 +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 {getUtxos} = require('./../../');
-
-const format = 'p2wpkh';
-const times = 300;
-const tokens = 1e8;
-
-// Getting utxos should list out the utxos
-test(`Get utxos`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{generate, lnd}] = nodes;
-
-  // Generate some funds for LND
-  await asyncRetry({times}, async () => {
-    await generate({});
-
-    const wallet = await getChainBalance({lnd});
-
-    if (!wallet.chain_balance) {
-      throw new Error('ExpectedChainBalanceForNode');
-    }
-  });
-
-  const {utxos} = await getUtxos({lnd});
-
-  strictEqual(!!utxos.length, true, 'Unspent output returned');
-
-  const [utxo] = utxos;
-
-  strictEqual(!!utxo.address, true, 'UTXO address returned');
-  strictEqual(utxo.address_format, format, 'UTXO address format returned');
-  strictEqual(utxo.confirmation_count, 100, 'Confirmation count returned');
-  strictEqual(!!utxo.output_script, true, 'Output script returned');
-  strictEqual(!!utxo.tokens, true, 'UTXO amount returned');
-  strictEqual(!!utxo.transaction_id, true, 'UTXO transaction id returned');
-  strictEqual(utxo.transaction_vout !== undefined, true, 'UTXO vout returned');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_get_wallet_info.js

@@ -1,55 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const {ok} = require('node:assert').strict;
-const {strictEqual} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {getWalletInfo} = require('./../../');
-
-const initHeight = 1;
-const interval = 10;
-const pubKeyHexLength = Buffer.alloc(33).toString('hex').length;
-const regtestChainId = '06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f';
-const times = 1000;
-const walletInfoType = 'wallet';
-
-// Getting the wallet info should return info about the wallet
-test(`Get wallet info`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({});
-
-  const [{generate, lnd}] = nodes;
-
-  try {
-    const result = await asyncRetry({interval, times}, async () => {
-      await generate({});
-
-      const result = await getWalletInfo({lnd});
-
-      if (result.current_block_height >= initHeight) {
-        return result;
-      }
-
-      throw new Error('ExpectedBlockHeightAtInitHeight');
-    });
-
-    strictEqual(result.active_channels_count, 0, 'Expected channels count');
-    strictEqual(!!result.alias, true, 'Expected alias');
-    deepStrictEqual(result.chains, [regtestChainId], 'Got chains');
-    strictEqual(!!result.current_block_hash, true, 'Expected best block hash');
-    ok(result.current_block_height >= initHeight, 'Expected block height');
-    strictEqual(!!result.latest_block_at, true, 'Last block time');
-    strictEqual(result.peers_count, 0, 'Expected wallet peers count');
-    strictEqual(result.pending_channels_count, 0, 'Expected pending channels');
-    strictEqual(result.public_key.length, pubKeyHexLength, 'Expected key');
-    deepStrictEqual(result.uris.length, 1, 'Expected node URI');
-    strictEqual(!!result.version, true, 'Expected version');
-  } catch (err) {
-    strictEqual(err, null, 'Expected no error');
-  }
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_grant_access.js

@@ -1,69 +0,0 @@
-const {deepStrictEqual} = require('node:assert').strict;
-const {rejects} = require('node:assert').strict;
-const test = require('node:test');
-
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {createChainAddress} = require('./../../');
-const {grantAccess} = require('./../../');
-
-const format = 'np2wpkh';
-
-// Granting access should result in access granted
-test(`Get access credentials`, async () => {
-  const [{lnd, kill, rpc}] = (await spawnLightningCluster({})).nodes;
-
-  await grantAccess({lnd, is_ok_to_create_chain_addresses: true});
-
-  const makeChainAddresses = await grantAccess({
-    lnd,
-    is_ok_to_create_chain_addresses: true,
-    permissions: ['address:read'],
-  });
-
-  const permissions = ['address:write', 'address:read'];
-
-  deepStrictEqual(makeChainAddresses.permissions, permissions, 'Permissions');
-
-  const canPay = rpc({
-    macaroon: (await grantAccess({lnd, is_ok_to_pay: true})).macaroon,
-  });
-
-  const makeAddress = rpc({macaroon: makeChainAddresses.macaroon});
-
-  await rejects(
-    grantAccess({lnd: makeAddress.lnd, is_ok_to_create_chain_addresses: true}),
-    [403, 'PermissionDeniedToBakeMacaroon'],
-    'Cannot grant access using a non-generate macaroon'
-  );
-
-  await rejects(
-    createChainAddress({format, lnd: canPay.lnd}),
-    [503, 'UnexpectedErrorCreatingAddress'],
-    'Cannot create a chain address using an offchain pay macaroon'
-  );
-
-  const {address} = await createChainAddress({format, lnd: makeAddress.lnd});
-
-  deepStrictEqual(!!address, true, 'Can make address with proper credential');
-
-  const createChainAddressCredential = await grantAccess({
-    lnd,
-    methods: ['createChainAddress'],
-  });
-
-  const authenticatedToCreateAddress = rpc({
-    macaroon: createChainAddressCredential.macaroon,
-  });
-
-  const created = await createChainAddress({
-    format,
-    lnd: authenticatedToCreateAddress.lnd,
-  });
-
-  deepStrictEqual(!!created, true, 'Can make address with URI credential');
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_open_channel.js

@@ -1,93 +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 {createChainAddress} = require('./../../');
-const {getChainBalance} = require('./../../');
-const {getChannel} = require('./../../');
-const {getChannels} = require('./../../');
-const {openChannel} = require('./../../');
-
-const baseFee = '1337';
-const channelCapacityTokens = 1e6;
-const count = 100;
-const defaultBaseFee = '1000';
-const defaultFee = 1e3;
-const defaultVout = 0;
-const description = 'description';
-const feeRate = 420;
-const giftTokens = 1000;
-const interval = 250;
-const size = 2;
-const times = 1000;
-const txIdHexLength = 32 * 2;
-
-// Opening a channel should open a channel
-test(`Open channel`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, id, lnd}, target] = nodes;
-
-  const {address} = await createChainAddress({lnd});
-
-  await generate({count});
-
-  const channelOpen = await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    return await openChannel({
-      description,
-      lnd,
-      base_fee_mtokens: baseFee,
-      chain_fee_tokens_per_vbyte: defaultFee,
-      cooperative_close_address: address,
-      fee_rate: feeRate,
-      give_tokens: giftTokens,
-      local_tokens: channelCapacityTokens,
-      partner_public_key: target.id,
-      socket: target.socket,
-    });
-  });
-
-  strictEqual(channelOpen.transaction_id.length, txIdHexLength, 'Channel id');
-  strictEqual(channelOpen.transaction_vout, defaultVout, 'Channel tx output');
-
-  await asyncRetry({interval, times}, async () => {
-    await generate({});
-
-    const {channels} = await getChannels({lnd});
-
-    const [channel] = channels;
-
-    if (!channel) {
-      throw new Error('ExpectedChannelOpened');
-    }
-
-    if (!!channel.description) {
-      strictEqual(channel.description, description, 'Description set');
-    }
-
-    const {policies} = await getChannel({lnd, id: channel.id});
-
-    const policy = policies.find(n => n.public_key === id);
-
-    if (!policy.base_fee_mtokens) {
-      throw new Error('ExpectedKnownPolicyBaseFeeMtokens');
-    }
-
-    // LND 0.15.5 and below do not support setting fees on open
-    if (policy.base_fee_mtokens === defaultBaseFee) {
-      return;
-    }
-
-    strictEqual(policy.base_fee_mtokens, baseFee, 'Base fee is set');
-    strictEqual(policy.fee_rate, feeRate, 'Fee rate is set');
-  });
-
-  await kill({});
-
-  return;
-});

package/test/integration/test_open_channel_max.js

@@ -1,92 +0,0 @@
-const {equal} = require('node:assert').strict;
-const test = require('node:test');
-
-const asyncRetry = require('async/retry');
-const {componentsOfTransaction} = require('@alexbosworth/blockchain');
-const {spawnLightningCluster} = require('ln-docker-daemons');
-
-const {addPeer} = require('./../../');
-const {getChainTransactions} = require('./../../');
-const {getChannels} = require('./../../');
-const {getUtxos} = require('./../../');
-const {openChannel} = require('./../../');
-
-const count = 101;
-const description = 'description';
-const interval = 250;
-const size = 2;
-const times = 1000;
-
-// Opening a channel with max funds should open a channel using all funds
-test(`Open channel max`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
-
-  const [{generate, id, lnd}, target] = nodes;
-
-  await generate({count});
-
-  // Find the second UTXO, it would not normally be chosen by coin selection
-  const utxo = await asyncRetry({interval, times}, async () => {
-    const {utxos} = await getUtxos({lnd});
-
-    const [, outpoint] = utxos;
-
-    if (!outpoint) {
-      throw new Error('ExpectedMultipleUtxos');
-    }
-
-    return {
-      transaction_id: outpoint.transaction_id,
-      transaction_vout: outpoint.transaction_vout,
-    };
-  });
-
-  // Open the channel using coin selection
-  const channelOpen = await asyncRetry({interval, times}, async () => {
-    await addPeer({lnd, public_key: target.id, socket: target.socket});
-
-    return await openChannel({
-      description,
-      lnd,
-      inputs: [utxo],
-      is_max_funding: true,
-      partner_public_key: target.id,
-      socket: target.socket,
-    });
-  });
-
-  const {transactions} = await getChainTransactions({lnd});
-
-  const tx = transactions.find(n => n.id === channelOpen.transaction_id);
-
-  const components = componentsOfTransaction({transaction: tx.transaction});
-
-  const [input] = components.inputs;
-
-  // Wait for the channel to activate
-  await asyncRetry({interval, times}, async () => {
-    await generate({});
-
-    const {channels} = await getChannels({lnd});
-
-    const [channel] = channels;
-
-    if (!channel) {
-      throw new Error('ExpectedMaxChannelOpened');
-    }
-
-    // LND 0.16.4 and below do not support max funding for channel opens
-    if (channel.description !== description) {
-      return;
-    }
-
-    // Make sure the channel spent the correct transaction output
-    equal(input.id, utxo.transaction_id, 'Channel open spent down right UTXO');
-
-    return;
-  });
-
-  await kill({});
-
-  return;
-});