ln-service 57.14.0 → 57.14.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 57.14.0
+## 57.14.2
 
 - `getChannel`: Add support for specifying `transaction_id` and
     `transaction_vout` instead of `id`

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.14.0",
+    "lightning": "10.14.1",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -24,7 +24,7 @@
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.18",
+    "ln-docker-daemons": "6.0.19",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
@@ -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.14.0"
+  "version": "57.14.2"
 }

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