ln-service 56.9.0 → 56.11.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 56.11.0
+
+- `openChannel`: Add `inputs` to select inputs for channel open funding
+
+## 56.10.0
+
+- `createInvoice`, `createHodlInvoice`: Add `routes` to customize the hop hints
+
 ## 56.9.0
 
 - `openChannel`: Add `is_trusted_funding` to support skipping confirmation wait

package/README.md

@@ -641,6 +641,13 @@ Requires `address:write`, `invoices:write` permission
       [is_including_private_channels]: <Invoice Includes Private Channels Bool>
       lnd: <Authenticated LND API Object>
       [mtokens]: <Millitokens String>
+      [routes]: [[{
+        [base_fee_mtokens]: <Base Routing Fee In Millitokens String>
+        [channel]: <Standard Format Channel Id String>
+        [cltv_delta]: <CLTV Blocks Delta Number>
+        [fee_rate]: <Fee Rate In Millitokens Per Million Number>
+        public_key: <Forward Edge Public Key Hex String>
+      }]]
       [tokens]: <Tokens Number>
     }
 
@@ -707,6 +714,13 @@ Requires `address:write`, `invoices:write` permission
       lnd: <Authenticated LND API Object>
       [secret]: <Payment Preimage Hex String>
       [mtokens]: <Millitokens String>
+      [routes]: [[{
+        [base_fee_mtokens]: <Base Routing Fee In Millitokens String>
+        [channel]: <Standard Format Channel Id String>
+        [cltv_delta]: <CLTV Blocks Delta Number>
+        [fee_rate]: <Fee Rate In Millitokens Per Million Number>
+        public_key: <Forward Edge Public Key Hex String>
+      }]]
       [tokens]: <Tokens Number>
     }
 
@@ -3715,6 +3729,8 @@ Requires `offchain:write`, `onchain:write`, `peers:write` permissions
 
 `description` is not supported on LND 0.16.4 and below
 
+`inputs` is not supported on LND 0.16.4 and below
+
     {
       [base_fee_mtokens]: <Routing Base Fee Millitokens Charged String>
       [chain_fee_tokens_per_vbyte]: <Chain Fee Tokens Per VByte Number>
@@ -3722,6 +3738,10 @@ Requires `offchain:write`, `onchain:write`, `peers:write` permissions
       [description]: <Immutable Channel Description String>
       [fee_rate]: <Routing Fee Rate In Millitokens Per Million Number>
       [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
+      [inputs]: [{
+        transaction_id: <Fund With Unspent Transaction Id Hex String>
+        transaction_vout: <Fund With Unspent Transaction Output Index Number>
+      }]
       [is_max_funding]: <Use Maximal Chain Funds For Local Funding Bool>
       [is_private]: <Channel is Private Bool> // Defaults to false
       [is_trusted_funding]: <Accept Funding as Trusted Bool>

package/package.json

@@ -11,7 +11,7 @@
     "cors": "2.8.5",
     "express": "4.18.2",
     "invoices": "3.0.0",
-    "lightning": "9.9.0",
+    "lightning": "9.11.1",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.13.0"
@@ -28,7 +28,7 @@
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "5.1.1",
+    "ln-docker-daemons": "5.1.2",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
@@ -69,5 +69,5 @@
     "integration-test-0.14.4": "DOCKER_LND_VERSION=v0.14.4-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && node test/runner"
   },
-  "version": "56.9.0"
+  "version": "56.11.0"
 }

package/test/integration/test_delete_pending_channel.js

@@ -1,4 +1,4 @@
-const {deepStrictEqual} = require('node:assert').strict;
+const {deepEqual} = require('node:assert').strict;
 const test = require('node:test');
 
 const asyncEach = require('async/each');
@@ -34,154 +34,150 @@ const timeout = 1000 * 20;
 const times = 2000;
 
 // Forfeiting a pending channel should remove the pending channel
-test(`Forfeit pending channel`, async () => {
+test(`Forfeit pending channel`, async t => {
   const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
 
   const {kill, nodes} = await spawnLightningCluster({size});
 
+  t.after(async () => await kill({}));
+
   const [{generate, lnd}, target, remote] = nodes;
 
-  try {
-    await generate({count});
+  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,
-      },
-      cbk);
-    });
+  await asyncEach([target, remote], async node => {
+    return await addPeer({lnd, public_key: node.id, socket: node.socket});
+  });
 
-    // Setup funding for the target
-    const fundTarget = await fundPsbt({lnd, outputs: proposeToTarget.pending});
+  const channels = [{
+    capacity,
+    description,
+    is_private: true,
+    partner_public_key: target.id,
+  }];
 
-    // Sign the funding to the target
-    const signTarget = await signPsbt({lnd, psbt: fundTarget.psbt});
-
-    // Fund the target channel that will get stuck
-    await fundPendingChannels({
+  // Propose a channel to target
+  const proposeToTarget = await asyncRetry({interval: 1000, times}, cbk => {
+    return asyncTimeout(openChannels, 1000 * 3)({
+      channels,
       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({
+      is_avoiding_broadcast: true,
+    },
+    cbk);
+  });
+
+  // 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,
-      inputs: fundTarget.inputs,
-      outputs: proposeToRemote.pending
+      id: utxo.lock_id,
+      transaction_id: utxo.transaction_id,
+      transaction_vout: utxo.transaction_vout,
     });
+  });
 
-    // Sign the funding to the target
-    const signRemote = await signPsbt({lnd, psbt: fundRemote.psbt});
-
-    // Fund the remote channel
-    await fundPendingChannels({
+  // Propose a channel to remote
+  const proposeToRemote = await asyncRetry({interval: 1000, times}, cbk => {
+    return asyncTimeout(openChannels, 1000 * 3)({
       lnd,
-      channels: proposeToRemote.pending.map(n => n.id),
-      funding: signRemote.psbt,
-    });
-
-    await delay(1000);
-
-    const {transaction} = extractTransaction({ecp, psbt: signRemote.psbt});
+      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(1000);
+
+  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({});
 
-    const channel = await asyncRetry({interval: 1000, times}, async () => {
-      const [channel] = (await getChannels({lnd})).channels;
+    throw new Error('ExpectedNewChannelCreated');
+  });
 
-      // Exit early when the channel is created
-      if (!!channel) {
-        return channel;
-      }
+  const [pending] = (await getPendingChannels({lnd})).pending_channels;
 
-      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) {
-      strictSame(pending.description, description, 'Got expected description');
-      strictSame(pending.is_private, true, 'Got pending private status');
-    }
+  // 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 stuckTx = extractTransaction({ecp, psbt: signTarget.psbt});
 
-    const [stuckPending] = proposeToTarget.pending;
+  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;
+  // Try to cancel the pending channel, it will fail
+  try {
+    await cancelPendingChannel({lnd, id: stuckPending.id});
+  } catch (err) {
+    const [code] = err;
 
-      deepStrictEqual(code, 503, 'Pending channel cannot be canceled');
-    }
+    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,
-      });
+  try {
+    await deletePendingChannel({
+      lnd,
+      confirmed_transaction: transaction,
+      pending_transaction: stuckTx.transaction,
+      pending_transaction_vout: pending.transaction_vout,
+    });
 
-      const [notPending] = (await getPendingChannels({lnd})).pending_channels;
+    const [notPending] = (await getPendingChannels({lnd})).pending_channels;
 
-      deepStrictEqual(notPending, undefined, 'Conflicting pending deleted');
-    } catch (err) {
-      deepStrictEqual(err, [501, 'DeletePendingChannelMethodNotSupported']);
-    }
+    deepEqual(notPending, undefined, 'Conflicting pending deleted');
   } catch (err) {
-    deepStrictEqual(err, null, 'No error is expected');
+    deepEqual(err, [501, 'DeletePendingChannelMethodNotSupported']);
   }
 
-  await kill({});
-
   return;
 });

package/test/integration/test_get_closed_channels.js

@@ -1,3 +1,4 @@
+const {exit} = require('node:process');
 const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 
@@ -20,9 +21,11 @@ const size = 2;
 const times = 1000;
 
 // Getting closed channels should return closed channels
-test(`Get closed channels`, async () => {
+test(`Get closed channels`, async t => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
+  t.after(() => exit());
+
   const [control, target] = nodes;
 
   const {generate, lnd} = control;

package/test/integration/test_open_channel_max.js

@@ -0,0 +1,92 @@
+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;
+});

package/test/integration/test_stop_daemon.js

@@ -1,3 +1,4 @@
+const {exit} = require('node:process');
 const {fail} = require('node:assert').strict;
 const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
@@ -8,9 +9,11 @@ const {getWalletInfo} = require('./../../');
 const {stopDaemon} = require('./../../');
 
 // Stopping the daemon should gracefully shut down the daemon
-test(`Stop daemon`, async ({end, equal, fail}) => {
+test(`Stop daemon`, async t => {
   const [{kill, lnd}] = (await spawnLightningCluster({})).nodes;
 
+  t.after(() => exit());
+
   await stopDaemon({lnd});
 
   try {

package/test/integration/test_subscribe_to_graph.js

@@ -1,5 +1,6 @@
 const {deepEqual} = require('node:assert').strict;
 const {equal} = require('node:assert').strict;
+const {exit} = require('node:process');
 const test = require('node:test');
 
 const asyncRetry = require('async/retry');
@@ -19,9 +20,11 @@ const size = 2;
 const times = 1000;
 
 // Subscribing to graph should trigger graph events
-test('Subscribe to channels', async () => {
+test('Subscribe to channels', async t => {
   const attempts = [];
 
+  t.after(() => exit());
+
   await asyncRetry({interval, times}, async () => {
     const {kill, nodes} = await spawnLightningCluster({size});
 

package/test/integration/test_trusted_funding.js

@@ -1,5 +1,6 @@
 const {deepEqual} = require('node:assert').strict;
 const {equal} = require('node:assert').strict;
+const {exit} = require('node:process');
 const {match} = require('node:assert').strict;
 const test = require('node:test');
 
@@ -29,7 +30,9 @@ const size = 2;
 const times = 4000;
 
 // Opening unconfirmed channels should in immediate channel opening
-test(`Open unconfirmed channels`, async () => {
+test(`Open unconfirmed channels`, async t => {
+  t.after(() => exit());
+
   // Unconfirmed channels are not supported on LND 0.15.0 and below
   {
     const {kill, nodes} = await spawnLightningCluster({});

package/test/invoicesrpc-integration/test_create_hinted_invoice.js

@@ -0,0 +1,91 @@
+const {deepEqual} = 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 {createHodlInvoice} = require('./../../');
+const {createInvoice} = require('./../../');
+const {parsePaymentRequest} = require('./../../');
+
+const interval = 10;
+const size = 3;
+const times = 1000;
+const tokens = 100;
+
+// createInvoice should result in a created invoice with hop hints
+test(`Create an invoice with hop hints`, async t => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  t.after(async () => await kill({}));
+
+  const [{generate, lnd}, target, remote] = nodes;
+
+  const channel = await setupChannel({generate, lnd, to: target});
+
+  const remoteChannel = await setupChannel({
+    generate: target.generate,
+    is_private: true,
+    lnd: target.lnd,
+    to: remote,
+  });
+
+  const specialRoutes = [[
+    {
+      public_key: target.id,
+    },
+    {
+      base_fee_mtokens: '123456',
+      channel: remoteChannel.id,
+      cltv_delta: 200,
+      fee_rate: 123456,
+      public_key: remote.id,
+    },
+  ]];
+
+  const invoice = await asyncRetry({interval, times}, async () => {
+    const invoice = await createInvoice({
+      tokens,
+      is_including_private_channels: true,
+      lnd: remote.lnd,
+      routes: specialRoutes,
+    });
+
+    const hodlInvoice = await createHodlInvoice({
+      tokens,
+      is_including_private_channels: true,
+      lnd: remote.lnd,
+      routes: specialRoutes,
+    });
+
+    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');
+    }
+
+    const hodl = parsePaymentRequest({request: hodlInvoice.request});
+
+    // Wait for private routes to get picked up
+    if (!hodl.routes) {
+      await cancelHodlInvoice({id: hodl.id, lnd: remote.lnd});
+
+      throw new Error('ExpectedRouteForHodlInvoice');
+    }
+
+    return {
+      normal_routes: routes,
+      hodl_routes: hodl.routes,
+    };
+  });
+
+  deepEqual(invoice.normal_routes, specialRoutes, 'Got expected routes');
+  deepEqual(invoice.hodl_routes, specialRoutes, 'Got expected hodl routes');
+
+  return;
+});

package/test/invoicesrpc-integration/test_get_sweep_transactions.js

@@ -1,4 +1,5 @@
 const {equal} = require('node:assert').strict;
+const {exit} = require('node:process');
 const test = require('node:test');
 
 const asyncAuto = require('async/auto');
@@ -17,9 +18,7 @@ const {getSweepTransactions} = require('./../../');
 const {getWalletInfo} = require('./../../');
 const {openChannel} = require('./../../');
 const {pay} = require('./../../');
-const {subscribeToInvoice} = require('./../../');
 
-const anchorsFeatureBit = 23;
 const blockDelay = 50;
 const channelCapacityTokens = 1e6;
 const confirmationCount = 6;
@@ -31,14 +30,12 @@ const times = 10000;
 const tokens = 100;
 
 // Force close a channel and get the resulting sweep transaction
-test(`Get sweep transactions`, async () => {
+test(`Get sweep transactions`, async t => {
   const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [{generate, lnd}, target] = nodes;
-
-  const {features} = await getWalletInfo({lnd});
+  t.after(() => exit());
 
-  const isAnchors = !!features.find(n => n.bit === anchorsFeatureBit);
+  const [{generate, lnd}, target] = nodes;
 
   const channel = await setupChannel({
     generate,
@@ -79,28 +76,21 @@ test(`Get sweep transactions`, async () => {
 
   const [transaction] = transactions;
 
-  // LND 0.12.0 uses anchor channels
-  if (isAnchors) {
-    const [anchorTokens, sweepTokens] = transactions
-      .map(n => n.tokens).sort();
-
-    equal(transactions.length, 2, 'Got closed channel sweep');
-
-    // LND 0.15.0 and before have different sweep tokens
-    if (sweepTokens === 890455) {
-      equal(anchorTokens, 149, 'Sweep has tokens amount');
-      equal(sweepTokens, 890455, 'Sweep has tokens amount');
-    } else if (anchorTokens === 147) {
-      equal(anchorTokens, 147, 'Sweep has tokens amount');
-      equal(sweepTokens, 889855, 'Sweep has tokens amount');
-    } else {
-      equal(anchorTokens, 136, 'Sweep has tokens amount');
-      equal(sweepTokens, 889855, 'Sweep has tokens amount');
-    }
+  const [anchorTokens, sweepTokens] = transactions
+    .map(n => n.tokens).sort();
+
+  equal(transactions.length, 2, 'Got closed channel sweep');
+
+  // LND 0.15.0 and before have different sweep tokens
+  if (sweepTokens === 890455) {
+    equal(anchorTokens, 149, 'Sweep has tokens amount');
+    equal(sweepTokens, 890455, 'Sweep has tokens amount');
+  } else if (anchorTokens === 147) {
+    equal(anchorTokens, 147, 'Sweep has tokens amount');
+    equal(sweepTokens, 889855, 'Sweep has tokens amount');
   } else {
-    equal(transactions.length, [channel].length, 'Got closed channel sweep');
-    equal(transaction.spends.length, 1, 'Sweep has spends');
-    equal(transaction.tokens, 884875, 'Sweep has tokens amount');
+    equal(anchorTokens, 136, 'Sweep has tokens amount');
+    equal(sweepTokens, 889855, 'Sweep has tokens amount');
   }
 
   equal(transaction.block_id.length, 64, 'Sweep confirmed');

package/test/routerrpc-integration/test_pay_via_routes.js

@@ -48,8 +48,16 @@ test(`Pay via routes`, async () => {
   const remoteLnd = remote.lnd;
   const targetPubKey = target.id;
 
+  await addPeer({lnd, public_key: target.id, socket: target.socket});
+
   const channel = await setupChannel({generate, lnd, to: target});
 
+  await addPeer({
+    lnd: target.lnd,
+    public_key: remote.id,
+    socket: remote.socket,
+  });
+
   const targetToRemoteChan = await setupChannel({
     generate: target.generate,
     is_private: true,