ln-service 57.13.3 → 57.14.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## 57.14.1
+
+- `getChannel`: Add support for specifying `transaction_id` and
+    `transaction_vout` instead of `id`
+
 ## 57.13.3
 
 - `getWalletInfo`: Add support for LND 0.18.0

package/README.md

@@ -1883,14 +1883,23 @@ const balanceInChannels = (await getChannelBalance({lnd})).channel_balance;
 
 Get graph information about a channel on the network
 
+Either channel `id` or a `transaction_id` and `transaction_vout` is required
+
 Requires `info:read` permission
 
 `inbound_base_discount_mtokens` is not supported on LND 0.17.5 and below
+
 `inbound_rate_discount` is not supported on LND 0.17.5 and below
 
+`transaction_id` is not supported on LND 0.18.0 and below
+
+`transaction_vout` is not supported on LND 0.18.0 and below
+
     {
-      id: <Standard Format Channel Id String>
+      [id]: <Standard Format Channel Id String>
       lnd: <Authenticated LND API Object>
+      [transaction_id]: <Funding Outpoint Transaction Id Hex String>
+      [transaction_vout]: <Funding Outpoint Transaction Output Index Number>
     }
 
     @returns via cbk or Promise
@@ -1900,18 +1909,18 @@ Requires `info:read` permission
       policies: [{
         [base_fee_mtokens]: <Base Fee Millitokens String>
         [cltv_delta]: <Locktime Delta Number>
-        [fee_rate]: <Fees Charged Per Million Millitokens Number>
+        [fee_rate]: <Fees Charged in Millitokens Per Million Number>
         [inbound_base_discount_mtokens]: <Source Based Base Fee Reduction String>
         [inbound_rate_discount]: <Source Based Per Million Rate Reduction Number>
         [is_disabled]: <Channel Is Disabled Bool>
         [max_htlc_mtokens]: <Maximum HTLC Millitokens Value String>
         [min_htlc_mtokens]: <Minimum HTLC Millitokens Value String>
         public_key: <Node Public Key String>
-        [updated_at]: <Policy Last Updated At ISO 8601 Date String>
+        [updated_at]: <Edge Last Updated At ISO 8601 Date String>
       }]
       transaction_id: <Transaction Id Hex String>
       transaction_vout: <Transaction Output Index Number>
-      [updated_at]: <Last Update Epoch ISO 8601 Date String>
+      [updated_at]: <Channel Last Updated At ISO 8601 Date String>
     }
 
 Example:

package/package.json

@@ -7,9 +7,9 @@
     "url": "https://github.com/alexbosworth/ln-service/issues"
   },
   "dependencies": {
-    "bolt07": "1.9.2",
+    "bolt07": "1.9.3",
     "invoices": "3.0.0",
-    "lightning": "10.13.1",
+    "lightning": "10.14.0",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -20,18 +20,18 @@
     "asyncjs-util": "1.2.12",
     "bip32": "4.0.0",
     "bip66": "1.1.5",
-    "bitcoinjs-lib": "6.1.5",
+    "bitcoinjs-lib": "6.1.6",
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.17",
+    "ln-docker-daemons": "6.0.18",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
     "rimraf": "5.0.7",
     "secp256k1": "5.0.0",
     "tiny-secp256k1": "2.2.3",
-    "uuid": "9.0.1",
+    "uuid": "10.0.0",
     "varuint-bitcoin": "1.1.2"
   },
   "engines": {
@@ -72,5 +72,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": "57.13.3"
+  "version": "57.14.1"
 }

package/test/integration/test_get_channel.js

@@ -43,6 +43,21 @@ test(`Get channel`, async () => {
 
   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/routerrpc-integration/test_route_from_channels.js

@@ -0,0 +1,136 @@
+const {equal} = 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 {addPeer} = require('./../../');
+const {createInvoice} = require('./../../');
+const {decodePaymentRequest} = require('./../../');
+const {getHeight} = require('./../../');
+const {getChannel} = require('./../../');
+const {getRouteThroughHops} = require('./../../');
+const {getRouteToDestination} = require('./../../');
+const {getWalletInfo} = require('./../../');
+const {payViaRoutes} = require('./../../');
+const {routeFromChannels} = require('./../../');
+const {updateRoutingFees} = require('./../../');
+const {waitForRoute} = require('./../macros');
+
+const baseFee = '1000';
+const confirmationCount = 6;
+const discount = '1000';
+const interval = 10;
+const size = 3;
+const times = 1000;
+const tokens = 100;
+
+// Calculating a route from channels should result in a route
+test(`Get route through hops`, async () => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [{generate, lnd}, target, remote] = nodes;
+
+  const controlToTargetChan = await setupChannel({generate, lnd, to: target});
+
+  await generate({});
+
+  const targetRemoteChannel = await asyncRetry({interval, times}, async () => {
+    await generate({});
+
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
+    });
+
+    return await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
+    });
+  });
+
+  await target.generate({count: confirmationCount});
+
+  await asyncRetry({interval, times}, async () => {
+    const wallet = await getWalletInfo({lnd: remote.lnd});
+
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+    if (!wallet.is_synced_to_chain) {
+      throw new Error('ExpectedWalletSyncedToChain');
+    }
+  });
+
+  const invoice = await createInvoice({tokens, lnd: remote.lnd});
+
+  const {id} = invoice;
+  const {request} = invoice;
+
+  const decodedRequest = await decodePaymentRequest({lnd, request});
+
+  await waitForRoute({lnd, destination: remote.id, tokens: invoice.tokens});
+
+  const {route} = await asyncRetry({interval, times}, async () => {
+    return await getRouteToDestination({
+      lnd,
+      cltv_delta: decodedRequest.cltv_delta,
+      destination: decodedRequest.destination,
+      tokens: invoice.tokens,
+    });
+  });
+
+  const policyAStart = await getChannel({lnd, id: controlToTargetChan.id});
+
+  // Target gives a discount to traffic coming from control
+  await updateRoutingFees({
+    inbound_base_discount_mtokens: discount,
+    lnd: target.lnd,
+    transaction_id: controlToTargetChan.transaction_id,
+    transaction_vout: controlToTargetChan.transaction_vout,
+  });
+
+  // Wait for policy to be updated
+  const policyA = await asyncRetry({interval, times}, async () => {
+    const policy = await getChannel({lnd, id: controlToTargetChan.id});
+
+    if (policy.updated_at === policyAStart.updated_at) {
+      throw new Error('PolicyNotUpdatedYet');
+    }
+
+    return policy;
+  });
+
+  // A discount should be set for traffic from control to remote
+  const discountFee = policyA.policies.find(n => n.public_key === target.id);
+
+  // Get the routing policy of target to remote to calculate the route
+  const policyB = await getChannel({
+    id: targetRemoteChannel.id,
+    lnd: target.lnd,
+  });
+
+  const channelsRoute = routeFromChannels({
+    channels: [policyA, policyB],
+    cltv_delta: decodedRequest.cltv_delta + confirmationCount,
+    destination: decodedRequest.destination,
+    height: (await getHeight({lnd})).current_block_height,
+    mtokens: decodedRequest.mtokens,
+    payment: decodedRequest.payment,
+    total_mtokens: decodedRequest.mtokens,
+  });
+
+  const discounted = BigInt(discountFee.inbound_base_discount_mtokens);
+
+  const gotTotalFee = BigInt(channelsRoute.route.fee_mtokens);
+
+  await payViaRoutes({lnd, id: invoice.id, routes: [channelsRoute.route]});
+
+  await kill({});
+
+  equal(gotTotalFee, BigInt(baseFee) - discounted, 'Got expected discount');
+
+  return;
+});