ln-service 57.14.1 → 57.14.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 57.14.1
+## 57.14.3
 
 - `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.3",
+    "bolt07": "1.9.4",
     "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.1"
+  "version": "57.14.3"
 }

package/test/integration/test_get_route_to_destination.js

@@ -24,128 +24,130 @@ const tokens = 1000;
 
 // Getting a route to a destination should return a route to the destination
 test(`Get a route to a destination`, async () => {
-  const {kill, nodes} = await spawnLightningCluster({size});
+  await asyncRetry({}, async () => {
+    const {kill, nodes} = await spawnLightningCluster({size});
 
-  const [control, target, remote] = nodes;
+    const [control, target, remote] = nodes;
 
-  await control.generate({count: 500});
+    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,
+    await setupChannel({
+      generate: control.generate,
+      lnd: control.lnd,
+      to: target,
     });
 
-    const {routes} = parsePaymentRequest({request: invoice.request});
-
-    // Wait for private routes to get picked up
-    if (!routes) {
-      await cancelHodlInvoice({id: invoice.id, lnd: remote.lnd});
+    await setupChannel({
+      generate: target.generate,
+      give_tokens: 1e5,
+      is_private: true,
+      lnd: target.lnd,
+      to: remote,
+    });
 
-      throw new Error('ExpectedRouteForInvoice');
-    }
+    const invoice = await asyncRetry({interval, times}, async () => {
+      const invoice = await createInvoice({
+        tokens,
+        is_including_private_channels: true,
+        lnd: remote.lnd,
+      });
 
-    return invoice;
-  });
+      const {routes} = parsePaymentRequest({request: invoice.request});
 
-  const parsed = parsePaymentRequest({request: invoice.request});
+      // Wait for private routes to get picked up
+      if (!routes) {
+        await cancelHodlInvoice({id: invoice.id, lnd: remote.lnd});
 
-  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,
-    });
+        throw new Error('ExpectedRouteForInvoice');
+      }
 
-    const paid = await payViaRoutes({
-      id: parsed.id,
-      lnd: control.lnd,
-      routes: [route],
+      return invoice;
     });
 
-    strictEqual(invoice.secret, paid.secret, 'Paid multi-hop private route');
-  });
-
-  const inv = await createInvoice({tokens, lnd: target.lnd});
+    const parsed = parsePaymentRequest({request: invoice.request});
 
-  const invDetails = await decodePaymentRequest({
-    lnd: control.lnd,
-    request: inv.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],
+      });
 
-  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,
-  });
+      strictEqual(invoice.secret, paid.secret, 'Paid multi-hop private route');
+    });
 
-  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,
-  });
+    const inv = await createInvoice({tokens, lnd: target.lnd});
 
-  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],
-      }),
-    ]);
+    const invDetails = await decodePaymentRequest({
+      lnd: control.lnd,
+      request: inv.request,
+    });
 
-    strictEqual(controlPay.secret, inv.secret, 'Control paid for secret');
-    strictEqual(remotePay.secret, inv.secret, 'Remote paid for secret');
+    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 {payments} = await getInvoice({
-      id: invDetails.id,
-      lnd: target.lnd,
+    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,
     });
 
-    const [payment1, payment2] = payments;
+    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;
+      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');
-  }
+      deepStrictEqual(message1, message, 'Target received message');
+      deepStrictEqual(message2, message, 'Target received both messages');
+    } catch (err) {
+      strictEqual(err, null, 'Unexpected error paying invoice');
+    }
 
-  await kill({});
+    await kill({});
+  });
 
   return;
 });

package/test/routerrpc-integration/test_route_from_channels_complex.js

@@ -0,0 +1,323 @@
+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 {getNode} = 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 = 5;
+const times = 1000;
+const tokens = 100;
+
+// Calculating a route from complex channels set should result in a route
+test(`Get route through complex hops`, async () => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  try {
+    const [{generate, lnd}, target, remote, far, farthest] = 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 generate({});
+
+    const remoteFarChannel = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      await addPeer({lnd: remote.lnd, public_key: far.id, socket: far.socket});
+
+      return await setupChannel({
+        generate: remote.generate,
+        lnd: remote.lnd,
+        to: far,
+      });
+    });
+
+    await target.generate({count: confirmationCount});
+
+    const farFarthestChannel = await asyncRetry({
+      interval,
+      times,
+    },
+    async () => {
+      await generate({});
+
+      await addPeer({
+        lnd: far.lnd,
+        public_key: farthest.id,
+        socket: farthest.socket,
+      });
+
+      return await setupChannel({
+        generate: far.generate,
+        lnd: far.lnd,
+        to: farthest,
+      });
+    });
+
+    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');
+      }
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: far.lnd});
+
+      await addPeer({lnd, public_key: far.id, socket: far.socket});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('ExpectedWalletSyncedToChain');
+      }
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      const wallet = await getWalletInfo({lnd: farthest.lnd});
+
+      await addPeer({lnd, public_key: farthest.id, socket: farthest.socket});
+
+      if (!wallet.is_synced_to_chain) {
+        throw new Error('ExpectedWalletSyncedToChain');
+      }
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      await getNode({lnd, public_key: remote.id});
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      const {features} = await getNode({lnd, public_key: far.id});
+
+      if (!features.length) {
+        throw new Error('ExpectedFarFeatures');
+      }
+    });
+
+    await asyncRetry({interval, times}, async () => {
+      const {features} = await getNode({lnd, public_key: farthest.id});
+
+      if (!features.length) {
+        throw new Error('ExpectedFarthestFeatures');
+      }
+    });
+
+    const invoice = await createInvoice({
+      tokens,
+      cltv_delta: 50,
+      lnd: farthest.lnd,
+    });
+
+    const {id} = invoice;
+    const {request} = invoice;
+
+    const decodedRequest = await decodePaymentRequest({lnd, request});
+
+    await waitForRoute({
+      lnd,
+      destination: farthest.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});
+    const policyBStart = await getChannel({lnd, id: targetRemoteChannel.id});
+    const policyCStart = await getChannel({lnd, id: remoteFarChannel.id});
+    const policyDStart = await getChannel({lnd, id: farFarthestChannel.id});
+
+    await updateRoutingFees({
+      cltv_delta: 200,
+      lnd: target.lnd,
+      transaction_id: targetRemoteChannel.transaction_id,
+      transaction_vout: targetRemoteChannel.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 200,
+      lnd: remote.lnd,
+      transaction_id: targetRemoteChannel.transaction_id,
+      transaction_vout: targetRemoteChannel.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 100,
+      inbound_base_discount_mtokens: discount,
+      lnd: target.lnd,
+      transaction_id: controlToTargetChan.transaction_id,
+      transaction_vout: controlToTargetChan.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 300,
+      lnd: far.lnd,
+      transaction_id: remoteFarChannel.transaction_id,
+      transaction_vout: remoteFarChannel.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 400,
+      lnd: remote.lnd,
+      transaction_id: remoteFarChannel.transaction_id,
+      transaction_vout: remoteFarChannel.transaction_vout,
+    });
+
+    // Control updates their routing policy
+    await updateRoutingFees({
+      lnd,
+      cltv_delta: 100,
+      transaction_id: controlToTargetChan.transaction_id,
+      transaction_vout: controlToTargetChan.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 500,
+      lnd: far.lnd,
+      transaction_id: farFarthestChannel.transaction_id,
+      transaction_vout: farFarthestChannel.transaction_vout,
+    });
+
+    await updateRoutingFees({
+      cltv_delta: 100,
+      lnd: farthest.lnd,
+      transaction_id: farFarthestChannel.transaction_id,
+      transaction_vout: farFarthestChannel.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);
+
+    // Wait for policy to be updated
+    const policyB = await asyncRetry({interval, times}, async () => {
+      const policy = await getChannel({lnd, id: targetRemoteChannel.id});
+
+      if (policy.updated_at === policyBStart.updated_at) {
+        throw new Error('PolicyNotUpdatedYet');
+      }
+
+      return policy;
+    });
+
+    // Wait for policy to be updated
+    const policyC = await asyncRetry({interval, times}, async () => {
+      const policy = await getChannel({lnd, id: remoteFarChannel.id});
+
+      if (policy.updated_at === policyCStart.updated_at) {
+        throw new Error('PolicyNotUpdatedYet');
+      }
+
+      return policy;
+    });
+
+    const policyD = await asyncRetry({interval, times}, async () => {
+      const policy = await getChannel({lnd, id: farFarthestChannel.id});
+
+      if (policy.updated_at === policyDStart.updated_at) {
+        throw new Error('PolicyNotUpdatedYet');
+      }
+
+      return policy;
+    });
+
+    const channelsRoute = routeFromChannels({
+      channels: [policyA, policyB, policyC, policyD],
+      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 lndRoute = await getRouteThroughHops({
+      lnd,
+      cltv_delta: decodedRequest.cltv_delta + confirmationCount,
+      mtokens: decodedRequest.mtokens,
+      payment: decodedRequest.payment,
+      public_keys: [target.id, remote.id, far.id, farthest.id],
+      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]});
+
+    equal(gotTotalFee, BigInt(baseFee * 2), 'Got expected discount');
+
+    await kill({});
+  } catch (err) {
+    await kill({});
+
+    equal(err, null, 'Expected no error');
+  }
+
+  return;
+});

package/test/routerrpc-integration/{test_route_from_channels.js → test_route_from_channels_simple.js}

@@ -64,7 +64,11 @@ test(`Get route through hops`, async () => {
     }
   });
 
-  const invoice = await createInvoice({tokens, lnd: remote.lnd});
+  const invoice = await createInvoice({
+    tokens,
+    cltv_delta: 60,
+    lnd: remote.lnd,
+  });
 
   const {id} = invoice;
   const {request} = invoice;
@@ -122,6 +126,15 @@ test(`Get route through hops`, async () => {
     total_mtokens: decodedRequest.mtokens,
   });
 
+  const lndRoute = await getRouteThroughHops({
+    lnd,
+    cltv_delta: decodedRequest.cltv_delta + confirmationCount,
+    mtokens: decodedRequest.mtokens,
+    payment: decodedRequest.payment,
+    public_keys: [target.id, remote.id],
+    total_mtokens: decodedRequest.mtokens,
+  });
+
   const discounted = BigInt(discountFee.inbound_base_discount_mtokens);
 
   const gotTotalFee = BigInt(channelsRoute.route.fee_mtokens);
@@ -133,4 +146,4 @@ test(`Get route through hops`, async () => {
   equal(gotTotalFee, BigInt(baseFee) - discounted, 'Got expected discount');
 
   return;
-});
+});