lightning 10.1.3 → 10.1.4

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 10.1.3
+## 10.1.4
 
 - `getBlockHeader`: Add method to get the header portion of a block
 

package/lnd_methods/generic/get_route_confidence.js

@@ -11,6 +11,7 @@ const decBase = 10;
 const defaultOdds = 950000;
 const fullConfidence = 1e6;
 const {isArray} = Array;
+const notFoundIndex = -1;
 const oddsDenominator = BigInt(1e6);
 const unimplemented = 'QueryProbabilityNotImplemented';
 
@@ -43,7 +44,7 @@ module.exports = ({from, hops, lnd}, cbk) => {
           return cbk([400, 'ExpectedArrayOfHopsToCalculateRoutingOdds']);
         }
 
-        if (!!hops.find(n => !n.channel || !n.public_key)) {
+        if (hops.findIndex(n => !n.public_key) !== notFoundIndex) {
           return cbk([400, 'ExpectedHopsWithEdges']);
         }
 

package/lnd_methods/info/constants.json

@@ -19,6 +19,7 @@
   "prefAttachType": "preferential",
   "versions": {
     "0d5b0fefa4d9082f7964836f5e58c3a6bda8e471": "0.10.2-beta",
+    "13aa7f99248c7ee63989d3b62e0cbfe86d7b0964": "0.17.3-beta",
     "15c1eb13972f86a7c1e8cb084aa6d52700d685ff": "0.14.5-beta",
     "1a3194d302f33bb52823297d9d7f75cd37516053": "0.10.0-beta",
     "1e511be523eb8e97c4e2d9c89a7a263963a3929f": "0.14.2-beta",

package/package.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.9.11",
+    "@grpc/grpc-js": "1.9.12",
     "@grpc/proto-loader": "0.7.10",
-    "@types/node": "20.9.2",
+    "@types/node": "20.10.3",
     "@types/request": "2.48.12",
-    "@types/ws": "8.5.9",
+    "@types/ws": "8.5.10",
     "async": "3.2.5",
     "asyncjs-util": "1.2.12",
     "bitcoinjs-lib": "6.1.5",
@@ -22,12 +22,12 @@
     "invoices": "3.0.0",
     "psbt": "3.0.0",
     "tiny-secp256k1": "2.2.3",
-    "type-fest": "4.8.1"
+    "type-fest": "4.8.3"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
     "tsd": "0.29.0",
-    "typescript": "5.3.2"
+    "typescript": "5.3.3"
   },
   "engines": {
     "node": ">=18"
@@ -53,5 +53,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "10.1.3"
+  "version": "10.1.4"
 }

package/test/lnd_methods/generic/test_get_route_confidence.js

@@ -0,0 +1,143 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {getInfoResponse} = require('./../fixtures');
+const {getRouteConfidence} = require('./../../../');
+
+const makeLnd = ({err, res}) => {
+  return {
+    default: {
+      getInfo: ({}, cbk) => cbk(err, getInfoResponse),
+    },
+    router: {
+      queryMissionControl: ({}, cbk) => {
+        if (!!err) {
+          return cbk(err);
+        }
+
+        if (res !== undefined) {
+          return cbk(null, res);
+        }
+
+        return cbk(null, {
+          pairs: [{
+            history: {
+              fail_amt_msat: '1000',
+              fail_amt_sat: '1',
+              fail_time: '1',
+              success_amt_msat: '1000',
+              success_amt_sat: '1',
+              success_time: '1',
+            },
+            node_from: Buffer.alloc(33, 3),
+            node_to: Buffer.alloc(33, 2),
+          }],
+        });
+      },
+      queryProbability: ({}, cbk) => {
+        if (!!err) {
+          return cbk(err);
+        }
+
+        if (res !== undefined) {
+          return cbk(null, res);
+        }
+
+        return cbk(null, {history: {}, probability: 0.5});
+      },
+    },
+    wallet: {
+      deriveKey: ({}, cbk) => cbk('err'),
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'Hops are required',
+    error: [400, 'ExpectedArrayOfHopsToCalculateRoutingOdds'],
+  },
+  {
+    args: {hops: [{}]},
+    description: 'Valid hops are required',
+    error: [400, 'ExpectedHopsWithEdges'],
+  },
+  {
+    args: {
+      from: Buffer.alloc(33, 1).toString('hex'),
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: {
+        default: {
+          getInfo: ({}, cbk) => cbk(null, getInfoResponse),
+        },
+        router: {
+          queryMissionControl: ({}, cbk) => {
+            return cbk(null, {
+              pairs: [{
+                history: {
+                  fail_amt_msat: '1000',
+                  fail_amt_sat: '1',
+                  fail_time: '1',
+                  success_amt_msat: '1000',
+                  success_amt_sat: '1',
+                  success_time: '1',
+                },
+                node_from: Buffer.alloc(33, 3),
+                node_to: Buffer.alloc(33, 2),
+              }],
+            });
+          },
+          queryProbability: ({}, cbk) => cbk('err'),
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk('err'),
+        },
+      },
+    },
+    description: 'Get route confidence when confidence query returns err',
+    error: [503, 'UnexpectedErrorFromQueryProbability', {err: 'err'}],
+  },
+  {
+    args: {
+      from: Buffer.alloc(33, 1).toString('hex'),
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: makeLnd({}),
+    },
+    description: 'Get route confidence from non self',
+    expected: {confidence: 950000},
+  },
+  {
+    args: {
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: makeLnd({}),
+    },
+    description: 'Get route confidence',
+    expected: {confidence: 950000},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(getRouteConfidence(args), error, 'Got expected error');
+    } else {
+      const got = await getRouteConfidence(args);
+
+      deepStrictEqual(got, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_is_destination_payable.js

@@ -0,0 +1,276 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {isDestinationPayable} = require('./../../../');
+
+const makePaymentData = overrides => {
+  const data = {
+    creation_date: '1',
+    creation_time_ns: '0',
+    failure_reason: 'FAILURE_REASON_TIMEOUT',
+    fee_msat: '1000',
+    fee_sat: '1',
+    htlcs: [{
+      attempt_time_ns: '1000000',
+      failure: {
+        channel_update: {
+          base_fee: '1000',
+          chain_hash: Buffer.alloc(32),
+          chan_id: '1',
+          channel_flags: 1,
+          extra_opaque_data: Buffer.alloc(1),
+          fee_rate: 1,
+          htlc_maximum_msat: '1000',
+          htlc_minimum_msat: '1000',
+          message_flags: 1,
+          signature: Buffer.alloc(71),
+          time_lock_delta: 1,
+          timestamp: 1,
+        },
+        code: 'UNREADABLE_FAILURE',
+        failure_source_index1: 1,
+        height: 1,
+        htlc_msat: '1000',
+      },
+      resolve_time_ns: '1000000',
+      route: {
+        hops: [{
+          amt_to_forward_msat: '1000',
+          chan_id: '1',
+          chan_capacity: 1,
+          expiry: 1,
+          fee_msat: '1000',
+          mpp_record: {
+            payment_addr: Buffer.alloc(32),
+            total_amt_msat: '1000',
+          },
+          pub_key: Buffer.alloc(33).toString('hex'),
+          tlv_payload: true,
+        }],
+        total_amt: '1',
+        total_amt_msat: '1000',
+        total_fees: '1',
+        total_fees_msat: '1000',
+        total_time_lock: 1,
+      },
+      status: 'FAILED',
+    }],
+    path: [Buffer.alloc(33).toString('hex'), Buffer.alloc(33).toString('hex')],
+    payment_hash: Buffer.alloc(32).toString('hex'),
+    payment_index: '1',
+    payment_preimage: Buffer.alloc(32).toString('hex'),
+    payment_request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
+    status: 'FAILED',
+    value: '1',
+    value_msat: '1000',
+    value_sat: '1',
+  };
+
+  Object.keys(overrides).forEach(k => data[k] = overrides[k]);
+
+  return data;
+};
+
+const makeLnd = args => {
+  return {
+    chain: {
+      registerBlockEpochNtfn: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => emitter.emit('error', 'err'));
+
+        return emitter;
+      },
+    },
+    default: {
+      getInfo: ({}, cbk) => {
+        return cbk(null, {
+          alias: 'alias',
+          best_header_timestamp: 1,
+          block_hash: '00',
+          block_height: 1,
+          chains: [{chain: 'chain', network: 'network'}],
+          color: '#000000',
+          features: {'1': {is_known: true, is_required: false}},
+          identity_pubkey: Buffer.alloc(33).toString('hex'),
+          num_active_channels: 1,
+          num_peers: 1,
+          num_pending_channels: 1,
+          synced_to_chain: true,
+          uris: [],
+          version: 'version',
+        });
+      },
+    },
+    router: {
+      sendPaymentV2: ({}) => {
+        const data = args.data || makePaymentData({});
+        const emitter = new EventEmitter();
+
+        if (!!args.is_end) {
+          process.nextTick(() => emitter.emit('end'));
+        } else if (!!args.err) {
+          process.nextTick(() => emitter.emit('error', args.err));
+        } else {
+          process.nextTick(() => emitter.emit('data', data));
+        }
+
+        return emitter;
+      },
+    },
+  };
+};
+
+const makeArgs = overrides => {
+  const args = {
+    cltv_delta: 1,
+    destination: Buffer.alloc(33).toString('hex'),
+    features: [{bit: 1}],
+    id: Buffer.alloc(32).toString('hex'),
+    incoming_peer: Buffer.alloc(33).toString('hex'),
+    lnd: makeLnd({}),
+    max_fee: 1,
+    max_fee_mtokens: '1000',
+    messages: [{
+      type: '1',
+      value: Buffer.alloc(1).toString('hex'),
+    }],
+    mtokens: '1000',
+    outgoing_channel: '0x0x1',
+    pathfinding_timeout: 1,
+    routes: [[{
+      base_fee_mtokens: '1000',
+      channel: '0x0x1',
+      cltv_delta: 1,
+      fee_rate: 1,
+      public_key: Buffer.alloc(33).toString('hex'),
+    }]],
+    tokens: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpectedPayment = ({}) => {
+  return {
+    failed: undefined,
+    is_confirmed: true,
+    is_failed: false,
+    is_pending: false,
+    payment: {
+      fee: 0,
+      fee_mtokens: '1',
+      hops: [{
+        channel: '0x0x1',
+        channel_capacity: 1,
+        fee: 0,
+        fee_mtokens: '1',
+        forward: 0,
+        forward_mtokens: '1',
+        public_key: 'b',
+        timeout: 1,
+      }],
+      id: '66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925',
+      paths: [{
+        fee: 0,
+        fee_mtokens: '1',
+        hops: [{
+          channel: '0x0x1',
+          channel_capacity: 1,
+          fee: 0,
+          fee_mtokens: '1',
+          forward: 0,
+          forward_mtokens: '1',
+          public_key: 'b',
+          timeout: 1
+        }],
+        mtokens: '1',
+        safe_fee: 1,
+        safe_tokens: 1,
+        timeout: 1,
+        tokens: 0,
+      }],
+      mtokens: '1',
+      safe_fee: 1,
+      safe_tokens: 1,
+      secret: Buffer.alloc(32).toString('hex'),
+      timeout: 1,
+      tokens: 0,
+    },
+  };
+};
+
+const tests = [
+  {
+    args: makeArgs({destination: undefined}),
+    description: 'The payment destination is required',
+    error: [400, 'ExpectedDestinationToCheckPayability'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedAuthenticatedLndWithRouterToTestPayable'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        chain: {
+          registerBlockEpochNtfn: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('error', 'err'));
+
+            return emitter;
+          },
+        },
+        default: {
+          getInfo: ({}, cbk) => {
+            return cbk('err');
+          },
+        },
+        router: {
+          sendPaymentV2: ({}) => {
+            const emitter = new EventEmitter();
+
+            process.nextTick(() => emitter.emit('error', 'err'));
+
+            return emitter;
+          },
+        },
+      },
+    }),
+    description: 'A payment attempt times out',
+    error: [
+      503,
+      'UnexpectedErrorCheckingPayability',
+      {err: [503, 'UnexpectedPaymentError', {err: 'err'}]},
+    ],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A payment attempt times out',
+    expected: {is_payable: false},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => isDestinationPayable(args), error, 'Got error');
+    } else {
+      const payment = await isDestinationPayable(args);
+
+      deepStrictEqual(payment, expected, 'Got expected payment');
+    }
+
+    return;
+  });
+});